folly/futures/test/SemiFutureTest.cpp

   1 /*
   2  * Copyright 2017 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <folly/Baton.h>
  18 #include <folly/Executor.h>
  19 #include <folly/Memory.h>
  20 #include <folly/Unit.h>
  21 #include <folly/dynamic.h>
  22 #include <folly/futures/Future.h>
  23 #include <folly/io/async/EventBase.h>
  24 #include <folly/portability/GTest.h>
  25
  26 #include <algorithm>
  27 #include <atomic>
  28 #include <memory>
  29 #include <numeric>
  30 #include <string>
  31 #include <thread>
  32 #include <type_traits>
  33
  34 using namespace folly;
  35
  36 #define EXPECT_TYPE(x, T) EXPECT_TRUE((std::is_same<decltype(x), T>::value))
  37
  38 typedef FutureException eggs_t;
  39 static eggs_t eggs("eggs");
  40
  41 // Future
  42
  43 TEST(SemiFuture, makeEmpty) {
  44   auto f = SemiFuture<int>::makeEmpty();
  45   EXPECT_THROW(f.isReady(), NoState);
  46 }
  47
  48 TEST(SemiFuture, futureDefaultCtor) {
  49   SemiFuture<Unit>();
  50 }
  51
  52 TEST(SemiFuture, makeSemiFutureWithUnit) {
  53   int count = 0;
  54   SemiFuture<Unit> fu = makeSemiFutureWith([&] { count++; });
  55   EXPECT_EQ(1, count);
  56 }
  57
  58 namespace {
  59 SemiFuture<int> onErrorHelperEggs(const eggs_t&) {
  60   return makeSemiFuture(10);
  61 }
  62 SemiFuture<int> onErrorHelperGeneric(const std::exception&) {
  63   return makeSemiFuture(20);
  64 }
  65 } // namespace
  66
  67 TEST(SemiFuture, special) {
  68   EXPECT_FALSE(std::is_copy_constructible<SemiFuture<int>>::value);
  69   EXPECT_FALSE(std::is_copy_assignable<SemiFuture<int>>::value);
  70   EXPECT_TRUE(std::is_move_constructible<SemiFuture<int>>::value);
  71   EXPECT_TRUE(std::is_move_assignable<SemiFuture<int>>::value);
  72 }
  73
  74 TEST(SemiFuture, value) {
  75   auto f = makeSemiFuture(std::make_unique<int>(42));
  76   auto up = std::move(f.value());
  77   EXPECT_EQ(42, *up);
  78
  79   EXPECT_THROW(makeSemiFuture<int>(eggs).value(), eggs_t);
  80
  81   EXPECT_TYPE(std::declval<SemiFuture<int>&>().value(), int&);
  82   EXPECT_TYPE(std::declval<SemiFuture<int> const&>().value(), int const&);
  83   EXPECT_TYPE(std::declval<SemiFuture<int>&&>().value(), int&&);
  84   EXPECT_TYPE(std::declval<SemiFuture<int> const&&>().value(), int const&&);
  85 }
  86
  87 TEST(SemiFuture, hasException) {
  88   EXPECT_TRUE(makeSemiFuture<int>(eggs).getTry().hasException());
  89   EXPECT_FALSE(makeSemiFuture(42).getTry().hasException());
  90 }
  91
  92 TEST(SemiFuture, hasValue) {
  93   EXPECT_TRUE(makeSemiFuture(42).getTry().hasValue());
  94   EXPECT_FALSE(makeSemiFuture<int>(eggs).getTry().hasValue());
  95 }
  96
  97 TEST(SemiFuture, makeSemiFuture) {
  98   EXPECT_TYPE(makeSemiFuture(42), SemiFuture<int>);
  99   EXPECT_EQ(42, makeSemiFuture(42).value());
 100
 101   EXPECT_TYPE(makeSemiFuture<float>(42), SemiFuture<float>);
 102   EXPECT_EQ(42, makeSemiFuture<float>(42).value());
 103
 104   auto fun = [] { return 42; };
 105   EXPECT_TYPE(makeSemiFutureWith(fun), SemiFuture<int>);
 106   EXPECT_EQ(42, makeSemiFutureWith(fun).value());
 107
 108   auto funf = [] { return makeSemiFuture<int>(43); };
 109   EXPECT_TYPE(makeSemiFutureWith(funf), SemiFuture<int>);
 110   EXPECT_EQ(43, makeSemiFutureWith(funf).value());
 111
 112   auto failfun = []() -> int { throw eggs; };
 113   EXPECT_TYPE(makeSemiFutureWith(failfun), SemiFuture<int>);
 114   EXPECT_NO_THROW(makeSemiFutureWith(failfun));
 115   EXPECT_THROW(makeSemiFutureWith(failfun).value(), eggs_t);
 116
 117   auto failfunf = []() -> SemiFuture<int> { throw eggs; };
 118   EXPECT_TYPE(makeSemiFutureWith(failfunf), SemiFuture<int>);
 119   EXPECT_NO_THROW(makeSemiFutureWith(failfunf));
 120   EXPECT_THROW(makeSemiFutureWith(failfunf).value(), eggs_t);
 121
 122   EXPECT_TYPE(makeSemiFuture(), SemiFuture<Unit>);
 123 }
 124
 125 TEST(SemiFuture, Constructor) {
 126   auto f1 = []() -> SemiFuture<int> { return SemiFuture<int>(3); }();
 127   EXPECT_EQ(f1.value(), 3);
 128   auto f2 = []() -> SemiFuture<Unit> { return SemiFuture<Unit>(); }();
 129   EXPECT_NO_THROW(f2.value());
 130 }
 131
 132 TEST(SemiFuture, ImplicitConstructor) {
 133   auto f1 = []() -> SemiFuture<int> { return 3; }();
 134   EXPECT_EQ(f1.value(), 3);
 135 }
 136
 137 TEST(SemiFuture, InPlaceConstructor) {
 138   auto f = SemiFuture<std::pair<int, double>>(in_place, 5, 3.2);
 139   EXPECT_EQ(5, f.value().first);
 140 }
 141
 142 TEST(SemiFuture, makeSemiFutureNoThrow) {
 143   makeSemiFuture().value();
 144 }
 145
 146 TEST(SemiFuture, ConstructSemiFutureFromEmptyFuture) {
 147   auto f = SemiFuture<int>{Future<int>::makeEmpty()};
 148   EXPECT_THROW(f.isReady(), NoState);
 149 }
 150
 151 TEST(SemiFuture, ConstructSemiFutureFromFutureDefaultCtor) {
 152   SemiFuture<Unit>(Future<Unit>{});
 153 }
 154
 155 TEST(SemiFuture, MakeSemiFutureFromFutureWithUnit) {
 156   int count = 0;
 157   SemiFuture<Unit> fu = SemiFuture<Unit>{makeFutureWith([&] { count++; })};
 158   EXPECT_EQ(1, count);
 159 }
 160
 161 TEST(SemiFuture, MakeSemiFutureFromFutureWithValue) {
 162   auto f =
 163       SemiFuture<std::unique_ptr<int>>{makeFuture(std::make_unique<int>(42))};
 164   auto up = std::move(f.value());
 165   EXPECT_EQ(42, *up);
 166 }
 167
 168 TEST(SemiFuture, MakeSemiFutureFromReadyFuture) {
 169   Promise<int> p;
 170   auto f = SemiFuture<int>{p.getFuture()};
 171   EXPECT_FALSE(f.isReady());
 172   p.setValue(42);
 173   EXPECT_TRUE(f.isReady());
 174 }
 175
 176 TEST(SemiFuture, MakeSemiFutureFromNotReadyFuture) {
 177   Promise<int> p;
 178   auto f = SemiFuture<int>{p.getFuture()};
 179   EXPECT_THROW(f.value(), eggs_t);
 180 }
 181
 182 TEST(SemiFuture, MakeFutureFromSemiFuture) {
 183   folly::EventBase e;
 184   Promise<int> p;
 185   std::atomic<int> result{0};
 186   auto f = SemiFuture<int>{p.getFuture()};
 187   auto future = std::move(f).via(&e).then([&](int value) {
 188     result = value;
 189     return value;
 190   });
 191   e.loop();
 192   EXPECT_EQ(result, 0);
 193   EXPECT_FALSE(future.isReady());
 194   p.setValue(42);
 195   e.loop();
 196   EXPECT_TRUE(future.isReady());
 197   ASSERT_EQ(future.value(), 42);
 198   ASSERT_EQ(result, 42);
 199 }
 200
 201 TEST(SemiFuture, MakeFutureFromSemiFutureLValue) {
 202   folly::EventBase e;
 203   Promise<int> p;
 204   std::atomic<int> result{0};
 205   auto f = SemiFuture<int>{p.getFuture()};
 206   auto future = std::move(f).via(&e).then([&](int value) {
 207     result = value;
 208     return value;
 209   });
 210   e.loop();
 211   EXPECT_EQ(result, 0);
 212   EXPECT_FALSE(future.isReady());
 213   p.setValue(42);
 214   e.loop();
 215   EXPECT_TRUE(future.isReady());
 216   ASSERT_EQ(future.value(), 42);
 217   ASSERT_EQ(result, 42);
 218 }
 219
 220 TEST(SemiFuture, SimpleDefer) {
 221   std::atomic<int> innerResult{0};
 222   Promise<folly::Unit> p;
 223   auto f = p.getFuture();
 224   auto sf = std::move(f).semi().defer([&]() { innerResult = 17; });
 225   p.setValue();
 226   // Run "F" here inline in the calling thread
 227   std::move(sf).get();
 228   ASSERT_EQ(innerResult, 17);
 229 }
 230
 231 TEST(SemiFuture, DeferWithVia) {
 232   std::atomic<int> innerResult{0};
 233   EventBase e2;
 234   Promise<folly::Unit> p;
 235   auto f = p.getFuture();
 236   auto sf = std::move(f).semi().defer([&]() { innerResult = 17; });
 237   // Run "F" here inline in the calling thread
 238   auto tf = std::move(sf).via(&e2);
 239   p.setValue();
 240   tf.getVia(&e2);
 241   ASSERT_EQ(innerResult, 17);
 242 }
 243
 244 TEST(SemiFuture, ChainingDefertoThen) {
 245   std::atomic<int> innerResult{0};
 246   std::atomic<int> result{0};
 247   EventBase e2;
 248   Promise<folly::Unit> p;
 249   auto f = p.getFuture();
 250   auto sf = std::move(f).semi().defer([&]() { innerResult = 17; });
 251   // Run "F" here inline in a task running on the eventbase
 252   auto tf = std::move(sf).via(&e2).then([&]() { result = 42; });
 253   p.setValue();
 254   tf.getVia(&e2);
 255   ASSERT_EQ(innerResult, 17);
 256   ASSERT_EQ(result, 42);
 257 }
 258
 259 TEST(SemiFuture, SimpleDeferWithValue) {
 260   std::atomic<int> innerResult{0};
 261   Promise<int> p;
 262   auto f = p.getFuture();
 263   auto sf = std::move(f).semi().defer([&](int a) { innerResult = a; });
 264   p.setValue(7);
 265   // Run "F" here inline in the calling thread
 266   std::move(sf).get();
 267   ASSERT_EQ(innerResult, 7);
 268 }
 269
 270 TEST(SemiFuture, ChainingDefertoThenWithValue) {
 271   std::atomic<int> innerResult{0};
 272   std::atomic<int> result{0};
 273   EventBase e2;
 274   Promise<int> p;
 275   auto f = p.getFuture();
 276   auto sf = std::move(f).semi().defer([&](int a) {
 277     innerResult = a;
 278     return a;
 279   });
 280   // Run "F" here inline in a task running on the eventbase
 281   auto tf = std::move(sf).via(&e2).then([&](int a) { result = a; });
 282   p.setValue(7);
 283   tf.getVia(&e2);
 284   ASSERT_EQ(innerResult, 7);
 285   ASSERT_EQ(result, 7);
 286 }
 287
 288 TEST(SemiFuture, MakeSemiFutureFromFutureWithTry) {
 289   Promise<int> p;
 290   auto f = p.getFuture();
 291   auto sf = std::move(f).semi().defer([&](Try<int> t) {
 292     if (auto err = t.tryGetExceptionObject<std::logic_error>()) {
 293       return Try<std::string>(err->what());
 294     }
 295     return Try<std::string>(
 296         make_exception_wrapper<std::logic_error>("Exception"));
 297   });
 298   p.setException(make_exception_wrapper<std::logic_error>("Try"));
 299   auto tryResult = std::move(sf).get();
 300   ASSERT_EQ(tryResult.value(), "Try");
 301 }