Precommit (#1)

* first commit

* cleanup

tests/component_tests/core_library/CMakeLists.txt

@@ -0,0 +1,31 @@
+# Define project
+project (ComponentTest_CoreLibrary VERSION 1.0 LANGUAGES CXX)
+
+# Data maneger executable
+add_executable(ComponentTest_CoreLibrary
+    "main.cpp"
+    "app_control_test.cpp"
+    "app_control_test_no_event_handler.cpp"
+    "app_control_test_event_handler.cpp"
+    "app_control_test_mgnt_class.cpp"
+     "app_config.cpp")
+
+target_link_libraries(ComponentTest_CoreLibrary ${CMAKE_DL_LIBS} GTest::GTest)
+
+# Add the Data Dispatch Service unittest
+add_test(NAME ComponentTest_CoreLibrary COMMAND ComponentTest_CoreLibrary WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+
+# Execute the test
+# Currently disabled due to issues with MINGW causing the application to sporadically crash. A bug ticket has been filed:
+# https://dev.azure.com/SW4ZF/AZP-074_DivDI_SofDCarResearch/_workitems/edit/608132
+#add_custom_command(TARGET ComponentTest_CoreLibrary POST_BUILD
+#    COMMAND ${CMAKE_COMMAND} -E env TEST_EXECUTION_MODE=CMake "$<TARGET_FILE:ComponentTest_CoreLibrary>" --gtest_output=xml:${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ComponentTest_CoreLibrary.xml
+#    VERBATIM
+#)
+
+
+# Build dependencies
+add_dependencies(ComponentTest_CoreLibrary install_manifest)
+add_dependencies(ComponentTest_CoreLibrary dependency_sdv_components)
+add_dependencies(ComponentTest_CoreLibrary data_dispatch_service)
+add_dependencies(ComponentTest_CoreLibrary ComponentTest_Repository)    # Use the repository components for this test

tests/component_tests/core_library/app_config.cpp

@@ -0,0 +1,29 @@
+// Application config tests
+// Load config file - Save config file - identical?
+// Load config file - add module - save config file - module added?
+// Load config file - add and delete module - identical?
+// Load config file - add component - save config file - module added?
+// Load config file - add and delete component - identical?
+// Load config file - load another config file - Save config file - identical to last config file?
+// Load config file - reset baseline - add module - save config file - only module in config?
+// Load config file - reset baseline - add component - save config file - only component in config?
+// Add module - save config - only module in config?
+// Add component - save config - only component in config?
+// Add config file in Startup - config loaded?
+// For main app: add system config file in settings - config loaded?
+// For main app: add multiple system config file in settings - config loaded?
+// For main app: add application config file in settings - config loaded?
+// For main app: add multiple system config files and an application config in settings - configs loaded?
+// For main app: add application config file in settings - config loaded? - add component - auto save config - config updated with additional compoment?
+// For main app: add multiple system config files and an application config file in settings - config loaded? - add component - auto save config - config updated with additional compoment?
+// For main app: add system config file in settings - add config in application startup - configs loaded?
+// For main app: add multiple system config file in settings - add config in application startup - configs loaded?
+// For main app: add application config file in settings - add config in application startup - startup config loaded (and otherone not)?
+// For main app: add application config file in settings - add config in application startup - add service - startup config not updated? Settings config also not?
+// Test search algorithm with multiple modules with similar name in different location for standalone and essential
+// Test search algorithm with multiple modules with similar name in different location for main and isolated
+// Test configuration saving of module path shoudl not change when module is found somewhere else.
+// Test not existing config
+// Test partially existing config (some modules/components do not exist)
+// Test multiple manifest for loading components
+

tests/component_tests/core_library/app_control_test.cpp

@@ -0,0 +1,33 @@
+#include <gtest/gtest.h>
+#include <support/sdv_core.h>
+#include <interfaces/app.h>
+#include <support/mem_access.h>
+#include <support/app_control.h>
+#include "../../../global/exec_dir_helper.h"
+
+TEST(CoreLibrary_AppControl, SetModuleSearchPath)
+{
+    sdv::core::IModuleControlConfig* pModuleConfig = sdv::core::GetCore<sdv::core::IModuleControlConfig>();
+    ASSERT_NE(pModuleConfig, nullptr);
+    bool bResult = pModuleConfig->AddModuleSearchDir("../../bin");
+    EXPECT_TRUE(bResult);
+    sdv::sequence<sdv::u8string> seqSearchDirs = pModuleConfig->GetModuleSearchDirs();
+    std::filesystem::path pathModuleDir = (GetExecDirectory() / "../../bin").lexically_normal();
+    auto itDir = std::find_if(seqSearchDirs.begin(), seqSearchDirs.end(),
+        [&](const sdv::u8string& rssDir)
+        {
+            std::filesystem::path pathDir = static_cast<std::string>(rssDir);
+            if (pathDir.is_relative())
+                pathDir = (GetExecDirectory() / pathDir).lexically_normal();
+            return pathDir == pathModuleDir;
+        });
+    EXPECT_NE(itDir, seqSearchDirs.end());
+}
+
+TEST(CoreLibrary_AppControl, SetModuleSearchPathMgntClass)
+{
+    sdv::app::CAppControl appcontrol;
+    bool bResult = appcontrol.AddModuleSearchDir("../../bin");
+    EXPECT_TRUE(bResult);
+}
+

tests/component_tests/core_library/app_control_test_mgnt_class.cpp

@@ -0,0 +1,510 @@
+#include <gtest/gtest.h>
+#include <support/sdv_core.h>
+#include <interfaces/app.h>
+#include <support/mem_access.h>
+#include <support/app_control.h>
+#include "../../../sdv_services/core/local_shutdown_request.h"
+#include "../../../global/base64.h"
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Invalid_ApplicationMode)
+{
+    // Prevent error reporting on std::cerr - they will influence test outcome.
+    auto* pCErr = std::cerr.rdbuf();
+    std::ostringstream sstreamCErr;
+    std::cerr.rdbuf(sstreamCErr.rdbuf());
+
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Invalid\"");
+    EXPECT_FALSE(bResult);
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    std::cerr.rdbuf(pCErr);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Default_NoConfig)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::standalone);
+    EXPECT_EQ(control.GetInstanceID(), 1000u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Standalone_NoConfig)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Standalone\"");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::standalone);
+    EXPECT_EQ(control.GetInstanceID(), 1000u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_External_NoConfig)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"External\"");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::external);
+    EXPECT_EQ(control.GetInstanceID(), 1000u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Isolated_NoConfig)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup(R"code(
+[Application]
+Mode = "Isolated"
+
+[Console]
+Report = "Silent"
+)code");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::isolated);
+    EXPECT_EQ(control.GetInstanceID(), 1000u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Main_NoConfig)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Main\"");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::main);
+    EXPECT_EQ(control.GetInstanceID(), 1000u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Essential_NoConfig)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Essential\"");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::essential);
+    EXPECT_EQ(control.GetInstanceID(), 1000u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Maintenance_NoConfig)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Maintenance\"");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::maintenance);
+    EXPECT_EQ(control.GetInstanceID(), 1000u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Default_DefineInstance)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nInstance=2005");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::standalone);
+    EXPECT_EQ(control.GetInstanceID(), 2005u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Standalone_DefineInstance)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Standalone\"\nInstance=2005");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::standalone);
+    EXPECT_EQ(control.GetInstanceID(), 2005u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_External_DefineInstance)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"External\"\nInstance=2005");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::external);
+    EXPECT_EQ(control.GetInstanceID(), 2005u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Isolated_DefineInstance)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    std::string ssConfig = R"code([Application]
+Mode = "Isolated"
+Instance = 2005
+Connection = ")code";
+    ssConfig += Base64EncodePlainText("test") + "\"";
+    bool bResult = control.Startup(ssConfig);
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::isolated);
+    EXPECT_EQ(control.GetInstanceID(), 2005u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Main_DefineInstance)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Main\"\nInstance=2005");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::main);
+    EXPECT_EQ(control.GetInstanceID(), 2005u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Essential_DefineInstance)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Essential\"\nInstance=2005");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::essential);
+    EXPECT_EQ(control.GetInstanceID(), 2005u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, Startup_Maintenance_DefineInstance)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Maintenance\"\nInstance=2005");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::maintenance);
+    EXPECT_EQ(control.GetInstanceID(), 2005u);
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, RunLoop_Default)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nInstance=2007");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::standalone);
+    EXPECT_EQ(control.GetInstanceID(), 2007u);
+
+    auto tpStart = std::chrono::high_resolution_clock::now();
+    std::thread threadShutdownRequest([]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(250));
+            RequestShutdown(2007u);
+        });
+    EXPECT_TRUE(control.RunLoop());
+    EXPECT_GT(std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count(), 0.100);
+    threadShutdownRequest.join();
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, RunLoop_Standalone)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Standalone\"\nInstance=2007");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::standalone);
+    EXPECT_EQ(control.GetInstanceID(), 2007u);
+
+    auto tpStart = std::chrono::high_resolution_clock::now();
+    std::thread threadShutdownRequest([]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(250));
+            RequestShutdown(2007u);
+        });
+    EXPECT_TRUE(control.RunLoop());
+    EXPECT_GT(std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count(), 0.100);
+    threadShutdownRequest.join();
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, RunLoop_External)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"External\"\nInstance=2007");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::external);
+    EXPECT_EQ(control.GetInstanceID(), 2007u);
+
+    auto tpStart = std::chrono::high_resolution_clock::now();
+    std::thread threadShutdownRequest([]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(250));
+            RequestShutdown(2007u);
+        });
+    EXPECT_TRUE(control.RunLoop());
+    EXPECT_GT(std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count(), 0.100);
+    threadShutdownRequest.join();
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, RunLoop_Isolated)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    std::string ssConfig = R"code([Application]
+Mode = "Isolated"
+Instance = 2007
+Connection = ")code";
+    ssConfig += Base64EncodePlainText("test") + "\"";
+    bool bResult = control.Startup(ssConfig);
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::isolated);
+    EXPECT_EQ(control.GetInstanceID(), 2007u);
+
+    auto tpStart = std::chrono::high_resolution_clock::now();
+    std::thread threadShutdownRequest([]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(250));
+            sdv::app::IAppShutdownRequest* pShutdownRequest = sdv::core::GetObject<sdv::app::IAppShutdownRequest>("AppControlService");
+            ASSERT_NE(pShutdownRequest, nullptr);
+            pShutdownRequest->RequestShutdown();
+        });
+    EXPECT_TRUE(control.RunLoop());
+    EXPECT_GT(std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count(), 0.100);
+    threadShutdownRequest.join();
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, RunLoop_Main)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Main\"\nInstance=2007");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::main);
+    EXPECT_EQ(control.GetInstanceID(), 2007u);
+
+    auto tpStart = std::chrono::high_resolution_clock::now();
+    std::thread threadShutdownRequest([]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(250));
+            sdv::app::IAppShutdownRequest* pShutdownRequest = sdv::core::GetObject<sdv::app::IAppShutdownRequest>("AppControlService");
+            ASSERT_NE(pShutdownRequest, nullptr);
+            pShutdownRequest->RequestShutdown();
+        });
+    EXPECT_TRUE(control.RunLoop());
+    EXPECT_GT(std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count(), 0.100);
+    threadShutdownRequest.join();
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, RunLoop_Essential)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Essential\"\nInstance=2007");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::essential);
+    EXPECT_EQ(control.GetInstanceID(), 2007u);
+
+    auto tpStart = std::chrono::high_resolution_clock::now();
+    std::thread threadShutdownRequest([]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(250));
+            RequestShutdown(2007u);
+        });
+    EXPECT_TRUE(control.RunLoop());
+    EXPECT_GT(std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count(), 0.100);
+    threadShutdownRequest.join();
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_MgntClass, RunLoop_Maintenance)
+{
+    sdv::app::CAppControl control;
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+
+    bool bResult = control.Startup("[Application]\nMode=\"Maintenance\"\nInstance=2007");
+    EXPECT_TRUE(bResult);
+    EXPECT_TRUE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::maintenance);
+    EXPECT_EQ(control.GetInstanceID(), 2007u);
+
+    // Loop not allowed...
+    EXPECT_FALSE(control.RunLoop());
+
+    control.Shutdown();
+    EXPECT_FALSE(control.IsRunning());
+    EXPECT_EQ(control.GetAppContext(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(control.GetInstanceID(), 0u);
+}
+

tests/component_tests/core_library/app_control_test_no_event_handler.cpp

@@ -0,0 +1,643 @@
+#include <gtest/gtest.h>
+#include <support/sdv_core.h>
+#include <interfaces/app.h>
+#include <support/mem_access.h>
+#include <support/app_control.h>
+#include "../../../sdv_services/core/local_shutdown_request.h"
+#include "../../../global/base64.h"
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Invalid_ApplicationMode)
+{
+    // Prevent error reporting on std::cerr - they will influence test outcome.
+    auto* pCErr = std::cerr.rdbuf();
+    std::ostringstream sstreamCErr;
+    std::cerr.rdbuf(sstreamCErr.rdbuf());
+
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Invalid\"", nullptr);
+    EXPECT_FALSE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    std::cerr.rdbuf(pCErr);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Default_NoConfig)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::standalone);
+    EXPECT_EQ(pContext->GetInstanceID(), 1000u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Standalone_NoConfig)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Standalone\"", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::standalone);
+    EXPECT_EQ(pContext->GetInstanceID(), 1000u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_External_NoConfig)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"External\"", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::external);
+    EXPECT_EQ(pContext->GetInstanceID(), 1000u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Isolated_NoConfig)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup(R"code(
+[Application]
+Mode = "Isolated"
+
+[Console]
+Report = "Silent"
+)code", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::isolated);
+    EXPECT_EQ(pContext->GetInstanceID(), 1000u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Main_NoConfig)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Main\"", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::main);
+    EXPECT_EQ(pContext->GetInstanceID(), 1000u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Essential_NoConfig)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Essential\"", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::essential);
+    EXPECT_EQ(pContext->GetInstanceID(), 1000u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Maintenance_NoConfig)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Maintenance\"", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::maintenance);
+    EXPECT_EQ(pContext->GetInstanceID(), 1000u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Default_DefineInstance)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nInstance=2005", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::standalone);
+    EXPECT_EQ(pContext->GetInstanceID(), 2005u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Standalone_DefineInstance)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Standalone\"\nInstance=2005", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::standalone);
+    EXPECT_EQ(pContext->GetInstanceID(), 2005u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_External_DefineInstance)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"External\"\nInstance=2005", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::external);
+    EXPECT_EQ(pContext->GetInstanceID(), 2005u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Isolated_DefineInstance)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    std::string ssConfig = R"code([Application]
+Mode = "Isolated"
+Instance = 2005
+Connection = ")code";
+    ssConfig += Base64EncodePlainText("test") + "\"";
+    bool bResult = pControl->Startup(ssConfig, nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::isolated);
+    EXPECT_EQ(pContext->GetInstanceID(), 2005u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Main_DefineInstance)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Main\"\nInstance=2005", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::main);
+    EXPECT_EQ(pContext->GetInstanceID(), 2005u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Essential_DefineInstance)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Essential\"\nInstance=2005", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::essential);
+    EXPECT_EQ(pContext->GetInstanceID(), 2005u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, Startup_Maintenance_DefineInstance)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Maintenance\"\nInstance=2005", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::maintenance);
+    EXPECT_EQ(pContext->GetInstanceID(), 2005u);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, RunLoop_Default)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nInstance=2007", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::standalone);
+    EXPECT_EQ(pContext->GetInstanceID(), 2007u);
+
+    auto tpStart = std::chrono::high_resolution_clock::now();
+    std::thread threadShutdownRequest([]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(250));
+            RequestShutdown(2007u);
+        });
+    pControl->RunLoop();
+    EXPECT_GT(std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count(), 0.100);
+    threadShutdownRequest.join();
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, RunLoop_Standalone)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Standalone\"\nInstance=2007", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::standalone);
+    EXPECT_EQ(pContext->GetInstanceID(), 2007u);
+
+    auto tpStart = std::chrono::high_resolution_clock::now();
+    std::thread threadShutdownRequest([]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(250));
+            RequestShutdown(2007u);
+        });
+    pControl->RunLoop();
+    EXPECT_GT(std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count(), 0.100);
+    threadShutdownRequest.join();
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, RunLoop_External)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"External\"\nInstance=2007", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::external);
+    EXPECT_EQ(pContext->GetInstanceID(), 2007u);
+
+    auto tpStart = std::chrono::high_resolution_clock::now();
+    std::thread threadShutdownRequest([]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(250));
+            RequestShutdown(2007u);
+        });
+    pControl->RunLoop();
+    EXPECT_GT(std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count(), 0.100);
+    threadShutdownRequest.join();
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, RunLoop_Isolated)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    std::string ssConfig = R"code([Application]
+Mode = "Isolated"
+Instance = 2007
+Connection = ")code";
+    ssConfig += Base64EncodePlainText("test") + "\"";
+    bool bResult = pControl->Startup(ssConfig, nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::isolated);
+    EXPECT_EQ(pContext->GetInstanceID(), 2007u);
+
+    auto tpStart = std::chrono::high_resolution_clock::now();
+    std::thread threadShutdownRequest([]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(250));
+            sdv::app::IAppShutdownRequest* pShutdownRequest = sdv::core::GetObject<sdv::app::IAppShutdownRequest>("AppControlService");
+            ASSERT_NE(pShutdownRequest, nullptr);
+            pShutdownRequest->RequestShutdown();
+        });
+    pControl->RunLoop();
+    EXPECT_GT(std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count(), 0.100);
+    threadShutdownRequest.join();
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, RunLoop_Main)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Main\"\nInstance=2007", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::main);
+    EXPECT_EQ(pContext->GetInstanceID(), 2007u);
+
+    auto tpStart = std::chrono::high_resolution_clock::now();
+    std::thread threadShutdownRequest([]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(250));
+            sdv::app::IAppShutdownRequest* pShutdownRequest = sdv::core::GetObject<sdv::app::IAppShutdownRequest>("AppControlService");
+            ASSERT_NE(pShutdownRequest, nullptr);
+            pShutdownRequest->RequestShutdown();
+        });
+    pControl->RunLoop();
+    EXPECT_GT(std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count(), 0.100);
+    threadShutdownRequest.join();
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, RunLoop_Essential)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Essential\"\nInstance=2007", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::essential);
+    EXPECT_EQ(pContext->GetInstanceID(), 2007u);
+
+    auto tpStart = std::chrono::high_resolution_clock::now();
+    std::thread threadShutdownRequest([]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(250));
+            RequestShutdown(2007u);
+        });
+    pControl->RunLoop();
+    EXPECT_GT(std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count(), 0.100);
+    threadShutdownRequest.join();
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+
+TEST(CoreLibrary_AppControl_NoEventHandler, RunLoop_Maintenance)
+{
+    sdv::app::IAppControl* pControl = sdv::core::GetCore<sdv::app::IAppControl>();
+    ASSERT_NE(pControl, nullptr);
+    sdv::app::IAppContext* pContext = sdv::core::GetCore<sdv::app::IAppContext>();
+    ASSERT_NE(pContext, nullptr);
+    sdv::app::IAppOperation* pOperation = sdv::core::GetCore<sdv::app::IAppOperation>();
+    ASSERT_NE(pOperation, nullptr);
+
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+
+    bool bResult = pControl->Startup("[Application]\nMode=\"Maintenance\"\nInstance=2007", nullptr);
+    EXPECT_TRUE(bResult);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::running);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::maintenance);
+    EXPECT_EQ(pContext->GetInstanceID(), 2007u);
+
+    // Loop not allowed...
+    EXPECT_THROW(pControl->RunLoop(), sdv::XAccessDenied);
+
+    pControl->Shutdown(true);
+    EXPECT_EQ(pOperation->GetOperationState(), sdv::app::EAppOperationState::not_started);
+    EXPECT_EQ(pContext->GetContextType(), sdv::app::EAppContext::no_context);
+    EXPECT_EQ(pContext->GetInstanceID(), 0u);
+}
+

tests/component_tests/core_library/main.cpp

@@ -0,0 +1,14 @@
+#include <gtest/gtest.h>
+#include "../../../global/process_watchdog.h"
+
+#if defined(_WIN32) && defined(_UNICODE)
+extern "C" int wmain(int argc, wchar_t* argv[])
+#else
+extern "C" int main(int argc, char* argv[])
+#endif
+{
+    CProcessWatchdog watchdog;
+
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}