[celix] branch master updated: Correcting and testing Exceptions

[pnoltes]

This is an automated email from the ASF dual-hosted git repository.

pnoltes pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/celix.git


The following commit(s) were added to refs/heads/master by this push:
     new 0b00872  Correcting and testing Exceptions
     new 81d4d0b  Merge pull request #365 from stegemr/feature/FixExceptions
0b00872 is described below

commit 0b0087263b5391bbd17482c2eda91f039ff9670a
Author: stegemanr <stegeman...@gmail.com>
AuthorDate: Wed Sep 15 10:45:53 2021 +0200

    Correcting and testing Exceptions
---
 .../api/celix/PromiseInvocationException.h         |   4 +-
 libs/promises/gtest/src/PromisesTestSuite.cc       | 100 +++++++++++++++++++++
 2 files changed, 102 insertions(+), 2 deletions(-)

diff --git a/libs/promises/api/celix/PromiseInvocationException.h 
b/libs/promises/api/celix/PromiseInvocationException.h
index 0a0b453..1a5226b 100644
--- a/libs/promises/api/celix/PromiseInvocationException.h
+++ b/libs/promises/api/celix/PromiseInvocationException.h
@@ -30,10 +30,10 @@ namespace celix {
         explicit PromiseInvocationException(const char* what) : w{what} {}
         explicit PromiseInvocationException(std::string what) : 
w{std::move(what)} {}
 
-        PromiseInvocationException(const PromiseInvocationException&) = delete;
+        PromiseInvocationException(const PromiseInvocationException&) = 
default;
         PromiseInvocationException(PromiseInvocationException&&) noexcept = 
default;
 
-        PromiseInvocationException& operator=(const 
PromiseInvocationException&) = delete;
+        PromiseInvocationException& operator=(const 
PromiseInvocationException&) = default;
         PromiseInvocationException& operator=(PromiseInvocationException&&) 
noexcept = default;
 
         [[nodiscard]] const char* what() const noexcept override { return 
w.c_str(); }
diff --git a/libs/promises/gtest/src/PromisesTestSuite.cc 
b/libs/promises/gtest/src/PromisesTestSuite.cc
index 025af0f..41eff5a 100644
--- a/libs/promises/gtest/src/PromisesTestSuite.cc
+++ b/libs/promises/gtest/src/PromisesTestSuite.cc
@@ -226,6 +226,106 @@ TEST_F(PromiseTestSuite, onFailureHandlingLogicError) {
     EXPECT_EQ(true, resolveCalled);
 }
 
+TEST_F(PromiseTestSuite, onFailureHandlingPromiseIllegalStateException) {
+    auto deferred =  factory->deferred<long>();
+    std::atomic<bool> successCalled = false;
+    std::atomic<bool> failureCalled = false;
+    std::atomic<bool> resolveCalled = false;
+    auto p = deferred.getPromise()
+            .onSuccess([&](long /*value*/) {
+                successCalled = true;
+            })
+            .onFailure([&](const std::exception &e) {
+                failureCalled = true;
+                ASSERT_TRUE(0 == strcmp("Illegal state",  e.what())) << 
std::string(e.what());
+            })
+            .onResolve([&]() {
+                resolveCalled = true;
+            });
+
+    deferred.fail(celix::PromiseIllegalStateException());
+
+    factory->wait();
+    EXPECT_EQ(false, successCalled);
+    EXPECT_EQ(true, failureCalled);
+    EXPECT_EQ(true, resolveCalled);
+}
+
+TEST_F(PromiseTestSuite, onFailureHandlingPromiseInvocationException) {
+    auto deferred =  factory->deferred<long>();
+    std::atomic<bool> successCalled = false;
+    std::atomic<bool> failureCalled = false;
+    std::atomic<bool> resolveCalled = false;
+    auto p = deferred.getPromise()
+            .onSuccess([&](long /*value*/) {
+                successCalled = true;
+            })
+            .onFailure([&](const std::exception &e) {
+                failureCalled = true;
+                ASSERT_TRUE(0 == strcmp("MyExceptionText",  e.what())) << 
std::string(e.what());
+            })
+            .onResolve([&]() {
+                resolveCalled = true;
+            });
+
+    deferred.fail(celix::PromiseInvocationException("MyExceptionText"));
+
+    factory->wait();
+    EXPECT_EQ(false, successCalled);
+    EXPECT_EQ(true, failureCalled);
+    EXPECT_EQ(true, resolveCalled);
+}
+
+TEST_F(PromiseTestSuite, onFailureHandlingPromiseTimeoutException) {
+    auto deferred =  factory->deferred<long>();
+    std::atomic<bool> successCalled = false;
+    std::atomic<bool> failureCalled = false;
+    std::atomic<bool> resolveCalled = false;
+    auto p = deferred.getPromise()
+            .onSuccess([&](long /*value*/) {
+                successCalled = true;
+            })
+            .onFailure([&](const std::exception &e) {
+                failureCalled = true;
+                ASSERT_TRUE(0 == strcmp("Timeout",  e.what())) << 
std::string(e.what());
+            })
+            .onResolve([&]() {
+                resolveCalled = true;
+            });
+
+    deferred.fail(celix::PromiseTimeoutException());
+
+    factory->wait();
+    EXPECT_EQ(false, successCalled);
+    EXPECT_EQ(true, failureCalled);
+    EXPECT_EQ(true, resolveCalled);
+}
+
+TEST_F(PromiseTestSuite, onFailureHandlingRejectedExecutionException) {
+    auto deferred =  factory->deferred<long>();
+    std::atomic<bool> successCalled = false;
+    std::atomic<bool> failureCalled = false;
+    std::atomic<bool> resolveCalled = false;
+    auto p = deferred.getPromise()
+            .onSuccess([&](long /*value*/) {
+                successCalled = true;
+            })
+            .onFailure([&](const std::exception &e) {
+                failureCalled = true;
+                ASSERT_TRUE(0 == strcmp("Cannot accept task for execution",  
e.what())) << std::string(e.what());
+            })
+            .onResolve([&]() {
+                resolveCalled = true;
+            });
+
+    deferred.fail(celix::RejectedExecutionException());
+
+    factory->wait();
+    EXPECT_EQ(false, successCalled);
+    EXPECT_EQ(true, failureCalled);
+    EXPECT_EQ(true, resolveCalled);
+}
+
 TEST_F(PromiseTestSuite, resolveSuccessWith) {
     auto deferred1 = factory->deferred<long>();
     std::atomic<bool> called = false;