modernize Future::get(): 2/n = 'our' tests use only rvalue-get()

Summary:
Change the folly/future/... tests to use mainly[*] the rvalue-qualified versions of get() and get(dur).

[*] Although the lvalue-qualified get is deprecated, it is not yet removed, so this diff leaves a test for the lvalue-qualified version. But the bulk of the tests are for the rvalue-qualified get.

Reviewed By: yfeldblum

Differential Revision: D8239792

fbshipit-source-id: c8a2e90cb5ab97a59ec97994c8c6a6ca27dab86e

folly/futures/test/CollectTest.cpp

@@ -751,7 +751,7 @@ TEST(Collect, collectVariadicWithException) {
   pi.setException(eggs);
   EXPECT_TRUE(f.isReady());
   EXPECT_TRUE(f.getTry().hasException());
-  EXPECT_THROW(f.get(), eggs_t);
+  EXPECT_THROW(std::move(f).get(), eggs_t);
 }
 
 TEST(Collect, collectAllNone) {

folly/futures/test/EnsureTest.cpp

@@ -30,7 +30,7 @@ TEST(Ensure, basic) {
     .then([](int) { throw std::runtime_error("ensure"); })
     .ensure(cob);
 
-  EXPECT_THROW(f.get(), std::runtime_error);
+  EXPECT_THROW(std::move(f).get(), std::runtime_error);
   EXPECT_EQ(2, count);
 }
 
@@ -44,5 +44,5 @@ TEST(Ensure, mutableLambda) {
     .then([]() { throw std::runtime_error("ensure"); });
 
   EXPECT_EQ(0, set->size());
-  EXPECT_THROW(f.get(), std::runtime_error);
+  EXPECT_THROW(std::move(f).get(), std::runtime_error);
 }

folly/futures/test/FutureSplitterTest.cpp

@@ -154,7 +154,7 @@ TEST(FutureSplitter, splitFutureScope) {
   p.setValue(1);
   EXPECT_TRUE(f1.isReady());
   EXPECT_TRUE(f1.hasValue());
-  EXPECT_EQ(1, f1.get());
+  EXPECT_EQ(1, std::move(f1).get());
 }
 
 TEST(FutureSplitter, splitFutureFailure) {

folly/futures/test/FutureTest.cpp

@@ -1407,7 +1407,7 @@ TEST(Future, thenDynamic) {
       }
   );
   p.setValue(2);
-  EXPECT_EQ(f.get(), 5);
+  EXPECT_EQ(std::move(f).get(), 5);
 }
 
 TEST(Future, RequestContext) {

folly/futures/test/NonCopyableLambdaTest.cpp

@@ -33,7 +33,7 @@ TEST(NonCopyableLambda, basic) {
   //  });
 
   EXPECT_TRUE(future.isReady());
-  EXPECT_EQ(future.get(), 123);
+  EXPECT_EQ(std::move(future).get(), 123);
 }
 
 TEST(NonCopyableLambda, unique_ptr) {
@@ -59,7 +59,7 @@ TEST(NonCopyableLambda, unique_ptr) {
   EXPECT_FALSE(future.isReady());
   promise.setValue();
   EXPECT_TRUE(future.isReady());
-  EXPECT_EQ(*future.get(), 2);
+  EXPECT_EQ(*std::move(future).get(), 2);
 }
 
 TEST(NonCopyableLambda, Function) {
@@ -73,7 +73,7 @@ TEST(NonCopyableLambda, Function) {
   EXPECT_FALSE(future.isReady());
   promise.setValue(100);
   EXPECT_TRUE(future.isReady());
-  EXPECT_EQ(future.get(), 101);
+  EXPECT_EQ(std::move(future).get(), 101);
 }
 
 TEST(NonCopyableLambda, FunctionConst) {
@@ -87,5 +87,5 @@ TEST(NonCopyableLambda, FunctionConst) {
   EXPECT_FALSE(future.isReady());
   promise.setValue(100);
   EXPECT_TRUE(future.isReady());
-  EXPECT_EQ(future.get(), 101);
+  EXPECT_EQ(std::move(future).get(), 101);
 }

folly/futures/test/ReduceTest.cpp

@@ -36,7 +36,7 @@ TEST(Reduce, basic) {
       [](double a, Try<int>&& b){
         return a + *b + 0.1;
       });
-    EXPECT_EQ(1.2, f1.get());
+    EXPECT_EQ(1.2, std::move(f1).get());
   }
 
   // One (Try)
@@ -47,7 +47,7 @@ TEST(Reduce, basic) {
       [](double a, Try<int>&& b){
         return a + *b + 0.1;
       });
-    EXPECT_EQ(1.1, f1.get());
+    EXPECT_EQ(1.1, std::move(f1).get());
   }
 
   // Returning values (Try)
@@ -58,7 +58,7 @@ TEST(Reduce, basic) {
       [](double a, Try<int>&& b){
         return a + *b + 0.1;
       });
-    EXPECT_EQ(6.3, f1.get());
+    EXPECT_EQ(6.3, std::move(f1).get());
   }
 
   // Returning values
@@ -69,7 +69,7 @@ TEST(Reduce, basic) {
       [](double a, int&& b){
         return a + b + 0.1;
       });
-    EXPECT_EQ(6.3, f1.get());
+    EXPECT_EQ(6.3, std::move(f1).get());
   }
 
   // Returning futures (Try)
@@ -80,7 +80,7 @@ TEST(Reduce, basic) {
       [](double a, Try<int>&& b){
         return makeFuture<double>(a + *b + 0.1);
       });
-    EXPECT_EQ(6.3, f2.get());
+    EXPECT_EQ(6.3, std::move(f2).get());
   }
 
   // Returning futures
@@ -91,7 +91,7 @@ TEST(Reduce, basic) {
       [](double a, int&& b){
         return makeFuture<double>(a + b + 0.1);
       });
-    EXPECT_EQ(6.3, f2.get());
+    EXPECT_EQ(6.3, std::move(f2).get());
   }
 }
 
@@ -108,13 +108,13 @@ TEST(Reduce, chain) {
     auto f = collectAll(makeFutures(3)).reduce(0, [](int a, Try<int>&& b){
       return a + *b;
     });
-    EXPECT_EQ(6, f.get());
+    EXPECT_EQ(6, std::move(f).get());
   }
   {
     auto f = collect(makeFutures(3)).reduce(0, [](int a, int&& b){
       return a + b;
     });
-    EXPECT_EQ(6, f.get());
+    EXPECT_EQ(6, std::move(f).get());
   }
 }
 
@@ -130,7 +130,7 @@ TEST(Reduce, unorderedReduce) {
                         fs.end(),
                         0.0,
                         [](double /* a */, int&& b) { return double(b); });
-    EXPECT_EQ(3.0, f.get());
+    EXPECT_EQ(3.0, std::move(f).get());
   }
   {
     Promise<int> p1;
@@ -150,7 +150,7 @@ TEST(Reduce, unorderedReduce) {
     p3.setValue(3);
     p2.setValue(2);
     p1.setValue(1);
-    EXPECT_EQ(1.0, f.get());
+    EXPECT_EQ(1.0, std::move(f).get());
   }
 }
 
@@ -172,7 +172,7 @@ TEST(Reduce, unorderedReduceException) {
   p3.setValue(3);
   p2.setException(exception_wrapper(std::runtime_error("blah")));
   p1.setValue(1);
-  EXPECT_THROW(f.get(), std::runtime_error);
+  EXPECT_THROW(std::move(f).get(), std::runtime_error);
 }
 
 TEST(Reduce, unorderedReduceFuture) {

folly/futures/test/RetryingTest.cpp

@@ -101,7 +101,7 @@ TEST(RetryingTest, policy_throws) {
   auto r = futures::retrying(
       [](size_t, exception_wrapper) -> bool { throw eggs(); },
       [](size_t) -> Future<size_t> { throw std::runtime_error("ha"); });
-  EXPECT_THROW(r.get(), eggs);
+  EXPECT_THROW(std::move(r).get(), eggs);
 }
 
 TEST(RetryingTest, policy_future) {

folly/futures/test/SelfDestructTest.cpp

@@ -27,14 +27,14 @@ TEST(SelfDestruct, then) {
     return x + 1;
   });
   p->setValue(123);
-  EXPECT_EQ(124, future.get());
+  EXPECT_EQ(124, std::move(future).get());
 }
 
 TEST(SelfDestruct, ensure) {
   auto* p = new Promise<int>();
   auto future = p->getFuture().ensure([p] { delete p; });
   p->setValue(123);
-  EXPECT_EQ(123, future.get());
+  EXPECT_EQ(123, std::move(future).get());
 }
 
 class ThrowingExecutorError : public std::runtime_error {
@@ -58,7 +58,7 @@ TEST(SelfDestruct, throwingExecutor) {
         return 456;
       });
   p->setValue(123);
-  EXPECT_EQ(456, future.get());
+  EXPECT_EQ(456, std::move(future).get());
 }
 
 TEST(SelfDestruct, throwingInlineExecutor) {
@@ -73,5 +73,5 @@ TEST(SelfDestruct, throwingInlineExecutor) {
                     })
                     .onError([](ThrowingExecutorError const&) { return 456; });
   p->setValue(123);
-  EXPECT_EQ(456, future.get());
+  EXPECT_EQ(456, std::move(future).get());
 }

folly/futures/test/TimekeeperTest.cpp

@@ -44,7 +44,7 @@ TEST_F(TimekeeperFixture, after) {
   auto t1 = now();
   auto f = timeLord_->after(awhile);
   EXPECT_FALSE(f.isReady());
-  f.get();
+  std::move(f).get();
   auto t2 = now();
 
   EXPECT_GE(t2 - t1, awhile);
@@ -96,7 +96,7 @@ TEST(Timekeeper, futureWithinHandlesNullTimekeeperSingleton) {
   };
   Promise<int> p;
   auto f = p.getFuture().within(one_ms);
-  EXPECT_THROW(f.get(), FutureNoTimekeeper);
+  EXPECT_THROW(std::move(f).get(), FutureNoTimekeeper);
 }
 
 TEST(Timekeeper, semiFutureWithinHandlesNullTimekeeperSingleton) {
@@ -200,7 +200,7 @@ TEST(Timekeeper, futureWithinThrows) {
   auto f =
       p.getFuture().within(one_ms).onError([](FutureTimeout&) { return -1; });
 
-  EXPECT_EQ(-1, f.get());
+  EXPECT_EQ(-1, std::move(f).get());
 }
 
 TEST(Timekeeper, semiFutureWithinThrows) {
@@ -215,7 +215,7 @@ TEST(Timekeeper, futureWithinAlreadyComplete) {
   auto f =
       makeFuture(42).within(one_ms).onError([&](FutureTimeout&) { return -1; });
 
-  EXPECT_EQ(42, f.get());
+  EXPECT_EQ(42, std::move(f).get());
 }
 
 TEST(Timekeeper, semiFutureWithinAlreadyComplete) {
@@ -232,7 +232,7 @@ TEST(Timekeeper, futureWithinFinishesInTime) {
                .onError([&](FutureTimeout&) { return -1; });
   p.setValue(42);
 
-  EXPECT_EQ(42, f.get());
+  EXPECT_EQ(42, std::move(f).get());
 }
 
 TEST(Timekeeper, semiFutureWithinFinishesInTime) {
@@ -257,7 +257,7 @@ TEST(Timekeeper, semiFutureWithinVoidSpecialization) {
 TEST(Timekeeper, futureWithinException) {
   Promise<Unit> p;
   auto f = p.getFuture().within(awhile, std::runtime_error("expected"));
-  EXPECT_THROW(f.get(), std::runtime_error);
+  EXPECT_THROW(std::move(f).get(), std::runtime_error);
 }
 
 TEST(Timekeeper, semiFutureWithinException) {

folly/futures/test/ViaTest.cpp

@@ -186,7 +186,7 @@ TEST(Via, chain3) {
       [&]{ count++; return 3.14159; },
       [&](double) { count++; return std::string("hello"); },
       [&]{ count++; return makeFuture(42); });
-  EXPECT_EQ(42, f.get());
+  EXPECT_EQ(42, std::move(f).get());
   EXPECT_EQ(3, count);
 }
 
@@ -500,9 +500,10 @@ TEST(Via, viaDummyExecutorFutureSetValueFirst) {
   auto future = makeFuture().via(&x).then(
       [c = std::move(captured_promise)] { return 42; });
 
-  EXPECT_THROW(future.get(std::chrono::seconds(5)), BrokenPromise);
+  EXPECT_THROW(std::move(future).get(std::chrono::seconds(5)), BrokenPromise);
   EXPECT_THROW(
-      captured_promise_future.get(std::chrono::seconds(5)), BrokenPromise);
+      std::move(captured_promise_future).get(std::chrono::seconds(5)),
+      BrokenPromise);
 }
 
 TEST(Via, viaDummyExecutorFutureSetCallbackFirst) {
@@ -519,9 +520,10 @@ TEST(Via, viaDummyExecutorFutureSetCallbackFirst) {
       [c = std::move(captured_promise)] { return 42; });
   trigger.setValue();
 
-  EXPECT_THROW(future.get(std::chrono::seconds(5)), BrokenPromise);
+  EXPECT_THROW(std::move(future).get(std::chrono::seconds(5)), BrokenPromise);
   EXPECT_THROW(
-      captured_promise_future.get(std::chrono::seconds(5)), BrokenPromise);
+      std::move(captured_promise_future).get(std::chrono::seconds(5)),
+      BrokenPromise);
 }
 
 TEST(Via, viaExecutorDiscardsTaskFutureSetValueFirst) {
@@ -540,9 +542,10 @@ TEST(Via, viaExecutorDiscardsTaskFutureSetValueFirst) {
         [c = std::move(captured_promise)] { return 42; });
   }
 
-  EXPECT_THROW(future->get(std::chrono::seconds(5)), BrokenPromise);
+  EXPECT_THROW(std::move(*future).get(std::chrono::seconds(5)), BrokenPromise);
   EXPECT_THROW(
-      captured_promise_future.get(std::chrono::seconds(5)), BrokenPromise);
+      std::move(captured_promise_future).get(std::chrono::seconds(5)),
+      BrokenPromise);
 }
 
 TEST(Via, viaExecutorDiscardsTaskFutureSetCallbackFirst) {
@@ -563,9 +566,10 @@ TEST(Via, viaExecutorDiscardsTaskFutureSetCallbackFirst) {
     trigger.setValue();
   }
 
-  EXPECT_THROW(future->get(std::chrono::seconds(5)), BrokenPromise);
+  EXPECT_THROW(std::move(*future).get(std::chrono::seconds(5)), BrokenPromise);
   EXPECT_THROW(
-      captured_promise_future.get(std::chrono::seconds(5)), BrokenPromise);
+      std::move(captured_promise_future).get(std::chrono::seconds(5)),
+      BrokenPromise);
 }
 
 TEST(ViaFunc, liftsVoid) {

folly/futures/test/WillEqualTest.cpp

@@ -48,7 +48,7 @@ TEST(WillEqual, basic) {
     auto f3 = f1.willEqual(f2);
     p1.setValue(27);
     p2.setValue(27);
-    EXPECT_TRUE(f3.get());
+    EXPECT_TRUE(std::move(f3).get());
   }
   {
     Promise<int> p1;
@@ -58,7 +58,7 @@ TEST(WillEqual, basic) {
     auto f3 = f1.willEqual(f2);
     p1.setValue(27);
     p2.setValue(36);
-    EXPECT_FALSE(f3.get());
+    EXPECT_FALSE(std::move(f3).get());
   }
   // p1 already fulfilled, p2 not yet fulfilled
   {
@@ -69,7 +69,7 @@ TEST(WillEqual, basic) {
     auto f2 = p2.getFuture();
     auto f3 = f1.willEqual(f2);
     p2.setValue(27);
-    EXPECT_TRUE(f3.get());
+    EXPECT_TRUE(std::move(f3).get());
   }
   {
     Promise<int> p1;
@@ -79,7 +79,7 @@ TEST(WillEqual, basic) {
     auto f2 = p2.getFuture();
     auto f3 = f1.willEqual(f2);
     p2.setValue(36);
-    EXPECT_FALSE(f3.get());
+    EXPECT_FALSE(std::move(f3).get());
   }
   // p2 already fulfilled, p1 not yet fulfilled
   {
@@ -90,7 +90,7 @@ TEST(WillEqual, basic) {
     auto f2 = p2.getFuture();
     auto f3 = f1.willEqual(f2);
     p1.setValue(27);
-    EXPECT_TRUE(f3.get());
+    EXPECT_TRUE(std::move(f3).get());
   }
   {
     Promise<int> p1;
@@ -100,6 +100,6 @@ TEST(WillEqual, basic) {
     auto f2 = p2.getFuture();
     auto f3 = f1.willEqual(f2);
     p1.setValue(27);
-    EXPECT_FALSE(f3.get());
+    EXPECT_FALSE(std::move(f3).get());
   }
 }

folly/futures/test/WindowTest.cpp

@@ -137,7 +137,7 @@ TEST(Window, exception) {
   }
 
   // Should have received 2 exceptions.
-  EXPECT_EQ(2, res.get());
+  EXPECT_EQ(2, std::move(res).get());
 }
 
 TEST(Window, stackOverflow) {
@@ -171,7 +171,7 @@ TEST(Window, stackOverflow) {
         return sum;
       });
 
-  EXPECT_EQ(res.get(), expectedSum);
+  EXPECT_EQ(std::move(res).get(), expectedSum);
 }
 
 TEST(Window, parallel) {
@@ -290,7 +290,7 @@ TEST(WindowExecutor, basic) {
         0,
         [](int sum, const Try<int>& b) { return sum + *b; });
     executor_->waitFor(res);
-    EXPECT_EQ(expect, res.get());
+    EXPECT_EQ(expect, std::move(res).get());
   };
   {
     SCOPED_TRACE("2 in-flight at a time");
@@ -321,7 +321,7 @@ TEST(WindowExecutor, basic) {
           return sum + 1;
         });
     executor.waitFor(res);
-    EXPECT_EQ(3, res.get());
+    EXPECT_EQ(3, std::move(res).get());
   }
   {
     // string -> return Future<int>
@@ -334,7 +334,7 @@ TEST(WindowExecutor, basic) {
         0,
         [](int sum, const Try<int>& b) { return sum + *b; });
     executor.waitFor(res);
-    EXPECT_EQ(6, res.get());
+    EXPECT_EQ(6, std::move(res).get());
   }
 }