tests: add Google Test

Author: romintomasetti

.github/workflows/build-with-kokkos.yml

@@ -71,9 +71,10 @@ jobs:
                   exit -1
           esac
 
-      - name: Install CMake, OpenMPI, PAPI and dtrace
+      - name: Install git, CMake, OpenMPI, PAPI and dtrace
         run: |
           apt --yes --no-install-recommends install \
+            git ca-certificates \
             cmake make \
             libopenmpi-dev \
             systemtap-sdt-dev \

CMakeLists.txt

@@ -272,6 +272,7 @@ endif()
 # Tests
 if(KokkosTools_ENABLE_TESTS)
   enable_testing()
+  include(cmake/BuildGTest.cmake)
   add_subdirectory(tests)
 endif()
 

cmake/BuildGTest.cmake

@@ -0,0 +1,35 @@
+# Look for Google Test and enable it as a target.
+#
+# The main targets that will be available are:
+#       * GTest::gtest
+#       * GTest::gmock
+#
+# References:
+#   * https://github.com/google/googletest
+#   * https://matgomes.com/integrate-google-test-into-cmake/
+#   * https://google.github.io/googletest/quickstart-cmake.html
+#   * https://jeremimucha.com/2021/04/cmake-fetchcontent/
+
+include(FetchContent)
+
+# Declare the Google Test dependency
+FetchContent_Declare(
+    googletest
+    GIT_REPOSITORY https://github.com/google/googletest.git
+    GIT_TAG        v1.14.0
+)
+
+# If not yet populated, add Google Test to the build with the following options:
+#       * disable installation of Google Test
+#       * enable GMock
+# Note that we could have used FetchContent_MakeAvailable instead, but it would then
+# use the default configuration that would install Google Test.
+FetchContent_GetProperties(googletest)
+if (NOT googletest_POPULATED)
+    FetchContent_Populate(googletest)
+
+    set(BUILD_GMOCK   ON)
+    set(INSTALL_GTEST OFF)
+
+    add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR} EXCLUDE_FROM_ALL)
+endif()

tests/CMakeLists.txt

@@ -1 +1,50 @@
+# Add one test.
+#
+# The executable is always linked to 'kokkostools' and 'test_common'.
+#
+# Arguments:
+#   TARGET_NAME : name of the test
+#   SOURCE_FILE : source file, defaults to <TARGET_NAME>.cpp
+function(add_one_test)
+
+    cmake_parse_arguments(aot_args "" "TARGET_NAME;SOURCE_FILE" "" ${ARGN})
+
+    if(NOT DEFINED aot_args_TARGET_NAME)
+        message(FATAL_ERROR "Wrong usage.")
+    endif()
+
+    if(NOT DEFINED aot_args_SOURCE_FILE)
+        set(aot_args_SOURCE_FILE "${aot_args_NAME}.cpp")
+    endif()
+
+    add_executable(${aot_args_TARGET_NAME})
+
+    target_sources(
+        ${aot_args_TARGET_NAME}
+        PRIVATE
+            ${aot_args_SOURCE_FILE}
+    )
+    target_link_libraries(
+        ${aot_args_TARGET_NAME}
+        PRIVATE
+            kokkostools test_common
+    )
+
+    add_test(
+        NAME ${aot_args_TARGET_NAME}
+        COMMAND $<TARGET_FILE:${aot_args_TARGET_NAME}>
+    )
+
+endfunction(add_one_test)
+
+# Create a test library that contains the required Kokkos and Google Test
+# initialization sequence.
+add_library(test_common OBJECT)
+target_sources(
+    test_common
+    PRIVATE
+        TestBase.cpp
+)
+target_link_libraries(test_common PUBLIC GTest::gtest GTest::gmock Kokkos::kokkos)
+
 add_subdirectory(space-time-stack)

tests/TestBase.cpp

@@ -0,0 +1,14 @@
+#include "gtest/gtest.h"
+
+#include "Kokkos_Core.hpp"
+
+//! Main entry point for tests.
+int main(int argc, char* argv[]) {
+  //! Initialize Google Test.
+  ::testing::InitGoogleTest(&argc, argv);
+
+  //! Run tests.
+  auto success = RUN_ALL_TESTS();
+
+  return success;
+}

tests/space-time-stack/CMakeLists.txt

@@ -1,18 +1,10 @@
 # A function to add such "simple" tests in 'tests/CMakeLists.txt' might be a good option.
-add_executable(test_space_time_stack_demangling)
-target_sources(
-    test_space_time_stack_demangling
-    PRIVATE
-        test_demangling.cpp
+add_one_test(
+    TARGET_NAME test_space_time_stack_demangling
+    SOURCE_FILE test_demangling
 )
-target_link_libraries(
+target_compile_definitions(
     test_space_time_stack_demangling
     PRIVATE
-        Kokkos::kokkos kokkostools
-)
-add_test(
-    NAME test_space_time_stack_demangling
-    COMMAND $<TARGET_FILE:test_space_time_stack_demangling>
-        --kokkos-tools-libs=$<TARGET_FILE:kp_space_time_stack>
-        --kokkos-tools-args=1e-9
+        LIBKP_SPACE_TIME_STACK="$<TARGET_FILE:kp_space_time_stack>"
 )

tests/space-time-stack/test_demangling.cpp

@@ -1,10 +1,10 @@
 #include <iostream>
-#include <regex>
 #include <sstream>
 
-#include "Kokkos_Core.hpp"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
 
-#include "utils/demangle.hpp"
+#include "Kokkos_Core.hpp"
 
 struct Tester {
   struct TagNamed {};
@@ -49,9 +49,18 @@ static const std::vector<std::string> matchers{
     "[0-9.e]+ sec [0-9.]+% 100.0% 0.0% ------ 1 Tester/Tester::TagUnnamed "
     "\\[for\\]"};
 
-int main(int argc, char* argv[]) {
+/**
+ * @test This test checks that the tool effectively uses
+ *       the demangling helpers.
+ */
+TEST(SpaceTimeStackTest, demangling) {
+  //! Fake arguments a user would give via CLI.
+  std::string arg {"--kokkos-tools-libs=" LIBKP_SPACE_TIME_STACK};
+  int argc = 1;
+  std::vector<char*> argv {arg.data(), nullptr};
+
   //! Initialize @c Kokkos.
-  Kokkos::initialize(argc, argv);
+  Kokkos::initialize(argc, argv.data());
 
   //! Redirect output for later analysis.
   std::cout.flush();
@@ -71,10 +80,6 @@ int main(int argc, char* argv[]) {
 
   //! Analyze test output.
   for (const auto& matcher : matchers) {
-    if (!std::regex_search(output.str(), std::regex(matcher)))
-      throw std::runtime_error("Couln't find " + matcher + " in output\n" +
-                               output.str());
+    EXPECT_THAT(output.str(), ::testing::ContainsRegex(matcher));
   }
-
-  return EXIT_SUCCESS;
 }