diff --git a/doc/website/release-notes/iceoryx-unreleased.md b/doc/website/release-notes/iceoryx-unreleased.md
index bdc456c1ac..ab295ff03e 100644
--- a/doc/website/release-notes/iceoryx-unreleased.md
+++ b/doc/website/release-notes/iceoryx-unreleased.md
@@ -12,6 +12,8 @@
 
 **Refactoring:**
 
+- Separate test specific code from `ErrorHandler` and templatize `setTemporaryErrorHandler()` [\#1099](https://github.com/eclipse-iceoryx/iceoryx/issues/1099)
+
 **New API features:**
 
 **API Breaking Changes:**
diff --git a/iceoryx_binding_c/test/moduletests/test_c2cpp_enum_translation.cpp b/iceoryx_binding_c/test/moduletests/test_c2cpp_enum_translation.cpp
index 84977cb89f..e11c10a892 100644
--- a/iceoryx_binding_c/test/moduletests/test_c2cpp_enum_translation.cpp
+++ b/iceoryx_binding_c/test/moduletests/test_c2cpp_enum_translation.cpp
@@ -55,8 +55,8 @@ TEST(c2cpp_enum_translation_test, SubscriberState)
 // the clang sanitizer detects this successfully and this leads to termination, and with this the test fails
 #if !defined(__clang__)
     iox::Error errorValue = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error e, const std::function<void()>, const iox::ErrorLevel) { errorValue = e; });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error e, const iox::ErrorLevel) { errorValue = e; });
     EXPECT_EQ(c2cpp::subscriberState(iox_test_binding_c::maxUnderlyingCEnumValue<iox_SubscriberState>()),
               iox::popo::SubscriberState::HAS_DATA);
     EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__C2CPP_ENUM_TRANSLATION_INVALID_SUBSCRIBER_STATE_VALUE));
@@ -88,8 +88,8 @@ TEST(c2cpp_enum_translation_test, SubscriberEvent)
 // the clang sanitizer detects this successfully and this leads to termination, and with this the test fails
 #if !defined(__clang__)
     iox::Error errorValue = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error e, const std::function<void()>, const iox::ErrorLevel) { errorValue = e; });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error e, const iox::ErrorLevel) { errorValue = e; });
     EXPECT_EQ(c2cpp::subscriberEvent(iox_test_binding_c::maxUnderlyingCEnumValue<iox_SubscriberEvent>()),
               iox::popo::SubscriberEvent::DATA_RECEIVED);
     EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__C2CPP_ENUM_TRANSLATION_INVALID_SUBSCRIBER_EVENT_VALUE));
@@ -125,8 +125,8 @@ TEST(c2cpp_enum_translation_test, ConsumerTooSlowPolicy)
 // the clang sanitizer detects this successfully and this leads to termination, and with this the test fails
 #if !defined(__clang__)
     iox::Error errorValue = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error e, const std::function<void()>, const iox::ErrorLevel) { errorValue = e; });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error e, const iox::ErrorLevel) { errorValue = e; });
     EXPECT_EQ(c2cpp::consumerTooSlowPolicy(iox_test_binding_c::maxUnderlyingCEnumValue<iox_ConsumerTooSlowPolicy>()),
               iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA);
     EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__UNDEFINED_STATE_IN_IOX_CONSUMER_TOO_SLOW_POLICY));
@@ -162,8 +162,8 @@ TEST(c2cpp_enum_translation_test, QueueFullPolicy)
 // the clang sanitizer detects this successfully and this leads to termination, and with this the test fails
 #if !defined(__clang__)
     iox::Error errorValue = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error e, const std::function<void()>, const iox::ErrorLevel) { errorValue = e; });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error e, const iox::ErrorLevel) { errorValue = e; });
     EXPECT_EQ(c2cpp::queueFullPolicy(iox_test_binding_c::maxUnderlyingCEnumValue<iox_QueueFullPolicy>()),
               iox::popo::QueueFullPolicy::DISCARD_OLDEST_DATA);
     EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__UNDEFINED_STATE_IN_IOX_QUEUE_FULL_POLICY));
@@ -195,8 +195,8 @@ TEST(c2cpp_enum_translation_test, ClientState)
 // the clang sanitizer detects this successfully and this leads to termination, and with this the test fails
 #if !defined(__clang__)
     iox::Error errorValue = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error e, const std::function<void()>, const iox::ErrorLevel) { errorValue = e; });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error e, const iox::ErrorLevel) { errorValue = e; });
     EXPECT_EQ(c2cpp::clientState(iox_test_binding_c::maxUnderlyingCEnumValue<iox_ClientState>()),
               iox::popo::ClientState::HAS_RESPONSE);
     EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__C2CPP_ENUM_TRANSLATION_INVALID_CLIENT_STATE_VALUE));
@@ -228,8 +228,8 @@ TEST(c2cpp_enum_translation_test, ClientEvent)
 // the clang sanitizer detects this successfully and this leads to termination, and with this the test fails
 #if !defined(__clang__)
     iox::Error errorValue = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error e, const std::function<void()>, const iox::ErrorLevel) { errorValue = e; });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error e, const iox::ErrorLevel) { errorValue = e; });
     EXPECT_EQ(c2cpp::clientEvent(iox_test_binding_c::maxUnderlyingCEnumValue<iox_ClientEvent>()),
               iox::popo::ClientEvent::RESPONSE_RECEIVED);
     EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__C2CPP_ENUM_TRANSLATION_INVALID_CLIENT_EVENT_VALUE));
@@ -261,8 +261,8 @@ TEST(c2cpp_enum_translation_test, ServerState)
 // the clang sanitizer detects this successfully and this leads to termination, and with this the test fails
 #if !defined(__clang__)
     iox::Error errorValue = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error e, const std::function<void()>, const iox::ErrorLevel) { errorValue = e; });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error e, const iox::ErrorLevel) { errorValue = e; });
     EXPECT_EQ(c2cpp::serverState(iox_test_binding_c::maxUnderlyingCEnumValue<iox_ServerState>()),
               iox::popo::ServerState::HAS_REQUEST);
     EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__C2CPP_ENUM_TRANSLATION_INVALID_SERVER_STATE_VALUE));
@@ -294,8 +294,8 @@ TEST(c2cpp_enum_translation_test, ServerEvent)
 // the clang sanitizer detects this successfully and this leads to termination, and with this the test fails
 #if !defined(__clang__)
     iox::Error errorValue = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error e, const std::function<void()>, const iox::ErrorLevel) { errorValue = e; });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error e, const iox::ErrorLevel) { errorValue = e; });
     EXPECT_EQ(c2cpp::serverEvent(iox_test_binding_c::maxUnderlyingCEnumValue<iox_ServerEvent>()),
               iox::popo::ServerEvent::REQUEST_RECEIVED);
     EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__C2CPP_ENUM_TRANSLATION_INVALID_SERVER_EVENT_VALUE));
@@ -328,8 +328,8 @@ TEST(c2cpp_enum_translation_test, ServiceDiscoveryEvent)
 // the clang sanitizer detects this successfully and this leads to termination, and with this the test fails
 #if !defined(__clang__)
     iox::Error errorValue = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error e, const std::function<void()>, const iox::ErrorLevel) { errorValue = e; });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error e, const iox::ErrorLevel) { errorValue = e; });
     EXPECT_EQ(c2cpp::serviceDiscoveryEvent(iox_test_binding_c::maxUnderlyingCEnumValue<iox_ServiceDiscoveryEvent>()),
               iox::runtime::ServiceDiscoveryEvent::SERVICE_REGISTRY_CHANGED);
     EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__C2CPP_ENUM_TRANSLATION_INVALID_SERVICE_DISCOVERY_EVENT_VALUE));
@@ -366,8 +366,8 @@ TEST(c2cpp_enum_translation_test, MessagingPattern)
 // the clang sanitizer detects this successfully and this leads to termination, and with this the test fails
 #if !defined(__clang__)
     iox::Error errorValue = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error e, const std::function<void()>, const iox::ErrorLevel) { errorValue = e; });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error e, const iox::ErrorLevel) { errorValue = e; });
     EXPECT_EQ(c2cpp::messagingPattern(iox_test_binding_c::maxUnderlyingCEnumValue<iox_MessagingPattern>()),
               iox::popo::MessagingPattern::PUB_SUB);
     EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__C2CPP_ENUM_TRANSLATION_INVALID_MESSAGING_PATTERN_VALUE));
diff --git a/iceoryx_binding_c/test/test.hpp b/iceoryx_binding_c/test/test.hpp
index 922d8c91c5..2941c68a0b 100644
--- a/iceoryx_binding_c/test/test.hpp
+++ b/iceoryx_binding_c/test/test.hpp
@@ -17,6 +17,8 @@
 #ifndef IOX_BINDING_C_TEST_HPP
 #define IOX_BINDING_C_TEST_HPP
 
+#include "iceoryx_hoofs/testing/mocks/error_handler_mock.hpp"
+
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
diff --git a/iceoryx_hoofs/CMakeLists.txt b/iceoryx_hoofs/CMakeLists.txt
index a0ba120e74..5287a289e1 100644
--- a/iceoryx_hoofs/CMakeLists.txt
+++ b/iceoryx_hoofs/CMakeLists.txt
@@ -85,6 +85,7 @@ if(GTest_FOUND) # only GTest_FOUND, just in case someone want's to use iceoryx_h
     add_library(iceoryx_hoofs_testing
         STATIC
         testing/mocks/time_mock.cpp
+        testing/mocks/error_handler_mock.cpp
         testing/timing_test.cpp
         testing/compile_test.cpp
     )
@@ -113,12 +114,14 @@ if(GTest_FOUND) # only GTest_FOUND, just in case someone want's to use iceoryx_h
         $<INSTALL_INTERFACE:include/${PREFIX}>
     )
 
-    target_link_libraries(iceoryx_hoofs_testing PRIVATE
-        ${CODE_COVERAGE_LIBS}
-        iceoryx_hoofs
-        GTest::gtest
-        GTest::gmock
-        ${CMAKE_DL_LIBS}
+    target_link_libraries(iceoryx_hoofs_testing
+        PUBLIC
+            GTest::gtest
+            GTest::gmock
+        PRIVATE
+            ${CODE_COVERAGE_LIBS}
+            iceoryx_hoofs
+            ${CMAKE_DL_LIBS}
     )
 
     if(LINUX)
diff --git a/iceoryx_hoofs/include/iceoryx_hoofs/error_handling/error_handling.hpp b/iceoryx_hoofs/include/iceoryx_hoofs/error_handling/error_handling.hpp
index 2b5245c67a..6c338b82f0 100644
--- a/iceoryx_hoofs/include/iceoryx_hoofs/error_handling/error_handling.hpp
+++ b/iceoryx_hoofs/include/iceoryx_hoofs/error_handling/error_handling.hpp
@@ -17,20 +17,21 @@
 #ifndef IOX_HOOFS_ERROR_HANDLING_ERROR_HANDLING_HPP
 #define IOX_HOOFS_ERROR_HANDLING_ERROR_HANDLING_HPP
 
+/// @todo #1099 rename this file to error_handler.hpp
+
 #include "iceoryx_hoofs/cxx/generic_raii.hpp"
-#include "iceoryx_hoofs/cxx/vector.hpp"
+#include "iceoryx_hoofs/log/logger.hpp"
+#include "iceoryx_hoofs/log/logging.hpp"
+#include "iceoryx_hoofs/log/logmanager.hpp"
 
-#include <cassert>
 #include <functional>
 #include <iostream>
-#include <mutex>
 
 namespace iox
 {
 // clang-format off
 #define ICEORYX_ERRORS(error) \
     error(NO_ERROR)\
-    error(FILEREADER__FAILED_TO_OPEN_FILE) \
     error(POSH__ROUDI_PROCESS_SHUTDOWN_FAILED) \
     error(POSH__ROUDI_PROCESS_SEND_VIA_IPC_CHANNEL_FAILED)\
     error(POSH__RUNTIME_FACTORY_IS_NOT_SET) \
@@ -168,8 +169,6 @@ namespace iox
     error(ICEORYX_ROUDI_MEMORY_MANAGER__ROUDI_STILL_RUNNING) \
     error(ICEORYX_ROUDI_MEMORY_MANAGER__FAILED_TO_ADD_PORTPOOL_MEMORY_BLOCK) \
     error(ICEORYX_ROUDI_MEMORY_MANAGER__FAILED_TO_ADD_MANAGEMENT_MEMORY_BLOCK) \
-    error(MQ_UNKNOWN_MSG) \
-    error(MQ_INVALID_MSG) \
     error(IPC_INTERFACE__UNABLE_TO_CREATE_APPLICATION_CHANNEL) \
     error(IPC_INTERFACE__REG_ROUDI_NOT_AVAILABLE) \
     error(IPC_INTERFACE__REG_UNABLE_TO_WRITE_TO_ROUDI_CHANNEL) \
@@ -178,11 +177,6 @@ namespace iox
     error(IPC_INTERFACE__CHECK_MQ_MAPS_TO_FILE) \
     error(IPC_INTERFACE__APP_WITH_SAME_NAME_STILL_RUNNING) \
     error(IPC_INTERFACE__COULD_NOT_ACQUIRE_FILE_LOCK) \
-    error(POSIX_WRAPPER__FAILED_TO_CREATE_SEMAPHORE) \
-    error(POSIX_TIMER__FIRED_TIMER_BUT_STATE_IS_INVALID) \
-    error(POSIX_TIMER__TIMERPOOL_OVERFLOW) \
-    error(POSIX_TIMER__INCONSISTENT_STATE) \
-    error(POSIX_TIMER__CALLBACK_RUNTIME_EXCEEDS_RETRIGGER_TIME) \
     error(BINDING_C__UNDEFINED_STATE_IN_IOX_QUEUE_FULL_POLICY) \
     error(BINDING_C__UNDEFINED_STATE_IN_IOX_CONSUMER_TOO_SLOW_POLICY) \
     error(BINDING_C__PUBLISHER_OPTIONS_NOT_INITIALIZED) \
@@ -210,12 +204,6 @@ enum class Error : uint32_t
     ICEORYX_ERRORS(CREATE_ICEORYX_ERROR_ENUM)
 };
 
-/// @brief Convenience stream operator to easily use the Error enum with std::ostream
-/// @param[in] stream sink to write the message to
-/// @param[in] value to convert to a string literal
-/// @return the reference to `stream` which was provided as input parameter
-std::ostream& operator<<(std::ostream& stream, Error value) noexcept;
-
 /// @brief the available error levels
 /// FATAL
 /// - Log message with FATAL
@@ -242,45 +230,18 @@ enum class ErrorLevel : uint32_t
     MODERATE
 };
 
-using HandlerFunction = std::function<void(const Error error, const std::function<void()>, const ErrorLevel)>;
-
-/// @brief This handler is needed for unit testing, special debugging cases and
-///         other corner cases where we'd like to explicitly suppress the
-///         error handling.
-class ErrorHandler
-{
-    friend void
-    errorHandler(const Error error, const std::function<void()>& errorCallBack, const ErrorLevel level) noexcept;
-
-  public:
-    static cxx::GenericRAII setTemporaryErrorHandler(const HandlerFunction& newHandler) noexcept;
-
-    static const char* toString(const Error error) noexcept;
-
-  protected:
-    static void reactOnErrorLevel(const ErrorLevel level, const char* errorText) noexcept;
-
-  private:
-    static void defaultHandler(const Error error,
-                               const std::function<void()>& errorCallBack,
-                               const ErrorLevel level = ErrorLevel::FATAL) noexcept;
-
-    static const char* ERROR_NAMES[];
-    static iox::HandlerFunction handler;
-    /// Needed, if you want to exchange the handler. Remember the old one and call it if it is not your error. The error
-    /// mock needs to be the last one exchanging the handler in tests.
-    static std::mutex handler_mutex;
-};
-
 /// @brief Howto use the error handler correctly
-///     1.) If the error you would like to handle is not listed in ICEORYX_ERRORS(error)\...
-///             macro just add them like:
+///     1.) Use the macro ICEORYX_ERRORS(error) to create the enum for your component and
+///             add new errors like:
 ///             error(MODULE_NAME__MY_FUNKY_ERROR)
 ///         Attention: Create an error after the following convention:
 ///             MODULE_NAME__A_CLEAR_BUT_SHORT_ERROR_DESCRIPTION
 ///         And a long name is alright!
 ///
-///     2.) Call errorHandler(Error::kMODULE_NAME__MY_FUNKY_ERROR);
+///     2.) Specialize the following methods for your NewEnumErrorType:
+///         - const char* toString(const NewEnumErrorType error)
+///
+///     3.) Call errorHandler(Error::kMODULE_NAME__MY_FUNKY_ERROR);
 ///             Please pay attention to the "k" prefix
 ///         The defaults for errorCallback and ErrorLevel can also be overwritten:
 ///             errorHandler(
@@ -309,9 +270,36 @@ class ErrorHandler
 /// errorHandler(Error::kTEST__ASSERT_CALLED);
 /// ASSERT_TRUE(called);
 /// @endcode
+/// @tparam[in] Error type which is used to report the error (typically an enum)
+template <typename Error>
 void errorHandler(const Error error,
                   const std::function<void()>& errorCallBack = std::function<void()>(),
                   const ErrorLevel level = ErrorLevel::FATAL) noexcept;
+
+using HandlerFunction = std::function<void(const uint32_t, const char*, const ErrorLevel)>;
+
+/// @brief This handler is needed for unit testing, special debugging cases and
+///         other corner cases where we'd like to explicitly suppress the
+///         error handling.
+class ErrorHandler
+{
+    template <typename Error>
+    friend void
+    errorHandler(const Error error, const std::function<void()>& errorCallBack, const ErrorLevel level) noexcept;
+
+  protected:
+    static void reactOnErrorLevel(const ErrorLevel level, const char* errorText) noexcept;
+
+    static void
+    defaultHandler(const uint32_t error, const char* errorName, const ErrorLevel level = ErrorLevel::FATAL) noexcept;
+
+    static iox::HandlerFunction handler;
+};
+
+const char* toString(const Error error) noexcept;
+
 } // namespace iox
 
+#include "iceoryx_hoofs/internal/error_handling/error_handling.inl"
+
 #endif // IOX_HOOFS_ERROR_HANDLING_ERROR_HANDLING_HPP
diff --git a/iceoryx_hoofs/include/iceoryx_hoofs/internal/cxx/variant_queue.inl b/iceoryx_hoofs/include/iceoryx_hoofs/internal/cxx/variant_queue.inl
index 9c5e6dcbce..f3b7595079 100644
--- a/iceoryx_hoofs/include/iceoryx_hoofs/internal/cxx/variant_queue.inl
+++ b/iceoryx_hoofs/include/iceoryx_hoofs/internal/cxx/variant_queue.inl
@@ -1,5 +1,5 @@
 // Copyright (c) 2020 by Robert Bosch GmbH. All rights reserved.
-// Copyright (c) 2020 - 2021 by Apex.AI Inc. All rights reserved.
+// Copyright (c) 2020 - 2022 by Apex.AI Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -17,7 +17,7 @@
 #ifndef IOX_HOOFS_CXX_VARIANT_QUEUE_INL
 #define IOX_HOOFS_CXX_VARIANT_QUEUE_INL
 
-#include "iceoryx_hoofs/error_handling/error_handling.hpp"
+#include "iceoryx_hoofs/cxx/variant_queue.hpp"
 
 namespace iox
 {
diff --git a/iceoryx_hoofs/include/iceoryx_hoofs/internal/error_handling/error_handling.inl b/iceoryx_hoofs/include/iceoryx_hoofs/internal/error_handling/error_handling.inl
new file mode 100644
index 0000000000..f8d1fad732
--- /dev/null
+++ b/iceoryx_hoofs/include/iceoryx_hoofs/internal/error_handling/error_handling.inl
@@ -0,0 +1,33 @@
+// Copyright (c) 2022 by Apex.AI Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+#ifndef IOX_HOOFS_ERROR_HANDLING_ERROR_HANDLING_INL
+#define IOX_HOOFS_ERROR_HANDLING_ERROR_HANDLING_INL
+
+#include "iceoryx_hoofs/error_handling/error_handling.hpp"
+
+namespace iox
+{
+template <typename Error>
+inline void errorHandler(const Error error,
+                         const std::function<void()>& errorCallBack IOX_MAYBE_UNUSED,
+                         const ErrorLevel level) noexcept
+{
+    ErrorHandler::handler(static_cast<typename std::underlying_type<Error>::type>(error), toString(error), level);
+}
+
+} // namespace iox
+
+#endif // IOX_HOOFS_ERROR_HANDLING_ERROR_HANDLING_INL
\ No newline at end of file
diff --git a/iceoryx_hoofs/include/iceoryx_hoofs/internal/file_reader/file_reader.hpp b/iceoryx_hoofs/include/iceoryx_hoofs/internal/file_reader/file_reader.hpp
index 51b3d0342a..038920cd92 100644
--- a/iceoryx_hoofs/include/iceoryx_hoofs/internal/file_reader/file_reader.hpp
+++ b/iceoryx_hoofs/include/iceoryx_hoofs/internal/file_reader/file_reader.hpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2019 by Robert Bosch GmbH. All rights reserved.
-// Copyright (c) 2021 by Apex.AI Inc. All rights reserved.
+// Copyright (c) 2021 - 2022 by Apex.AI Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -17,8 +17,6 @@
 #ifndef IOX_HOOFS_FILE_READER_FILE_READER_HPP
 #define IOX_HOOFS_FILE_READER_FILE_READER_HPP
 
-#include "iceoryx_hoofs/error_handling/error_handling.hpp"
-
 #include <fstream>
 
 namespace iox
diff --git a/iceoryx_hoofs/source/error_handling/error_handling.cpp b/iceoryx_hoofs/source/error_handling/error_handling.cpp
index 91e2140123..0b4d29e027 100644
--- a/iceoryx_hoofs/source/error_handling/error_handling.cpp
+++ b/iceoryx_hoofs/source/error_handling/error_handling.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2019 by Robert Bosch GmbH. All rights reserved.
-// Copyright (c) 2021 by Apex.AI Inc. All rights reserved.
+// Copyright (c) 2021 - 2022 by Apex.AI Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -17,43 +17,24 @@
 
 #include "iceoryx_hoofs/error_handling/error_handling.hpp"
 
-#include "iceoryx_hoofs/log/logger.hpp"
-#include "iceoryx_hoofs/log/logging.hpp"
-#include "iceoryx_hoofs/log/logmanager.hpp"
-
-#include <iostream>
-#include <sstream>
-
 namespace iox
 {
-const char* ErrorHandler::ERROR_NAMES[] = {ICEORYX_ERRORS(CREATE_ICEORYX_ERROR_STRING)};
+const char* ERROR_NAMES[] = {ICEORYX_ERRORS(CREATE_ICEORYX_ERROR_STRING)};
 
 // NOLINTNEXTLINE(cert-err58-cpp) ErrorHander only used in tests
-HandlerFunction ErrorHandler::handler = {ErrorHandler::defaultHandler};
+iox::HandlerFunction ErrorHandler::handler = {ErrorHandler::defaultHandler};
 
-std::mutex ErrorHandler::handler_mutex;
-
-std::ostream& operator<<(std::ostream& stream, Error value) noexcept
+const char* toString(const Error error) noexcept
 {
-    stream << ErrorHandler::toString(value);
-    return stream;
+    return ERROR_NAMES[static_cast<typename std::underlying_type<Error>::type>(error)];
 }
 
-void ErrorHandler::defaultHandler(const Error error,
-                                  const std::function<void()>& errorCallBack,
-                                  const ErrorLevel level) noexcept
+void ErrorHandler::defaultHandler(const uint32_t, const char* errorName, const ErrorLevel level) noexcept
 {
-    if (errorCallBack)
-    {
-        errorCallBack();
-    }
-    else
-    {
-        std::stringstream ss;
-        ss << "ICEORYX error! " << error;
+    std::stringstream ss;
+    ss << "ICEORYX error! " << errorName;
 
-        reactOnErrorLevel(level, ss.str().c_str());
-    }
+    reactOnErrorLevel(level, ss.str().c_str());
 }
 
 void ErrorHandler::reactOnErrorLevel(const ErrorLevel level, const char* errorText) noexcept
@@ -76,27 +57,4 @@ void ErrorHandler::reactOnErrorLevel(const ErrorLevel level, const char* errorTe
     }
 }
 
-cxx::GenericRAII ErrorHandler::setTemporaryErrorHandler(const HandlerFunction& newHandler) noexcept
-{
-    return cxx::GenericRAII(
-        [&newHandler] {
-            std::lock_guard<std::mutex> lock(handler_mutex);
-            handler = newHandler;
-        },
-        [] {
-            std::lock_guard<std::mutex> lock(handler_mutex);
-            handler = defaultHandler;
-        });
-}
-
-
-const char* ErrorHandler::toString(const Error error) noexcept
-{
-    return ErrorHandler::ERROR_NAMES[static_cast<uint32_t>(error)];
-}
-
-void errorHandler(const Error error, const std::function<void()>& errorCallBack, const ErrorLevel level) noexcept
-{
-    ErrorHandler::handler(error, errorCallBack, level);
-}
 } // namespace iox
diff --git a/iceoryx_hoofs/source/file_reader/file_reader.cpp b/iceoryx_hoofs/source/file_reader/file_reader.cpp
index 465a33e256..4e5972b787 100644
--- a/iceoryx_hoofs/source/file_reader/file_reader.cpp
+++ b/iceoryx_hoofs/source/file_reader/file_reader.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2019 by Robert Bosch GmbH. All rights reserved.
-// Copyright (c) 2021 by Apex.AI Inc. All rights reserved.
+// Copyright (c) 2021 - 2022 by Apex.AI Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -16,7 +16,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "iceoryx_hoofs/internal/file_reader/file_reader.hpp"
+#include "iceoryx_hoofs/cxx/helplets.hpp"
 
+#include <iostream>
 #include <string>
 
 namespace iox
@@ -33,34 +35,31 @@ FileReader::FileReader(const std::string& f_fileName, const std::string& f_fileP
 
     if (!isOpen())
     {
-        errorHandler(Error::kFILEREADER__FAILED_TO_OPEN_FILE, [=]() {
-            switch (m_errorMode)
-            {
-            case ErrorMode::Ignore:
-            {
-                break;
-            }
-            default:
-            case ErrorMode::Inform:
-            {
-                std::cerr << "\033[5;31m"
-                          << "Could not open file '" << m_file << "'."
-                          << "\033[0m" << std::endl;
-                break;
-            }
-            case ErrorMode::Terminate:
-            {
-                std::cerr << "\033[5;31m"
-                          << "Could not open file '" << m_file << "'. Exiting!"
-                          << "\033[0m" << std::endl;
-                std::terminate();
-                break;
-            }
-            }
-        });
+        switch (m_errorMode)
+        {
+        case ErrorMode::Ignore:
+        {
+            return;
+        }
+        default:
+        case ErrorMode::Inform:
+        {
+            std::cerr << "\033[5;31m"
+                      << "Could not open file '" << m_file << "'."
+                      << "\033[0m" << std::endl;
+            return;
+        }
+        case ErrorMode::Terminate:
+        {
+            std::cerr << "\033[5;31m"
+                      << "Could not open file '" << m_file << "'. Exiting!"
+                      << "\033[0m" << std::endl;
+            cxx::Ensures(false);
+            return;
+        }
+        }
     }
 }
-
 bool FileReader::isOpen() const noexcept
 {
     return m_fileStream.is_open();
diff --git a/iceoryx_hoofs/source/posix_wrapper/timer.cpp b/iceoryx_hoofs/source/posix_wrapper/timer.cpp
index 1b55954f7b..18658a5af0 100644
--- a/iceoryx_hoofs/source/posix_wrapper/timer.cpp
+++ b/iceoryx_hoofs/source/posix_wrapper/timer.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2019 by Robert Bosch GmbH. All rights reserved.
-// Copyright (c) 2021 by Apex.AI Inc. All rights reserved.
+// Copyright (c) 2021 - 2022 by Apex.AI Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -17,7 +17,6 @@
 
 #include "iceoryx_hoofs/posix_wrapper/timer.hpp"
 #include "iceoryx_hoofs/cxx/generic_raii.hpp"
-#include "iceoryx_hoofs/error_handling/error_handling.hpp"
 #include "iceoryx_hoofs/platform/platform_correction.hpp"
 #include "iceoryx_hoofs/posix_wrapper/posix_call.hpp"
 #include <atomic>
@@ -113,11 +112,7 @@ void Timer::OsTimer::callbackHelper(sigval data) noexcept
             // prohibits other threads from entering the flag protected region
             handle.m_callbackIsAboutToBeExecuted.test_and_set(std::memory_order_acq_rel);
 
-            if (handle.m_timer == nullptr)
-            {
-                errorHandler(Error::kPOSIX_TIMER__INCONSISTENT_STATE);
-                return;
-            }
+            cxx::Expects((handle.m_timer != nullptr) && "Timer in inconsistent state");
 
             if (!handle.m_inUse.load(std::memory_order::memory_order_relaxed))
             {
@@ -166,11 +161,8 @@ void Timer::OsTimer::callbackHelper(sigval data) noexcept
     }
     else
     {
-        if (handle.m_catchUpPolicy == CatchUpPolicy::TERMINATE)
-        {
-            errorHandler(Error::kPOSIX_TIMER__CALLBACK_RUNTIME_EXCEEDS_RETRIGGER_TIME);
-        }
-        return;
+        cxx::Ensures((handle.m_catchUpPolicy != CatchUpPolicy::TERMINATE)
+                     && "Timer callback runtime exceeds retrigger time");
     }
 }
 
@@ -218,10 +210,7 @@ Timer::OsTimer::OsTimer(const units::Duration timeToWait, const std::function<vo
         m_callbackHandleIndex++;
     }
 
-    if (!callbackHandleFound)
-    {
-        errorHandler(Error::kPOSIX_TIMER__TIMERPOOL_OVERFLOW);
-    }
+    cxx::Ensures(callbackHandleFound && "Timerpool overflowed");
 
     // Create the struct in order to configure the timer in the OS
     struct sigevent asyncCallNotification = {};
@@ -274,16 +263,9 @@ Timer::OsTimer::~OsTimer() noexcept
 
 void Timer::OsTimer::executeCallback() noexcept
 {
-    if (m_isInitialized && m_callback)
-    {
-        m_callback();
-    }
-    else
-    {
-        // Thread couldn't reach callback or object is not correctly initalized, maybe the originial object was a
-        // temporary?
-        errorHandler(Error::kPOSIX_TIMER__FIRED_TIMER_BUT_STATE_IS_INVALID);
-    }
+    cxx::Expects(m_isInitialized && m_callback && "Timer fired but state is invalid");
+
+    m_callback();
 }
 
 cxx::expected<TimerError> Timer::OsTimer::start(const RunMode runMode, const CatchUpPolicy catchUpPolicy) noexcept
diff --git a/iceoryx_hoofs/test/moduletests/test_cxx_functional_interface_expect.cpp b/iceoryx_hoofs/test/moduletests/test_cxx_functional_interface_expect.cpp
index d5cc9d23f0..7bd9c27f2a 100644
--- a/iceoryx_hoofs/test/moduletests/test_cxx_functional_interface_expect.cpp
+++ b/iceoryx_hoofs/test/moduletests/test_cxx_functional_interface_expect.cpp
@@ -15,6 +15,7 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 #include "iceoryx_hoofs/error_handling/error_handling.hpp"
+#include "iceoryx_hoofs/testing/mocks/error_handler_mock.hpp"
 
 #include "test_cxx_functional_interface_types.hpp"
 
@@ -36,8 +37,8 @@ void ExpectDoesNotCallTerminateWhenObjectIsValid(const ExpectCall& callExpect)
     bool wasErrorHandlerCalled = false;
     SutType sut = FactoryType::createValidObject();
     {
-        auto handle =
-            iox::ErrorHandler::setTemporaryErrorHandler([&](auto, auto, auto) { wasErrorHandlerCalled = true; });
+        auto handle = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+            [&](auto, auto) { wasErrorHandlerCalled = true; });
         callExpect(sut);
     }
 
@@ -75,8 +76,8 @@ void ExpectDoesCallTerminateWhenObjectIsInvalid(const ExpectCall& callExpect)
     bool wasErrorHandlerCalled = true;
     SutType sut = FactoryType::createInvalidObject();
     {
-        auto handle =
-            iox::ErrorHandler::setTemporaryErrorHandler([&](auto, auto, auto) { wasErrorHandlerCalled = true; });
+        auto handle = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+            [&](auto, auto) { wasErrorHandlerCalled = true; });
         callExpect(sut);
     }
 
diff --git a/iceoryx_hoofs/test/moduletests/test_posix_timer.cpp b/iceoryx_hoofs/test/moduletests/test_posix_timer.cpp
index a435cd2f62..7722e33670 100644
--- a/iceoryx_hoofs/test/moduletests/test_posix_timer.cpp
+++ b/iceoryx_hoofs/test/moduletests/test_posix_timer.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2019 by Robert Bosch GmbH. All rights reserved.
-// Copyright (c) 2021 by Apex.AI Inc. All rights reserved.
+// Copyright (c) 2021 - 2022 by Apex.AI Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -16,7 +16,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "iceoryx_hoofs/cxx/expected.hpp"
-#include "iceoryx_hoofs/error_handling/error_handling.hpp"
 #include "iceoryx_hoofs/internal/units/duration.hpp"
 #include "iceoryx_hoofs/posix_wrapper/timer.hpp"
 #include "iceoryx_hoofs/testing/test.hpp"
@@ -379,57 +378,44 @@ TEST_F(Timer_test, GetOverrunsFailsWithNoCallback)
 }
 
 TIMING_TEST_F(Timer_test, CatchUpPolicySkipToNextBeatContinuesWhenCallbackIsLongerThenTriggerTime, Repeat(5), [&] {
-    std::atomic_bool hasTerminated{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error, const std::function<void()>, const iox::ErrorLevel) { hasTerminated = true; });
-
     Timer sut(TIMEOUT, [] { std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10)); });
-
     ASSERT_FALSE(sut.start(Timer::RunMode::PERIODIC, Timer::CatchUpPolicy::SKIP_TO_NEXT_BEAT).has_error());
-
     std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10));
-    TIMING_TEST_EXPECT_FALSE(hasTerminated);
+    // EXPECT_NO_DEATH
+    EXPECT_TRUE(true);
 });
 
 TIMING_TEST_F(Timer_test, CatchUpPolicyImmediateContinuesWhenCallbackIsLongerThenTriggerTime, Repeat(5), [&] {
-    std::atomic_bool hasTerminated{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error, const std::function<void()>, const iox::ErrorLevel) { hasTerminated = true; });
-
     Timer sut(TIMEOUT, [] { std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10)); });
-
     ASSERT_FALSE(sut.start(Timer::RunMode::PERIODIC, Timer::CatchUpPolicy::IMMEDIATE).has_error());
-
     std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10));
-    TIMING_TEST_EXPECT_FALSE(hasTerminated);
+    // EXPECT_NO_DEATH
+    EXPECT_TRUE(true);
 });
 
 TIMING_TEST_F(Timer_test, CatchUpPolicyTerminateTerminatesWhenCallbackIsLongerThenTriggerTime, Repeat(5), [&] {
-    std::atomic_bool hasTerminated{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error, const std::function<void()>, const iox::ErrorLevel) { hasTerminated = true; });
-
-    Timer sut(TIMEOUT, [] { std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10)); });
-
-    ASSERT_FALSE(sut.start(Timer::RunMode::PERIODIC, Timer::CatchUpPolicy::TERMINATE).has_error());
-
-    std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10));
-    TIMING_TEST_EXPECT_TRUE(hasTerminated);
+    EXPECT_DEATH(
+        {
+            Timer sut(TIMEOUT,
+                      [] { std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10)); });
+            ASSERT_FALSE(sut.start(Timer::RunMode::PERIODIC, Timer::CatchUpPolicy::TERMINATE).has_error());
+            std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10));
+        },
+        ".*");
 });
 
 TIMING_TEST_F(Timer_test, CatchUpPolicyChangeToTerminateChangesBehaviorToTerminate, Repeat(5), [&] {
-    std::atomic_bool hasTerminated{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error, const std::function<void()>, const iox::ErrorLevel) { hasTerminated = true; });
-
-    Timer sut(TIMEOUT, [] { std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10)); });
-
-    ASSERT_FALSE(sut.start(Timer::RunMode::PERIODIC, Timer::CatchUpPolicy::SKIP_TO_NEXT_BEAT).has_error());
-    std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10));
-    ASSERT_FALSE(sut.restart(TIMEOUT, Timer::RunMode::PERIODIC, Timer::CatchUpPolicy::TERMINATE).has_error());
-    std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10));
-
-    TIMING_TEST_EXPECT_TRUE(hasTerminated);
+    EXPECT_DEATH(
+        {
+            Timer sut(TIMEOUT,
+                      [] { std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10)); });
+
+            ASSERT_FALSE(sut.start(Timer::RunMode::PERIODIC, Timer::CatchUpPolicy::SKIP_TO_NEXT_BEAT).has_error());
+            std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10));
+            ASSERT_FALSE(sut.restart(TIMEOUT, Timer::RunMode::PERIODIC, Timer::CatchUpPolicy::TERMINATE).has_error());
+            std::this_thread::sleep_for(std::chrono::milliseconds(TIMEOUT.toMilliseconds() * 10));
+        },
+        ".*");
 });
 
 TIMING_TEST_F(Timer_test, CatchUpPolicySkipToNextBeatSkipsCallbackWhenStillRunning, Repeat(5), [&] {
diff --git a/iceoryx_hoofs/testing/include/iceoryx_hoofs/testing/mocks/error_handler_mock.hpp b/iceoryx_hoofs/testing/include/iceoryx_hoofs/testing/mocks/error_handler_mock.hpp
new file mode 100644
index 0000000000..2e5f7f3839
--- /dev/null
+++ b/iceoryx_hoofs/testing/include/iceoryx_hoofs/testing/mocks/error_handler_mock.hpp
@@ -0,0 +1,80 @@
+// Copyright (c) 2022 by Apex.AI Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+#ifndef IOX_HOOFS_TESTUTILS_ERROR_HANDLER_MOCK_HPP
+#define IOX_HOOFS_TESTUTILS_ERROR_HANDLER_MOCK_HPP
+
+#include "iceoryx_hoofs/error_handling/error_handling.hpp"
+#include <mutex>
+
+#include "iceoryx_hoofs/testing/test.hpp"
+
+namespace iox
+{
+template <typename Error>
+using TypedHandlerFunction = std::function<void(const Error, const ErrorLevel)>;
+
+class ErrorHandlerMock : protected ErrorHandler
+{
+  public:
+    template <typename Error>
+    static cxx::GenericRAII setTemporaryErrorHandler(const TypedHandlerFunction<Error>& newHandler) noexcept;
+
+  protected:
+    static std::mutex m_handlerMutex;
+};
+
+template <typename Error>
+cxx::optional<iox::TypedHandlerFunction<Error>> typedHandler;
+
+template <typename ErrorEnumType>
+inline void errorHandlerForTest(const uint32_t error, const char* errorName, const ErrorLevel level) noexcept
+{
+    uint32_t errorEnumType = error >> 16;
+    uint32_t expectedErrorEnumType =
+        static_cast<typename std::underlying_type<ErrorEnumType>::type>(ErrorEnumType::kNO_ERROR) >> 16;
+
+    if (errorEnumType == expectedErrorEnumType)
+    {
+        // We undo the type erasure
+        auto typedError = static_cast<ErrorEnumType>(error);
+        typedHandler<iox::Error>.and_then(
+            [&](TypedHandlerFunction<Error> storedHandler) { storedHandler(typedError, level); });
+    }
+    else
+    {
+        GTEST_FAIL() << "errorName: " << errorName << ", expected error enum type: " << expectedErrorEnumType
+                     << ", actual error enum type: " << errorEnumType;
+    }
+}
+
+template <typename Error>
+inline cxx::GenericRAII
+ErrorHandlerMock::setTemporaryErrorHandler(const TypedHandlerFunction<Error>& newHandler) noexcept
+{
+    return cxx::GenericRAII(
+        [&newHandler] {
+            std::lock_guard<std::mutex> lock(m_handlerMutex);
+            typedHandler<iox::Error>.emplace(newHandler);
+            handler = errorHandlerForTest<Error>;
+        },
+        [] {
+            std::lock_guard<std::mutex> lock(m_handlerMutex);
+            typedHandler<iox::Error>.reset();
+            handler = defaultHandler;
+        });
+}
+} // namespace iox
+#endif // IOX_HOOFS_TESTUTILS_ERROR_HANDLER_MOCK_HPP
diff --git a/iceoryx_hoofs/testing/mocks/error_handler_mock.cpp b/iceoryx_hoofs/testing/mocks/error_handler_mock.cpp
new file mode 100644
index 0000000000..744c479b22
--- /dev/null
+++ b/iceoryx_hoofs/testing/mocks/error_handler_mock.cpp
@@ -0,0 +1,22 @@
+// Copyright (c) 2022 by Apex.AI Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "iceoryx_hoofs/testing/mocks/error_handler_mock.hpp"
+
+namespace iox
+{
+std::mutex ErrorHandlerMock::m_handlerMutex;
+} // namespace iox
diff --git a/iceoryx_posh/CMakeLists.txt b/iceoryx_posh/CMakeLists.txt
index 8f28ac07bf..b852b07556 100644
--- a/iceoryx_posh/CMakeLists.txt
+++ b/iceoryx_posh/CMakeLists.txt
@@ -460,6 +460,7 @@ if(ROUDI_ENVIRONMENT OR BUILD_TEST)
         iceoryx_posh::iceoryx_posh
         iceoryx_hoofs::iceoryx_hoofs
         iceoryx_posh::iceoryx_posh_roudi
+        iceoryx_hoofs_testing::iceoryx_hoofs_testing
     )
 
     target_compile_options(iceoryx_posh_testing PRIVATE ${ICEORYX_WARNINGS})
diff --git a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_queue_data.hpp b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_queue_data.hpp
index db2400d543..21f8fcb6c0 100644
--- a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_queue_data.hpp
+++ b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_queue_data.hpp
@@ -27,6 +27,8 @@
 #include "iceoryx_posh/internal/popo/building_blocks/condition_variable_data.hpp"
 #include "iceoryx_posh/popo/port_queue_policies.hpp"
 
+#include <mutex>
+
 namespace iox
 {
 namespace popo
diff --git a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/typed_unique_id.hpp b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/typed_unique_id.hpp
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/iceoryx_posh/include/iceoryx_posh/internal/runtime/ipc_interface_base.hpp b/iceoryx_posh/include/iceoryx_posh/internal/runtime/ipc_interface_base.hpp
index 293c3c066a..abb46fa971 100644
--- a/iceoryx_posh/include/iceoryx_posh/internal/runtime/ipc_interface_base.hpp
+++ b/iceoryx_posh/include/iceoryx_posh/internal/runtime/ipc_interface_base.hpp
@@ -20,6 +20,7 @@
 
 #include "iceoryx_hoofs/cxx/deadline_timer.hpp"
 #include "iceoryx_hoofs/cxx/optional.hpp"
+#include "iceoryx_hoofs/error_handling/error_handling.hpp"
 #include "iceoryx_hoofs/internal/posix_wrapper/unix_domain_socket.hpp"
 #include "iceoryx_hoofs/internal/relocatable_pointer/relative_pointer.hpp"
 #include "iceoryx_hoofs/internal/units/duration.hpp"
diff --git a/iceoryx_posh/include/iceoryx_posh/roudi/roudi_app.hpp b/iceoryx_posh/include/iceoryx_posh/roudi/roudi_app.hpp
index 6d902d6b2d..5069bf8639 100644
--- a/iceoryx_posh/include/iceoryx_posh/roudi/roudi_app.hpp
+++ b/iceoryx_posh/include/iceoryx_posh/roudi/roudi_app.hpp
@@ -17,6 +17,7 @@
 #ifndef IOX_POSH_ROUDI_ROUDI_APP_HPP
 #define IOX_POSH_ROUDI_ROUDI_APP_HPP
 
+#include "iceoryx_hoofs/error_handling/error_handling.hpp"
 #include "iceoryx_hoofs/log/logcommon.hpp"
 #include "iceoryx_hoofs/posix_wrapper/semaphore.hpp"
 #include "iceoryx_posh/iceoryx_posh_config.hpp"
diff --git a/iceoryx_posh/test/integrationtests/test_posh_mepoo.cpp b/iceoryx_posh/test/integrationtests/test_posh_mepoo.cpp
index 145bcf258f..e454f62bba 100644
--- a/iceoryx_posh/test/integrationtests/test_posh_mepoo.cpp
+++ b/iceoryx_posh/test/integrationtests/test_posh_mepoo.cpp
@@ -414,10 +414,8 @@ TEST_F(Mepoo_IntegrationTest, WrongSampleSize)
     constexpr uint32_t SAMPLE_SIZE = 2048U;
     constexpr uint32_t REPETITION = 1U;
     iox::cxx::optional<iox::Error> receivedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&receivedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
-            receivedError.emplace(error);
-        });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&receivedError](const iox::Error error, const iox::ErrorLevel) { receivedError.emplace(error); });
 
     EXPECT_TRUE(sendReceiveSample<SAMPLE_SIZE>(REPETITION, {iox::popo::AllocationError::NO_MEMPOOLS_AVAILABLE}));
 
@@ -434,10 +432,8 @@ TEST_F(Mepoo_IntegrationTest, SampleOverflow)
     constexpr uint32_t SAMPLE_SIZE_1 = 200U;
     constexpr uint32_t REPETITION = 1U;
     iox::cxx::optional<iox::Error> receivedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&receivedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
-            receivedError.emplace(error);
-        });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&receivedError](const iox::Error error, const iox::ErrorLevel) { receivedError.emplace(error); });
 
     // make the mempool empty
     EXPECT_TRUE(sendReceiveSample<SAMPLE_SIZE_1>(DEFAULT_NUMBER_OF_CHUNKS));
diff --git a/iceoryx_posh/test/moduletests/test_mepoo_memory_manager.cpp b/iceoryx_posh/test/moduletests/test_mepoo_memory_manager.cpp
index 243da4a675..38da0fcd40 100644
--- a/iceoryx_posh/test/moduletests/test_mepoo_memory_manager.cpp
+++ b/iceoryx_posh/test/moduletests/test_mepoo_memory_manager.cpp
@@ -92,8 +92,8 @@ TEST_F(MemoryManager_test, AddingMempoolNotInTheIncreasingOrderReturnsError)
     mempoolconf.addMemPool({CHUNK_SIZE_256, CHUNK_COUNT});
     mempoolconf.addMemPool({CHUNK_SIZE_64, CHUNK_COUNT});
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_EQ(errorLevel, iox::ErrorLevel::FATAL);
         });
@@ -112,8 +112,8 @@ TEST_F(MemoryManager_test, WrongCallOfConfigureMemoryManagerReturnsError)
     mempoolconf.addMemPool({CHUNK_SIZE_64, CHUNK_COUNT});
     sut->configureMemoryManager(mempoolconf, *allocator, *allocator);
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_EQ(errorLevel, iox::ErrorLevel::FATAL);
         });
@@ -158,8 +158,8 @@ TEST_F(MemoryManager_test, GetChunkMethodWithNoMemPoolInMemConfigReturnsError)
 {
     ::testing::Test::RecordProperty("TEST_ID", "dff31ea2-8ae0-4786-8c97-633af59c287d");
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_EQ(errorLevel, iox::ErrorLevel::SEVERE);
         });
@@ -189,8 +189,8 @@ TEST_F(MemoryManager_test, GetChunkMethodWithChunkSizeGreaterThanAvailableChunkS
     sut->configureMemoryManager(mempoolconf, *allocator, *allocator);
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_EQ(errorLevel, iox::ErrorLevel::SEVERE);
         });
@@ -222,8 +222,8 @@ TEST_F(MemoryManager_test, GetChunkMethodWhenNoFreeChunksInMemPoolConfigReturnsE
     auto chunkStore = getChunksFromSut(CHUNK_COUNT, chunkSettings);
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_EQ(errorLevel, iox::ErrorLevel::MODERATE);
         });
diff --git a/iceoryx_posh/test/moduletests/test_mepoo_mempool.cpp b/iceoryx_posh/test/moduletests/test_mepoo_mempool.cpp
index ce16b975ae..e81c2897dd 100644
--- a/iceoryx_posh/test/moduletests/test_mepoo_mempool.cpp
+++ b/iceoryx_posh/test/moduletests/test_mepoo_mempool.cpp
@@ -72,8 +72,8 @@ TEST_F(MemPool_test, MempoolCtorWhenChunkSizeIsNotAMultipleOfAlignmentReturnErro
     constexpr uint32_t NOT_ALLIGNED_CHUNKED_SIZE{33U};
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::FATAL));
         });
@@ -176,8 +176,8 @@ TEST_F(MemPool_test, FreeChunkMethodWhenSameChunkIsTriedToFreeTwiceReturnsError)
     chunks.push_back(reinterpret_cast<uint8_t*>(sut.getChunk()));
     sut.freeChunk(chunks[INDEX]);
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::FATAL));
         });
diff --git a/iceoryx_posh/test/moduletests/test_mepoo_segment_management.cpp b/iceoryx_posh/test/moduletests/test_mepoo_segment_management.cpp
index ef14c4d7cd..709b21ebe9 100644
--- a/iceoryx_posh/test/moduletests/test_mepoo_segment_management.cpp
+++ b/iceoryx_posh/test/moduletests/test_mepoo_segment_management.cpp
@@ -162,8 +162,8 @@ TEST_F(SegmentManager_test, ADD_TEST_WITH_ADDITIONAL_USER(addingMoreThanOneWrite
     SegmentManager<> sut{segmentConfig, &allocator};
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::FATAL));
         });
diff --git a/iceoryx_posh/test/moduletests/test_popo_base_client.cpp b/iceoryx_posh/test/moduletests/test_popo_base_client.cpp
index a4a2a84c5c..53b017ab8c 100644
--- a/iceoryx_posh/test/moduletests/test_popo_base_client.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_base_client.cpp
@@ -251,9 +251,9 @@ TYPED_TEST(BaseClient_test, EnableStateCallsUnderlyingPortAndTriggerHandle)
         EXPECT_CALL(this->sut->port(), setConditionVariable(Ref(condVar), TRIGGER_ID)).Times(1);
 
         bool errorDetected{false};
-        auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler([&](const iox::Error error,
-                                                                                 const std::function<void()>,
-                                                                                 const iox::ErrorLevel errorLevel) {
+        auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const iox::Error error,
+                                                                                                 const iox::ErrorLevel
+                                                                                                     errorLevel) {
             EXPECT_THAT(
                 error,
                 Eq(iox::Error::
@@ -313,9 +313,9 @@ TYPED_TEST(BaseClient_test, EnableEventCallsUnderlyingPortAndTriggerHandle)
         EXPECT_CALL(this->sut->port(), setConditionVariable(Ref(condVar), TRIGGER_ID)).Times(1);
 
         bool errorDetected{false};
-        auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler([&](const iox::Error error,
-                                                                                 const std::function<void()>,
-                                                                                 const iox::ErrorLevel errorLevel) {
+        auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const iox::Error error,
+                                                                                                 const iox::ErrorLevel
+                                                                                                     errorLevel) {
             EXPECT_THAT(
                 error,
                 Eq(iox::Error::
diff --git a/iceoryx_posh/test/moduletests/test_popo_base_server.cpp b/iceoryx_posh/test/moduletests/test_popo_base_server.cpp
index 654e71e333..59fca012d5 100644
--- a/iceoryx_posh/test/moduletests/test_popo_base_server.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_base_server.cpp
@@ -261,9 +261,9 @@ TYPED_TEST(BaseServer_test, EnableStateCallsUnderlyingPortAndTriggerHandle)
         EXPECT_CALL(this->sut->port(), setConditionVariable(Ref(condVar), TRIGGER_ID)).Times(1);
 
         bool errorDetected{false};
-        auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler([&](const iox::Error error,
-                                                                                 const std::function<void()>,
-                                                                                 const iox::ErrorLevel errorLevel) {
+        auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const iox::Error error,
+                                                                                                 const iox::ErrorLevel
+                                                                                                     errorLevel) {
             EXPECT_THAT(
                 error,
                 Eq(iox::Error::
@@ -323,9 +323,9 @@ TYPED_TEST(BaseServer_test, EnableEventCallsUnderlyingPortAndTriggerHandle)
         EXPECT_CALL(this->sut->port(), setConditionVariable(Ref(condVar), TRIGGER_ID)).Times(1);
 
         bool errorDetected{false};
-        auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler([&](const iox::Error error,
-                                                                                 const std::function<void()>,
-                                                                                 const iox::ErrorLevel errorLevel) {
+        auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const iox::Error error,
+                                                                                                 const iox::ErrorLevel
+                                                                                                     errorLevel) {
             EXPECT_THAT(
                 error,
                 Eq(iox::Error::
diff --git a/iceoryx_posh/test/moduletests/test_popo_chunk_distributor.cpp b/iceoryx_posh/test/moduletests/test_popo_chunk_distributor.cpp
index c5642747d4..30f3b72c0c 100644
--- a/iceoryx_posh/test/moduletests/test_popo_chunk_distributor.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_chunk_distributor.cpp
@@ -168,10 +168,8 @@ TYPED_TEST(ChunkDistributor_test, QueueOverflow)
     typename TestFixture::ChunkDistributor_t sut(sutData.get());
 
     auto errorHandlerCalled{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled](const iox::Error, const std::function<void()>, const iox::ErrorLevel) {
-            errorHandlerCalled = true;
-        });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
 
     for (uint32_t i = 0; i < this->MAX_NUMBER_QUEUES; ++i)
     {
diff --git a/iceoryx_posh/test/moduletests/test_popo_chunk_queue.cpp b/iceoryx_posh/test/moduletests/test_popo_chunk_queue.cpp
index f3f0edc64c..b56e4913f6 100644
--- a/iceoryx_posh/test/moduletests/test_popo_chunk_queue.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_chunk_queue.cpp
@@ -193,8 +193,8 @@ TYPED_TEST(ChunkQueue_test, PopChunkWithIncompatibleChunkHeaderCallsErrorHandler
     this->m_pusher.push(chunk);
 
     iox::Error receivedError{iox::Error::kNO_ERROR};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             receivedError = error;
             EXPECT_EQ(errorLevel, iox::ErrorLevel::SEVERE);
         });
diff --git a/iceoryx_posh/test/moduletests/test_popo_chunk_receiver.cpp b/iceoryx_posh/test/moduletests/test_popo_chunk_receiver.cpp
index 8a0d3abd1b..69d15cf9b8 100644
--- a/iceoryx_posh/test/moduletests/test_popo_chunk_receiver.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_chunk_receiver.cpp
@@ -200,10 +200,8 @@ TEST_F(ChunkReceiver_test, releaseInvalidChunk)
     }
 
     auto errorHandlerCalled{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled](const iox::Error, const std::function<void()>, const iox::ErrorLevel) {
-            errorHandlerCalled = true;
-        });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
 
     ChunkMock<bool> myCrazyChunk;
     m_chunkReceiver.release(myCrazyChunk.chunkHeader());
diff --git a/iceoryx_posh/test/moduletests/test_popo_chunk_sender.cpp b/iceoryx_posh/test/moduletests/test_popo_chunk_sender.cpp
index 9a5f613deb..be44e686c6 100644
--- a/iceoryx_posh/test/moduletests/test_popo_chunk_sender.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_chunk_sender.cpp
@@ -242,10 +242,8 @@ TEST_F(ChunkSender_test, freeInvalidChunk)
     EXPECT_THAT(m_memoryManager.getMemPoolInfo(0).m_usedChunks, Eq(1U));
 
     auto errorHandlerCalled{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled](const iox::Error, const std::function<void()>, const iox::ErrorLevel) {
-            errorHandlerCalled = true;
-        });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
 
     ChunkMock<bool> myCrazyChunk;
     m_chunkSender.release(myCrazyChunk.chunkHeader());
@@ -420,10 +418,8 @@ TEST_F(ChunkSender_test, sendTillRunningOutOfChunks)
     }
 
     auto errorHandlerCalled{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled](const iox::Error, const std::function<void()>, const iox::ErrorLevel) {
-            errorHandlerCalled = true;
-        });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
 
     auto maybeChunkHeader = m_chunkSender.tryAllocate(
         UniquePortId(), sizeof(DummySample), alignof(DummySample), USER_HEADER_SIZE, USER_HEADER_ALIGNMENT);
@@ -440,10 +436,8 @@ TEST_F(ChunkSender_test, sendInvalidChunk)
     EXPECT_THAT(m_memoryManager.getMemPoolInfo(0).m_usedChunks, Eq(1U));
 
     auto errorHandlerCalled{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled](const iox::Error, const std::function<void()>, const iox::ErrorLevel) {
-            errorHandlerCalled = true;
-        });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
 
     ChunkMock<bool> myCrazyChunk;
     auto numberOfDeliveries = m_chunkSender.send(myCrazyChunk.chunkHeader());
@@ -502,8 +496,8 @@ TEST_F(ChunkSender_test, sendToQueueWithInvalidChunkTriggersTheErrorHandler)
     EXPECT_THAT(m_memoryManager.getMemPoolInfo(0).m_usedChunks, Eq(1U));
 
     auto errorHandlerCalled{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled](const iox::Error error, const iox::ErrorLevel errorLevel) {
             errorHandlerCalled = true;
             EXPECT_THAT(error, Eq(iox::Error::kPOPO__CHUNK_SENDER_INVALID_CHUNK_TO_SEND_FROM_USER));
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::SEVERE));
@@ -542,10 +536,8 @@ TEST_F(ChunkSender_test, pushInvalidChunkToHistory)
     EXPECT_THAT(m_memoryManager.getMemPoolInfo(0).m_usedChunks, Eq(1U));
 
     auto errorHandlerCalled{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled](const iox::Error, const std::function<void()>, const iox::ErrorLevel) {
-            errorHandlerCalled = true;
-        });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
 
     ChunkMock<bool> myCrazyChunk;
     m_chunkSender.pushToHistory(myCrazyChunk.chunkHeader());
diff --git a/iceoryx_posh/test/moduletests/test_popo_client_port.cpp b/iceoryx_posh/test/moduletests/test_popo_client_port.cpp
index 31cabe6535..bea8dd2061 100644
--- a/iceoryx_posh/test/moduletests/test_popo_client_port.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_client_port.cpp
@@ -260,8 +260,8 @@ TEST_F(ClientPort_test, ReleaseRequestWithNullptrCallsErrorHandler)
     auto& sut = clientPortWithConnectOnCreate;
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_EQ(errorLevel, iox::ErrorLevel::SEVERE);
         });
@@ -294,8 +294,8 @@ TEST_F(ClientPort_test, SendRequestWithNullptrOnConnectedClientPortCallsErrorHan
     auto& sut = clientPortWithConnectOnCreate;
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_EQ(errorLevel, iox::ErrorLevel::SEVERE);
         });
@@ -418,8 +418,8 @@ TEST_F(ClientPort_test, ReleaseResponseWithNullptrIsTerminating)
     auto& sut = clientPortWithConnectOnCreate;
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_EQ(errorLevel, iox::ErrorLevel::SEVERE);
         });
@@ -984,8 +984,8 @@ TEST_F(ClientPort_test, InvalidStateTransitionsCallErrorHandler)
             }
 
             iox::cxx::optional<iox::Error> detectedError;
-            auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-                [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+            auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+                [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
                     detectedError.emplace(error);
                     EXPECT_EQ(errorLevel, iox::ErrorLevel::SEVERE);
                 });
diff --git a/iceoryx_posh/test/moduletests/test_popo_notification_info.cpp b/iceoryx_posh/test/moduletests/test_popo_notification_info.cpp
index fd14d5e750..7d24e7b065 100644
--- a/iceoryx_posh/test/moduletests/test_popo_notification_info.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_notification_info.cpp
@@ -94,8 +94,8 @@ TEST_F(NotificationInfo_test, getOriginReturnsNullptrWithWrongType)
     ::testing::Test::RecordProperty("TEST_ID", "badb467b-bf64-4e43-af30-77c163e90c99");
     auto errorHandlerCalled{false};
     iox::Error errorHandlerType;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard =
+        iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const iox::Error error, const iox::ErrorLevel) {
             errorHandlerType = error;
             errorHandlerCalled = true;
         });
@@ -111,8 +111,8 @@ TEST_F(NotificationInfo_test, constGetOriginReturnsNullptrWithWrongType)
     ::testing::Test::RecordProperty("TEST_ID", "4fdb2bed-9928-4181-b195-e411d1b16572");
     auto errorHandlerCalled{false};
     iox::Error errorHandlerType;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard =
+        iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const iox::Error error, const iox::ErrorLevel) {
             errorHandlerType = error;
             errorHandlerCalled = true;
         });
diff --git a/iceoryx_posh/test/moduletests/test_popo_request.cpp b/iceoryx_posh/test/moduletests/test_popo_request.cpp
index b557ef8768..3fa997fa16 100644
--- a/iceoryx_posh/test/moduletests/test_popo_request.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_request.cpp
@@ -77,8 +77,8 @@ TEST_F(Request_test, SendingAlreadySentRequestCallsErrorHandler)
     EXPECT_FALSE(sutProducer.send().has_error());
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>&, const auto errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const auto errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::MODERATE));
         });
@@ -98,8 +98,8 @@ TEST_F(Request_test, SendingMovedRequestCallsErrorHandler)
     constexpr ClientSendError CLIENT_SEND_ERROR{ClientSendError::INVALID_REQUEST};
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>&, const auto errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const auto errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::MODERATE));
         });
diff --git a/iceoryx_posh/test/moduletests/test_popo_response.cpp b/iceoryx_posh/test/moduletests/test_popo_response.cpp
index 638ff48093..2c6e3aded9 100644
--- a/iceoryx_posh/test/moduletests/test_popo_response.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_response.cpp
@@ -77,8 +77,8 @@ TEST_F(Response_test, SendingAlreadySentResponseCallsErrorHandler)
     EXPECT_FALSE(sutProducer.send().has_error());
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>&, const auto errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const auto errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::MODERATE));
         });
@@ -98,8 +98,8 @@ TEST_F(Response_test, SendingMovedResponseCallsErrorHandler)
     constexpr ServerSendError SERVER_SEND_ERROR{ServerSendError::INVALID_RESPONSE};
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>&, const auto errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const auto errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::MODERATE));
         });
diff --git a/iceoryx_posh/test/moduletests/test_popo_sample.cpp b/iceoryx_posh/test/moduletests/test_popo_sample.cpp
index bc0ff90d1c..93f039b6b3 100644
--- a/iceoryx_posh/test/moduletests/test_popo_sample.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_sample.cpp
@@ -60,8 +60,8 @@ TEST_F(Sample_test, PublishingAlreadyPublishedSampleCallsErrorHandler)
     sutProducer.publish();
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>&, const auto errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::MODERATE));
         });
@@ -77,8 +77,8 @@ TEST_F(Sample_test, PublishingMovedSampleCallsErrorHandler)
     ::testing::Test::RecordProperty("TEST_ID", "4c3a9a19-0581-4e47-aed7-f55892bef7fa");
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>&, const auto errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const auto errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::MODERATE));
         });
diff --git a/iceoryx_posh/test/moduletests/test_popo_server_port_roudi.cpp b/iceoryx_posh/test/moduletests/test_popo_server_port_roudi.cpp
index 9dda03655b..0a3671bbbb 100644
--- a/iceoryx_posh/test/moduletests/test_popo_server_port_roudi.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_server_port_roudi.cpp
@@ -199,8 +199,8 @@ TEST_F(ServerPort_test, StateOfferedWithCaProMessageTypeConnectAndNoResponseQueu
     caproMessage.m_chunkQueueData = nullptr;
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             EXPECT_THAT(error, Eq(iox::Error::kPOPO__SERVER_PORT_NO_CLIENT_RESPONSE_QUEUE_TO_CONNECT));
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::MODERATE));
             detectedError.emplace(error);
@@ -261,8 +261,8 @@ TEST_F(ServerPort_test, StateNotOfferedWithInvalidCaProMessageTypeCallsErrorHand
     auto caproMessage = CaproMessage{CaproMessageType::PUB, sut.portData.m_serviceDescription};
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             EXPECT_THAT(error, Eq(iox::Error::kPOPO__CAPRO_PROTOCOL_ERROR));
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::SEVERE));
             detectedError.emplace(error);
@@ -283,8 +283,8 @@ TEST_F(ServerPort_test, StateOfferedWithInvalidCaProMessageTypeCallsErrorHandler
     auto caproMessage = CaproMessage{CaproMessageType::SUB, sut.portData.m_serviceDescription};
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             EXPECT_THAT(error, Eq(iox::Error::kPOPO__CAPRO_PROTOCOL_ERROR));
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::SEVERE));
             detectedError.emplace(error);
diff --git a/iceoryx_posh/test/moduletests/test_popo_server_port_user.cpp b/iceoryx_posh/test/moduletests/test_popo_server_port_user.cpp
index 291a45e459..523f427f5b 100644
--- a/iceoryx_posh/test/moduletests/test_popo_server_port_user.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_server_port_user.cpp
@@ -403,8 +403,8 @@ TEST_F(ServerPort_test, ReleaseRequestWithInvalidChunkCallsTheErrorHandler)
     auto sharedChunk = getChunkWithInitializedRequestHeaderAndData();
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             EXPECT_THAT(error, Eq(iox::Error::kPOPO__CHUNK_RECEIVER_INVALID_CHUNK_TO_RELEASE_FROM_USER));
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::SEVERE));
             detectedError.emplace(error);
@@ -421,8 +421,8 @@ TEST_F(ServerPort_test, ReleaseRequestWithNullptrRequestHeaderCallsTheErrorHandl
     auto& sut = serverPortWithOfferOnCreate;
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             EXPECT_THAT(error, Eq(iox::Error::kPOPO__SERVER_PORT_INVALID_REQUEST_TO_RELEASE_FROM_USER));
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::SEVERE));
             detectedError.emplace(error);
@@ -635,8 +635,8 @@ TEST_F(ServerPort_test, ReleaseResponseWithInvalidChunkCallsTheErrorHandler)
     auto& sut = serverPortWithOfferOnCreate;
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             EXPECT_THAT(error, Eq(iox::Error::kPOPO__CHUNK_SENDER_INVALID_CHUNK_TO_FREE_FROM_USER));
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::SEVERE));
             detectedError.emplace(error);
@@ -658,8 +658,8 @@ TEST_F(ServerPort_test, ReleaseResponseWithWithNullptrResponseHeaderCallsTheErro
     auto& sut = serverPortWithOfferOnCreate;
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             EXPECT_THAT(error, Eq(iox::Error::kPOPO__SERVER_PORT_INVALID_RESPONSE_TO_FREE_FROM_USER));
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::SEVERE));
             detectedError.emplace(error);
@@ -680,8 +680,8 @@ TEST_F(ServerPort_test, SendResponseWithWithNullptrResponseHeaderCallsTheErrorHa
     auto& sut = serverPortWithOfferOnCreate;
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             EXPECT_THAT(error, Eq(iox::Error::kPOPO__SERVER_PORT_INVALID_RESPONSE_TO_SEND_FROM_USER));
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::SEVERE));
             detectedError.emplace(error);
diff --git a/iceoryx_posh/test/moduletests/test_popo_subscriber_port.cpp b/iceoryx_posh/test/moduletests/test_popo_subscriber_port.cpp
index 0f9bbecacb..af175c646a 100644
--- a/iceoryx_posh/test/moduletests/test_popo_subscriber_port.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_subscriber_port.cpp
@@ -315,10 +315,8 @@ TEST_F(SubscriberPortSingleProducer_test, InvalidMessageResultsInError)
 {
     ::testing::Test::RecordProperty("TEST_ID", "23aaa4fd-5567-4831-b539-802c5de238ab");
     auto errorHandlerCalled{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled](const iox::Error, const std::function<void()>, const iox::ErrorLevel) {
-            errorHandlerCalled = true;
-        });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
     iox::capro::CaproMessage caproMessage(iox::capro::CaproMessageType::SUB,
                                           SubscriberPortSingleProducer_test::TEST_SERVICE_DESCRIPTION);
 
@@ -332,10 +330,8 @@ TEST_F(SubscriberPortSingleProducer_test, AckWhenNotWaitingForResultsInError)
 {
     ::testing::Test::RecordProperty("TEST_ID", "541719e5-fdfa-4ef8-86f6-a9baf4919fe8");
     auto errorHandlerCalled{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled](const iox::Error, const std::function<void()>, const iox::ErrorLevel) {
-            errorHandlerCalled = true;
-        });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
     iox::capro::CaproMessage caproMessage(iox::capro::CaproMessageType::ACK,
                                           SubscriberPortSingleProducer_test::TEST_SERVICE_DESCRIPTION);
 
@@ -350,9 +346,8 @@ TEST_F(SubscriberPortSingleProducer_test, NackWhenNotWaitingForResultsInError)
     ::testing::Test::RecordProperty("TEST_ID", "063e3a61-209b-4755-abfa-69aed6258ab3");
     auto errorHandlerCalled{false};
     iox::Error receivedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled,
-         &receivedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled, &receivedError](const iox::Error error, const iox::ErrorLevel) {
             errorHandlerCalled = true;
             receivedError = error;
         });
@@ -534,9 +529,8 @@ TEST_F(SubscriberPortMultiProducer_test, InvalidMessageResultsInError)
     ::testing::Test::RecordProperty("TEST_ID", "419aa91f-991b-4814-b1ee-11637ee14d30");
     auto errorHandlerCalled{false};
     iox::Error receivedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled,
-         &receivedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled, &receivedError](const iox::Error error, const iox::ErrorLevel) {
             errorHandlerCalled = true;
             receivedError = error;
         });
diff --git a/iceoryx_posh/test/moduletests/test_popo_trigger.cpp b/iceoryx_posh/test/moduletests/test_popo_trigger.cpp
index 6c953605fb..a60a0fd06a 100644
--- a/iceoryx_posh/test/moduletests/test_popo_trigger.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_trigger.cpp
@@ -200,8 +200,8 @@ TEST_F(Trigger_test, TriggerWithInvalidHasTriggeredCallbackCallsErrorHandlerAndI
 
     bool hasTerminated = false;
     iox::Error errorType = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard =
+        iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const iox::Error error, const iox::ErrorLevel) {
             hasTerminated = true;
             errorType = error;
         });
@@ -232,8 +232,8 @@ TEST_F(Trigger_test, TriggerWithEmptyResetCallCallsErrorHandlerAndIsInvalid)
 
     bool hasTerminated = false;
     iox::Error errorType = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard =
+        iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const iox::Error error, const iox::ErrorLevel) {
             hasTerminated = true;
             errorType = error;
         });
@@ -303,8 +303,8 @@ TEST_F(Trigger_test, TriggerWithEmptyResetInvalidatesTriggerWhenBeingResetted)
     constexpr uint64_t type = 0U;
     constexpr uint64_t typeHash = 0U;
 
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error, const std::function<void()>, const iox::ErrorLevel) {});
+    auto errorHandlerGuard =
+        iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const iox::Error, const iox::ErrorLevel) {});
 
     Trigger sut(StateBasedTrigger,
                 &m_triggerClass,
@@ -699,8 +699,8 @@ TEST_F(Trigger_test, EventBasedTriggerWithEmptyResetCallInvokesErrorHandlerAndIs
 
     bool hasTerminated = false;
     iox::Error errorType = iox::Error::kNO_ERROR;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard =
+        iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const iox::Error error, const iox::ErrorLevel) {
             hasTerminated = true;
             errorType = error;
         });
diff --git a/iceoryx_posh/test/moduletests/test_popo_unique_port_id.cpp b/iceoryx_posh/test/moduletests/test_popo_unique_port_id.cpp
index 5eee2d8e82..360a42b82e 100644
--- a/iceoryx_posh/test/moduletests/test_popo_unique_port_id.cpp
+++ b/iceoryx_posh/test/moduletests/test_popo_unique_port_id.cpp
@@ -33,7 +33,7 @@ TEST(UniquePortId_test, SettingTheRouDiIdWorks)
     ::testing::Test::RecordProperty("TEST_ID", "473467bf-1a6f-4cd2-acd8-447a623a5301");
     uint16_t someId = 1243U;
     // we cannot ensure that setUniqueRouDiId wasn't called before, therefore we ignore the error
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler([](auto, auto, auto) {});
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([](auto, auto) {});
     auto uniqueRouDiIdResetScopeGuard =
         GenericRAII{[] {}, [] { iox::popo::UniquePortId::setUniqueRouDiId(iox::roudi::DEFAULT_UNIQUE_ROUDI_ID); }};
     iox::popo::UniquePortId::setUniqueRouDiId(someId);
@@ -46,8 +46,8 @@ TEST(UniquePortId_test, SettingTheRouDiIdTwiceFails)
     uint16_t someId = 1243U;
     optional<iox::Error> detectedError;
     optional<iox::ErrorLevel> detectedErrorLevel;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             detectedErrorLevel.emplace(errorLevel);
         });
diff --git a/iceoryx_posh/test/moduletests/test_posh_runtime.cpp b/iceoryx_posh/test/moduletests/test_posh_runtime.cpp
index 7972c82003..6499976181 100644
--- a/iceoryx_posh/test/moduletests/test_posh_runtime.cpp
+++ b/iceoryx_posh/test/moduletests/test_posh_runtime.cpp
@@ -156,9 +156,8 @@ TEST(PoshRuntime, LeadingSlashAppName)
 
     auto errorHandlerCalled{false};
     iox::Error receivedError{iox::Error::kNO_ERROR};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled,
-         &receivedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled, &receivedError](const iox::Error error, const iox::ErrorLevel) {
             errorHandlerCalled = true;
             receivedError = error;
         });
@@ -194,8 +193,8 @@ TEST_F(PoshRuntime_test, GetMiddlewareInterfaceWithInvalidNodeNameIsNotSuccessfu
 {
     ::testing::Test::RecordProperty("TEST_ID", "d207e121-d7c2-4a23-a202-1af311f6982b");
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::SEVERE));
         });
@@ -220,8 +219,8 @@ TEST_F(PoshRuntime_test, GetMiddlewareInterfaceInterfacelistOverflow)
 {
     ::testing::Test::RecordProperty("TEST_ID", "0e164d07-dede-46c3-b2a3-ad78a11c0691");
     auto interfacelistOverflowDetected{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&interfacelistOverflowDetected](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&interfacelistOverflowDetected](const iox::Error error, const iox::ErrorLevel) {
             interfacelistOverflowDetected = true;
             EXPECT_THAT(error, Eq(iox::Error::kPORT_POOL__INTERFACELIST_OVERFLOW));
         });
@@ -309,8 +308,8 @@ TEST_F(PoshRuntime_test, getMiddlewarePublisherPublisherlistOverflow)
     ::testing::Test::RecordProperty("TEST_ID", "f1f1a662-9580-40a1-a116-6ea1cb791516");
     auto publisherlistOverflowDetected{false};
 
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&publisherlistOverflowDetected](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&publisherlistOverflowDetected](const iox::Error error, const iox::ErrorLevel) {
             if (error == iox::Error::kPORT_POOL__PUBLISHERLIST_OVERFLOW)
             {
                 publisherlistOverflowDetected = true;
@@ -340,8 +339,8 @@ TEST_F(PoshRuntime_test, GetMiddlewarePublisherWithSameServiceDescriptionsAndOne
 {
     ::testing::Test::RecordProperty("TEST_ID", "77fb6dfd-a00d-459e-9dd3-90010d7b8af7");
     auto publisherDuplicateDetected{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&publisherDuplicateDetected](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&publisherDuplicateDetected](const iox::Error error, const iox::ErrorLevel) {
             if (error == iox::Error::kPOSH__RUNTIME_PUBLISHER_PORT_NOT_UNIQUE)
             {
                 publisherDuplicateDetected = true;
@@ -373,9 +372,8 @@ TEST_F(PoshRuntime_test, GetMiddlewarePublisherWithForbiddenServiceDescriptionsF
 {
     ::testing::Test::RecordProperty("TEST_ID", "130541c9-94de-4bc4-9471-0a65de310232");
     uint16_t forbiddenServiceDescriptionDetected{0U};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&forbiddenServiceDescriptionDetected](
-            const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&forbiddenServiceDescriptionDetected](const iox::Error error, const iox::ErrorLevel) {
             if (error == iox::Error::kPOSH__RUNTIME_SERVICE_DESCRIPTION_FORBIDDEN)
             {
                 forbiddenServiceDescriptionDetected++;
@@ -544,8 +542,8 @@ TEST_F(PoshRuntime_test, GetMiddlewareSubscriberSubscriberlistOverflow)
 {
     ::testing::Test::RecordProperty("TEST_ID", "d1281cbd-6520-424e-aace-fbd3aa5d73e9");
     auto subscriberlistOverflowDetected{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&subscriberlistOverflowDetected](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&subscriberlistOverflowDetected](const iox::Error error, const iox::ErrorLevel) {
             if (error == iox::Error::kPORT_POOL__SUBSCRIBERLIST_OVERFLOW)
             {
                 subscriberlistOverflowDetected = true;
@@ -707,8 +705,8 @@ TEST_F(PoshRuntime_test, GetMiddlewareClientWhenMaxClientsAreUsedResultsInClient
 {
     ::testing::Test::RecordProperty("TEST_ID", "6f2de2bf-5e7e-47b1-be42-92cf3fa71ba6");
     auto clientOverflowDetected{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard =
+        iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const iox::Error error, const iox::ErrorLevel) {
             if (error == iox::Error::kPORT_POOL__CLIENTLIST_OVERFLOW)
             {
                 clientOverflowDetected = true;
@@ -742,8 +740,8 @@ TEST_F(PoshRuntime_test, GetMiddlewareClientWithInvalidNodeNameLeadsToErrorHandl
     clientOptions.nodeName = m_invalidNodeName;
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::SEVERE));
         });
@@ -818,8 +816,8 @@ TEST_F(PoshRuntime_test, GetMiddlewareServerWhenMaxServerAreUsedResultsInServerl
 {
     ::testing::Test::RecordProperty("TEST_ID", "8f679838-3332-440c-aa95-d5c82d53a7cd");
     auto serverOverflowDetected{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard =
+        iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const iox::Error error, const iox::ErrorLevel) {
             if (error == iox::Error::kPORT_POOL__SERVERLIST_OVERFLOW)
             {
                 serverOverflowDetected = true;
@@ -853,8 +851,8 @@ TEST_F(PoshRuntime_test, GetMiddlewareServerWithInvalidNodeNameLeadsToErrorHandl
     serverOptions.nodeName = m_invalidNodeName;
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::SEVERE));
         });
@@ -877,9 +875,8 @@ TEST_F(PoshRuntime_test, GetMiddlewareConditionVariableListOverflow)
 {
     ::testing::Test::RecordProperty("TEST_ID", "6776a648-03c7-4bd0-ab24-72ed7e118e4f");
     auto conditionVariableListOverflowDetected{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&conditionVariableListOverflowDetected](
-            const iox::Error error, const std::function<void()>, const iox::ErrorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&conditionVariableListOverflowDetected](const iox::Error error, const iox::ErrorLevel) {
             if (error == iox::Error::kPORT_POOL__CONDITION_VARIABLE_LIST_OVERFLOW)
             {
                 conditionVariableListOverflowDetected = true;
@@ -920,8 +917,8 @@ TEST_F(PoshRuntime_test, CreatingNodeWithInvalidNodeNameLeadsToErrorHandlerCall)
     iox::runtime::NodeProperty nodeProperty(m_invalidNodeName, nodeDeviceIdentifier);
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::SEVERE));
         });
diff --git a/iceoryx_posh/test/moduletests/test_posh_runtime_single_process.cpp b/iceoryx_posh/test/moduletests/test_posh_runtime_single_process.cpp
index 452a299c65..1a390b06e0 100644
--- a/iceoryx_posh/test/moduletests/test_posh_runtime_single_process.cpp
+++ b/iceoryx_posh/test/moduletests/test_posh_runtime_single_process.cpp
@@ -69,8 +69,8 @@ TEST_F(PoshRuntimeSingleProcess_test, ConstructorPoshRuntimeSingleProcessMultipl
     const RuntimeName_t runtimeName{"App"};
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&detectedError](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&detectedError](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::FATAL));
         });
diff --git a/iceoryx_posh/test/moduletests/test_roudi_iceoryx_roudi_app.cpp b/iceoryx_posh/test/moduletests/test_roudi_iceoryx_roudi_app.cpp
index 967a608188..8e9816654a 100644
--- a/iceoryx_posh/test/moduletests/test_roudi_iceoryx_roudi_app.cpp
+++ b/iceoryx_posh/test/moduletests/test_roudi_iceoryx_roudi_app.cpp
@@ -194,8 +194,8 @@ TEST_F(IceoryxRoudiApp_test, ConstructorCalledWithArgUniqueIdTwoTimesReturnError
 
     iox::cxx::optional<iox::Error> detectedError;
     iox::cxx::optional<iox::ErrorLevel> detectedErrorLevel;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const iox::Error error, const iox::ErrorLevel errorLevel) {
             detectedError.emplace(error);
             detectedErrorLevel.emplace(errorLevel);
         });
diff --git a/iceoryx_posh/test/moduletests/test_roudi_portmanager.cpp b/iceoryx_posh/test/moduletests/test_roudi_portmanager.cpp
index acd162b7a5..fcff3cd766 100644
--- a/iceoryx_posh/test/moduletests/test_roudi_portmanager.cpp
+++ b/iceoryx_posh/test/moduletests/test_roudi_portmanager.cpp
@@ -244,10 +244,8 @@ TEST_F(PortManager_test, AcquiringOneMoreThanMaximumNumberOfPublishersFails)
     { // test if overflow errors get hit
 
         bool errorHandlerCalled = false;
-        auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-            [&errorHandlerCalled](const iox::Error error IOX_MAYBE_UNUSED,
-                                  const std::function<void()>,
-                                  const iox::ErrorLevel) { errorHandlerCalled = true; });
+        auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+            [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
 
         auto publisherPortDataResult = m_portManager->acquirePublisherPortData(
             getUniqueSD(), publisherOptions, runtimeName, m_payloadDataSegmentMemoryManager, PortConfigInfo());
@@ -305,7 +303,7 @@ TEST_F(PortManager_test, AcquirePublisherPortDataWithSameServiceDescriptionTwice
 
     iox::cxx::optional<iox::Error> detectedError;
     auto errorHandlerGuard =
-        iox::ErrorHandler::setTemporaryErrorHandler([&](const auto error, const auto, const auto errorLevel) {
+        iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const auto error, const auto errorLevel) {
             EXPECT_THAT(error, Eq(iox::Error::kPOSH__PORT_MANAGER_PUBLISHERPORT_NOT_UNIQUE));
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::MODERATE));
             detectedError.emplace(error);
@@ -344,8 +342,8 @@ TEST_F(PortManager_test,
     publisherPortDataResult.value()->m_toBeDestroyed = true;
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const auto error, const auto, const auto) { detectedError.emplace(error); });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const auto error, const auto) { detectedError.emplace(error); });
 
     // second call must now also succeed
     m_portManager->acquirePublisherPortData(sd, publisherOptions, runtimeName, m_payloadDataSegmentMemoryManager, {})
@@ -353,8 +351,10 @@ TEST_F(PortManager_test,
             GTEST_FAIL() << "Expected ClientPortData but got PortPoolError: " << static_cast<uint8_t>(error);
         });
 
-    detectedError.and_then(
-        [&](const auto& error) { GTEST_FAIL() << "Expected error handler to not be called but got: " << error; });
+    detectedError.and_then([&](const auto& error) {
+        GTEST_FAIL() << "Expected error handler to not be called but got: "
+                     << static_cast<std::underlying_type<iox::Error>::type>(error);
+    });
 }
 
 TEST_F(PortManager_test, AcquiringOneMoreThanMaximumNumberOfSubscribersFails)
@@ -373,10 +373,8 @@ TEST_F(PortManager_test, AcquiringOneMoreThanMaximumNumberOfSubscribersFails)
     { // test if overflow errors get hit
 
         bool errorHandlerCalled = false;
-        auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-            [&errorHandlerCalled](const iox::Error error IOX_MAYBE_UNUSED,
-                                  const std::function<void()>,
-                                  const iox::ErrorLevel) { errorHandlerCalled = true; });
+        auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+            [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
         auto subscriberPortDataResult =
             m_portManager->acquireSubscriberPortData(getUniqueSD(), subscriberOptions, runtimeName1, PortConfigInfo());
         EXPECT_TRUE(errorHandlerCalled);
@@ -395,10 +393,8 @@ TEST_F(PortManager_test, AcquiringOneMoreThanMaximumNumberOfInterfacesFails)
     // test if overflow errors get hit
     {
         auto errorHandlerCalled{false};
-        auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-            [&errorHandlerCalled](const iox::Error, const std::function<void()>, const iox::ErrorLevel) {
-                errorHandlerCalled = true;
-            });
+        auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+            [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
 
         auto interfacePort = m_portManager->acquireInterfacePortData(iox::capro::Interfaces::INTERNAL, "itfPenguin");
         EXPECT_EQ(interfacePort, nullptr);
@@ -634,10 +630,8 @@ TEST_F(PortManager_test, AcquiringOneMoreThanMaximumNumberOfConditionVariablesFa
     // test if overflow errors get hit
     {
         auto errorHandlerCalled{false};
-        auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-            [&errorHandlerCalled](const iox::Error, const std::function<void()>, const iox::ErrorLevel) {
-                errorHandlerCalled = true;
-            });
+        auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+            [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
 
         auto conditionVariableResult = m_portManager->acquireConditionVariableData("AnotherToad");
         EXPECT_TRUE(conditionVariableResult.has_error());
@@ -708,10 +702,8 @@ TEST_F(PortManager_test, AcquiringOneMoreThanMaximumNumberOfNodesFails)
 
     // test if overflow errors get hit
     auto errorHandlerCalled{false};
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&errorHandlerCalled](const iox::Error, const std::function<void()>, const iox::ErrorLevel) {
-            errorHandlerCalled = true;
-        });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&errorHandlerCalled](const iox::Error, const iox::ErrorLevel) { errorHandlerCalled = true; });
 
     auto nodeResult = m_portManager->acquireNodeData("AnotherProcess", "AnotherNode");
     EXPECT_THAT(nodeResult.has_error(), Eq(true));
diff --git a/iceoryx_posh/test/moduletests/test_roudi_portmanager_client_server.cpp b/iceoryx_posh/test/moduletests/test_roudi_portmanager_client_server.cpp
index 321237b3e6..a7fc354522 100644
--- a/iceoryx_posh/test/moduletests/test_roudi_portmanager_client_server.cpp
+++ b/iceoryx_posh/test/moduletests/test_roudi_portmanager_client_server.cpp
@@ -109,7 +109,7 @@ TEST_F(PortManager_test, AcquireServerPortDataWithSameServiceDescriptionTwiceCal
 
     iox::cxx::optional<iox::Error> detectedError;
     auto errorHandlerGuard =
-        iox::ErrorHandler::setTemporaryErrorHandler([&](const auto error, const auto, const auto errorLevel) {
+        iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const auto error, const auto errorLevel) {
             EXPECT_THAT(error, Eq(iox::Error::kPOSH__PORT_MANAGER_SERVERPORT_NOT_UNIQUE));
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::MODERATE));
             detectedError.emplace(error);
@@ -141,8 +141,8 @@ TEST_F(PortManager_test, AcquireServerPortDataWithSameServiceDescriptionTwiceAnd
     serverPortDataResult.value()->m_toBeDestroyed = true;
 
     iox::cxx::optional<iox::Error> detectedError;
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&](const auto error, const auto, const auto) { detectedError.emplace(error); });
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&](const auto error, const auto) { detectedError.emplace(error); });
 
     // second call must now also succeed
     m_portManager->acquireServerPortData(sd, serverOptions, runtimeName, m_payloadDataSegmentMemoryManager, {})
@@ -150,8 +150,10 @@ TEST_F(PortManager_test, AcquireServerPortDataWithSameServiceDescriptionTwiceAnd
             GTEST_FAIL() << "Expected ClientPortData but got PortPoolError: " << static_cast<uint8_t>(error);
         });
 
-    detectedError.and_then(
-        [&](const auto& error) { GTEST_FAIL() << "Expected error handler to not be called but got: " << error; });
+    detectedError.and_then([&](const auto& error) {
+        GTEST_FAIL() << "Expected error handler to not be called but got: "
+                     << static_cast<std::underlying_type<iox::Error>::type>(error);
+    });
 }
 
 // END aquireServerPortData tests
diff --git a/iceoryx_posh/test/moduletests/test_roudi_portpool.cpp b/iceoryx_posh/test/moduletests/test_roudi_portpool.cpp
index fec8ff327c..bdc698ed6f 100644
--- a/iceoryx_posh/test/moduletests/test_roudi_portpool.cpp
+++ b/iceoryx_posh/test/moduletests/test_roudi_portpool.cpp
@@ -137,7 +137,7 @@ TEST_F(PortPool_test, AddNodeDataWhenNodeListIsFullReturnsError)
     auto errorHandlerCalled{false};
     Error errorHandlerType;
     auto errorHandlerGuard =
-        ErrorHandler::setTemporaryErrorHandler([&](const Error error, const std::function<void()>, const ErrorLevel) {
+        ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const Error error, const ErrorLevel) {
             errorHandlerType = error;
             errorHandlerCalled = true;
         });
@@ -259,7 +259,7 @@ TEST_F(PortPool_test, AddPublisherPortWhenPublisherListOverflowsReturnsError)
     auto errorHandlerCalled{false};
     Error errorHandlerType;
     auto errorHandlerGuard =
-        ErrorHandler::setTemporaryErrorHandler([&](const Error error, const std::function<void()>, const ErrorLevel) {
+        ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const Error error, const ErrorLevel) {
             errorHandlerType = error;
             errorHandlerCalled = true;
         });
@@ -393,7 +393,7 @@ TEST_F(PortPool_test, AddSubscriberPortWhenSubscriberListOverflowsReturnsError)
     auto errorHandlerCalled{false};
     Error errorHandlerType;
     auto errorHandlerGuard =
-        ErrorHandler::setTemporaryErrorHandler([&](const Error error, const std::function<void()>, const ErrorLevel) {
+        ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const Error error, const ErrorLevel) {
             errorHandlerType = error;
             errorHandlerCalled = true;
         });
@@ -500,8 +500,8 @@ TEST_F(PortPool_test, AddClientPortWhenClientListOverflowsReturnsError)
     EXPECT_TRUE(addSuccessful);
 
     auto errorHandlerCalled{false};
-    auto errorHandlerGuard = ErrorHandler::setTemporaryErrorHandler(
-        [&](const Error error, const std::function<void()>, const ErrorLevel level) {
+    auto errorHandlerGuard =
+        ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const Error error, const ErrorLevel level) {
             errorHandlerCalled = true;
             EXPECT_THAT(error, Eq(Error::kPORT_POOL__CLIENTLIST_OVERFLOW));
             EXPECT_THAT(level, Eq(ErrorLevel::MODERATE));
@@ -608,8 +608,8 @@ TEST_F(PortPool_test, AddServerPortWhenServerListOverflowsReturnsError)
     EXPECT_TRUE(addSuccessful);
 
     auto errorHandlerCalled{false};
-    auto errorHandlerGuard = ErrorHandler::setTemporaryErrorHandler(
-        [&](const Error error, const std::function<void()>, const ErrorLevel level) {
+    auto errorHandlerGuard =
+        ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const Error error, const ErrorLevel level) {
             errorHandlerCalled = true;
             EXPECT_THAT(error, Eq(Error::kPORT_POOL__SERVERLIST_OVERFLOW));
             EXPECT_THAT(level, Eq(ErrorLevel::MODERATE));
@@ -705,7 +705,7 @@ TEST_F(PortPool_test, AddInterfacePortWhenInterfaceListOverflowsReturnsError)
     auto errorHandlerCalled{false};
     Error errorHandlerType;
     auto errorHandlerGuard =
-        ErrorHandler::setTemporaryErrorHandler([&](const Error error, const std::function<void()>, const ErrorLevel) {
+        ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const Error error, const ErrorLevel) {
             errorHandlerType = error;
             errorHandlerCalled = true;
         });
@@ -793,7 +793,7 @@ TEST_F(PortPool_test, AddConditionVariableDataWhenContainerIsFullReturnsError)
     auto errorHandlerCalled{false};
     Error errorHandlerType;
     auto errorHandlerGuard =
-        ErrorHandler::setTemporaryErrorHandler([&](const Error error, const std::function<void()>, const ErrorLevel) {
+        ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([&](const Error error, const ErrorLevel) {
             errorHandlerType = error;
             errorHandlerCalled = true;
         });
diff --git a/iceoryx_posh/test/moduletests/test_roudi_process.cpp b/iceoryx_posh/test/moduletests/test_roudi_process.cpp
index 0fb08c814c..683da8f2be 100644
--- a/iceoryx_posh/test/moduletests/test_roudi_process.cpp
+++ b/iceoryx_posh/test/moduletests/test_roudi_process.cpp
@@ -96,9 +96,8 @@ TEST_F(Process_test, sendViaIpcChannelFail)
     iox::runtime::IpcMessage data{""};
     iox::cxx::optional<iox::Error> sendViaIpcChannelStatusFail;
 
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler(
-        [&sendViaIpcChannelStatusFail](
-            const iox::Error error, const std::function<void()>, const iox::ErrorLevel errorLevel) {
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>(
+        [&sendViaIpcChannelStatusFail](const iox::Error error, const iox::ErrorLevel errorLevel) {
             sendViaIpcChannelStatusFail.emplace(error);
             EXPECT_THAT(errorLevel, Eq(iox::ErrorLevel::MODERATE));
         });
diff --git a/iceoryx_posh/test/test.hpp b/iceoryx_posh/test/test.hpp
index 70936d4a3e..20cd1d6c01 100644
--- a/iceoryx_posh/test/test.hpp
+++ b/iceoryx_posh/test/test.hpp
@@ -1,4 +1,5 @@
 // Copyright (c) 2019 by Robert Bosch GmbH. All rights reserved.
+// Copyright (c) 2022 by Apex.AI Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -16,6 +17,8 @@
 #ifndef IOX_POSH_TEST_TEST_HPP
 #define IOX_POSH_TEST_TEST_HPP
 
+#include "iceoryx_hoofs/testing/mocks/error_handler_mock.hpp"
+
 #include <fstream>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
diff --git a/iceoryx_posh/testing/roudi_environment/roudi_environment.cpp b/iceoryx_posh/testing/roudi_environment/roudi_environment.cpp
index 63aa7a771e..dd7232fd0a 100644
--- a/iceoryx_posh/testing/roudi_environment/roudi_environment.cpp
+++ b/iceoryx_posh/testing/roudi_environment/roudi_environment.cpp
@@ -19,6 +19,7 @@
 #include "iceoryx_hoofs/cxx/helplets.hpp"
 #include "iceoryx_hoofs/internal/posix_wrapper/shared_memory_object/memory_map.hpp"
 #include "iceoryx_hoofs/log/logmanager.hpp"
+#include "iceoryx_hoofs/testing/mocks/error_handler_mock.hpp"
 #include "iceoryx_posh/internal/popo/building_blocks/unique_port_id.hpp"
 #include "iceoryx_posh/internal/roudi/roudi.hpp"
 #include "iceoryx_posh/runtime/posh_runtime.hpp"
@@ -30,7 +31,7 @@ namespace roudi
 RouDiEnvironment::RouDiEnvironment(BaseCTor, const uint16_t uniqueRouDiId)
 {
     // setUniqueRouDiId is called multiple times but it is okay for the tests
-    auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler([](auto, auto, auto) {});
+    auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([](auto, auto) {});
     iox::popo::UniquePortId::setUniqueRouDiId(uniqueRouDiId);
     iox::log::LogManager::GetLogManager().SetDefaultLogLevel(iox::log::LogLevel::kWarn,
                                                              iox::log::LogLevelOutput::kHideLogLevel);
@@ -52,7 +53,7 @@ RouDiEnvironment::~RouDiEnvironment()
     if (m_runtimes.m_doCleanupOnDestruction)
     {
         // setUniqueRouDiId is called multiple times but it is okay for the tests
-        auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler([](auto, auto, auto) {});
+        auto errorHandlerGuard = iox::ErrorHandlerMock::setTemporaryErrorHandler<iox::Error>([](auto, auto) {});
         popo::UniquePortId::setUniqueRouDiId(roudi::DEFAULT_UNIQUE_ROUDI_ID);
     }
     CleanupRuntimes();
diff --git a/tools/iceoryx_build_test.sh b/tools/iceoryx_build_test.sh
index cc52e815e3..e8a4f6370f 100755
--- a/tools/iceoryx_build_test.sh
+++ b/tools/iceoryx_build_test.sh
@@ -119,7 +119,7 @@ while (( "$#" )); do
         shift 1
         ;;
     "binding-c")
-        echo " [i] Including DDS gateway in build"
+        echo " [i] Including C binding in build"
         BINDING_C_FLAG="ON"
         shift 1
         ;;