Convert tests to Catch2

Author: gjbex

source-code/convolution/cpp/src/CMakeLists.txt

@@ -1,11 +1,19 @@
 add_subdirectory(convolution)
 
-add_executable(test_convolution.exe
+find_package(Catch2)
+
+if(Catch2_FOUND)
+    add_executable(test_convolution.exe
         test_convolution.cpp)
-target_include_directories(test_convolution.exe
-    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/convolution)
-target_link_libraries(test_convolution.exe
-    PRIVATE convolution)
+    target_link_libraries(test_convolution.exe
+        PRIVATE Catch2::Catch2WithMain)
+    target_include_directories(test_convolution.exe
+        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/convolution)
+    target_link_libraries(test_convolution.exe
+        PRIVATE convolution)
+else()
+    message(STATUS "Catch2 not found, tests will not be built")
+endif()
 
 add_executable(benchmark_convolution.exe
         benchmark_convolution.cpp)

source-code/convolution/cpp/src/test_convolution.cpp

@@ -1,34 +1,134 @@
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
 #include <convolution.h>
-#include <iostream>
-
-int main() {
-    // Create a 10x10 image
-    Matrix image(10, 10);
-    for (int i = 0; i < image.rows(); ++i) {
-        for (int j = 0; j < image.cols(); ++j) {
-            image(i, j) = 1.0;
+
+TEST_CASE("3x3 kernel", "[convolution]") {
+    const int input_size {5};
+    const int kernel_size {3};
+
+    Matrix input(input_size, input_size);
+    for (int i = 0; i < input.rows(); ++i) {
+        for (int j = 0; j < input.cols(); ++j) {
+            input(i, j) = 1.0;
         }
     }
 
-    // Print the image
-    std::cout << image << std::endl;
+    Matrix kernel(kernel_size, kernel_size);
+    for (int i = 0; i < kernel.rows(); ++i) {
+        for (int j = 0; j < kernel.cols(); ++j) {
+            kernel(i, j) = 1.0;
+        }
+    }
 
-    // Create a 3x3 kernel
-    Matrix kernel(3, 3);
+    Matrix target(input_size, input_size);
+    target(0, 0) = 4.0;
+    target(0, 1) = 6.0;
+    target(0, 2) = 6.0;
+    target(0, 3) = 6.0;
+    target(0, 4) = 4.0;
+    target(1, 0) = 6.0;
+    target(1, 1) = 9.0;
+    target(1, 2) = 9.0;
+    target(1, 3) = 9.0;
+    target(1, 4) = 6.0;
+    target(2, 0) = 6.0;
+    target(2, 1) = 9.0;
+    target(2, 2) = 9.0;
+    target(2, 3) = 9.0;
+    target(2, 4) = 6.0;
+    target(3, 0) = 6.0;
+    target(3, 1) = 9.0;
+    target(3, 2) = 9.0;
+    target(3, 3) = 9.0;
+    target(3, 4) = 6.0;
+    target(4, 0) = 4.0;
+    target(4, 1) = 6.0;
+    target(4, 2) = 6.0;
+    target(4, 3) = 6.0;
+    target(4, 4) = 4.0;
+
+    auto result = convolve(input, kernel);
+
+    REQUIRE(result == target);
+}
+
+TEST_CASE("5x5 kernel", "[convolution]") {
+    const int input_size {6};
+    const int kernel_size {5};
+
+    Matrix input(input_size, input_size);
+    for (int i = 0; i < input.rows(); ++i) {
+        for (int j = 0; j < input.cols(); ++j) {
+            input(i, j) = 1.0;
+        }
+    }
+
+    Matrix kernel(kernel_size, kernel_size);
     for (int i = 0; i < kernel.rows(); ++i) {
         for (int j = 0; j < kernel.cols(); ++j) {
             kernel(i, j) = 1.0;
         }
     }
 
-    // Print the kernel
-    std::cout << kernel << std::endl;
+    Matrix target(input_size, input_size);
+    target(0, 0) = 9.0;
+    target(0, 1) = 12.0;
+    target(0, 2) = 15.0;
+    target(0, 3) = 15.0;
+    target(0, 4) = 12.0;
+    target(0, 5) = 9.0;
+    target(1, 0) = 12.0;
+    target(1, 1) = 16.0;
+    target(1, 2) = 20.0;
+    target(1, 3) = 20.0;
+    target(1, 4) = 16.0;
+    target(1, 5) = 12.0;
+    target(2, 0) = 15.0;
+    target(2, 1) = 20.0;
+    target(2, 2) = 25.0;
+    target(2, 3) = 25.0;
+    target(2, 4) = 20.0;
+    target(2, 5) = 15.0;
+    target(3, 0) = 15.0;
+    target(3, 1) = 20.0;
+    target(3, 2) = 25.0;
+    target(3, 3) = 25.0;
+    target(3, 4) = 20.0;
+    target(3, 5) = 15.0;
+    target(4, 0) = 12.0;
+    target(4, 1) = 16.0;
+    target(4, 2) = 20.0;
+    target(4, 3) = 20.0;
+    target(4, 4) = 16.0;
+    target(4, 5) = 12.0;
+    target(5, 0) = 9.0;
+    target(5, 1) = 12.0;
+    target(5, 2) = 15.0;
+    target(5, 3) = 15.0;
+    target(5, 4) = 12.0;
+    target(5, 5) = 9.0;
+    auto result = convolve(input, kernel);
+
+    REQUIRE(result == target);
+}
 
-    // Create a convolution object
-    auto new_image = convolve(image, kernel);
+TEST_CASE("even-sized kernel error", "[convolution]") {
+    const int input_size {5};
+    const int kernel_size {4};
 
-    // Print the result
-    std::cout << new_image << std::endl;
+    Matrix input(input_size, input_size);
+    for (int i = 0; i < input.rows(); ++i) {
+        for (int j = 0; j < input.cols(); ++j) {
+            input(i, j) = 1.0;
+        }
+    }
 
-    return 0;
+    Matrix kernel(kernel_size, kernel_size);
+    for (int i = 0; i < kernel.rows(); ++i) {
+        for (int j = 0; j < kernel.cols(); ++j) {
+            kernel(i, j) = 1.0;
+        }
+    }
+    REQUIRE_THROWS_AS(convolve(input, kernel), std::invalid_argument);
 }
+