add test data and test report

.github/workflows/ci.yml

@@ -43,6 +43,23 @@ jobs:
           git config --global --add safe.directory $GITHUB_WORKSPACE
           cmake --preset default
           cmake --build ./build -- -j2
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: test
+        run: |
+          cd build/bin
+          ./srs_backend_test --gtest_output=xml
+
+      - name: publish test report
+        uses: mikepenz/action-junit-report@v5
+        if: success() || failure()
+        with:
+          report_paths: 'build/bin/test_detail.xml'
+
+      - name: cache-delete
+        run: |
+          git config --global --add safe.directory $GITHUB_WORKSPACE
           gh cache delete ${{ steps.cache-restore.outputs.cache-primary-key }} || true
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

backend/srs/Application.cpp

@@ -30,18 +30,25 @@ namespace srs
     {
         auto monitoring_action = [this]()
         {
-            signal_set_.async_wait(
-                [this](const boost::system::error_code& error, auto)
-                {
-                    if (error == asio::error::operation_aborted)
+            try
+            {
+                signal_set_.async_wait(
+                    [this](const boost::system::error_code& error, auto)
                     {
-                        return;
-                    }
+                        if (error == asio::error::operation_aborted)
+                        {
+                            return;
+                        }
 
-                    spdlog::trace("calling SIGINT from monitoring thread");
-                    exit();
-                });
-            io_context_.join();
+                        spdlog::trace("calling SIGINT from monitoring thread");
+                        exit();
+                    });
+                io_context_.join();
+            }
+            catch (const std::exception& ex)
+            {
+                spdlog::critical("Exception on working thread occured: {}", ex.what());
+            }
             end_of_work();
             spdlog::debug("Application: working thread is finished");
         };

backend/srs/Application.hpp

@@ -48,20 +48,23 @@ namespace srs
         void set_status_is_reading(bool val = true) { status_.is_reading.store(val); }
         void set_print_mode(DataPrintMode mode);
         void set_output_filenames(const std::vector<std::string>& filenames);
+        void set_error_string(std::string_view err_msg) { error_string_ = err_msg; }
 
         // getters:
         [[nodiscard]] auto get_channel_address() const -> uint16_t { return channel_address_; }
         // [[nodiscard]] auto get_fec_config() const -> const auto& { return fec_config_; }
         [[nodiscard]] auto get_status() const -> const auto& { return status_; }
         [[nodiscard]] auto get_io_context() -> auto& { return io_context_; }
         auto get_data_reader() -> DataReader* { return data_reader_.get(); }
+        [[nodiscard]] auto get_error_string() const -> const std::string& { return error_string_; }
 
       private:
         using udp = asio::ip::udp;
 
         Status status_;
         uint16_t channel_address_ = DEFAULT_CHANNEL_ADDRE;
         Config configurations_;
+        std::string error_string_;
         io_context_type io_context_{ 4 };
         asio::executor_work_guard<io_context_type::executor_type> io_work_guard_;
         asio::signal_set signal_set_{ io_context_, SIGINT, SIGTERM };

backend/srs/analysis/DataProcessor.cpp

@@ -147,11 +147,13 @@ namespace srs
         catch (tbb::user_abort& ex)
         {
             spdlog::debug("Data processing: {}", ex.what());
+            app_->set_error_string(ex.what());
         }
         catch (std::exception& ex)
         {
             spdlog::critical("Exception occured: {}", ex.what());
-            app_->exit();
+            app_->set_error_string(ex.what());
+            // app_->exit();
         }
         spdlog::debug("Analysis loop is stopped");
     }

backend/srs/converters/DataConvertOptions.hpp

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <array>
 #include <cstdint>
+#include <print>
 #include <string_view>
 
 namespace srs
@@ -69,6 +70,9 @@ namespace srs
 
     constexpr auto convert_option_has_dependency(DataConvertOptions dependee, DataConvertOptions depender) -> bool
     {
+        std::println("-----------dependee: {}, depender: {}",
+                     convert_option_to_string(dependee),
+                     convert_option_to_string(dependee));
         if (dependee == depender)
         {
             return true;

backend/srs/utils/AppStatus.hpp

@@ -12,6 +12,7 @@ namespace srs
         std::atomic<bool> is_reading = false;
         std::atomic<bool> is_acq_off = false;
         std::atomic<bool> is_on_exit = false;
+        // std::atomic<bool> is_already_exit = false;
         std::condition_variable status_change;
 
         void wait_for_status(auto&& condition, std::chrono::seconds time_duration = DEFAULT_STATUS_WAITING_TIME_SECONDS)

backend/srs/utils/ConnectionBase.hpp

@@ -71,6 +71,7 @@ namespace srs
         udp::endpoint remote_endpoint_;
         SerializableMsgBuffer write_msg_buffer_;
         std::span<const char> continuous_send_msg_;
+        std::unique_ptr<asio::signal_set> signal_set_;
         ReadBufferType<buffer_size> read_msg_buffer_{};
         int timeout_seconds_ = DEFAULT_TIMEOUT_SECONDS;
 
@@ -130,10 +131,8 @@ namespace srs
                 co_return;
             }
 
-            spdlog::trace("reading messages ...");
             auto receive_data_size = co_await connection->socket_->async_receive(
                 asio::buffer(connection->read_msg_buffer_), asio::use_awaitable);
-            spdlog::trace("Messages received");
             auto read_msg = std::span{ connection->read_msg_buffer_.data(), receive_data_size };
             connection->read_data_handle(read_msg);
             // spdlog::info("Connection {}: received {} bytes data", connection->get_name(), read_msg.size());
@@ -169,9 +168,9 @@ namespace srs
     template <int size>
     auto ConnectionBase<size>::signal_handling(auto* connection) -> asio::awaitable<void>
     {
-        auto interrupt_signal = asio::signal_set(co_await asio::this_coro::executor, SIGINT);
+        connection->signal_set_ = std::make_unique<asio::signal_set>(co_await asio::this_coro::executor, SIGINT);
         spdlog::trace("Connection {}: waiting for signals", connection->get_name());
-        auto [error, sig_num] = co_await interrupt_signal.async_wait(asio::as_tuple(asio::use_awaitable));
+        auto [error, sig_num] = co_await connection->signal_set_->async_wait(asio::as_tuple(asio::use_awaitable));
         if (error == asio::error::operation_aborted)
         {
             spdlog::trace("Connection {}: Signal ended with {}", connection->get_name(), error.message());
@@ -244,6 +243,10 @@ namespace srs
             spdlog::trace("Connection {}: Closing the socket ...", name_);
             socket_->cancel();
             socket_->close();
+            if (signal_set_ != nullptr)
+            {
+                signal_set_->cancel();
+            }
             spdlog::trace("Connection {}: Socket is closed and cancelled.", name_);
         }
     }

test/CMakeLists.txt

@@ -1,3 +1,4 @@
-if(ENABLE_TEST)
-    add_subdirectory(backend)
-endif()
+add_subdirectory(backend)
+
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/data/test_data.bin
+               ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_data.bin COPYONLY USE_SOURCE_PERMISSIONS)

test/backend/srs/TestOutputs.cpp

@@ -7,7 +7,7 @@ namespace srs::test
 {
     namespace
     {
-        void run_application(const std::string& output_filename)
+        void run_application(const std::string& output_filename, std::string& error_msg)
         {
             try
             {
@@ -28,10 +28,11 @@ namespace srs::test
                 emulator.start_send_data();
                 app.exit();
                 app.wait_for_finish();
+                error_msg = app.get_error_string();
             }
-            catch (const std::runtime_error& err)
+            catch (std::exception& ex)
             {
-                spdlog::critical("Exception occurred: {}", err.what());
+                spdlog::critical("Exception occured: {}", ex.what());
             }
         }
 
@@ -55,15 +56,19 @@ namespace
 TEST(check_outputs, binary_output)
 {
     const auto filename = std::string{ "test_output.bin" };
-    srs::test::run_application(filename);
+    auto error_msg = std::string{};
+    ASSERT_NO_THROW(srs::test::run_application(filename, error_msg));
+    EXPECT_EQ(error_msg, "");
     auto res = check_if_file_exist(filename);
     ASSERT_TRUE(res);
 }
 
 TEST(check_outputs, root_output)
 {
     const auto filename = std::string{ "test_output.root" };
-    srs::test::run_application(filename);
+    auto error_msg = std::string{};
+    ASSERT_NO_THROW(srs::test::run_application(filename, error_msg));
+    EXPECT_EQ(error_msg, "");
     auto res = check_if_file_exist(filename);
 #ifdef HAS_ROOT
     ASSERT_TRUE(res);
@@ -75,15 +80,19 @@ TEST(check_outputs, root_output)
 TEST(check_outputs, proto_binary)
 {
     const auto filename = std::string{ "test_output.binpb" };
-    srs::test::run_application(filename);
+    auto error_msg = std::string{};
+    ASSERT_NO_THROW(srs::test::run_application(filename, error_msg));
+    EXPECT_EQ(error_msg, "");
     auto res = check_if_file_exist(filename);
     ASSERT_TRUE(res);
 }
 
 TEST(check_outputs, json_output)
 {
     const auto filename = std::string{ "test_output.json" };
-    srs::test::run_application(filename);
+    auto error_msg = std::string{};
+    ASSERT_NO_THROW(srs::test::run_application(filename, error_msg));
+    EXPECT_EQ(error_msg, "");
     auto res = check_if_file_exist(filename);
 #ifdef HAS_ROOT
     ASSERT_TRUE(res);