fix assignment operators on Promise/Future

Author: beekld

libs/internal/include/launchdarkly/async/promise.hpp

@@ -283,7 +283,9 @@ class Promise {
     Promise() : internal_(new PromiseInternal<T>()) {}
     ~Promise() = default;
     Promise(Promise const&) = delete;
+    Promise& operator=(Promise const&) = delete;
     Promise(Promise&&) = default;
+    Promise& operator=(Promise&&) = default;
 
     // Sets the result to the given value and schedules any continuations that
     // were registered via Future::Then. Returns true if the result was set, or
@@ -336,7 +338,9 @@ class Future {
         : internal_(internal) {}
     ~Future() = default;
     Future(Future const&) = default;
+    Future& operator=(Future const&) = default;
     Future(Future&&) = default;
+    Future& operator=(Future&&) = default;
 
     // Returns true if the associated Promise has been resolved.
     bool IsFinished() const { return internal_->IsFinished(); }

libs/internal/tests/promise_test.cpp

@@ -307,6 +307,43 @@ TEST(Promise, ExpectedFailure) {
     EXPECT_EQ(result->error(), "timed out");
 }
 
+// Verifies that Promise supports move assignment, consistent with it being
+// move-only.
+TEST(Promise, MoveAssignment) {
+    Promise<int> p1;
+    Future<int> future = p1.GetFuture();
+
+    Promise<int> p2;
+    p2 = std::move(p1);
+    p2.Resolve(42);
+
+    EXPECT_EQ(*future.GetResult(), 42);
+}
+
+// Verifies that Future supports move assignment.
+TEST(Promise, FutureMoveAssignment) {
+    Promise<int> promise;
+    Future<int> f1 = promise.GetFuture();
+    Future<int> f2 = promise.GetFuture();
+
+    f2 = std::move(f1);
+    promise.Resolve(42);
+
+    EXPECT_EQ(*f2.GetResult(), 42);
+}
+
+// Verifies that Future supports copy assignment.
+TEST(Promise, FutureCopyAssignment) {
+    Promise<int> promise;
+    Future<int> f1 = promise.GetFuture();
+    Future<int> f2 = promise.GetFuture();
+
+    f2 = f1;
+    promise.Resolve(42);
+
+    EXPECT_EQ(*f2.GetResult(), 42);
+}
+
 // Verifies that a Continuation can be constructed from an lvalue callable
 // (named lambda), not just from a temporary.
 TEST(Promise, LvalueLambdaContinuation) {