start integration tests for worker

CMakeLists.txt

@@ -18,6 +18,11 @@ add_subdirectory(common/cpp)
 add_subdirectory(producer/inotify-event-detector-cpp)
 add_subdirectory(worker/api/cpp)
 
+if(BUILD_TESTS)
+    add_subdirectory(tests)
+endif()
+
+
 
 if(BUILD_DOCS)
     include(doxygen)

CMakeModules/testing_cpp.cmake

@@ -13,6 +13,7 @@ function(gtest target test_source_files test_libraries)
             target_link_libraries(test-${target} ${test_libraries})
         endif ()
         add_test(NAME test-${target} COMMAND test-${target})
+        set_tests_properties(test-${target} PROPERTIES LABELS "unit;all")
 
         message(STATUS "Added test 'test-${target}'")
 
@@ -23,8 +24,8 @@ function(gtest target test_source_files test_libraries)
             SETUP_TARGET_FOR_COVERAGE(NAME coverage-${target} EXECUTABLE test-${target} ${target})
             add_test(NAME coveragetest-${target}
                     COMMAND ${CMAKE_MODULE_PATH}/check_test.sh
-                    coverage-${target} ${CMAKE_BINARY_DIR} ${HIDRA2_MINIMUM_COVERAGE}
-                    )
+                    coverage-${target} ${CMAKE_BINARY_DIR} ${HIDRA2_MINIMUM_COVERAGE})
+            set_tests_properties(coveragetest-${target} PROPERTIES LABELS "coverage;all")
             SET_TESTS_PROPERTIES(coveragetest-${target} PROPERTIES DEPENDS test-${target})
             set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS} PARENT_SCOPE)
             set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} PARENT_SCOPE)

common/cpp/CMakeLists.txt

@@ -3,8 +3,9 @@ set(SOURCE_FILES
         include/common/os.h
         include/common/networking.h
         include/system_wrappers/io.h
-        include/system_wrappers/system_io.h src/system_io.cpp
-        include/system_wrappers/system_io_linux.cpp)
+        include/system_wrappers/system_io.h
+        src/system_io.cpp
+        src/system_io_linux.cpp)
 
 
 ################################

common/cpp/include/system_wrappers/system_io_linux.cpp → common/cpp/src/system_io_linux.cpp

-#include "system_io.h"
+#include "system_wrappers/system_io.h"
 
 namespace hidra2 {
 
 std::vector<std::string> SystemIO::FilesInFolder(std::string folder, IOErrors* err) {
+    *err=IOErrors::FOLDER_NOT_FOUND;
     return {};
-// TODO
 }
 
 }
\ No newline at end of file

tests/CMakeLists.txt

+
+add_subdirectory(system_io)
+

tests/system_io/CMakeLists.txt

+set(TARGET_NAME read_folder_content)
+set(SOURCE_FILES read_folder_content.cpp)
+
+
+################################
+# Executable and link
+################################
+add_executable(${TARGET_NAME} ${SOURCE_FILES})
+target_link_libraries(${TARGET_NAME} common)
+set_target_properties(${TARGET_NAME} PROPERTIES LINKER_LANGUAGE CXX)
+
+################################
+# Testing
+################################
+
+add_test(NAME test-${TARGET_NAME} COMMAND ${TARGET_NAME} test notfound)
+set_tests_properties(test-${TARGET_NAME} PROPERTIES LABELS "integration;all")

tests/system_io/read_folder_content.cpp

+#include <iostream>
+#include <string>
+
+#include <system_wrappers/system_io.h>
+
+using hidra2::SystemIO;
+using hidra2::IOErrors;
+
+#
+
+
+void M_Assert(bool expr, std::string expected, std::string got, std::string msg) {
+    if (!expr) {
+        std::cerr << "Assert failed:\t" << msg << "\n"
+                  << "Expected:\t'" << expected << "'\n"
+                  << "Obtained:\t'" << got << "'\n";
+        abort();
+    }
+}
+
+
+int main(int argc, char* argv[]) {
+    auto io = new SystemIO;
+
+    if (argc != 3) {
+        std::cout << "Wrong number of arguments" << std::endl;
+        return 1;
+    }
+
+    std::string expect{argv[2]};
+
+    IOErrors err;
+
+    auto files = io->FilesInFolder(argv[1], &err);
+
+    switch (err) {
+    case IOErrors::FOLDER_NOT_FOUND:
+        M_Assert(expect.compare("notfound")==0,expect,"notfound","Folder not found");
+        return 0;
+    }
+
+    return 1;
+}

worker/api/cpp/src/folder_data_broker.cpp

@@ -7,16 +7,17 @@
 namespace hidra2 {
 
 WorkerErrorCode MapIOError(IOErrors io_err) {
-    std::map<IOErrors,WorkerErrorCode> error_mapping= {
-        {IOErrors::NO_ERROR,WorkerErrorCode::ERR__NO_ERROR},
-        {IOErrors::FOLDER_NOT_FOUND,WorkerErrorCode::SOURCE_NOT_FOUND}
-    };
-
-    auto search=error_mapping.find(io_err);
-
-    WorkerErrorCode err = WorkerErrorCode::UNKNOWN_IO_ERROR;
-    if(search != error_mapping.end()) {
-        err=search->second;
+    WorkerErrorCode err;
+    switch (io_err) { // we do not use map due to performance reasons
+        case IOErrors::NO_ERROR:
+            err = WorkerErrorCode::ERR__NO_ERROR;
+            break;
+        case IOErrors::FOLDER_NOT_FOUND:
+            err = WorkerErrorCode::SOURCE_NOT_FOUND;
+            break;
+        default:
+            err = WorkerErrorCode::UNKNOWN_IO_ERROR;
+            break;
     }
 
     return err;