diff --git a/.pkg b/.pkg index 8d84381..640d2ea 100644 --- a/.pkg +++ b/.pkg @@ -1,7 +1,7 @@ -[Catch2] - url=git@github.com:motis-project/Catch2.git +[googletest] + url=git@github.com:motis-project/googletest.git branch=master - commit=47d56f28a9801911c048d011b375e5631dbb658f + commit=34a46558609e05865c197f0260ab36daa7cbbb6e [fmt] url=git@github.com:motis-project/fmt.git branch=master @@ -9,5 +9,5 @@ [cista] url=git@github.com:felixguendling/cista.git branch=master - commit=23875effbc4f3441304137515991dbcfbc52caed + commit=251a73b51768bea0a23c538e3aa7f47648411a87 diff --git a/CMakeLists.txt b/CMakeLists.txt index 8b279cd..792cb45 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -25,7 +25,7 @@ if (MSVC) list(REMOVE_ITEM utl-test-files ${zip-test}) endif() add_executable(utl-test ${utl-test-files}) -target_link_libraries(utl-test utl Catch2::Catch2WithMain) +target_link_libraries(utl-test utl gtest gmock gtest_main) if (NOT MSVC) target_compile_options(utl-test PRIVATE -Wall -Wextra -Werror) endif() diff --git a/include/utl/pipes/avg.h b/include/utl/pipes/avg.h index a8caf4d..221812f 100644 --- a/include/utl/pipes/avg.h +++ b/include/utl/pipes/avg.h @@ -6,21 +6,21 @@ namespace utl { -struct avg { +struct avg_t { template - friend double operator|(T&& t, avg&& f) { - auto r = make_range(std::forward(t)); + friend double operator|(T&& r, avg_t) { + auto sum = std::size_t{0}; + auto count = std::size_t{0}; auto it = r.begin(); while (r.valid(it)) { - f.sum_ += r.read(it); - ++f.count_; + sum += r.read(it); + ++count; r.next(it); } - return f.sum_ / static_cast(f.count_); + return sum / static_cast(count); } - - int sum_ = 0; - int count_ = 0; }; +inline avg_t avg() { return {}; } + } // namespace utl \ No newline at end of file diff --git a/test/cmd_line_parser_test.cc b/test/cmd_line_parser_test.cc index 69c985e..76ea9e6 100644 --- a/test/cmd_line_parser_test.cc +++ b/test/cmd_line_parser_test.cc @@ -1,4 +1,4 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/cmd_line_parser.h" @@ -20,17 +20,17 @@ constexpr auto const expected_description = --file * target file --num_threads thread pool size)"; -TEST_CASE("cmd_line_flag_test") { +TEST(cmd, cmd_line_flag_test) { char const* args[] = {"./exe", "-c", "--file", "test", "--num_threads", "8"}; auto c = parse(sizeof(args) / sizeof(char const*), args); - CHECK(c.capture_.val()); - CHECK(c.file_.val() == "test"); - CHECK(c.num_threads_.val() == 8); - CHECK(description() == expected_description); + EXPECT_TRUE(c.capture_.val()); + EXPECT_TRUE(c.file_.val() == "test"); + EXPECT_TRUE(c.num_threads_.val() == 8); + EXPECT_TRUE(description() == expected_description); } -TEST_CASE("cmd_line_flag_required_test") { +TEST(cmd, cmd_line_flag_required_test) { char const* args[] = {"./exe", "-c", "--num_threads", "8"}; bool thrown = false; @@ -39,5 +39,5 @@ TEST_CASE("cmd_line_flag_required_test") { } catch (...) { thrown = true; } - CHECK(thrown); + EXPECT_TRUE(thrown); } diff --git a/test/is_uniform_test.cc b/test/is_uniform_test.cc index 15a5529..e09f7ca 100644 --- a/test/is_uniform_test.cc +++ b/test/is_uniform_test.cc @@ -1,11 +1,11 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/is_uniform.h" -TEST_CASE("is_uniform") { +TEST(is_uniform, is_uniform) { using utl::is_uniform; std::vector v1{1, 1, 3}; std::vector v2{1, 1, 1}; - CHECK(!is_uniform(v1)); - CHECK(is_uniform(v2)); + EXPECT_TRUE(!is_uniform(v1)); + EXPECT_TRUE(is_uniform(v2)); } diff --git a/test/join_test.cc b/test/join_test.cc index bcb68df..c050681 100644 --- a/test/join_test.cc +++ b/test/join_test.cc @@ -1,4 +1,4 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/join.h" @@ -53,131 +53,131 @@ struct tester { std::vector> ranges_both_, ranges_a_, ranges_b_; }; -TEST_CASE("inner_join") { +TEST(join, inner_join) { { tester t{{}, {}}; utl::inner_join(t.a_, t.b_, t.cb_both()); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_both({})); } { tester t{{0}, {0}}; utl::inner_join(t.a_, t.b_, t.cb_both()); - CHECK(t.eq_both({{0, 1, 0, 1}})); + EXPECT_TRUE(t.eq_both({{0, 1, 0, 1}})); } { tester t{{1, 1}, {1, 1}}; utl::inner_join(t.a_, t.b_, t.cb_both()); - CHECK(t.eq_both({{0, 2, 0, 2}})); + EXPECT_TRUE(t.eq_both({{0, 2, 0, 2}})); } { tester t{{1}, {1, 1}}; utl::inner_join(t.a_, t.b_, t.cb_both()); - CHECK(t.eq_both({{0, 1, 0, 2}})); + EXPECT_TRUE(t.eq_both({{0, 1, 0, 2}})); } { tester t{{1, 1}, {1}}; utl::inner_join(t.a_, t.b_, t.cb_both()); - CHECK(t.eq_both({{0, 2, 0, 1}})); + EXPECT_TRUE(t.eq_both({{0, 2, 0, 1}})); } { tester t{{0, 1}, {1}}; utl::inner_join(t.a_, t.b_, t.cb_both()); - CHECK(t.eq_both({{1, 2, 0, 1}})); + EXPECT_TRUE(t.eq_both({{1, 2, 0, 1}})); } { tester t{{1}, {0, 1}}; utl::inner_join(t.a_, t.b_, t.cb_both()); - CHECK(t.eq_both({{0, 1, 1, 2}})); + EXPECT_TRUE(t.eq_both({{0, 1, 1, 2}})); } { tester t{{1, 2}, {1}}; utl::inner_join(t.a_, t.b_, t.cb_both()); - CHECK(t.eq_both({{0, 1, 0, 1}})); + EXPECT_TRUE(t.eq_both({{0, 1, 0, 1}})); } { tester t{{1}, {1, 2}}; utl::inner_join(t.a_, t.b_, t.cb_both()); - CHECK(t.eq_both({{0, 1, 0, 1}})); + EXPECT_TRUE(t.eq_both({{0, 1, 0, 1}})); } { tester t{{1, 1, 3}, {1, 1, 3}}; utl::inner_join(t.a_, t.b_, t.cb_both()); - CHECK(t.eq_both({{0, 2, 0, 2}, {2, 3, 2, 3}})); + EXPECT_TRUE(t.eq_both({{0, 2, 0, 2}, {2, 3, 2, 3}})); } { tester t{{1, 1, 2, 3}, {1, 1, 3}}; utl::inner_join(t.a_, t.b_, t.cb_both()); - CHECK(t.eq_both({{0, 2, 0, 2}, {3, 4, 2, 3}})); + EXPECT_TRUE(t.eq_both({{0, 2, 0, 2}, {3, 4, 2, 3}})); } { tester t{{1, 1, 3}, {1, 1, 2, 3}}; utl::inner_join(t.a_, t.b_, t.cb_both()); - CHECK(t.eq_both({{0, 2, 0, 2}, {2, 3, 3, 4}})); + EXPECT_TRUE(t.eq_both({{0, 2, 0, 2}, {2, 3, 3, 4}})); } } -TEST_CASE("inner_join_reverse") { +TEST(join, inner_join_reverse) { { tester t{{1, 1}, {1, 1}}; utl::inner_join( t.a_, t.b_, [](auto const& lhs, auto const& rhs) { return lhs > rhs; }, t.cb_both()); - CHECK(t.eq_both({{0, 2, 0, 2}})); + EXPECT_TRUE(t.eq_both({{0, 2, 0, 2}})); } { tester t{{2, 1}, {2, 1}}; utl::inner_join( t.a_, t.b_, [](auto const& lhs, auto const& rhs) { return lhs > rhs; }, t.cb_both()); - CHECK(t.eq_both({{0, 1, 0, 1}, {1, 2, 1, 2}})); + EXPECT_TRUE(t.eq_both({{0, 1, 0, 1}, {1, 2, 1, 2}})); } } -TEST_CASE("left_join") { +TEST(join, left_join) { { tester t{{}, {}}; utl::left_join(t.a_, t.b_, t.cb_both(), t.cb_a()); - CHECK(t.eq_a({})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({})); + EXPECT_TRUE(t.eq_both({})); } { tester t{{1}, {1}}; utl::left_join(t.a_, t.b_, t.cb_both(), t.cb_a()); - CHECK(t.eq_a({})); - CHECK(t.eq_both({{0, 1, 0, 1}})); + EXPECT_TRUE(t.eq_a({})); + EXPECT_TRUE(t.eq_both({{0, 1, 0, 1}})); } { tester t{{0, 1}, {1}}; utl::left_join(t.a_, t.b_, t.cb_both(), t.cb_a()); - CHECK(t.eq_a({{0, 1}})); - CHECK(t.eq_both({{1, 2, 0, 1}})); + EXPECT_TRUE(t.eq_a({{0, 1}})); + EXPECT_TRUE(t.eq_both({{1, 2, 0, 1}})); } { tester t{{0, 1, 2}, {2}}; utl::left_join(t.a_, t.b_, t.cb_both(), t.cb_a()); - CHECK(t.eq_a({{0, 1}, {1, 2}})); - CHECK(t.eq_both({{2, 3, 0, 1}})); + EXPECT_TRUE(t.eq_a({{0, 1}, {1, 2}})); + EXPECT_TRUE(t.eq_both({{2, 3, 0, 1}})); } { tester t{{1, 2, 3, 4}, {1}}; utl::left_join(t.a_, t.b_, t.cb_both(), t.cb_a()); - CHECK(t.eq_a({{1, 2}, {2, 3}, {3, 4}})); - CHECK(t.eq_both({{0, 1, 0, 1}})); + EXPECT_TRUE(t.eq_a({{1, 2}, {2, 3}, {3, 4}})); + EXPECT_TRUE(t.eq_both({{0, 1, 0, 1}})); } { tester t{{1, 2, 2, 3, 5}, {1, 5}}; utl::left_join(t.a_, t.b_, t.cb_both(), t.cb_a()); - CHECK(t.eq_a({{1, 3}, {3, 4}})); - CHECK(t.eq_both({{0, 1, 0, 1}, {4, 5, 1, 2}})); + EXPECT_TRUE(t.eq_a({{1, 3}, {3, 4}})); + EXPECT_TRUE(t.eq_both({{0, 1, 0, 1}, {4, 5, 1, 2}})); } { tester t{{3}, {2}}; utl::left_join(t.a_, t.b_, t.cb_both(), t.cb_a()); - CHECK(t.eq_a({{0, 1}})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({{0, 1}})); + EXPECT_TRUE(t.eq_both({})); } { @@ -185,89 +185,89 @@ TEST_CASE("left_join") { utl::left_join( t.a_, t.b_, [](auto const& lhs, auto const& rhs) { return lhs > rhs; }, t.cb_both(), t.cb_a()); - CHECK(t.eq_a({{0, 1}})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({{0, 1}})); + EXPECT_TRUE(t.eq_both({})); } } -TEST_CASE("full_join") { +TEST(join, full_join) { { tester t{{}, {}}; utl::full_join(t.a_, t.b_, t.cb_both(), t.cb_a(), t.cb_b()); - CHECK(t.eq_a({})); - CHECK(t.eq_b({})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({})); + EXPECT_TRUE(t.eq_b({})); + EXPECT_TRUE(t.eq_both({})); } { tester t{{1}, {1}}; utl::full_join(t.a_, t.b_, t.cb_both(), t.cb_a(), t.cb_b()); - CHECK(t.eq_a({})); - CHECK(t.eq_b({})); - CHECK(t.eq_both({{0, 1, 0, 1}})); + EXPECT_TRUE(t.eq_a({})); + EXPECT_TRUE(t.eq_b({})); + EXPECT_TRUE(t.eq_both({{0, 1, 0, 1}})); } { tester t{{2}, {3}}; utl::full_join(t.a_, t.b_, t.cb_both(), t.cb_a(), t.cb_b()); - CHECK(t.eq_a({{0, 1}})); - CHECK(t.eq_b({{0, 1}})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({{0, 1}})); + EXPECT_TRUE(t.eq_b({{0, 1}})); + EXPECT_TRUE(t.eq_both({})); } { tester t{{1}, {}}; utl::full_join(t.a_, t.b_, t.cb_both(), t.cb_a(), t.cb_b()); - CHECK(t.eq_a({{0, 1}})); - CHECK(t.eq_b({})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({{0, 1}})); + EXPECT_TRUE(t.eq_b({})); + EXPECT_TRUE(t.eq_both({})); } { tester t{{}, {1}}; utl::full_join(t.a_, t.b_, t.cb_both(), t.cb_a(), t.cb_b()); - CHECK(t.eq_a({})); - CHECK(t.eq_b({{0, 1}})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({})); + EXPECT_TRUE(t.eq_b({{0, 1}})); + EXPECT_TRUE(t.eq_both({})); } { tester t{{}, {1, 2}}; utl::full_join(t.a_, t.b_, t.cb_both(), t.cb_a(), t.cb_b()); - CHECK(t.eq_a({})); - CHECK(t.eq_b({{0, 1}, {1, 2}})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({})); + EXPECT_TRUE(t.eq_b({{0, 1}, {1, 2}})); + EXPECT_TRUE(t.eq_both({})); } { tester t{{}, {1, 2, 2}}; utl::full_join(t.a_, t.b_, t.cb_both(), t.cb_a(), t.cb_b()); - CHECK(t.eq_a({})); - CHECK(t.eq_b({{0, 1}, {1, 3}})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({})); + EXPECT_TRUE(t.eq_b({{0, 1}, {1, 3}})); + EXPECT_TRUE(t.eq_both({})); } { tester t{{3}, {1, 2}}; utl::full_join(t.a_, t.b_, t.cb_both(), t.cb_a(), t.cb_b()); - CHECK(t.eq_a({{0, 1}})); - CHECK(t.eq_b({{0, 1}, {1, 2}})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({{0, 1}})); + EXPECT_TRUE(t.eq_b({{0, 1}, {1, 2}})); + EXPECT_TRUE(t.eq_both({})); } { tester t{{3}, {1, 1, 2}}; utl::full_join(t.a_, t.b_, t.cb_both(), t.cb_a(), t.cb_b()); - CHECK(t.eq_a({{0, 1}})); - CHECK(t.eq_b({{0, 2}, {2, 3}})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({{0, 1}})); + EXPECT_TRUE(t.eq_b({{0, 2}, {2, 3}})); + EXPECT_TRUE(t.eq_both({})); } { tester t{{2, 4}, {1, 3, 5}}; utl::full_join(t.a_, t.b_, t.cb_both(), t.cb_a(), t.cb_b()); - CHECK(t.eq_a({{0, 1}, {1, 2}})); - CHECK(t.eq_b({{0, 1}, {1, 2}, {2, 3}})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({{0, 1}, {1, 2}})); + EXPECT_TRUE(t.eq_b({{0, 1}, {1, 2}, {2, 3}})); + EXPECT_TRUE(t.eq_both({})); } { tester t{{2, 8}, {1, 3, 3, 4, 4, 5}}; utl::full_join(t.a_, t.b_, t.cb_both(), t.cb_a(), t.cb_b()); - CHECK(t.eq_a({{0, 1}, {1, 2}})); - CHECK(t.eq_b({{0, 1}, {1, 3}, {3, 5}, {5, 6}})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({{0, 1}, {1, 2}})); + EXPECT_TRUE(t.eq_b({{0, 1}, {1, 3}, {3, 5}, {5, 6}})); + EXPECT_TRUE(t.eq_both({})); } { @@ -275,8 +275,8 @@ TEST_CASE("full_join") { utl::full_join( t.a_, t.b_, [](auto const& lhs, auto const& rhs) { return lhs > rhs; }, t.cb_both(), t.cb_a(), t.cb_b()); - CHECK(t.eq_a({{0, 1}})); - CHECK(t.eq_b({{0, 1}})); - CHECK(t.eq_both({})); + EXPECT_TRUE(t.eq_a({{0, 1}})); + EXPECT_TRUE(t.eq_b({{0, 1}})); + EXPECT_TRUE(t.eq_both({})); } } diff --git a/test/match_test.cc b/test/match_test.cc index 5ab35df..accca1d 100644 --- a/test/match_test.cc +++ b/test/match_test.cc @@ -1,4 +1,4 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/match.h" @@ -21,12 +21,12 @@ struct sub_class_3 : public parent { int z_{}; }; -TEST_CASE("match") { +TEST(match, match) { auto obj = sub_class_2{}; obj.y_ = 77; - CHECK(utl::match( - reinterpret_cast(&obj), - [](sub_class_1 const* el) { return el->x_; }, - [](sub_class_2 const* el) { return el->y_; }, - [](sub_class_3 const* el) { return el->z_; }) == 77); + EXPECT_TRUE(utl::match( + reinterpret_cast(&obj), + [](sub_class_1 const* el) { return el->x_; }, + [](sub_class_2 const* el) { return el->y_; }, + [](sub_class_3 const* el) { return el->z_; }) == 77); } diff --git a/test/pairwise_test.cc b/test/pairwise_test.cc index 9135b78..db1812e 100644 --- a/test/pairwise_test.cc +++ b/test/pairwise_test.cc @@ -1,8 +1,8 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/pairwise.h" -TEST_CASE("pairwise") { +TEST(pairwise, pairwise) { struct obj { obj() = default; obj(int payload) : payload_{payload} {} // NOLINT @@ -31,34 +31,34 @@ TEST_CASE("pairwise") { std::array sut{}; std::string const expected; auto const actual = consume_pairwise(utl::pairwise(sut)); - CHECK(expected == actual); + EXPECT_TRUE(expected == actual); } { std::array sut{{1}}; std::string const expected; auto const actual = consume_pairwise(utl::pairwise(sut)); - CHECK(expected == actual); + EXPECT_TRUE(expected == actual); } { std::array sut{{1, 2}}; std::string const expected = "1,2;"; auto const actual = consume_pairwise(utl::pairwise(sut)); - CHECK(expected == actual); + EXPECT_TRUE(expected == actual); } { std::array sut{{1, 2, 3}}; std::string const expected = "1,2;2,3;"; auto const actual = consume_pairwise(utl::pairwise(sut)); - CHECK(expected == actual); + EXPECT_TRUE(expected == actual); } { std::array sut{{1, 2, 3, 4}}; std::string const expected = "1,2;2,3;3,4;"; auto const actual = consume_pairwise(utl::pairwise(sut)); - CHECK(expected == actual); + EXPECT_TRUE(expected == actual); } } diff --git a/test/parser/arg_parser_test.cc b/test/parser/arg_parser_test.cc index 77cd102..1423026 100644 --- a/test/parser/arg_parser_test.cc +++ b/test/parser/arg_parser_test.cc @@ -1,239 +1,239 @@ #include -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/parser/arg_parser.h" #include "utl/parser/csv.h" using namespace utl; -TEST_CASE("parse_int") { +TEST(arg_parser, parse_int) { cstr s = "33.7994;77"; int i{}; bool ok = parse_arg(s, i); - REQUIRE(!ok); - REQUIRE(s.len == 8); - REQUIRE(i == 33); + ASSERT_TRUE(!ok); + ASSERT_TRUE(s.len == 8); + ASSERT_TRUE(i == 33); } -TEST_CASE("parse_int_str_end") { +TEST(arg_parser, parse_int_str_end) { cstr s = "33"; int i{}; bool ok = parse_arg(s, i); - REQUIRE(ok); - REQUIRE(s.len == 0); - REQUIRE(i == 33); + ASSERT_TRUE(ok); + ASSERT_TRUE(s.len == 0); + ASSERT_TRUE(i == 33); } -TEST_CASE("parse_negative_int") { +TEST(arg_parser, parse_negative_int) { cstr s = "-33.7994;77"; int i{}; parse_arg(s, i); - REQUIRE(s.len == 8); - REQUIRE(i == -33); + ASSERT_TRUE(s.len == 8); + ASSERT_TRUE(i == -33); } -TEST_CASE("parse_int_default_default_value") { +TEST(arg_parser, parse_int_default_default_value) { cstr s = "a-33.7994;77"; int i{}; bool ok = parse_arg(s, i); - REQUIRE(!ok); - REQUIRE(s.len == 12); - REQUIRE(i == 0); + ASSERT_TRUE(!ok); + ASSERT_TRUE(s.len == 12); + ASSERT_TRUE(i == 0); } -TEST_CASE("parse_int_different_default_value") { +TEST(arg_parser, parse_int_different_default_value) { cstr s = "a-33.7994;77"; int i{}; bool ok = parse_arg(s, i, -1); - REQUIRE(!ok); - REQUIRE(s.len == 12); - REQUIRE(i == -1); + ASSERT_TRUE(!ok); + ASSERT_TRUE(s.len == 12); + ASSERT_TRUE(i == -1); } -TEST_CASE("parse_int_different_default_value_sign") { +TEST(arg_parser, parse_int_different_default_value_sign) { cstr s = "-a33.7994;77"; int i{}; parse_arg(s, i, -1); - REQUIRE(s.len == 11); - REQUIRE(i == -1); + ASSERT_TRUE(s.len == 11); + ASSERT_TRUE(i == -1); } -TEST_CASE("parse_string") { +TEST(arg_parser, parse_string) { cstr s = "hello,world"; std::string string1; std::string string2; parse_column(s, string1); - REQUIRE(s.len == 6); + ASSERT_TRUE(s.len == 6); ++s; - REQUIRE(s.len == 5); + ASSERT_TRUE(s.len == 5); parse_column(s, string2); - REQUIRE(string1 == "hello"); - REQUIRE(string2 == "world"); + ASSERT_TRUE(string1 == "hello"); + ASSERT_TRUE(string2 == "world"); } -TEST_CASE("parse_string_str_end") { +TEST(arg_parser, parse_string_str_end) { cstr s = "hello"; std::string string; parse_column(s, string); - REQUIRE(s.len == 0); - REQUIRE(string == "hello"); + ASSERT_TRUE(s.len == 0); + ASSERT_TRUE(string == "hello"); } -TEST_CASE("parse_string_\"") { +TEST(arg_parser, parse_string_quote) { cstr s = R"("hello","world")"; std::string string1; std::string string2; parse_column(s, string1); - REQUIRE(s.len == 8); - REQUIRE(*s.str == ','); + ASSERT_TRUE(s.len == 8); + ASSERT_TRUE(*s.str == ','); ++s; - REQUIRE(s.len == 7); + ASSERT_TRUE(s.len == 7); parse_column(s, string2); - REQUIRE(string1 == "hello"); - REQUIRE(string2 == "world"); + ASSERT_TRUE(string1 == "hello"); + ASSERT_TRUE(string2 == "world"); } -TEST_CASE("parse_string_str_\"_end") { +TEST(arg_parser, parse_string_str_quote_end) { cstr s = "\"hello\""; std::string string; parse_column(s, string); - REQUIRE(s.len == 0); - REQUIRE(string == "hello"); + ASSERT_TRUE(s.len == 0); + ASSERT_TRUE(string == "hello"); } -TEST_CASE("parse_string_str_missing_\"_end") { +TEST(arg_parser, parse_string_str_missing_quote_end) { cstr s = "\"hello"; std::string string; parse_column(s, string); - REQUIRE(s.len == 0); + ASSERT_TRUE(s.len == 0); } -TEST_CASE("parse_float") { +TEST(arg_parser, parse_float) { cstr s = "33.7994;77"; float f{}; parse_arg(s, f); - REQUIRE(s.len == 3); - REQUIRE(*s.str == ';'); + ASSERT_TRUE(s.len == 3); + ASSERT_TRUE(*s.str == ';'); float target = 33.7994F; - REQUIRE(std::abs(f - target) < 0.001); + ASSERT_TRUE(std::abs(f - target) < 0.001); } -TEST_CASE("parse_negative_float") { +TEST(arg_parser, parse_negative_float) { cstr s = "-33.7894,\""; float f{}; parse_arg(s, f); - REQUIRE(s.len == 2); - REQUIRE(*s.str == ','); + ASSERT_TRUE(s.len == 2); + ASSERT_TRUE(*s.str == ','); float target = -33.7894F; - REQUIRE(std::abs(f - target) < 0.001); + ASSERT_TRUE(std::abs(f - target) < 0.001); } -TEST_CASE("parse_float_str_end") { +TEST(arg_parser, parse_float_str_end) { cstr s = "33.7994"; float f{}; parse_arg(s, f); - REQUIRE(s.len == 0); + ASSERT_TRUE(s.len == 0); float target = 33.7994F; - REQUIRE(std::abs(f - target) < 0.001); + ASSERT_TRUE(std::abs(f - target) < 0.001); } -TEST_CASE("parse_negative_float_str_end") { +TEST(arg_parser, parse_negative_float_str_end) { cstr s = "-33.7894"; float f{}; parse_arg(s, f); - REQUIRE(s.len == 0); + ASSERT_TRUE(s.len == 0); float target = -33.7894F; - REQUIRE(std::abs(f - target) < 0.001); + ASSERT_TRUE(std::abs(f - target) < 0.001); } -TEST_CASE("parse_bool_false") { +TEST(arg_parser, parse_bool_false) { cstr s = "false"; bool b = true; parse_arg(s, b); - REQUIRE(!b); + ASSERT_TRUE(!b); } -TEST_CASE("parse_bool_true") { +TEST(arg_parser, parse_bool_true) { cstr s = "true"; bool b = false; parse_arg(s, b); - REQUIRE(b); + ASSERT_TRUE(b); } -TEST_CASE("parse_bool_falsy") { +TEST(arg_parser, parse_bool_falsy) { cstr s = "f.."; bool b = true; parse_arg(s, b); - REQUIRE(!b); - REQUIRE(s.len == 0); + ASSERT_TRUE(!b); + ASSERT_TRUE(s.len == 0); } -TEST_CASE("parse_bool_truey") { +TEST(arg_parser, parse_bool_truey) { cstr s = "t.."; bool b = false; auto ok = parse_arg(s, b); - REQUIRE(!ok); - REQUIRE(b); - REQUIRE(s.len == 0); + ASSERT_TRUE(!ok); + ASSERT_TRUE(b); + ASSERT_TRUE(s.len == 0); } -TEST_CASE("parse_bool_true_seperator") { +TEST(arg_parser, parse_bool_true_seperator) { cstr s = "true,next"; bool b = false; auto ok = parse_arg(s, b); - REQUIRE(!ok); - REQUIRE(b); - REQUIRE(s.len == 5); + ASSERT_TRUE(!ok); + ASSERT_TRUE(b); + ASSERT_TRUE(s.len == 5); } -TEST_CASE("parse_bool_false_seperator") { +TEST(arg_parser, parse_bool_false_seperator) { cstr s = "false,next"; bool b = true; parse_arg(s, b); - REQUIRE(!b); - REQUIRE(s.len == 5); + ASSERT_TRUE(!b); + ASSERT_TRUE(s.len == 5); } -TEST_CASE("parse_bool_exact_true") { +TEST(arg_parser, parse_bool_exact_true) { bool x = false; auto s = cstr{"true"}; - REQUIRE(parse_arg(s, x)); - REQUIRE(x == true); + ASSERT_TRUE(parse_arg(s, x)); + ASSERT_TRUE(x == true); } -TEST_CASE("parse_bool_exact_false") { +TEST(arg_parser, parse_bool_exact_false) { bool x = false; auto s = cstr{"false"}; - REQUIRE(parse_arg(s, x)); - REQUIRE(x == false); + ASSERT_TRUE(parse_arg(s, x)); + ASSERT_TRUE(x == false); } -TEST_CASE("parse_int_substr") { +TEST(arg_parser, parse_int_substr) { cstr s = "123456"; int a{}; auto sub = s.substr(2, 4); sub >> a; - REQUIRE(a == 34); + ASSERT_TRUE(a == 34); } diff --git a/test/parser/cstr_cr_test.cc b/test/parser/cstr_cr_test.cc index 9012181..d829714 100644 --- a/test/parser/cstr_cr_test.cc +++ b/test/parser/cstr_cr_test.cc @@ -1,4 +1,4 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/enumerate.h" #include "utl/parser/cstr.h" @@ -25,174 +25,180 @@ constexpr char const* empty_line_between_lines[] = {"1", "", "2"}; constexpr char const* empty_line_between_no_end = "1\r\n\n2"; constexpr char const* empty_line_between_no_end_lines[] = {"1", "", "2"}; -TEST_CASE("line iterator test") { +TEST(cstr_cr_test, line_iterator_test) { line_iterator it{empty_line_between_no_end}; line_iterator end; - REQUIRE(it != end); - REQUIRE(*it == empty_line_between_no_end_lines[0]); + ASSERT_TRUE(it != end); + ASSERT_TRUE(*it == empty_line_between_no_end_lines[0]); ++it; - REQUIRE(it != end); - REQUIRE(*it == empty_line_between_no_end_lines[1]); + ASSERT_TRUE(it != end); + ASSERT_TRUE(*it == empty_line_between_no_end_lines[1]); ++it; - REQUIRE(it != end); - REQUIRE(*it == empty_line_between_no_end_lines[2]); + ASSERT_TRUE(it != end); + ASSERT_TRUE(*it == empty_line_between_no_end_lines[2]); ++it; - REQUIRE(it == end); + ASSERT_TRUE(it == end); } -TEST_CASE("get_line_cr") { +TEST(cstr_cr_test, get_line_cr) { cstr str = one_line; auto line = get_line(str); - REQUIRE(line.len == 1); - REQUIRE(std::strncmp(line.str, "1", 1) == 0); - REQUIRE(std::strlen(line.str) == 3); + ASSERT_TRUE(line.len == 1); + ASSERT_TRUE(std::strncmp(line.str, "1", 1) == 0); + ASSERT_TRUE(std::strlen(line.str) == 3); } -TEST_CASE("one_line_cr") { +TEST(cstr_cr_test, one_line_cr) { int i = 0; for_each_line(one_line, [&](cstr line) { - REQUIRE(std::strncmp(line.str, one_line_lines[i++], line.len) // NOLINT - == 0); + ASSERT_TRUE(std::strncmp(line.str, one_line_lines[i++], line.len) // NOLINT + == 0); }); - REQUIRE(i == 1); + ASSERT_TRUE(i == 1); i = 0; for (auto const [idx, line] : enumerate(lines{one_line})) { - REQUIRE(std::strncmp(line.str, one_line_lines[idx], line.len) // NOLINT - == 0); + ASSERT_TRUE(std::strncmp(line.str, one_line_lines[idx], line.len) // NOLINT + == 0); ++i; } - REQUIRE(i == 1); + ASSERT_TRUE(i == 1); } -TEST_CASE("one_line_no_end_cr") { +TEST(cstr_cr_test, one_line_no_end_cr) { int i = 0; for_each_line(one_line_no_end, [&](cstr line) { - REQUIRE( + ASSERT_TRUE( std::strncmp(line.str, one_line_no_end_lines[i++], line.len) // NOLINT == 0); }); - REQUIRE(i == 1); + ASSERT_TRUE(i == 1); i = 0; for (auto const [idx, line] : enumerate(lines{one_line_no_end})) { - REQUIRE( + ASSERT_TRUE( std::strncmp(line.str, one_line_no_end_lines[idx], line.len) // NOLINT == 0); ++i; } - REQUIRE(i == 1); + ASSERT_TRUE(i == 1); } -TEST_CASE("two_lines_cr") { +TEST(cstr_cr_test, two_lines_cr) { int i = 0; for_each_line(two_lines, [&](cstr line) { - REQUIRE(std::strncmp(line.str, two_lines_lines[i++], line.len) // NOLINT - == 0); + ASSERT_TRUE( + std::strncmp(line.str, two_lines_lines[i++], line.len) // NOLINT + == 0); }); - REQUIRE(i == 2); + ASSERT_TRUE(i == 2); i = 0; for (auto const [idx, line] : enumerate(lines{two_lines})) { - REQUIRE(std::strncmp(line.str, two_lines_lines[idx], line.len) // NOLINT - == 0); + ASSERT_TRUE( + std::strncmp(line.str, two_lines_lines[idx], line.len) // NOLINT + == 0); ++i; } - REQUIRE(i == 2); + ASSERT_TRUE(i == 2); } -TEST_CASE("empty_line_cr") { +TEST(cstr_cr_test, empty_line_cr) { int i = 0; for_each_line(empty_line, [&](cstr line) { - REQUIRE(std::strncmp(line.str, empty_line_lines[i++], line.len) // NOLINT - == 0); + ASSERT_TRUE( + std::strncmp(line.str, empty_line_lines[i++], line.len) // NOLINT + == 0); }); - REQUIRE(i == 1); + ASSERT_TRUE(i == 1); i = 0; for (auto const [idx, line] : enumerate(lines{empty_line})) { - REQUIRE(std::strncmp(line.str, empty_line_lines[idx], line.len) // NOLINT - == 0); + ASSERT_TRUE( + std::strncmp(line.str, empty_line_lines[idx], line.len) // NOLINT + == 0); ++i; } - REQUIRE(i == 1); + ASSERT_TRUE(i == 1); } -TEST_CASE("empty_string_cr") { +TEST(cstr_cr_test, empty_string_cr) { int i = 0; for_each_line(empty_string, [&](cstr) { i++; }); - REQUIRE(i == 0); + ASSERT_TRUE(i == 0); for (auto const entry : enumerate(lines{empty_string})) { (void)entry; - REQUIRE(false); + ASSERT_TRUE(false); } } -TEST_CASE("empty_line_between_cr") { +TEST(cstr_cr_test, empty_line_between_cr) { int i = 0; for_each_line(empty_line_between, [&](cstr line) { - REQUIRE(std::strncmp(line.str, empty_line_between_lines[i++], // NOLINT - line.len) == 0); + ASSERT_TRUE(std::strncmp(line.str, empty_line_between_lines[i++], // NOLINT + line.len) == 0); }); - REQUIRE(i == 3); + ASSERT_TRUE(i == 3); i = 0; for (auto const [idx, line] : enumerate(lines{empty_line_between})) { - REQUIRE(std::strncmp(line.str, empty_line_between_lines[idx], // NOLINT - line.len) == 0); + ASSERT_TRUE(std::strncmp(line.str, empty_line_between_lines[idx], // NOLINT + line.len) == 0); ++i; } - REQUIRE(i == 3); + ASSERT_TRUE(i == 3); } -TEST_CASE("empty_line_between_no_end_cr") { +TEST(cstr_cr_test, empty_line_between_no_end_cr) { int i = 0; for_each_line(empty_line_between, [&](cstr line) { - REQUIRE(std::strncmp(line.str, // NOLINT - empty_line_between_no_end_lines[i++], line.len) == 0); + ASSERT_TRUE(std::strncmp(line.str, // NOLINT + empty_line_between_no_end_lines[i++], + line.len) == 0); }); - REQUIRE(i == 3); + ASSERT_TRUE(i == 3); i = 0; for (auto const [idx, line] : enumerate(lines{empty_line_between_no_end})) { - REQUIRE(std::strncmp(line.str, // NOLINT - empty_line_between_no_end_lines[idx], line.len) == 0); + ASSERT_TRUE(std::strncmp(line.str, // NOLINT + empty_line_between_no_end_lines[idx], + line.len) == 0); ++i; } - REQUIRE(i == 3); + ASSERT_TRUE(i == 3); } -TEST_CASE("substr_len_begin_cr") { +TEST(cstr_cr_test, substr_len_begin_cr) { cstr s = "abc"; - REQUIRE(s.substr(0, size(2)) == "ab"); - REQUIRE(s.substr(0, size(2)).len == 2); - REQUIRE(s.substr(0, size(2)).str == s.str); + ASSERT_TRUE(s.substr(0, size(2)) == "ab"); + ASSERT_TRUE(s.substr(0, size(2)).len == 2); + ASSERT_TRUE(s.substr(0, size(2)).str == s.str); } -TEST_CASE("substr_len_middle_cr") { +TEST(cstr_cr_test, substr_len_middle_cr) { cstr s = "abc"; - REQUIRE(s.substr(1, size(1)) == "b"); - REQUIRE(s.substr(1, size(1)).len == 1); - REQUIRE(s.substr(1, size(1)).str == s.str + 1); + ASSERT_TRUE(s.substr(1, size(1)) == "b"); + ASSERT_TRUE(s.substr(1, size(1)).len == 1); + ASSERT_TRUE(s.substr(1, size(1)).str == s.str + 1); } -TEST_CASE("substr_pos_begin_cr") { +TEST(cstr_cr_test, substr_pos_begin_cr) { cstr s = "abc"; - REQUIRE(s.substr(0, 2) == "ab"); - REQUIRE(s.substr(0, 2).len == 2); - REQUIRE(s.substr(0, 2).str == s.str); + ASSERT_TRUE(s.substr(0, 2) == "ab"); + ASSERT_TRUE(s.substr(0, 2).len == 2); + ASSERT_TRUE(s.substr(0, 2).str == s.str); } -TEST_CASE("substr_pos_middle_cr") { +TEST(cstr_cr_test, substr_pos_middle_cr) { cstr s = "abc"; - REQUIRE(s.substr(1, 2) == "b"); - REQUIRE(s.substr(1, 2).len == 1); - REQUIRE(s.substr(1, 2).str == s.str + 1); + ASSERT_TRUE(s.substr(1, 2) == "b"); + ASSERT_TRUE(s.substr(1, 2).len == 1); + ASSERT_TRUE(s.substr(1, 2).str == s.str + 1); } } // namespace utl::cstr_cr_test diff --git a/test/parser/cstr_test.cc b/test/parser/cstr_test.cc index 4fcab46..d0fab20 100644 --- a/test/parser/cstr_test.cc +++ b/test/parser/cstr_test.cc @@ -1,4 +1,4 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/parser/cstr.h" @@ -24,114 +24,118 @@ constexpr char const* empty_line_between_lines[] = {"1", "", "2"}; constexpr char const* empty_line_between_no_end = "1\n\n2"; constexpr char const* empty_line_between_no_end_lines[] = {"1", "", "2"}; -TEST_CASE("substr overflow") { +TEST(cstr_test, substr_overflow) { cstr s = "012345678"; - REQUIRE(s.substr(10, 12).len == 0U); - REQUIRE(s.substr(5, 10) == cstr{"5678"}); - REQUIRE(s.substr(5, 10).len == 4); + ASSERT_TRUE(s.substr(10, 12).len == 0U); + ASSERT_TRUE(s.substr(5, 10) == cstr{"5678"}); + ASSERT_TRUE(s.substr(5, 10).len == 4); - REQUIRE(s.substr(10, size{2}).len == 0U); - REQUIRE(s.substr(5, size{5}) == cstr{"5678"}); - REQUIRE(s.substr(5, size{5}).len == 4); + ASSERT_TRUE(s.substr(10, size{2}).len == 0U); + ASSERT_TRUE(s.substr(5, size{5}) == cstr{"5678"}); + ASSERT_TRUE(s.substr(5, size{5}).len == 4); } -TEST_CASE("get_line") { +TEST(cstr_test, get_line) { cstr str = one_line; auto line = get_line(str); - REQUIRE(line.len == 1); - REQUIRE(std::strncmp(line.str, "1", 1) == 0); - REQUIRE(std::strlen(line.str) == 2); + ASSERT_TRUE(line.len == 1); + ASSERT_TRUE(std::strncmp(line.str, "1", 1) == 0); + ASSERT_TRUE(std::strlen(line.str) == 2); } -TEST_CASE("one_line") { +TEST(cstr_test, one_line) { int i = 0; for_each_line(one_line, [&](cstr line) { - REQUIRE(i < 2); - REQUIRE(std::strncmp(line.str, one_line_lines[i++], line.len) == // NOLINT - 0); + ASSERT_TRUE(i < 2); + ASSERT_TRUE( + std::strncmp(line.str, one_line_lines[i++], line.len) == // NOLINT + 0); }); - REQUIRE(i == 1); + ASSERT_TRUE(i == 1); } -TEST_CASE("one_line_no_end") { +TEST(cstr_test, one_line_no_end) { int i = 0; for_each_line(one_line_no_end, [&](cstr line) { - REQUIRE( + ASSERT_TRUE( std::strncmp(line.str, one_line_no_end_lines[i++], line.len) // NOLINT == 0); }); - REQUIRE(i == 1); + ASSERT_TRUE(i == 1); } -TEST_CASE("two_lines") { +TEST(cstr_test, two_lines) { int i = 0; for_each_line(two_lines, [&](cstr line) { - REQUIRE(std::strncmp(line.str, two_lines_lines[i++], line.len) // NOLINT - == 0); + ASSERT_TRUE( + std::strncmp(line.str, two_lines_lines[i++], line.len) // NOLINT + == 0); }); - REQUIRE(i == 2); + ASSERT_TRUE(i == 2); } -TEST_CASE("empty_line") { +TEST(cstr_test, empty_line) { int i = 0; for_each_line(empty_line, [&](cstr line) { - REQUIRE(std::strncmp(line.str, empty_line_lines[i++], line.len) // NOLINT - == 0); + ASSERT_TRUE( + std::strncmp(line.str, empty_line_lines[i++], line.len) // NOLINT + == 0); }); - REQUIRE(i == 1); + ASSERT_TRUE(i == 1); } -TEST_CASE("empty_string") { +TEST(cstr_test, empty_string) { int i = 0; for_each_line(empty_string, [&](cstr) { ++i; }); - REQUIRE(i == 0); + ASSERT_TRUE(i == 0); } -TEST_CASE("empty_line_between") { +TEST(cstr_test, empty_line_between) { int i = 0; for_each_line(empty_line_between, [&](cstr line) { - REQUIRE(std::strncmp(line.str, empty_line_between_lines[i++], // NOLINT - line.len) == 0); + ASSERT_TRUE(std::strncmp(line.str, empty_line_between_lines[i++], // NOLINT + line.len) == 0); }); - REQUIRE(i == 3); + ASSERT_TRUE(i == 3); } -TEST_CASE("empty_line_between_no_end") { +TEST(cstr_test, empty_line_between_no_end) { int i = 0; for_each_line(empty_line_between_no_end, [&](cstr line) { - REQUIRE(std::strncmp(line.str, // NOLINT - empty_line_between_no_end_lines[i++], line.len) == 0); + ASSERT_TRUE(std::strncmp(line.str, // NOLINT + empty_line_between_no_end_lines[i++], + line.len) == 0); }); - REQUIRE(i == 3); + ASSERT_TRUE(i == 3); } -TEST_CASE("substr_len_begin") { +TEST(cstr_test, substr_len_begin) { cstr s = "abc"; - REQUIRE(s.substr(0, size(2)) == "ab"); - REQUIRE(s.substr(0, size(2)).len == 2); - REQUIRE(s.substr(0, size(2)).str == s.str); + ASSERT_TRUE(s.substr(0, size(2)) == "ab"); + ASSERT_TRUE(s.substr(0, size(2)).len == 2); + ASSERT_TRUE(s.substr(0, size(2)).str == s.str); } -TEST_CASE("substr_len_middle") { +TEST(cstr_test, substr_len_middle) { cstr s = "abc"; - REQUIRE(s.substr(1, size(1)) == "b"); - REQUIRE(s.substr(1, size(1)).len == 1); - REQUIRE(s.substr(1, size(1)).str == s.str + 1); + ASSERT_TRUE(s.substr(1, size(1)) == "b"); + ASSERT_TRUE(s.substr(1, size(1)).len == 1); + ASSERT_TRUE(s.substr(1, size(1)).str == s.str + 1); } -TEST_CASE("sbustr_pos_begin") { +TEST(cstr_test, sbustr_pos_begin) { cstr s = "abc"; - REQUIRE(s.substr(0, 2) == "ab"); - REQUIRE(s.substr(0, 2).len == 2); - REQUIRE(s.substr(0, 2).str == s.str); + ASSERT_TRUE(s.substr(0, 2) == "ab"); + ASSERT_TRUE(s.substr(0, 2).len == 2); + ASSERT_TRUE(s.substr(0, 2).str == s.str); } -TEST_CASE("sbustr_pos_middle") { +TEST(cstr_test, sbustr_pos_middle) { cstr s = "abc"; - REQUIRE(s.substr(1, 2) == "b"); - REQUIRE(s.substr(1, 2).len == 1); - REQUIRE(s.substr(1, 2).str == s.str + 1); + ASSERT_TRUE(s.substr(1, 2) == "b"); + ASSERT_TRUE(s.substr(1, 2).len == 1); + ASSERT_TRUE(s.substr(1, 2).str == s.str + 1); } } // namespace utl::cstr_test diff --git a/test/parser/csv_cr_test.cc b/test/parser/csv_cr_test.cc index b878663..f599943 100644 --- a/test/parser/csv_cr_test.cc +++ b/test/parser/csv_cr_test.cc @@ -1,4 +1,4 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/parser/csv.h" @@ -18,12 +18,12 @@ cstr const csv_file_semicolon = "2;78;3;57.0;\"world\";true\r\n" "\r\n"; -TEST_CASE("simple_csv_cr") { +TEST(csv_cr_test, simple_csv_cr) { using entry = std::tuple; std::vector entries; read(csv_file, entries, {{"index", "weight", "enabled"}}); - REQUIRE(entries.size() == 3); + ASSERT_TRUE(entries.size() == 3); std::array indices = {{0, 1, 2}}; std::array weights = {{55.2, 56.9, 57}}; @@ -31,20 +31,20 @@ TEST_CASE("simple_csv_cr") { auto i = 0U; for (auto const& r : entries) { - REQUIRE(std::get<0>(r) == indices[i]); - REQUIRE(std::abs(std::get<1>(r) - weights[i]) < 0.001); - REQUIRE(std::get<2>(r) == enabled[i]); + ASSERT_TRUE(std::get<0>(r) == indices[i]); + ASSERT_TRUE(std::abs(std::get<1>(r) - weights[i]) < 0.001); + ASSERT_TRUE(std::get<2>(r) == enabled[i]); ++i; } } -TEST_CASE("simple_csv_semicolon_seperator_cr") { +TEST(csv_cr_test, simple_csv_semicolon_seperator_cr) { using entry = std::tuple; std::vector entries; read(csv_file_semicolon, entries, {{"index", "weight", "enabled"}}); - REQUIRE(entries.size() == 3); + ASSERT_TRUE(entries.size() == 3); std::array indices = {{0, 1, 2}}; std::array weights = {{55.2, 56.9, 57}}; @@ -52,19 +52,19 @@ TEST_CASE("simple_csv_semicolon_seperator_cr") { auto i = 0U; for (auto const& r : entries) { - REQUIRE(std::get<0>(r) == indices[i]); - REQUIRE(std::abs(std::get<1>(r) - weights[i]) < 0.001); - REQUIRE(std::get<2>(r) == enabled[i]); + ASSERT_TRUE(std::get<0>(r) == indices[i]); + ASSERT_TRUE(std::abs(std::get<1>(r) - weights[i]) < 0.001); + ASSERT_TRUE(std::get<2>(r) == enabled[i]); ++i; } } -TEST_CASE("wrong_order_cr") { +TEST(csv_cr_test, wrong_order_cr) { using entry = std::tuple; std::vector entries; read(csv_file, entries, {{"enabled", "weight", "index"}}); - REQUIRE(entries.size() == 3); + ASSERT_TRUE(entries.size() == 3); std::array indices = {{0, 1, 2}}; std::array weights = {{55.2, 56.9, 57}}; @@ -72,14 +72,14 @@ TEST_CASE("wrong_order_cr") { auto i = 0U; for (auto const& r : entries) { - REQUIRE(std::get<2>(r) == indices[i]); - REQUIRE(std::abs(std::get<1>(r) - weights[i]) < 0.001); - REQUIRE(std::get<0>(r) == enabled[i]); + ASSERT_TRUE(std::get<2>(r) == indices[i]); + ASSERT_TRUE(std::abs(std::get<1>(r) - weights[i]) < 0.001); + ASSERT_TRUE(std::get<0>(r) == enabled[i]); ++i; } } -TEST_CASE("missing_selected_column_cr") { +TEST(csv_cr_test, missing_selected_column_cr) { cstr my_file = "width,height,weight,comment,enabled\r\n" "77,2,55.2,\"this is real!\",true\r\n" @@ -91,7 +91,7 @@ TEST_CASE("missing_selected_column_cr") { std::vector entries; read(my_file, entries, {{"enabled", "weight", "index"}}); - REQUIRE(entries.size() == 3); + ASSERT_TRUE(entries.size() == 3); std::array indices = {{0, 0, 0}}; std::array weights = {{55.2, 56.9, 57}}; @@ -99,14 +99,14 @@ TEST_CASE("missing_selected_column_cr") { auto i = 0U; for (auto const& r : entries) { - REQUIRE(std::get<2>(r) == indices[i]); - REQUIRE(std::abs(std::get<1>(r) - weights[i]) < 0.001); - REQUIRE(std::get<0>(r) == enabled[i]); + ASSERT_TRUE(std::get<2>(r) == indices[i]); + ASSERT_TRUE(std::abs(std::get<1>(r) - weights[i]) < 0.001); + ASSERT_TRUE(std::get<0>(r) == enabled[i]); ++i; } } -TEST_CASE("additional_column_cr") { +TEST(csv_cr_test, additional_column_cr) { cstr my_file = "width,height,weight,comment,enabled\r\n" "77,2,55.2,\"this is real!\",true,123\r\n" @@ -118,7 +118,7 @@ TEST_CASE("additional_column_cr") { std::vector entries; read(my_file, entries, {{"enabled", "weight", "index"}}); - REQUIRE(entries.size() == 3); + ASSERT_TRUE(entries.size() == 3); std::array indices = {{0, 0, 0}}; std::array weights = {{55.2, 56.9, 57}}; @@ -126,14 +126,14 @@ TEST_CASE("additional_column_cr") { auto i = 0U; for (auto const& r : entries) { - REQUIRE(std::get<2>(r) == indices[i]); - REQUIRE(std::abs(std::get<1>(r) - weights[i]) < 0.001); - REQUIRE(std::get<0>(r) == enabled[i]); + ASSERT_TRUE(std::get<2>(r) == indices[i]); + ASSERT_TRUE(std::abs(std::get<1>(r) - weights[i]) < 0.001); + ASSERT_TRUE(std::get<0>(r) == enabled[i]); ++i; } } -TEST_CASE("missing_column_bad_format_cr") { +TEST(csv_cr_test, missing_column_bad_format_cr) { cstr my_file = "width,height,weight,comment,enabled\r\n" "77,2,55.2,\"this is real!\"\r\n" @@ -145,7 +145,7 @@ TEST_CASE("missing_column_bad_format_cr") { std::vector entries; read(my_file, entries, {{"enabled", "weight", "index"}}); - REQUIRE(entries.size() == 3); + ASSERT_TRUE(entries.size() == 3); std::array indices = {{0, 0, 0}}; std::array weights = {{55.2, 56.9, 57}}; @@ -153,14 +153,14 @@ TEST_CASE("missing_column_bad_format_cr") { auto i = 0U; for (auto const& r : entries) { - REQUIRE(std::get<2>(r) == indices[i]); - REQUIRE(std::abs(std::get<1>(r) - weights[i]) < 0.001); - REQUIRE(std::get<0>(r) == enabled[i]); + ASSERT_TRUE(std::get<2>(r) == indices[i]); + ASSERT_TRUE(std::abs(std::get<1>(r) - weights[i]) < 0.001); + ASSERT_TRUE(std::get<0>(r) == enabled[i]); ++i; } } -TEST_CASE("doubles_cr") { +TEST(csv_cr_test, doubles_cr) { cstr my_file = "SENDER;RECEIVER_ID;TIME\r\n" "V1;0;0.9\r\n" @@ -181,10 +181,10 @@ TEST_CASE("doubles_cr") { dist{"V3", 1, 0.1}, dist{"V4", 0, 0.2}, dist{"V5", 3, 0.1}, dist{"V6", 1, 0.1}}}; - REQUIRE(check_dists == dists); + ASSERT_TRUE(check_dists == dists); } -TEST_CASE("empty_cr") { +TEST(csv_cr_test, empty_cr) { cstr my_file = "A:B:C\r\n" "::\r\n" @@ -203,7 +203,7 @@ TEST_CASE("empty_cr") { data{"", 0, ""}, data{"1", 2, "3"}, data{"hello", 77, "world"}}}; - REQUIRE(check_data == dists); + ASSERT_TRUE(check_data == dists); } } // namespace utl::csv_test diff --git a/test/parser/csv_test.cc b/test/parser/csv_test.cc index 6d1ab2b..a4a7b32 100644 --- a/test/parser/csv_test.cc +++ b/test/parser/csv_test.cc @@ -1,4 +1,4 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/parser/csv.h" @@ -16,12 +16,12 @@ cstr const csv_file_semicolon = R"(index;width;height;weight;comment;enabled 2;78;3;57.0;"world";true )"; -TEST_CASE("simple_csv") { +TEST(csv, simple_csv) { using entry = std::tuple; std::vector entries; read(csv_file, entries, {{"index", "weight", "enabled"}}); - REQUIRE(entries.size() == 3); + ASSERT_TRUE(entries.size() == 3); std::array indices = {{0, 1, 2}}; std::array weights = {{55.2, 56.9, 57}}; @@ -29,20 +29,20 @@ TEST_CASE("simple_csv") { auto i = 0U; for (auto const& r : entries) { - REQUIRE(std::get<0>(r) == indices[i]); - REQUIRE(std::abs(std::get<1>(r) - weights[i]) < 0.001); - REQUIRE(std::get<2>(r) == enabled[i]); + ASSERT_TRUE(std::get<0>(r) == indices[i]); + ASSERT_TRUE(std::abs(std::get<1>(r) - weights[i]) < 0.001); + ASSERT_TRUE(std::get<2>(r) == enabled[i]); ++i; } } -TEST_CASE("simple_csv_semicolon_seperator") { +TEST(csv, simple_csv_semicolon_seperator) { using entry = std::tuple; std::vector entries; read(csv_file_semicolon, entries, {{"index", "weight", "enabled"}}); - REQUIRE(entries.size() == 3); + ASSERT_TRUE(entries.size() == 3); std::array indices = {{0, 1, 2}}; std::array weights = {{55.2, 56.9, 57}}; @@ -50,19 +50,19 @@ TEST_CASE("simple_csv_semicolon_seperator") { auto i = 0U; for (auto const& r : entries) { - REQUIRE(std::get<0>(r) == indices[i]); - REQUIRE(std::abs(std::get<1>(r) - weights[i]) < 0.001); - REQUIRE(std::get<2>(r) == enabled[i]); + ASSERT_TRUE(std::get<0>(r) == indices[i]); + ASSERT_TRUE(std::abs(std::get<1>(r) - weights[i]) < 0.001); + ASSERT_TRUE(std::get<2>(r) == enabled[i]); ++i; } } -TEST_CASE("wrong_order") { +TEST(csv, wrong_order) { using entry = std::tuple; std::vector entries; read(csv_file, entries, {{"enabled", "weight", "index"}}); - REQUIRE(entries.size() == 3); + ASSERT_TRUE(entries.size() == 3); std::array indices = {{0, 1, 2}}; std::array weights = {{55.2, 56.9, 57}}; @@ -70,14 +70,14 @@ TEST_CASE("wrong_order") { auto i = 0U; for (auto const& r : entries) { - REQUIRE(std::get<2>(r) == indices[i]); - REQUIRE(std::abs(std::get<1>(r) - weights[i]) < 0.001); - REQUIRE(std::get<0>(r) == enabled[i]); + ASSERT_TRUE(std::get<2>(r) == indices[i]); + ASSERT_TRUE(std::abs(std::get<1>(r) - weights[i]) < 0.001); + ASSERT_TRUE(std::get<0>(r) == enabled[i]); ++i; } } -TEST_CASE("missing_selected_column") { +TEST(csv, missing_selected_column) { cstr my_file = R"(width,height,weight,comment,enabled 77,2,55.2,"this is real!",true 78,3,56.9,"hello",false @@ -88,7 +88,7 @@ TEST_CASE("missing_selected_column") { std::vector entries; read(my_file, entries, {{"enabled", "weight", "index"}}); - REQUIRE(entries.size() == 3); + ASSERT_TRUE(entries.size() == 3); std::array indices = {{0, 0, 0}}; std::array weights = {{55.2, 56.9, 57}}; @@ -96,14 +96,14 @@ TEST_CASE("missing_selected_column") { auto i = 0U; for (auto const& r : entries) { - REQUIRE(std::get<2>(r) == indices[i]); - REQUIRE(std::abs(std::get<1>(r) - weights[i]) < 0.001); - REQUIRE(std::get<0>(r) == enabled[i]); + ASSERT_TRUE(std::get<2>(r) == indices[i]); + ASSERT_TRUE(std::abs(std::get<1>(r) - weights[i]) < 0.001); + ASSERT_TRUE(std::get<0>(r) == enabled[i]); ++i; } } -TEST_CASE("additional_column") { +TEST(csv, additional_column) { cstr my_file = R"(width,height,weight,comment,enabled 77,2,55.2,"this is real!",true,123 78,3,56.9,"hello",false,123 @@ -114,7 +114,7 @@ TEST_CASE("additional_column") { std::vector entries; read(my_file, entries, {{"enabled", "weight", "index"}}); - REQUIRE(entries.size() == 3); + ASSERT_TRUE(entries.size() == 3); std::array indices = {{0, 0, 0}}; std::array weights = {{55.2, 56.9, 57}}; @@ -122,14 +122,14 @@ TEST_CASE("additional_column") { auto i = 0U; for (auto const& r : entries) { - REQUIRE(std::get<2>(r) == indices[i]); - REQUIRE(std::abs(std::get<1>(r) - weights[i]) < 0.001); - REQUIRE(std::get<0>(r) == enabled[i]); + ASSERT_TRUE(std::get<2>(r) == indices[i]); + ASSERT_TRUE(std::abs(std::get<1>(r) - weights[i]) < 0.001); + ASSERT_TRUE(std::get<0>(r) == enabled[i]); ++i; } } -TEST_CASE("missing_column_bad_format") { +TEST(csv, missing_column_bad_format) { cstr my_file = R"(width,height,weight,comment,enabled 77,2,55.2,"this is real!" 78,3,56.9,"hello" @@ -140,7 +140,7 @@ TEST_CASE("missing_column_bad_format") { std::vector entries; read(my_file, entries, {{"enabled", "weight", "index"}}); - REQUIRE(entries.size() == 3); + ASSERT_TRUE(entries.size() == 3); std::array indices = {{0, 0, 0}}; std::array weights = {{55.2, 56.9, 57}}; @@ -148,14 +148,14 @@ TEST_CASE("missing_column_bad_format") { auto i = 0U; for (auto const& r : entries) { - REQUIRE(std::get<2>(r) == indices[i]); - REQUIRE(std::abs(std::get<1>(r) - weights[i]) < 0.001); - REQUIRE(std::get<0>(r) == enabled[i]); + ASSERT_TRUE(std::get<2>(r) == indices[i]); + ASSERT_TRUE(std::abs(std::get<1>(r) - weights[i]) < 0.001); + ASSERT_TRUE(std::get<0>(r) == enabled[i]); ++i; } } -TEST_CASE("doubles") { +TEST(csv, doubles) { cstr my_file = R"(SENDER;RECEIVER_ID;TIME V1;0;0.9 V2;-1;0.1 @@ -175,10 +175,10 @@ V6;1;0.1)"; dist{"V3", 1, 0.1}, dist{"V4", 0, 0.2}, dist{"V5", 3, 0.1}, dist{"V6", 1, 0.1}}}; - REQUIRE(check_dists == dists); + ASSERT_TRUE(check_dists == dists); } -TEST_CASE("empty") { +TEST(csv, empty) { cstr my_file = R"(A:B:C :: :: @@ -196,10 +196,10 @@ hello:77:world)"; data{"", 0, ""}, data{"1", 2, "3"}, data{"hello", 77, "world"}}}; - REQUIRE(check_data == dists); + ASSERT_TRUE(check_data == dists); } -TEST_CASE("skip_whitespace") { +TEST(csv, skip_whitespace) { cstr my_file = R"(a,b,c,d,e,f 1 , 2 , 3.0 , 1.5, asdfgh , true )"; @@ -210,6 +210,6 @@ TEST_CASE("skip_whitespace") { std::vector dat; utl::read(my_file, dat, columns); - REQUIRE(dat.size() == 1); - CHECK(dat.front() == data{1, 2, 3.0, 1.5, " asdfgh ", true}); + ASSERT_TRUE(dat.size() == 1); + EXPECT_TRUE(dat.front() == (data{1, 2, 3.0, 1.5, " asdfgh ", true})); } diff --git a/test/parser/pipe_csv_test.cc b/test/parser/pipe_csv_test.cc index 3c44b3e..b0d3509 100644 --- a/test/parser/pipe_csv_test.cc +++ b/test/parser/pipe_csv_test.cc @@ -1,4 +1,4 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/parser/buf_reader.h" #include "utl/parser/csv_range.h" @@ -31,18 +31,18 @@ struct quote { csv_col time_; }; -TEST_CASE("csv") { +TEST(pipe_csv, csv) { auto const avg_volume = - line_range{buf_reader{input}} // + line_range{buf_reader{input, {}}} // | csv() // | remove_if([](auto&& row) { return row.open_ < 39.01; }) // | transform([](auto&& row) { return row.volume_; }) // | avg(); - CHECK(avg_volume <= 65844.5); - CHECK(avg_volume >= 65844.3); + EXPECT_TRUE(avg_volume <= 65844.5); + EXPECT_TRUE(avg_volume >= 65844.3); } -TEST_CASE("csv_no_rows") { +TEST(pipe_csv, csv_no_rows) { struct baz { csv_col foo_; csv_col bar_; @@ -50,25 +50,25 @@ TEST_CASE("csv_no_rows") { { constexpr auto const no_rows_input = R"(FOO,BAR)"; - auto const result = line_range{buf_reader{no_rows_input}} // + auto const result = line_range{make_buf_reader(no_rows_input, {})} // | csv() // | vec(); - CHECK(result.empty() == true); + EXPECT_TRUE(result.empty() == true); } { constexpr auto const no_rows_input = R"(FOO,BAR )"; - auto const result = line_range{buf_reader{no_rows_input}} // + auto const result = line_range{make_buf_reader(no_rows_input, {})} // | csv() // | vec(); - CHECK(result.empty() == true); + EXPECT_TRUE(result.empty() == true); } } -TEST_CASE("csv_separator") { +TEST(pipe_csv, csv_separator) { struct baz { csv_col foo_; csv_col bar_; @@ -77,16 +77,16 @@ TEST_CASE("csv_separator") { constexpr auto const no_rows_input = R"(BAR$FOO 1$2 )"; - auto const result = line_range{buf_reader{no_rows_input}} // + auto const result = line_range{make_buf_reader(no_rows_input, {})} // | csv() // | vec(); - REQUIRE(result.size() == 1); - CHECK(result[0].foo_.val() == 2); - CHECK(result[0].bar_.val() == 1); + ASSERT_TRUE(result.size() == 1); + EXPECT_TRUE(result[0].foo_.val() == 2); + EXPECT_TRUE(result[0].bar_.val() == 1); } -TEST_CASE("csv_escaped_string") { +TEST(pipe_csv, csv_escaped_string) { struct dat { csv_col foo_; csv_col bar_; @@ -96,12 +96,12 @@ TEST_CASE("csv_escaped_string") { constexpr auto const input = R"(BAR,FOO,BAZ "asd","[""asd"", ""bsd""]","xxx" )"; - auto const result = line_range{buf_reader{input}} // + auto const result = line_range{make_buf_reader(input, {})} // | csv() // | vec(); - REQUIRE(result.size() == 1); - CHECK(result[0].foo_.val() == R"([""asd"", ""bsd""])"); - CHECK(result[0].bar_.val() == "asd"); - CHECK(result[0].baz_.val() == "xxx"); + ASSERT_TRUE(result.size() == 1); + EXPECT_TRUE(result[0].foo_.val() == R"([""asd"", ""bsd""])"); + EXPECT_TRUE(result[0].bar_.val() == "asd"); + EXPECT_TRUE(result[0].baz_.val() == "xxx"); } diff --git a/test/pipes/avg_test.cc b/test/pipes/avg_test.cc index 92ddf10..4f6dc69 100644 --- a/test/pipes/avg_test.cc +++ b/test/pipes/avg_test.cc @@ -1,4 +1,4 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include @@ -8,7 +8,7 @@ using namespace utl; -TEST_CASE("vec test") { +TEST(pipes, avg_vec_test) { std::list v = {1, 2, 3, 4}; auto r0 = all(v) // | transform([](auto&& i) { return i * i; }) // @@ -21,50 +21,50 @@ TEST_CASE("vec test") { | remove_if([](auto&& i) { return i > 3; }) // | unique() // | vec(); - CHECK(r0 == r1); + EXPECT_TRUE(r0 == r1); } -TEST_CASE("find test") { +TEST(pipes, avg_find_test) { std::vector v = {1, 3, 5, 7, 9}; - CHECK(*(all(v) | find([](auto&& i) { return i == 7; })) == 7); + EXPECT_TRUE(*(all(v) | find([](auto&& i) { return i == 7; })) == 7); } -TEST_CASE("unique test") { +TEST(pipes, avg_unique_test) { std::vector v = {1, 3, 3, 5, 7, 7, 7, 7, 9}; std::vector result = {1, 3, 5, 7, 9}; - CHECK((all(v) | unique() | vec()) == result); + EXPECT_TRUE((all(v) | unique() | vec()) == result); int i = 0; for (auto const val : all(v) | unique() | iterable()) { - CHECK(val == result[i++]); + EXPECT_TRUE(val == result[i++]); } } -TEST_CASE("sum test default") { +TEST(pipes, avg_sum_test_default) { std::vector v = {1, 3, 3, 5, 7, 7, 7, 7, 9}; int result = all(v) | unique() | remove_if([](auto&& i) { return i > 3; }) | sum(); - CHECK(result == 4); + EXPECT_TRUE(result == 4); } -TEST_CASE("sum test template") { +TEST(pipes, avg_sum_test_template) { std::vector v = {1, 3, 3, 5, 7, 7, 7, 7, 9}; std::size_t result = all(v) | unique() | remove_if([](auto&& i) { return i > 3; }) | sum(); - CHECK(result == std::size_t{4}); + EXPECT_TRUE(result == std::size_t{4}); } -TEST_CASE("emplace back") { +TEST(pipes, avg_emplace_back) { std::vector v = {1, 2, 3, 4}; auto result = all(v) | transform([](auto&& x) { return x * x; }) | emplace_back>(); std::list expected = {1, 4, 9, 16}; - CHECK(result == expected); + EXPECT_TRUE(result == expected); } -TEST_CASE("insert") { +TEST(pipes, avg_insert) { std::vector v = {1, 2, 3, 4}; auto result = @@ -72,8 +72,8 @@ TEST_CASE("insert") { transform([](auto&& x) { return std::pair(std::to_string(x), x); }) | insert>(); - CHECK(result["1"] == 1); - CHECK(result["2"] == 2); - CHECK(result["3"] == 3); - CHECK(result["4"] == 4); + EXPECT_TRUE(result["1"] == 1); + EXPECT_TRUE(result["2"] == 2); + EXPECT_TRUE(result["3"] == 3); + EXPECT_TRUE(result["4"] == 4); } diff --git a/test/pipes/count_test.cc b/test/pipes/count_test.cc index 6e6d82e..77d5ae5 100644 --- a/test/pipes/count_test.cc +++ b/test/pipes/count_test.cc @@ -1,20 +1,20 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/pipes.h" using namespace utl; -TEST_CASE("count test int") { +TEST(pipes, count_int) { std::vector v = {1, 3, 5, 7, 9}; - CHECK((all(v) | count([](auto&& i) { return i == 3; })) == 1); + EXPECT_TRUE((all(v) | count([](auto&& i) { return i == 3; })) == 1); } -TEST_CASE("count test int 2") { +TEST(pipes, count_int2) { std::vector v = {5, 7, 9, 1, 4, 1, 3, 1, 5, 3, 1}; - CHECK((all(v) | count([](auto&& i) { return i == 1; })) == 4); + EXPECT_TRUE((all(v) | count([](auto&& i) { return i == 1; })) == 4); } -TEST_CASE("count test int 3") { +TEST(pipes, count_int3) { std::vector v = {5, 7, 9, 1, 4, 1, 3, 1, 5, 3, 1}; - CHECK((all(v) | count([](auto&& i) { return i == 10; })) == 0); + EXPECT_TRUE((all(v) | count([](auto&& i) { return i == 10; })) == 0); } diff --git a/test/pipes/max_test.cc b/test/pipes/max_test.cc index 515c295..0f3bdd7 100644 --- a/test/pipes/max_test.cc +++ b/test/pipes/max_test.cc @@ -1,20 +1,20 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "utl/pipes.h" using namespace utl; -TEST_CASE("max test int") { +TEST(pipes, max_int) { std::vector v = {1, 3, 5, 7, 9}; - CHECK((all(v) | max()) == 9); + EXPECT_TRUE((all(v) | max()) == 9); } -TEST_CASE("max test int 2") { +TEST(pipes, max_int_2) { std::vector v = {5, 7, 9, 1, 4}; - CHECK((all(v) | max()) == 9); + EXPECT_TRUE((all(v) | max()) == 9); } -TEST_CASE("max test float") { +TEST(pipes, max_float) { std::vector v = {1.2, 3.5, 5.5, 7.3, 9.8}; - CHECK((all(v) | max()) == 9.8); + EXPECT_TRUE((all(v) | max()) == 9.8); } diff --git a/test/printable_enum.cc b/test/printable_enum.cc index 2ebff83..55f5879 100644 --- a/test/printable_enum.cc +++ b/test/printable_enum.cc @@ -1,4 +1,4 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include @@ -6,12 +6,12 @@ PRINTABLE_ENUM(color, RED, GREEN, BLUE); -TEST_CASE("printable_enum") { - CHECK(as_string(color::RED) == "RED"); - CHECK(as_string(color::GREEN) == "GREEN"); - CHECK(as_string(color::BLUE) == "BLUE"); +TEST(printable_enum, print) { + EXPECT_TRUE(as_string(color::RED) == "RED"); + EXPECT_TRUE(as_string(color::GREEN) == "GREEN"); + EXPECT_TRUE(as_string(color::BLUE) == "BLUE"); std::stringstream ss; ss << color::RED << color::GREEN << color::BLUE; - CHECK(ss.str() == "REDGREENBLUE"); + EXPECT_TRUE(ss.str() == "REDGREENBLUE"); } diff --git a/test/progress_tracker_test.cc b/test/progress_tracker_test.cc index 76c3011..dad6473 100644 --- a/test/progress_tracker_test.cc +++ b/test/progress_tracker_test.cc @@ -1,4 +1,5 @@ -#include "catch2/catch_all.hpp" +#include "gmock/gmock-matchers.h" +#include "gtest/gtest.h" #include #include @@ -33,160 +34,151 @@ std::string capture_cout(Fn&& fn) { return ss.str(); } -TEST_CASE("progress_tracker") { - SECTION("msg") { - std::vector log; - utl::progress_tracker sut{[&](auto& t) { - log.push_back({t.show_progress_, t.out_, t.status_}); - }}; - - sut.status("Hello World!"); - sut.status("GO").show_progress(true); - sut.status("STOP").show_progress(false); - - REQUIRE(log.size() == 3); - CHECK(log.at(0) == log_entry{true, 0.F, "Hello World!"}); - CHECK(log.at(1) == log_entry{true, 0.F, "GO"}); - CHECK(log.at(2) == log_entry{false, 0.F, "STOP"}); - } - - SECTION("progress") { - std::vector log; - utl::progress_tracker sut{[&log](auto& t) { - log.push_back({t.show_progress_, t.out_, t.status_}); - }}; - - sut.out_bounds(30.F, 50.F).out_mod(2.F).in_high(100ULL); - - for (auto i = 0ULL; i <= 100ULL; ++i) { - sut.increment(); - } +TEST(progress_tracker_progress_tracker, msg) { + std::vector log; + utl::progress_tracker sut{[&](auto& t) { + log.push_back({t.show_progress_, t.out_, t.status_}); + }}; - REQUIRE(log.size() == 11); - for (auto i = 0; i < 11; ++i) { - CHECK(log.at(i) == log_entry{true, 30.F + 2 * i, ""}); - } - } + sut.status("Hello World!"); + sut.status("GO").show_progress(true); + sut.status("STOP").show_progress(false); - SECTION("in_high_zero") { - std::vector log; - utl::progress_tracker sut{[&log](auto& t) { - log.push_back({t.show_progress_, t.out_, t.status_}); - }}; + ASSERT_TRUE(log.size() == 3); + EXPECT_TRUE(log.at(0) == (log_entry{true, 0.F, "Hello World!"})); + EXPECT_TRUE(log.at(1) == (log_entry{true, 0.F, "GO"})); + EXPECT_TRUE(log.at(2) == (log_entry{false, 0.F, "STOP"})); +} - sut.out_bounds(30.F, 50.F).in_high(0ULL); +TEST(progress_tracker_progress_tracker, progress) { + std::vector log; + utl::progress_tracker sut{[&log](auto& t) { + log.push_back({t.show_progress_, t.out_, t.status_}); + }}; - REQUIRE(log.size() == 1); - CHECK(log.at(0) == log_entry{true, 30.F, ""}); - log.clear(); + sut.out_bounds(30.F, 50.F).out_mod(2.F).in_high(100ULL); + for (auto i = 0ULL; i <= 100ULL; ++i) { sut.increment(); - REQUIRE(log.size() == 1); - CHECK(log.at(0) == log_entry{true, 50.F, ""}); - log.clear(); + } - sut.increment(); - CHECK(log.empty()); + ASSERT_TRUE(log.size() == 11); + for (auto i = 0; i < 11; ++i) { + EXPECT_TRUE(log.at(i) == (log_entry{true, 30.F + 2 * i, ""})); } +} - SECTION("out_range_zero") { - std::vector log; - utl::progress_tracker sut{[&log](auto& t) { - log.push_back({t.show_progress_, t.out_, t.status_}); - }}; +TEST(progress_tracker_progress_tracker, in_high_zero) { + std::vector log; + utl::progress_tracker sut{[&log](auto& t) { + log.push_back({t.show_progress_, t.out_, t.status_}); + }}; - sut.out_bounds(30.F, 30.F); + sut.out_bounds(30.F, 50.F).in_high(0ULL); - REQUIRE(log.size() == 1); - CHECK(log.at(0) == log_entry{true, 30.F, ""}); - log.clear(); + ASSERT_TRUE(log.size() == 1); + EXPECT_TRUE(log.at(0) == (log_entry{true, 30.F, ""})); + log.clear(); - sut.increment(); - CHECK(log.empty()); - } + sut.increment(); + ASSERT_TRUE(log.size() == 1); + EXPECT_TRUE(log.at(0) == (log_entry{true, 50.F, ""})); + log.clear(); + + sut.increment(); + EXPECT_TRUE(log.empty()); } -#define RE_ANY "(?:.|\r|\n)*?" +TEST(progress_tracker_progress_tracker, out_range_zero) { + std::vector log; + utl::progress_tracker sut{[&log](auto& t) { + log.push_back({t.show_progress_, t.out_, t.status_}); + }}; -TEST_CASE("global_progress_tracker") { - SECTION("msg") { - auto t1 = utl::get_global_progress_trackers().get_tracker("module_1"); - auto t2 = utl::get_global_progress_trackers().get_tracker("module_2"); + sut.out_bounds(30.F, 30.F); - auto const str = capture_cout([&] { - auto const progress_bars = utl::global_progress_bars{}; - t1->status("WAITING"); - t2->status("READY"); - }); + ASSERT_TRUE(log.size() == 1); + EXPECT_TRUE(log.at(0) == (log_entry{true, 30.F, ""})); + log.clear(); - CHECK_THAT(str, - Catch::Matchers::Matches(RE_ANY "module_1.*?WAITING" RE_ANY)); - CHECK_THAT(str, Catch::Matchers::Matches(RE_ANY "module_2.*?READY" RE_ANY)); - } + sut.increment(); + EXPECT_TRUE(log.empty()); +} - SECTION("silent and clear") { - auto t1 = utl::get_global_progress_trackers().get_tracker("module_1"); +TEST(progress_tracker_global_progress_tracker, msg) { + auto t1 = utl::get_global_progress_trackers().get_tracker("module_1"); + auto t2 = utl::get_global_progress_trackers().get_tracker("module_2"); - auto const str1 = capture_cout([&] { t1->status("ASDF"); }); - CHECK(str1.empty()); + auto const str = capture_cout([&] { + auto const progress_bars = utl::global_progress_bars{}; + t1->status("WAITING"); + t2->status("READY"); + }); - utl::get_global_progress_trackers().clear(); - auto const str2 = - capture_cout([&] { utl::get_global_progress_trackers().print(); }); - CHECK(str2.empty()); - } + EXPECT_THAT(str, testing::ContainsRegex("module_1.*?WAITING")); + EXPECT_THAT(str, testing::ContainsRegex("module_2.*?READY")); +} - SECTION("progress") { - auto t1 = utl::get_global_progress_trackers().get_tracker("module_1"); - utl::get_global_progress_trackers().get_tracker("module_2"); +TEST(progress_tracker_global_progress_tracker, silent_and_clear) { + auto t1 = utl::get_global_progress_trackers().get_tracker("module_1"); - auto const str = capture_cout([&] { - auto const progress_bars = utl::global_progress_bars{}; - t1->update(50ULL); - }); + auto const str1 = capture_cout([&] { t1->status("ASDF"); }); + EXPECT_TRUE(str1.empty()); - CHECK_THAT(str, Catch::Matchers::Matches(RE_ANY "module_1.*?50%" RE_ANY)); - CHECK_THAT(str, Catch::Matchers::Matches(RE_ANY "module_2.*?0%" RE_ANY)); - } + utl::get_global_progress_trackers().clear(); + auto const str2 = + capture_cout([&] { utl::get_global_progress_trackers().print(); }); + EXPECT_TRUE(str2.empty()); } -TEST_CASE("active_progress_tracker") { - SECTION("one") { - auto const str = capture_cout([&] { - auto const progress_bars = utl::global_progress_bars{}; - utl::activate_progress_tracker("first")->status("YEAH"); - utl::get_active_progress_tracker()->status("ASDF"); - }); - - CHECK_THAT(str, Catch::Matchers::Matches(RE_ANY "first.*?YEAH" RE_ANY)); - CHECK_THAT(str, Catch::Matchers::Matches(RE_ANY "first.*?ASDF" RE_ANY)); - } +TEST(progress_tracker_global_progress_tracker, progress) { + auto t1 = utl::get_global_progress_trackers().get_tracker("module_1"); + utl::get_global_progress_trackers().get_tracker("module_2"); - SECTION("two") { - auto const str = capture_cout([&] { - auto const progress_bars = utl::global_progress_bars{}; - utl::activate_progress_tracker("second"); - utl::get_active_progress_tracker()->status("QWERTZ"); - }); + auto const str = capture_cout([&] { + auto const progress_bars = utl::global_progress_bars{}; + t1->update(50ULL); + }); - CHECK_THAT(str, Catch::Matchers::Matches(RE_ANY "second.*?QWERTZ" RE_ANY)); - } + EXPECT_THAT(str, testing::ContainsRegex("module_1.*?50%")); + EXPECT_THAT(str, testing::ContainsRegex("module_2.*?0%")); +} - SECTION("clear") { - utl::activate_progress_tracker("third"); +TEST(progress_tracker_active_progress_tracker, one) { + auto const str = capture_cout([&] { + auto const progress_bars = utl::global_progress_bars{}; + utl::activate_progress_tracker("first")->status("YEAH"); utl::get_active_progress_tracker()->status("ASDF"); + }); - utl::get_global_progress_trackers().clear(); - CHECK_THROWS(utl::get_active_progress_tracker()); - } + EXPECT_THAT(str, testing::ContainsRegex("first.*?YEAH")); + EXPECT_THAT(str, testing::ContainsRegex("first.*?ASDF")); +} + +TEST(progress_tracker_active_progress_tracker, two) { + auto const str = capture_cout([&] { + auto const progress_bars = utl::global_progress_bars{}; + utl::activate_progress_tracker("second"); + utl::get_active_progress_tracker()->status("QWERTZ"); + }); - SECTION("use after clear") { - auto tracker = utl::activate_progress_tracker("fourth"); - utl::get_global_progress_trackers().clear(); + EXPECT_THAT(str, testing::ContainsRegex("second.*?QWERTZ")); +} - auto const str = capture_cout([&] { tracker->status("detached tracker"); }); +TEST(progress_tracker_active_progress_tracker, clear) { + utl::activate_progress_tracker("third"); + utl::get_active_progress_tracker()->status("ASDF"); - CHECK(str.empty()); - CHECK(tracker->status_ == "detached tracker"); - } + utl::get_global_progress_trackers().clear(); + EXPECT_ANY_THROW(utl::get_active_progress_tracker()); } + +TEST(progress_tracker_active_progress_tracker, use_after_clear) { + auto tracker = utl::activate_progress_tracker("fourth"); + utl::get_global_progress_trackers().clear(); + + auto const str = capture_cout([&] { tracker->status("detached tracker"); }); + + EXPECT_TRUE(str.empty()); + EXPECT_TRUE(tracker->status_ == "detached tracker"); +} \ No newline at end of file diff --git a/test/sql/sql_example_test.cc b/test/sql/sql_example_test.cc index 63219fd..feab142 100644 --- a/test/sql/sql_example_test.cc +++ b/test/sql/sql_example_test.cc @@ -1,14 +1,14 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include "create_table.h" -TEST_CASE("create_table") { +TEST(sql, create_table) { struct row { sql_col user_id_ = 0; sql_col first_name_; sql_col last_name_; } r; - CHECK(create_table_statement(r) == R"(CREATE TABLE ( + EXPECT_TRUE(create_table_statement(r) == R"(CREATE TABLE ( id INT PRIMARY NOT NULL, firstName TEXT NOT NULL, lastName TEXT NOT NULL diff --git a/test/zip_test.cc b/test/zip_test.cc index 6af1165..b2b5bd4 100644 --- a/test/zip_test.cc +++ b/test/zip_test.cc @@ -1,4 +1,4 @@ -#include "catch2/catch_all.hpp" +#include "gtest/gtest.h" #include #include @@ -9,170 +9,167 @@ #include "utl/to_set.h" #include "utl/zip.h" -TEST_CASE("zip") { - SECTION("basic_usage") { - std::vector lhs{"asdf", "bsdf", "csdf"}; - std::vector rhs{1, 2, 3}; - - auto const range = utl::zip(lhs, rhs); - auto it = begin(range); - - { - REQUIRE(it != end(range)); - - auto [str, num] = *it; - CHECK(str == "asdf"); - CHECK(num == 1); - } - { - ++it; - REQUIRE(it != end(range)); - - auto [str, num] = *it; - CHECK(str == "bsdf"); - CHECK(num == 2); - } - { - ++it; - REQUIRE(it != end(range)); - - auto [str, num] = *it; - CHECK(str == "csdf"); - CHECK(num == 3); - } +TEST(zip, basic_usage) { + std::vector lhs{"asdf", "bsdf", "csdf"}; + std::vector rhs{1, 2, 3}; - ++it; - REQUIRE(it == end(range)); + auto const range = utl::zip(lhs, rhs); + auto it = begin(range); + + { + ASSERT_TRUE(it != end(range)); + + auto [str, num] = *it; + EXPECT_TRUE(str == "asdf"); + EXPECT_TRUE(num == 1); } + { + ++it; + ASSERT_TRUE(it != end(range)); - SECTION("safeguard") { - std::vector vec_short{1, 2, 3}; - std::vector vec_long{1, 2, 3, 4}; + auto [str, num] = *it; + EXPECT_TRUE(str == "bsdf"); + EXPECT_TRUE(num == 2); + } + { + ++it; + ASSERT_TRUE(it != end(range)); - REQUIRE_THROWS(utl::zip(vec_short, vec_long)); + auto [str, num] = *it; + EXPECT_TRUE(str == "csdf"); + EXPECT_TRUE(num == 3); } - SECTION("self_and_range_for") { - std::vector vec{1, 2, 3}; + ++it; + ASSERT_TRUE(it == end(range)); +} - std::vector result; - for (auto [a, b, c] : utl::zip(vec, vec, vec)) { - result.push_back(a * b * c); - } +TEST(zip, safeguard) { + std::vector vec_short{1, 2, 3}; + std::vector vec_long{1, 2, 3, 4}; - REQUIRE(result.size() == 3); - CHECK(result[0] == 1); - CHECK(result[1] == 8); - CHECK(result[2] == 27); - } + ASSERT_ANY_THROW(utl::zip(vec_short, vec_long)); +} + +TEST(zip, self_and_range_for) { + std::vector vec{1, 2, 3}; - SECTION("move_types_vs_ref_types") { - auto ref = std::vector{}; - static_assert(std::is_lvalue_reference_v( - utl::zip(ref, std::vector{}).tup_))>); - static_assert(std::is_rvalue_reference_v( - utl::zip(ref, std::vector{}).tup_))>); + std::vector result; + for (auto [a, b, c] : utl::zip(vec, vec, vec)) { + result.push_back(a * b * c); } - SECTION("const_input") { - std::vector lhs{1, 2, 3}; - const std::vector rhs{4, 5, 6}; + ASSERT_TRUE(result.size() == 3); + EXPECT_TRUE(result[0] == 1); + EXPECT_TRUE(result[1] == 8); + EXPECT_TRUE(result[2] == 27); +} - static_assert(!std::is_const( - *utl::zip(lhs, rhs).begin()))>>::value); - static_assert(std::is_const( - *utl::zip(lhs, rhs).begin()))>>::value); - } +TEST(zip, move_types_vs_ref_types) { + auto ref = std::vector{}; + static_assert(std::is_lvalue_reference_v( + utl::zip(ref, std::vector{}).tup_))>); + static_assert(std::is_rvalue_reference_v( + utl::zip(ref, std::vector{}).tup_))>); +} - SECTION("force_const_iterator") { - std::vector vec{1, 2, 3}; - static_assert(std::is_const( - *utl::czip(vec).begin()))>>::value); - } +TEST(zip, const_input) { + std::vector lhs{1, 2, 3}; + const std::vector rhs{4, 5, 6}; - SECTION("mutable") { - std::vector vec{1, 2, 3}; - std::vector vec2{4, 5, 6}; + static_assert(!std::is_const( + *utl::zip(lhs, rhs).begin()))>>::value); + static_assert(std::is_const( + *utl::zip(lhs, rhs).begin()))>>::value); +} - for (auto const [a, b] : utl::zip(vec, vec2)) { - a += b; - } +TEST(zip, force_const_iterator) { + std::vector vec{1, 2, 3}; + static_assert(std::is_const( + *utl::czip(vec).begin()))>>::value); +} - REQUIRE(vec.size() == 3); - CHECK(vec[0] == 5); - CHECK(vec[1] == 7); - CHECK(vec[2] == 9); - } +TEST(zip, mutable) { + std::vector vec{1, 2, 3}; + std::vector vec2{4, 5, 6}; - SECTION("zero_copy") { - struct solid_stuff { - explicit solid_stuff(int val) : val_(val) {} - - solid_stuff(const solid_stuff&) = delete; - solid_stuff(solid_stuff&&) = delete; - solid_stuff& operator=(const solid_stuff&) = delete; - solid_stuff& operator=(solid_stuff&&) = delete; - ~solid_stuff() = default; - - int val_; - }; - - std::array lhs{ - {solid_stuff{1}, solid_stuff{2}, solid_stuff{3}}}; - std::array rhs{ - {solid_stuff{5}, solid_stuff{6}, solid_stuff{7}}}; - - std::vector result; - for (auto const [a, b] : utl::zip(lhs, rhs)) { - result.push_back(a.val_ + b.val_); - } - - REQUIRE(result.size() == 3); - CHECK(result[0] == 6); - CHECK(result[1] == 8); - CHECK(result[2] == 10); + for (auto const [a, b] : utl::zip(vec, vec2)) { + a += b; } - SECTION("interoperability") { - std::vector vec{1, 2, 3}; - std::vector vec2{3, 2, 1}; + ASSERT_TRUE(vec.size() == 3); + EXPECT_TRUE(vec[0] == 5); + EXPECT_TRUE(vec[1] == 7); + EXPECT_TRUE(vec[2] == 9); +} - auto const set = utl::to_set(utl::zip(vec, vec2), [](auto const& tup) { - auto [lhs, rhs] = tup; - return lhs + rhs; - }); +TEST(zip, zero_copy) { + struct solid_stuff { + explicit solid_stuff(int val) : val_(val) {} - REQUIRE(set.size() == 1); - CHECK(*set.begin() == 4); - } + solid_stuff(const solid_stuff&) = delete; + solid_stuff(solid_stuff&&) = delete; + solid_stuff& operator=(const solid_stuff&) = delete; + solid_stuff& operator=(solid_stuff&&) = delete; + ~solid_stuff() = default; - SECTION("more_collections") { - std::initializer_list lst{1, 2, 3}; - std::map map{{4, true}, {1, false}, {3, true}}; - std::set set{"c", "b", "a"}; + int val_; + }; - std::vector> result; - for (auto const [i, pair, str] : utl::zip(lst, map, set)) { - result.emplace_back(i, pair.first, pair.second, str); - } + std::array lhs{ + {solid_stuff{1}, solid_stuff{2}, solid_stuff{3}}}; + std::array rhs{ + {solid_stuff{5}, solid_stuff{6}, solid_stuff{7}}}; - REQUIRE(result.size() == 3); - CHECK(result[0] == std::make_tuple(1, 1, false, "a")); - CHECK(result[1] == std::make_tuple(2, 3, true, "b")); - CHECK(result[2] == std::make_tuple(3, 4, true, "c")); + std::vector result; + for (auto const [a, b] : utl::zip(lhs, rhs)) { + result.push_back(a.val_ + b.val_); } - SECTION("algorithm") { - std::vector vec{1, 2, 3}; - std::vector vec2{2, 2, 1}; - - CHECK(std::all_of(begin(utl::zip(vec, vec2)), end(utl::zip(vec, vec2)), - [](auto const& t) { - return std::get<0>(t) > 0 && std::get<1>(t) > 0; - })); - CHECK(!std::any_of(begin(utl::zip(vec, vec2)), end(utl::zip(vec, vec2)), - [](auto const& t) { - return std::get<0>(t) <= 0 || std::get<1>(t) <= 0; - })); + ASSERT_TRUE(result.size() == 3); + EXPECT_TRUE(result[0] == 6); + EXPECT_TRUE(result[1] == 8); + EXPECT_TRUE(result[2] == 10); +} + +TEST(zip, interoperability) { + std::vector vec{1, 2, 3}; + std::vector vec2{3, 2, 1}; + + auto const set = utl::to_set(utl::zip(vec, vec2), [](auto const& tup) { + auto [lhs, rhs] = tup; + return lhs + rhs; + }); + + ASSERT_TRUE(set.size() == 1); + EXPECT_TRUE(*set.begin() == 4); +} + +TEST(zip, more_collections) { + std::initializer_list lst{1, 2, 3}; + std::map map{{4, true}, {1, false}, {3, true}}; + std::set set{"c", "b", "a"}; + + std::vector> result; + for (auto const [i, pair, str] : utl::zip(lst, map, set)) { + result.emplace_back(i, pair.first, pair.second, str); } + + ASSERT_TRUE(result.size() == 3); + EXPECT_TRUE(result[0] == std::make_tuple(1, 1, false, "a")); + EXPECT_TRUE(result[1] == std::make_tuple(2, 3, true, "b")); + EXPECT_TRUE(result[2] == std::make_tuple(3, 4, true, "c")); +} + +TEST(zip, algorithm) { + std::vector vec{1, 2, 3}; + std::vector vec2{2, 2, 1}; + + EXPECT_TRUE(std::all_of( + begin(utl::zip(vec, vec2)), end(utl::zip(vec, vec2)), + [](auto const& t) { return std::get<0>(t) > 0 && std::get<1>(t) > 0; })); + EXPECT_TRUE(!std::any_of(begin(utl::zip(vec, vec2)), end(utl::zip(vec, vec2)), + [](auto const& t) { + return std::get<0>(t) <= 0 || std::get<1>(t) <= 0; + })); }