mw/com: Update NonTrivialConstructors test

Fail the test using FailTest instead of propagating the errors up
through function return types which makes signatures and calling more
complex and can result in tests not failing when they should if the
error code is not handled correctly by the parent layer.

Author: bemerybmw

score/mw/com/test/methods/methods_test_resources/method_consumer.h

@@ -61,7 +61,7 @@ class MethodConsumer
         WITH_COPY
     };
 
-    bool CreateProxy(InstanceSpecifier instance_specifier);
+    void CreateProxy(InstanceSpecifier instance_specifier, const std::string& failure_message_prefix);
 
     bool CallMethodWithInArgsAndReturn(const std::int32_t input_argument_a,
                                        const std::int32_t input_argument_b,
@@ -80,9 +80,9 @@ class MethodConsumer
 };
 
 template <typename Proxy>
-bool MethodConsumer<Proxy>::CreateProxy(InstanceSpecifier instance_specifier)
+void MethodConsumer<Proxy>::CreateProxy(InstanceSpecifier instance_specifier, const std::string& failure_message_prefix)
 {
-    return proxy_container_.CreateProxy(std::move(instance_specifier));
+    proxy_container_.CreateProxy(std::move(instance_specifier), failure_message_prefix);
 }
 
 template <typename Proxy>

score/mw/com/test/methods/non_trivial_constructors/consumer.cpp

@@ -12,6 +12,7 @@
  ********************************************************************************/
 #include "score/mw/com/test/methods/non_trivial_constructors/consumer.h"
 
+#include "score/mw/com/test/common_test_resources/fail_test.h"
 #include "score/mw/com/test/methods/methods_test_resources/process_synchronizer.h"
 #include "score/mw/com/test/methods/methods_test_resources/proxy_container.h"
 #include "score/mw/com/test/methods/non_trivial_constructors/test_method_datatype.h"
@@ -33,14 +34,16 @@ const std::string kInterprocessNotificationShmPath{"/non_trivial_constructors_te
 const InstanceSpecifier kInstanceSpecifier =
     InstanceSpecifier::Create(std::string{"test/methods/non_trivial_constructors/MethodSignature"}).value();
 
-bool CallMethodWithInArgsAndReturn(NonTrivialConstructorProxy& proxy)
+void CallMethodWithInArgsAndReturn(NonTrivialConstructorProxy& proxy, const std::string& failure_message_prefix)
 {
-    auto call_result = [&proxy]() -> score::Result<impl::MethodReturnTypePtr<NonTriviallyConstructibleType>> {
+    auto call_result =
+        [&proxy, &failure_message_prefix]() -> score::Result<impl::MethodReturnTypePtr<NonTriviallyConstructibleType>> {
         std::cout << "\n=== Test: with_in_args_and_return (zero-copy) ===" << std::endl;
         auto allocated_args_result = proxy.with_in_args_and_return.Allocate();
         if (!allocated_args_result.has_value())
         {
-            std::cerr << "Consumer: Could not allocate method args: " << allocated_args_result.error() << std::endl;
+            FailTest(
+                failure_message_prefix, " Consumer: Could not allocate method args: ", allocated_args_result.error());
             return Unexpected(allocated_args_result.error());
         }
 
@@ -49,31 +52,31 @@ bool CallMethodWithInArgsAndReturn(NonTrivialConstructorProxy& proxy)
     }();
     if (!call_result.has_value())
     {
-        std::cerr << "Consumer: with_in_args_and_return call failed: " << call_result.error() << std::endl;
-        return false;
+        FailTest(failure_message_prefix, " Consumer: with_in_args_and_return call failed: ", call_result.error());
+        return;
     }
     const auto return_value = *(call_result.value());
 
     // Since provider adds the two input args which are both initialized with kInitialValue
     const auto expected_return_value = NonTriviallyConstructibleType{} + NonTriviallyConstructibleType{};
     if (return_value != expected_return_value)
     {
-        std::cerr << "Consumer: Expected " << expected_return_value << " but got " << return_value << std::endl;
-        return false;
+        FailTest(failure_message_prefix, " Consumer: Expected ", expected_return_value, " but got ", return_value);
+        return;
     }
 
     std::cout << "Consumer: with_in_args_and_return returned correct result: " << return_value << std::endl;
-    return true;
 }
 
-bool CallMethodWithInArgsOnly(NonTrivialConstructorProxy& proxy)
+void CallMethodWithInArgsOnly(NonTrivialConstructorProxy& proxy, const std::string& failure_message_prefix)
 {
-    auto call_result = [&proxy]() -> Result<void> {
+    auto call_result = [&proxy, &failure_message_prefix]() -> Result<void> {
         std::cout << "\n=== Test: with_in_args_only (zero-copy) ===" << std::endl;
         auto allocated_args_result = proxy.with_in_args_only.Allocate();
         if (!allocated_args_result.has_value())
         {
-            std::cerr << "Consumer: Could not allocate method args: " << allocated_args_result.error() << std::endl;
+            FailTest(
+                failure_message_prefix, " Consumer: Could not allocate method args: ", allocated_args_result.error());
             return Unexpected(allocated_args_result.error());
         }
 
@@ -83,90 +86,76 @@ bool CallMethodWithInArgsOnly(NonTrivialConstructorProxy& proxy)
     }();
     if (!call_result.has_value())
     {
-        std::cerr << "Consumer: with_in_args_only call failed: " << call_result.error() << std::endl;
-        return false;
+        FailTest(failure_message_prefix, " Consumer: with_in_args_only call failed: ", call_result.error());
+        return;
     }
 
     std::cout << "Consumer: with_in_args_only returned without error" << std::endl;
-    return true;
 }
 
-bool CallMethodWithReturnOnly(NonTrivialConstructorProxy& proxy)
+void CallMethodWithReturnOnly(NonTrivialConstructorProxy& proxy, const std::string& failure_message_prefix)
 {
     std::cout << "\n=== Test: with_return_only (copy call) ===" << std::endl;
     const auto call_result = proxy.with_return_only();
     if (!call_result.has_value())
     {
-        std::cerr << "Consumer: with_return_only call failed: " << call_result.error() << std::endl;
-        return false;
+        FailTest(failure_message_prefix, " Consumer: with_return_only call failed: ", call_result.error());
+        return;
     }
     const auto return_value = *(call_result.value());
 
     const auto expected_return_value = NonTriviallyConstructibleType{};
     if (return_value != expected_return_value)
     {
-        std::cerr << "Consumer: Expected " << expected_return_value << " but got " << return_value << std::endl;
-        return false;
+        FailTest(failure_message_prefix, " Consumer: Expected ", expected_return_value, " but got ", return_value);
+        return;
     }
 
     std::cout << "Consumer: with_return_only returned correct result: " << return_value << std::endl;
-    return true;
 }
 
 }  // namespace
 
-int run_consumer()
+void run_consumer()
 {
     auto process_synchronizer_result = ProcessSynchronizer::Create(kInterprocessNotificationShmPath);
     if (!(process_synchronizer_result.has_value()))
     {
-        std::cerr << "Methods non_trivial_constructors consumer failed: Could not create ProcessSynchronizer"
-                  << std::endl;
-        return EXIT_FAILURE;
+        FailTest("Methods non_trivial_constructors consumer failed: Could not create ProcessSynchronizer");
+        return;
     }
 
+    // Set an exit function to notify the provider in case of failure in calls to FailTest, so that it does not wait
+    // indefinitely for the consumer to finish.
+    ExitFunction process_synchronizer_guard{[&process_synchronizer_result]() {
+        process_synchronizer_result->Notify();
+    }};
+    SetFailTestExitFunction(process_synchronizer_guard);
+
+    // Create a scope exit guard to clear the fail test exit function, so that it cannot be called after the
+    // process_synchronizer has been destroyed.
+    utils::ScopeExit fail_test_exit_function_guard{[&process_synchronizer_result]() {
+        ClearTestExitFunction();
+        process_synchronizer_result->Notify();
+    }};
+
     ProxyContainer<NonTrivialConstructorProxy> consumer{};
 
     // Step 1. Find service and create proxy
     std::cout << "\nConsumer: Step 1" << std::endl;
-    if (!consumer.CreateProxy(kInstanceSpecifier))
-    {
-        std::cerr << "Methods non_trivial_constructors consumer failed: CreateProxy" << std::endl;
-        process_synchronizer_result->Notify();
-        return EXIT_FAILURE;
-    }
+    consumer.CreateProxy(kInstanceSpecifier, "non_trivial_constructors");
 
     // Step 2. Call zero-copy method with InArgs and Return
     std::cout << "\nConsumer: Step 2" << std::endl;
-    if (!CallMethodWithInArgsAndReturn(consumer.GetProxy()))
-    {
-        std::cerr << "Methods non_trivial_constructors consumer failed: CallMethodWithInArgsAndReturnZeroCopy"
-                  << std::endl;
-        process_synchronizer_result->Notify();
-        return EXIT_FAILURE;
-    }
+    CallMethodWithInArgsAndReturn(consumer.GetProxy(), "non_trivial_constructors");
 
     // Step 3. Call zero-copy method with InArgs only
     std::cout << "\nConsumer: Step 3" << std::endl;
-    if (!CallMethodWithInArgsOnly(consumer.GetProxy()))
-    {
-        std::cerr << "Methods non_trivial_constructors consumer failed: CallMethodWithInArgsOnlyZeroCopy" << std::endl;
-        process_synchronizer_result->Notify();
-        return EXIT_FAILURE;
-    }
+    CallMethodWithInArgsOnly(consumer.GetProxy(), "non_trivial_constructors");
 
     // Step 4. Call method with return only with copy
     std::cout << "\nConsumer: Step 4" << std::endl;
-    if (!CallMethodWithReturnOnly(consumer.GetProxy()))
-    {
-        std::cerr << "Methods non_trivial_constructors consumer failed: CallMethodWithReturnOnly" << std::endl;
-        process_synchronizer_result->Notify();
-        return EXIT_FAILURE;
-    }
-
-    process_synchronizer_result->Notify();
-
-    return EXIT_SUCCESS;
+    CallMethodWithReturnOnly(consumer.GetProxy(), "non_trivial_constructors");
 }
 
 }  // namespace score::mw::com::test

score/mw/com/test/methods/non_trivial_constructors/consumer.h

@@ -16,7 +16,7 @@
 namespace score::mw::com::test
 {
 
-int run_consumer();
+void run_consumer();
 
 }  // namespace score::mw::com::test
 

score/mw/com/test/methods/non_trivial_constructors/integration_test/BUILD

@@ -30,10 +30,3 @@ integration_test(
     filesystem = ":filesystem",
     flaky = True,  # TODO: Remove flaky tag once test is stable: Refer to issue 386
 )
-
-test_suite(
-    name = "component_tests",
-    tests = [
-        ":non_trivial_constructors_test",
-    ],
-)

score/mw/com/test/methods/non_trivial_constructors/main_consumer.cpp

@@ -18,5 +18,6 @@ int main(int argc, const char** argv)
 {
     score::mw::com::test::SetupAssertHandler();
     score::mw::com::runtime::InitializeRuntime(argc, argv);
-    return score::mw::com::test::run_consumer();
+    score::mw::com::test::run_consumer();
+    return EXIT_SUCCESS;
 }

score/mw/com/test/methods/non_trivial_constructors/main_provider.cpp

@@ -29,5 +29,6 @@ int main(int argc, const char** argv)
         std::cerr << "Unable to set signal handler for SIGINT and/or SIGTERM, cautiously continuing\n";
     }
 
-    return score::mw::com::test::run_provider(stop_source.get_token());
+    score::mw::com::test::run_provider(stop_source.get_token());
+    return EXIT_SUCCESS;
 }