feat: switch to gtest

CMakeLists.txt

@@ -33,14 +33,15 @@ add_executable(main src/main.c
 target_link_libraries(main PUBLIC ${EXTRA_LIBS})
 target_link_libraries(common PUBLIC ${EXTRA_LIBS})
 
-# Fetch Catch2
+# Fetch GoogleTest
 Include(FetchContent)
 FetchContent_Declare(
-        Catch2
-        GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-        GIT_TAG        v3.3.2
+        googletest
+        GIT_REPOSITORY https://github.com/google/googletest.git
+        GIT_TAG        v1.15.2
 )
-FetchContent_MakeAvailable(Catch2)
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
 
 # Build Tests
 enable_testing()
@@ -61,17 +62,15 @@ add_executable(test_ggT_rec
         src/ggt_rec.test.cpp
 )
 
-target_link_libraries(test_prime PRIVATE Catch2::Catch2WithMain)
+target_link_libraries(test_prime PRIVATE GTest::gtest_main)
 target_link_libraries(test_prime PUBLIC ${EXTRA_LIBS})
-target_link_libraries(test_ggT_kgV PRIVATE Catch2::Catch2WithMain)
+target_link_libraries(test_ggT_kgV PRIVATE GTest::gtest_main)
 target_link_libraries(test_ggT_kgV PUBLIC ${EXTRA_LIBS})
-target_link_libraries(test_ggT_rec PRIVATE Catch2::Catch2WithMain)
+target_link_libraries(test_ggT_rec PRIVATE GTest::gtest_main)
 target_link_libraries(test_ggT_rec PUBLIC ${EXTRA_LIBS})
 target_include_directories(test_prime PRIVATE src/)
 target_include_directories(test_ggT_kgV PRIVATE src/)
-add_test(test_prime ./test_prime)
-add_test(test_ggT_kgV ./test_ggT_kgV)
-add_test(test_ggT_rec ./test_ggT_rec)
-set_property(TEST test_prime PROPERTY ENVIRONMENT "CTEST_OUTPUT_ON_FAILURE=1")
-set_property(TEST test_ggT_kgV PROPERTY ENVIRONMENT "CTEST_OUTPUT_ON_FAILURE=1")
+include(GoogleTest)
+gtest_discover_tests(test_prime)
+gtest_discover_tests(test_ggT_kgV)
+gtest_discover_tests(test_ggT_rec)
\ No newline at end of file
-set_property(TEST test_ggT_rec PROPERTY ENVIRONMENT "CTEST_OUTPUT_ON_FAILURE=1")
\ No newline at end of file

src/ggT.test.cpp

-#include <catch2/benchmark/catch_benchmark.hpp>
-#include <catch2/catch_test_macros.hpp>
+#include <gtest/gtest.h>
 extern "C" {
 #include "ggT.h"
 }
-TEST_CASE("ggT_Zero") {
-    REQUIRE(ggT(0, 0) == 0);
-    REQUIRE(ggT(1, 0) == 1);
-    REQUIRE(ggT(0, 1) == 1);
+TEST(ggT, zero) {
+    EXPECT_EQ(ggT(0, 0), 0);
+    EXPECT_EQ(ggT(1, 0), 1);
+    EXPECT_EQ(ggT(0, 1), 1);
 }
 
-TEST_CASE("ggT_negativ") {
-    REQUIRE(ggT(-4, -2) == ggT(4, 2));
-    REQUIRE(ggT(4, -2) == ggT(4, 2));
-    REQUIRE(ggT(-4, 2) == ggT(4, 2));
+TEST(ggT, negative) {
+    EXPECT_EQ(ggT(-4, -2), ggT(4, 2));
+    EXPECT_EQ(ggT(4, -2), ggT(4, 2));
+    EXPECT_EQ(ggT(-4, 2), ggT(4, 2));
 }
 
-TEST_CASE("ggT_same") { REQUIRE(ggT(8, 8) == 8); }
+TEST(ggT, equal) { EXPECT_EQ(ggT(8, 8), 8); }
 
-TEST_CASE("ggT") {
-    REQUIRE(ggT(3528, 3780) == 252);
-    REQUIRE(ggT(70, 42) == 14);
-    REQUIRE(ggT(768, 912) == 48);
+TEST(ggT, positive) {
+    EXPECT_EQ(ggT(3528, 3780), 252);
+    EXPECT_EQ(ggT(70, 42), 14);
+    EXPECT_EQ(ggT(768, 912), 48);
 }

src/ggt_rec.test.cpp

-#include <catch2/benchmark/catch_benchmark.hpp>
-#include <catch2/catch_test_macros.hpp>
+#include <gtest/gtest.h>
 extern "C" {
 #include "ggT.h"
 }
-TEST_CASE("ggT_rec_Zero") {
-    REQUIRE(ggT_rec(0, 0) == 0);
-    REQUIRE(ggT_rec(1, 0) == 1);
-    REQUIRE(ggT_rec(0, 1) == 1);
+TEST(ggT_rec, zero) {
+    EXPECT_EQ(ggT_rec(0, 0), 0);
+    EXPECT_EQ(ggT_rec(1, 0), 1);
+    EXPECT_EQ(ggT_rec(0, 1), 1);
 }
 
-TEST_CASE("ggT_rec_negativ") {
-    REQUIRE(ggT_rec(-4, -2) == ggT_rec(4, 2));
-    REQUIRE(ggT_rec(4, -2) == ggT_rec(4, 2));
-    REQUIRE(ggT_rec(-4, 2) == ggT_rec(4, 2));
+TEST(ggT_rec, negative) {
+    EXPECT_EQ(ggT_rec(-4, -2), ggT_rec(4, 2));
+    EXPECT_EQ(ggT_rec(4, -2), ggT_rec(4, 2));
+    EXPECT_EQ(ggT_rec(-4, 2), ggT_rec(4, 2));
 }
 
-TEST_CASE("ggT_rec_same") { REQUIRE(ggT_rec(8, 8) == 8); }
+TEST(ggT_rec, same) { EXPECT_EQ(ggT_rec(8, 8), 8); }
 
-TEST_CASE("ggT_rec") {
-    REQUIRE(ggT_rec(3528, 3780) == 252);
-    REQUIRE(ggT_rec(70, 42) == 14);
-    REQUIRE(ggT_rec(768, 912) == 48);
+TEST(ggT_rec, positive) {
+    EXPECT_EQ(ggT_rec(3528, 3780), 252);
+    EXPECT_EQ(ggT_rec(70, 42), 14);
+    EXPECT_EQ(ggT_rec(768, 912), 48);
 }

src/kgV.test.cpp

-#include <catch2/benchmark/catch_benchmark.hpp>
-#include <catch2/catch_test_macros.hpp>
+#include <gtest/gtest.h>
 extern "C" {
 #include "kgV.h"
 }
-TEST_CASE("kgV") {
-    REQUIRE(kgV(12, 18) == 36);
-    REQUIRE(kgV(18, 24) == 72);
+TEST(kgv, positiv) {
+    EXPECT_EQ(kgV(12, 18), 36);
+    EXPECT_EQ(kgV(18, 24), 72);
+    EXPECT_EQ(kgV(1, 24), 24);
+    EXPECT_EQ(kgV(18, 1), 18);
+    EXPECT_EQ(kgV(18, 18), 18);
+}
+
+TEST(kgv, negative) {
+    EXPECT_EQ(kgV(-18, 24), 72);
+    EXPECT_EQ(kgV(18, -24), 72);
+    EXPECT_EQ(kgV(-18, -24), 72);
+}
+
+TEST(kgv, zero) {
+    EXPECT_EQ(kgV(0, 24), 0);
+    EXPECT_EQ(kgV(18, 0), 0);
+    EXPECT_EQ(kgV(0, -24), 0);
+    EXPECT_EQ(kgV(0, 0), 0);
 }

src/prime.test.cpp

-#include <catch2/benchmark/catch_benchmark.hpp>
-#include <catch2/catch_test_macros.hpp>
+#include <gtest/gtest.h>
+
 extern "C" {
 #include "prime.h"
 }
 
-TEST_CASE("primes_negativ") { REQUIRE_FALSE(isPrime(-2)); }
-
-TEST_CASE("primes_zero") { REQUIRE_FALSE(isPrime(0)); }
+TEST(Primes, Negativ) { EXPECT_FALSE(isPrime(-2)); }
 
-TEST_CASE("primes_one") { REQUIRE_FALSE(isPrime(1)); }
+TEST(Primes, Zero) { EXPECT_FALSE(isPrime(0)); }
 
-TEST_CASE("primes") {
-    REQUIRE(isPrime(2));
-    REQUIRE(isPrime(3));
-    REQUIRE_FALSE(isPrime(4));
-    REQUIRE(isPrime(5));
-    REQUIRE_FALSE(isPrime(6));
-    REQUIRE(isPrime(7));
-    REQUIRE_FALSE(isPrime(8));
-    REQUIRE_FALSE(isPrime(9));
-}
+TEST(Primes, One) { EXPECT_FALSE(isPrime(1)); }
 
-TEST_CASE("primes_high_numbers") {
-    REQUIRE(isPrime(241));
-    REQUIRE(isPrime(9857));
-    REQUIRE(isPrime(99971));
-    REQUIRE_FALSE(isPrime(9841));
+TEST(Prime, Small) {
+    EXPECT_TRUE(isPrime(2));
+    EXPECT_TRUE(isPrime(3));
+    EXPECT_FALSE(isPrime(4));
+    EXPECT_TRUE(isPrime(5));
+    EXPECT_FALSE(isPrime(6));
+    EXPECT_TRUE(isPrime(7));
+    EXPECT_FALSE(isPrime(8));
+    EXPECT_FALSE(isPrime(9));
 }
 
-TEST_CASE("Benchmark Prime") {
-    BENCHMARK("isPrime(99971)") { return isPrime(99971); };
+TEST(Primes, Large) {
+    EXPECT_TRUE(isPrime(241));
+    EXPECT_TRUE(isPrime(9857));
+    EXPECT_TRUE(isPrime(99971));
+    EXPECT_FALSE(isPrime(9841));
 }