folly/futures/test/FutureTest.cpp

   1 /*
   2  * Copyright 2015 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 <algorithm>
  18 #include <atomic>
  19 #include <folly/small_vector.h>
  20 #include <gtest/gtest.h>
  21 #include <memory>
  22 #include <string>
  23 #include <thread>
  24 #include <type_traits>
  25 #include <unistd.h>
  26 #include <folly/Memory.h>
  27 #include <folly/Executor.h>
  28 #include <folly/futures/Future.h>
  29 #include <folly/futures/ManualExecutor.h>
  30 #include <folly/futures/DrivableExecutor.h>
  31 #include <folly/MPMCQueue.h>
  32
  33 #include <folly/io/async/EventBase.h>
  34 #include <folly/io/async/Request.h>
  35
  36 using namespace folly;
  37 using std::pair;
  38 using std::string;
  39 using std::unique_ptr;
  40 using std::vector;
  41 using std::chrono::milliseconds;
  42
  43 #define EXPECT_TYPE(x, T) \
  44   EXPECT_TRUE((std::is_same<decltype(x), T>::value))
  45
  46 /// Simple executor that does work in another thread
  47 class ThreadExecutor : public Executor {
  48   folly::MPMCQueue<Func> funcs;
  49   std::atomic<bool> done {false};
  50   std::thread worker;
  51   folly::Baton<> baton;
  52
  53   void work() {
  54     baton.post();
  55     Func fn;
  56     while (!done) {
  57       while (!funcs.isEmpty()) {
  58         funcs.blockingRead(fn);
  59         fn();
  60       }
  61     }
  62   }
  63
  64  public:
  65   explicit ThreadExecutor(size_t n = 1024)
  66     : funcs(n) {
  67     worker = std::thread(std::bind(&ThreadExecutor::work, this));
  68   }
  69
  70   ~ThreadExecutor() {
  71     done = true;
  72     funcs.write([]{});
  73     worker.join();
  74   }
  75
  76   void add(Func fn) override {
  77     funcs.blockingWrite(std::move(fn));
  78   }
  79
  80   void waitForStartup() {
  81     baton.wait();
  82   }
  83 };
  84
  85 typedef FutureException eggs_t;
  86 static eggs_t eggs("eggs");
  87
  88 // Core
  89
  90 TEST(Future, coreSize) {
  91   // If this number goes down, it's fine!
  92   // If it goes up, please seek professional advice ;-)
  93   EXPECT_EQ(192, sizeof(detail::Core<void>));
  94 }
  95
  96 // Future
  97
  98 TEST(Future, onError) {
  99   bool theFlag = false;
 100   auto flag = [&]{ theFlag = true; };
 101 #define EXPECT_FLAG() \
 102   do { \
 103     EXPECT_TRUE(theFlag); \
 104     theFlag = false; \
 105   } while(0);
 106
 107 #define EXPECT_NO_FLAG() \
 108   do { \
 109     EXPECT_FALSE(theFlag); \
 110     theFlag = false; \
 111   } while(0);
 112
 113   // By reference
 114   {
 115     auto f = makeFuture()
 116       .then([] { throw eggs; })
 117       .onError([&] (eggs_t& e) { flag(); });
 118     EXPECT_FLAG();
 119     EXPECT_NO_THROW(f.value());
 120   }
 121
 122   {
 123     auto f = makeFuture()
 124       .then([] { throw eggs; })
 125       .onError([&] (eggs_t& e) { flag(); return makeFuture(); });
 126     EXPECT_FLAG();
 127     EXPECT_NO_THROW(f.value());
 128   }
 129
 130   // By value
 131   {
 132     auto f = makeFuture()
 133       .then([] { throw eggs; })
 134       .onError([&] (eggs_t e) { flag(); });
 135     EXPECT_FLAG();
 136     EXPECT_NO_THROW(f.value());
 137   }
 138
 139   {
 140     auto f = makeFuture()
 141       .then([] { throw eggs; })
 142       .onError([&] (eggs_t e) { flag(); return makeFuture(); });
 143     EXPECT_FLAG();
 144     EXPECT_NO_THROW(f.value());
 145   }
 146
 147   // Polymorphic
 148   {
 149     auto f = makeFuture()
 150       .then([] { throw eggs; })
 151       .onError([&] (std::exception& e) { flag(); });
 152     EXPECT_FLAG();
 153     EXPECT_NO_THROW(f.value());
 154   }
 155
 156   {
 157     auto f = makeFuture()
 158       .then([] { throw eggs; })
 159       .onError([&] (std::exception& e) { flag(); return makeFuture(); });
 160     EXPECT_FLAG();
 161     EXPECT_NO_THROW(f.value());
 162   }
 163
 164   // Non-exceptions
 165   {
 166     auto f = makeFuture()
 167       .then([] { throw -1; })
 168       .onError([&] (int e) { flag(); });
 169     EXPECT_FLAG();
 170     EXPECT_NO_THROW(f.value());
 171   }
 172
 173   {
 174     auto f = makeFuture()
 175       .then([] { throw -1; })
 176       .onError([&] (int e) { flag(); return makeFuture(); });
 177     EXPECT_FLAG();
 178     EXPECT_NO_THROW(f.value());
 179   }
 180
 181   // Mutable lambda
 182   {
 183     auto f = makeFuture()
 184       .then([] { throw eggs; })
 185       .onError([&] (eggs_t& e) mutable { flag(); });
 186     EXPECT_FLAG();
 187     EXPECT_NO_THROW(f.value());
 188   }
 189
 190   {
 191     auto f = makeFuture()
 192       .then([] { throw eggs; })
 193       .onError([&] (eggs_t& e) mutable { flag(); return makeFuture(); });
 194     EXPECT_FLAG();
 195     EXPECT_NO_THROW(f.value());
 196   }
 197
 198   // No throw
 199   {
 200     auto f = makeFuture()
 201       .then([] { return 42; })
 202       .onError([&] (eggs_t& e) { flag(); return -1; });
 203     EXPECT_NO_FLAG();
 204     EXPECT_EQ(42, f.value());
 205   }
 206
 207   {
 208     auto f = makeFuture()
 209       .then([] { return 42; })
 210       .onError([&] (eggs_t& e) { flag(); return makeFuture<int>(-1); });
 211     EXPECT_NO_FLAG();
 212     EXPECT_EQ(42, f.value());
 213   }
 214
 215   // Catch different exception
 216   {
 217     auto f = makeFuture()
 218       .then([] { throw eggs; })
 219       .onError([&] (std::runtime_error& e) { flag(); });
 220     EXPECT_NO_FLAG();
 221     EXPECT_THROW(f.value(), eggs_t);
 222   }
 223
 224   {
 225     auto f = makeFuture()
 226       .then([] { throw eggs; })
 227       .onError([&] (std::runtime_error& e) { flag(); return makeFuture(); });
 228     EXPECT_NO_FLAG();
 229     EXPECT_THROW(f.value(), eggs_t);
 230   }
 231
 232   // Returned value propagates
 233   {
 234     auto f = makeFuture()
 235       .then([] { throw eggs; return 0; })
 236       .onError([&] (eggs_t& e) { return 42; });
 237     EXPECT_EQ(42, f.value());
 238   }
 239
 240   // Returned future propagates
 241   {
 242     auto f = makeFuture()
 243       .then([] { throw eggs; return 0; })
 244       .onError([&] (eggs_t& e) { return makeFuture<int>(42); });
 245     EXPECT_EQ(42, f.value());
 246   }
 247
 248   // Throw in callback
 249   {
 250     auto f = makeFuture()
 251       .then([] { throw eggs; return 0; })
 252       .onError([&] (eggs_t& e) { throw e; return -1; });
 253     EXPECT_THROW(f.value(), eggs_t);
 254   }
 255
 256   {
 257     auto f = makeFuture()
 258       .then([] { throw eggs; return 0; })
 259       .onError([&] (eggs_t& e) { throw e; return makeFuture<int>(-1); });
 260     EXPECT_THROW(f.value(), eggs_t);
 261   }
 262 }
 263
 264 TEST(Future, try) {
 265   class A {
 266    public:
 267     A(int x) : x_(x) {}
 268
 269     int x() const {
 270       return x_;
 271     }
 272    private:
 273     int x_;
 274   };
 275
 276   A a(5);
 277   Try<A> t_a(std::move(a));
 278
 279   Try<void> t_void;
 280
 281   EXPECT_EQ(5, t_a.value().x());
 282 }
 283
 284 TEST(Future, special) {
 285   EXPECT_FALSE(std::is_copy_constructible<Future<int>>::value);
 286   EXPECT_FALSE(std::is_copy_assignable<Future<int>>::value);
 287   EXPECT_TRUE(std::is_move_constructible<Future<int>>::value);
 288   EXPECT_TRUE(std::is_move_assignable<Future<int>>::value);
 289 }
 290
 291 TEST(Future, then) {
 292   auto f = makeFuture<string>("0")
 293     .then([](){ return makeFuture<string>("1"); })
 294     .then([](Try<string>&& t) { return makeFuture(t.value() + ";2"); })
 295     .then([](const Try<string>&& t) { return makeFuture(t.value() + ";3"); })
 296     .then([](Try<string>& t) { return makeFuture(t.value() + ";4"); })
 297     .then([](const Try<string>& t) { return makeFuture(t.value() + ";5"); })
 298     .then([](Try<string> t) { return makeFuture(t.value() + ";6"); })
 299     .then([](const Try<string> t) { return makeFuture(t.value() + ";7"); })
 300     .then([](string&& s) { return makeFuture(s + ";8"); })
 301     .then([](const string&& s) { return makeFuture(s + ";9"); })
 302     .then([](string& s) { return makeFuture(s + ";10"); })
 303     .then([](const string& s) { return makeFuture(s + ";11"); })
 304     .then([](string s) { return makeFuture(s + ";12"); })
 305     .then([](const string s) { return makeFuture(s + ";13"); })
 306   ;
 307   EXPECT_EQ(f.value(), "1;2;3;4;5;6;7;8;9;10;11;12;13");
 308 }
 309
 310 TEST(Future, thenTry) {
 311   bool flag = false;
 312
 313   makeFuture<int>(42).then([&](Try<int>&& t) {
 314                               flag = true;
 315                               EXPECT_EQ(42, t.value());
 316                             });
 317   EXPECT_TRUE(flag); flag = false;
 318
 319   makeFuture<int>(42)
 320     .then([](Try<int>&& t) { return t.value(); })
 321     .then([&](Try<int>&& t) { flag = true; EXPECT_EQ(42, t.value()); });
 322   EXPECT_TRUE(flag); flag = false;
 323
 324   makeFuture().then([&](Try<void>&& t) { flag = true; t.value(); });
 325   EXPECT_TRUE(flag); flag = false;
 326
 327   Promise<void> p;
 328   auto f = p.getFuture().then([&](Try<void>&& t) { flag = true; });
 329   EXPECT_FALSE(flag);
 330   EXPECT_FALSE(f.isReady());
 331   p.setValue();
 332   EXPECT_TRUE(flag);
 333   EXPECT_TRUE(f.isReady());
 334 }
 335
 336 TEST(Future, thenValue) {
 337   bool flag = false;
 338   makeFuture<int>(42).then([&](int i){
 339     EXPECT_EQ(42, i);
 340     flag = true;
 341   });
 342   EXPECT_TRUE(flag); flag = false;
 343
 344   makeFuture<int>(42)
 345     .then([](int i){ return i; })
 346     .then([&](int i) { flag = true; EXPECT_EQ(42, i); });
 347   EXPECT_TRUE(flag); flag = false;
 348
 349   makeFuture().then([&]{
 350     flag = true;
 351   });
 352   EXPECT_TRUE(flag); flag = false;
 353
 354   auto f = makeFuture<int>(eggs).then([&](int i){});
 355   EXPECT_THROW(f.value(), eggs_t);
 356
 357   f = makeFuture<void>(eggs).then([&]{});
 358   EXPECT_THROW(f.value(), eggs_t);
 359 }
 360
 361 TEST(Future, thenValueFuture) {
 362   bool flag = false;
 363   makeFuture<int>(42)
 364     .then([](int i){ return makeFuture<int>(std::move(i)); })
 365     .then([&](Try<int>&& t) { flag = true; EXPECT_EQ(42, t.value()); });
 366   EXPECT_TRUE(flag); flag = false;
 367
 368   makeFuture()
 369     .then([]{ return makeFuture(); })
 370     .then([&](Try<void>&& t) { flag = true; });
 371   EXPECT_TRUE(flag); flag = false;
 372 }
 373
 374 static string doWorkStatic(Try<string>&& t) {
 375   return t.value() + ";static";
 376 }
 377
 378 TEST(Future, thenFunction) {
 379   struct Worker {
 380     string doWork(Try<string>&& t) {
 381       return t.value() + ";class";
 382     }
 383     static string doWorkStatic(Try<string>&& t) {
 384       return t.value() + ";class-static";
 385     }
 386   } w;
 387
 388   auto f = makeFuture<string>("start")
 389     .then(doWorkStatic)
 390     .then(Worker::doWorkStatic)
 391     .then(&Worker::doWork, &w);
 392
 393   EXPECT_EQ(f.value(), "start;static;class-static;class");
 394 }
 395
 396 static Future<string> doWorkStaticFuture(Try<string>&& t) {
 397   return makeFuture(t.value() + ";static");
 398 }
 399
 400 TEST(Future, thenFunctionFuture) {
 401   struct Worker {
 402     Future<string> doWorkFuture(Try<string>&& t) {
 403       return makeFuture(t.value() + ";class");
 404     }
 405     static Future<string> doWorkStaticFuture(Try<string>&& t) {
 406       return makeFuture(t.value() + ";class-static");
 407     }
 408   } w;
 409
 410   auto f = makeFuture<string>("start")
 411     .then(doWorkStaticFuture)
 412     .then(Worker::doWorkStaticFuture)
 413     .then(&Worker::doWorkFuture, &w);
 414
 415   EXPECT_EQ(f.value(), "start;static;class-static;class");
 416 }
 417
 418 TEST(Future, thenBind) {
 419   auto l = []() {
 420     return makeFuture("bind");
 421   };
 422   auto b = std::bind(l);
 423   auto f = makeFuture().then(std::move(b));
 424   EXPECT_EQ(f.value(), "bind");
 425 }
 426
 427 TEST(Future, thenBindTry) {
 428   auto l = [](Try<string>&& t) {
 429     return makeFuture(t.value() + ";bind");
 430   };
 431   auto b = std::bind(l, std::placeholders::_1);
 432   auto f = makeFuture<string>("start").then(std::move(b));
 433
 434   EXPECT_EQ(f.value(), "start;bind");
 435 }
 436
 437 TEST(Future, value) {
 438   auto f = makeFuture(unique_ptr<int>(new int(42)));
 439   auto up = std::move(f.value());
 440   EXPECT_EQ(42, *up);
 441
 442   EXPECT_THROW(makeFuture<int>(eggs).value(), eggs_t);
 443 }
 444
 445 TEST(Future, isReady) {
 446   Promise<int> p;
 447   auto f = p.getFuture();
 448   EXPECT_FALSE(f.isReady());
 449   p.setValue(42);
 450   EXPECT_TRUE(f.isReady());
 451   }
 452
 453 TEST(Future, futureNotReady) {
 454   Promise<int> p;
 455   Future<int> f = p.getFuture();
 456   EXPECT_THROW(f.value(), eggs_t);
 457 }
 458
 459 TEST(Future, hasException) {
 460   EXPECT_TRUE(makeFuture<int>(eggs).getTry().hasException());
 461   EXPECT_FALSE(makeFuture(42).getTry().hasException());
 462 }
 463
 464 TEST(Future, hasValue) {
 465   EXPECT_TRUE(makeFuture(42).getTry().hasValue());
 466   EXPECT_FALSE(makeFuture<int>(eggs).getTry().hasValue());
 467 }
 468
 469 TEST(Future, makeFuture) {
 470   EXPECT_TYPE(makeFuture(42), Future<int>);
 471   EXPECT_EQ(42, makeFuture(42).value());
 472
 473   EXPECT_TYPE(makeFuture<float>(42), Future<float>);
 474   EXPECT_EQ(42, makeFuture<float>(42).value());
 475
 476   auto fun = [] { return 42; };
 477   EXPECT_TYPE(makeFutureTry(fun), Future<int>);
 478   EXPECT_EQ(42, makeFutureTry(fun).value());
 479
 480   auto failfun = []() -> int { throw eggs; };
 481   EXPECT_TYPE(makeFutureTry(failfun), Future<int>);
 482   EXPECT_THROW(makeFutureTry(failfun).value(), eggs_t);
 483
 484   EXPECT_TYPE(makeFuture(), Future<void>);
 485 }
 486
 487 // Promise
 488
 489 TEST(Promise, special) {
 490   EXPECT_FALSE(std::is_copy_constructible<Promise<int>>::value);
 491   EXPECT_FALSE(std::is_copy_assignable<Promise<int>>::value);
 492   EXPECT_TRUE(std::is_move_constructible<Promise<int>>::value);
 493   EXPECT_TRUE(std::is_move_assignable<Promise<int>>::value);
 494 }
 495
 496 TEST(Promise, getFuture) {
 497   Promise<int> p;
 498   Future<int> f = p.getFuture();
 499   EXPECT_FALSE(f.isReady());
 500 }
 501
 502 TEST(Promise, setValue) {
 503   Promise<int> fund;
 504   auto ffund = fund.getFuture();
 505   fund.setValue(42);
 506   EXPECT_EQ(42, ffund.value());
 507
 508   struct Foo {
 509     string name;
 510     int value;
 511   };
 512
 513   Promise<Foo> pod;
 514   auto fpod = pod.getFuture();
 515   Foo f = {"the answer", 42};
 516   pod.setValue(f);
 517   Foo f2 = fpod.value();
 518   EXPECT_EQ(f.name, f2.name);
 519   EXPECT_EQ(f.value, f2.value);
 520
 521   pod = Promise<Foo>();
 522   fpod = pod.getFuture();
 523   pod.setValue(std::move(f2));
 524   Foo f3 = fpod.value();
 525   EXPECT_EQ(f.name, f3.name);
 526   EXPECT_EQ(f.value, f3.value);
 527
 528   Promise<unique_ptr<int>> mov;
 529   auto fmov = mov.getFuture();
 530   mov.setValue(unique_ptr<int>(new int(42)));
 531   unique_ptr<int> ptr = std::move(fmov.value());
 532   EXPECT_EQ(42, *ptr);
 533
 534   Promise<void> v;
 535   auto fv = v.getFuture();
 536   v.setValue();
 537   EXPECT_TRUE(fv.isReady());
 538 }
 539
 540 TEST(Promise, setException) {
 541   {
 542     Promise<void> p;
 543     auto f = p.getFuture();
 544     p.setException(eggs);
 545     EXPECT_THROW(f.value(), eggs_t);
 546   }
 547   {
 548     Promise<void> p;
 549     auto f = p.getFuture();
 550     try {
 551       throw eggs;
 552     } catch (...) {
 553       p.setException(exception_wrapper(std::current_exception()));
 554     }
 555     EXPECT_THROW(f.value(), eggs_t);
 556   }
 557 }
 558
 559 TEST(Promise, fulfil) {
 560   {
 561     Promise<int> p;
 562     auto f = p.getFuture();
 563     p.fulfil([] { return 42; });
 564     EXPECT_EQ(42, f.value());
 565   }
 566   {
 567     Promise<int> p;
 568     auto f = p.getFuture();
 569     p.fulfil([]() -> int { throw eggs; });
 570     EXPECT_THROW(f.value(), eggs_t);
 571   }
 572 }
 573
 574 TEST(Future, finish) {
 575   auto x = std::make_shared<int>(0);
 576   {
 577     Promise<int> p;
 578     auto f = p.getFuture().then([x](Try<int>&& t) { *x = t.value(); });
 579
 580     // The callback hasn't executed
 581     EXPECT_EQ(0, *x);
 582
 583     // The callback has a reference to x
 584     EXPECT_EQ(2, x.use_count());
 585
 586     p.setValue(42);
 587
 588     // the callback has executed
 589     EXPECT_EQ(42, *x);
 590   }
 591   // the callback has been destructed
 592   // and has released its reference to x
 593   EXPECT_EQ(1, x.use_count());
 594 }
 595
 596 TEST(Future, unwrap) {
 597   Promise<int> a;
 598   Promise<int> b;
 599
 600   auto fa = a.getFuture();
 601   auto fb = b.getFuture();
 602
 603   bool flag1 = false;
 604   bool flag2 = false;
 605
 606   // do a, then do b, and get the result of a + b.
 607   Future<int> f = fa.then([&](Try<int>&& ta) {
 608     auto va = ta.value();
 609     flag1 = true;
 610     return fb.then([va, &flag2](Try<int>&& tb) {
 611       flag2 = true;
 612       return va + tb.value();
 613     });
 614   });
 615
 616   EXPECT_FALSE(flag1);
 617   EXPECT_FALSE(flag2);
 618   EXPECT_FALSE(f.isReady());
 619
 620   a.setValue(3);
 621   EXPECT_TRUE(flag1);
 622   EXPECT_FALSE(flag2);
 623   EXPECT_FALSE(f.isReady());
 624
 625   b.setValue(4);
 626   EXPECT_TRUE(flag1);
 627   EXPECT_TRUE(flag2);
 628   EXPECT_EQ(7, f.value());
 629 }
 630
 631 TEST(Future, whenAll) {
 632   // returns a vector variant
 633   {
 634     vector<Promise<int>> promises(10);
 635     vector<Future<int>> futures;
 636
 637     for (auto& p : promises)
 638       futures.push_back(p.getFuture());
 639
 640     auto allf = whenAll(futures.begin(), futures.end());
 641
 642     random_shuffle(promises.begin(), promises.end());
 643     for (auto& p : promises) {
 644       EXPECT_FALSE(allf.isReady());
 645       p.setValue(42);
 646     }
 647
 648     EXPECT_TRUE(allf.isReady());
 649     auto& results = allf.value();
 650     for (auto& t : results) {
 651       EXPECT_EQ(42, t.value());
 652     }
 653   }
 654
 655   // check error semantics
 656   {
 657     vector<Promise<int>> promises(4);
 658     vector<Future<int>> futures;
 659
 660     for (auto& p : promises)
 661       futures.push_back(p.getFuture());
 662
 663     auto allf = whenAll(futures.begin(), futures.end());
 664
 665
 666     promises[0].setValue(42);
 667     promises[1].setException(eggs);
 668
 669     EXPECT_FALSE(allf.isReady());
 670
 671     promises[2].setValue(42);
 672
 673     EXPECT_FALSE(allf.isReady());
 674
 675     promises[3].setException(eggs);
 676
 677     EXPECT_TRUE(allf.isReady());
 678     EXPECT_FALSE(allf.getTry().hasException());
 679
 680     auto& results = allf.value();
 681     EXPECT_EQ(42, results[0].value());
 682     EXPECT_TRUE(results[1].hasException());
 683     EXPECT_EQ(42, results[2].value());
 684     EXPECT_TRUE(results[3].hasException());
 685   }
 686
 687   // check that futures are ready in then()
 688   {
 689     vector<Promise<void>> promises(10);
 690     vector<Future<void>> futures;
 691
 692     for (auto& p : promises)
 693       futures.push_back(p.getFuture());
 694
 695     auto allf = whenAll(futures.begin(), futures.end())
 696       .then([](Try<vector<Try<void>>>&& ts) {
 697         for (auto& f : ts.value())
 698           f.value();
 699       });
 700
 701     random_shuffle(promises.begin(), promises.end());
 702     for (auto& p : promises)
 703       p.setValue();
 704     EXPECT_TRUE(allf.isReady());
 705   }
 706 }
 707
 708
 709 TEST(Future, whenAny) {
 710   {
 711     vector<Promise<int>> promises(10);
 712     vector<Future<int>> futures;
 713
 714     for (auto& p : promises)
 715       futures.push_back(p.getFuture());
 716
 717     for (auto& f : futures) {
 718       EXPECT_FALSE(f.isReady());
 719     }
 720
 721     auto anyf = whenAny(futures.begin(), futures.end());
 722
 723     /* futures were moved in, so these are invalid now */
 724     EXPECT_FALSE(anyf.isReady());
 725
 726     promises[7].setValue(42);
 727     EXPECT_TRUE(anyf.isReady());
 728     auto& idx_fut = anyf.value();
 729
 730     auto i = idx_fut.first;
 731     EXPECT_EQ(7, i);
 732
 733     auto& f = idx_fut.second;
 734     EXPECT_EQ(42, f.value());
 735   }
 736
 737   // error
 738   {
 739     vector<Promise<void>> promises(10);
 740     vector<Future<void>> futures;
 741
 742     for (auto& p : promises)
 743       futures.push_back(p.getFuture());
 744
 745     for (auto& f : futures) {
 746       EXPECT_FALSE(f.isReady());
 747     }
 748
 749     auto anyf = whenAny(futures.begin(), futures.end());
 750
 751     EXPECT_FALSE(anyf.isReady());
 752
 753     promises[3].setException(eggs);
 754     EXPECT_TRUE(anyf.isReady());
 755     EXPECT_TRUE(anyf.value().second.hasException());
 756   }
 757
 758   // then()
 759   {
 760     vector<Promise<int>> promises(10);
 761     vector<Future<int>> futures;
 762
 763     for (auto& p : promises)
 764       futures.push_back(p.getFuture());
 765
 766     auto anyf = whenAny(futures.begin(), futures.end())
 767       .then([](pair<size_t, Try<int>> p) {
 768         EXPECT_EQ(42, p.second.value());
 769       });
 770
 771     promises[3].setValue(42);
 772     EXPECT_TRUE(anyf.isReady());
 773   }
 774 }
 775
 776
 777 TEST(when, already_completed) {
 778   {
 779     vector<Future<void>> fs;
 780     for (int i = 0; i < 10; i++)
 781       fs.push_back(makeFuture());
 782
 783     whenAll(fs.begin(), fs.end())
 784       .then([&](vector<Try<void>> ts) {
 785         EXPECT_EQ(fs.size(), ts.size());
 786       });
 787   }
 788   {
 789     vector<Future<int>> fs;
 790     for (int i = 0; i < 10; i++)
 791       fs.push_back(makeFuture(i));
 792
 793     whenAny(fs.begin(), fs.end())
 794       .then([&](pair<size_t, Try<int>> p) {
 795         EXPECT_EQ(p.first, p.second.value());
 796       });
 797   }
 798 }
 799
 800 TEST(when, whenN) {
 801   vector<Promise<void>> promises(10);
 802   vector<Future<void>> futures;
 803
 804   for (auto& p : promises)
 805     futures.push_back(p.getFuture());
 806
 807   bool flag = false;
 808   size_t n = 3;
 809   whenN(futures.begin(), futures.end(), n)
 810     .then([&](vector<pair<size_t, Try<void>>> v) {
 811       flag = true;
 812       EXPECT_EQ(n, v.size());
 813       for (auto& tt : v)
 814         EXPECT_TRUE(tt.second.hasValue());
 815     });
 816
 817   promises[0].setValue();
 818   EXPECT_FALSE(flag);
 819   promises[1].setValue();
 820   EXPECT_FALSE(flag);
 821   promises[2].setValue();
 822   EXPECT_TRUE(flag);
 823 }
 824
 825 /* Ensure that we can compile when_{all,any} with folly::small_vector */
 826 TEST(when, small_vector) {
 827
 828   static_assert(!FOLLY_IS_TRIVIALLY_COPYABLE(Future<void>),
 829                 "Futures should not be trivially copyable");
 830   static_assert(!FOLLY_IS_TRIVIALLY_COPYABLE(Future<int>),
 831                 "Futures should not be trivially copyable");
 832
 833   using folly::small_vector;
 834   {
 835     small_vector<Future<void>> futures;
 836
 837     for (int i = 0; i < 10; i++)
 838       futures.push_back(makeFuture());
 839
 840     auto anyf = whenAny(futures.begin(), futures.end());
 841   }
 842
 843   {
 844     small_vector<Future<void>> futures;
 845
 846     for (int i = 0; i < 10; i++)
 847       futures.push_back(makeFuture());
 848
 849     auto allf = whenAll(futures.begin(), futures.end());
 850   }
 851 }
 852
 853 TEST(Future, whenAllVariadic) {
 854   Promise<bool> pb;
 855   Promise<int> pi;
 856   Future<bool> fb = pb.getFuture();
 857   Future<int> fi = pi.getFuture();
 858   bool flag = false;
 859   whenAll(std::move(fb), std::move(fi))
 860     .then([&](std::tuple<Try<bool>, Try<int>> tup) {
 861       flag = true;
 862       EXPECT_TRUE(std::get<0>(tup).hasValue());
 863       EXPECT_EQ(std::get<0>(tup).value(), true);
 864       EXPECT_TRUE(std::get<1>(tup).hasValue());
 865       EXPECT_EQ(std::get<1>(tup).value(), 42);
 866     });
 867   pb.setValue(true);
 868   EXPECT_FALSE(flag);
 869   pi.setValue(42);
 870   EXPECT_TRUE(flag);
 871 }
 872
 873 TEST(Future, whenAllVariadicReferences) {
 874   Promise<bool> pb;
 875   Promise<int> pi;
 876   Future<bool> fb = pb.getFuture();
 877   Future<int> fi = pi.getFuture();
 878   bool flag = false;
 879   whenAll(fb, fi)
 880     .then([&](std::tuple<Try<bool>, Try<int>> tup) {
 881       flag = true;
 882       EXPECT_TRUE(std::get<0>(tup).hasValue());
 883       EXPECT_EQ(std::get<0>(tup).value(), true);
 884       EXPECT_TRUE(std::get<1>(tup).hasValue());
 885       EXPECT_EQ(std::get<1>(tup).value(), 42);
 886     });
 887   pb.setValue(true);
 888   EXPECT_FALSE(flag);
 889   pi.setValue(42);
 890   EXPECT_TRUE(flag);
 891 }
 892
 893 TEST(Future, whenAll_none) {
 894   vector<Future<int>> fs;
 895   auto f = whenAll(fs.begin(), fs.end());
 896   EXPECT_TRUE(f.isReady());
 897 }
 898
 899 TEST(Future, throwCaughtInImmediateThen) {
 900   // Neither of these should throw "Promise already satisfied"
 901   makeFuture().then(
 902     [=](Try<void>&&) -> int { throw std::exception(); });
 903   makeFuture().then(
 904     [=](Try<void>&&) -> Future<int> { throw std::exception(); });
 905 }
 906
 907 TEST(Future, throwIfFailed) {
 908   makeFuture<void>(eggs)
 909     .then([=](Try<void>&& t) {
 910       EXPECT_THROW(t.throwIfFailed(), eggs_t);
 911     });
 912   makeFuture()
 913     .then([=](Try<void>&& t) {
 914       EXPECT_NO_THROW(t.throwIfFailed());
 915     });
 916
 917   makeFuture<int>(eggs)
 918     .then([=](Try<int>&& t) {
 919       EXPECT_THROW(t.throwIfFailed(), eggs_t);
 920     });
 921   makeFuture<int>(42)
 922     .then([=](Try<int>&& t) {
 923       EXPECT_NO_THROW(t.throwIfFailed());
 924     });
 925 }
 926
 927 TEST(Future, waitImmediate) {
 928   makeFuture().wait();
 929   auto done = makeFuture(42).wait().value();
 930   EXPECT_EQ(42, done);
 931
 932   vector<int> v{1,2,3};
 933   auto done_v = makeFuture(v).wait().value();
 934   EXPECT_EQ(v.size(), done_v.size());
 935   EXPECT_EQ(v, done_v);
 936
 937   vector<Future<void>> v_f;
 938   v_f.push_back(makeFuture());
 939   v_f.push_back(makeFuture());
 940   auto done_v_f = whenAll(v_f.begin(), v_f.end()).wait().value();
 941   EXPECT_EQ(2, done_v_f.size());
 942
 943   vector<Future<bool>> v_fb;
 944   v_fb.push_back(makeFuture(true));
 945   v_fb.push_back(makeFuture(false));
 946   auto fut = whenAll(v_fb.begin(), v_fb.end());
 947   auto done_v_fb = std::move(fut.wait().value());
 948   EXPECT_EQ(2, done_v_fb.size());
 949 }
 950
 951 TEST(Future, wait) {
 952   Promise<int> p;
 953   Future<int> f = p.getFuture();
 954   std::atomic<bool> flag{false};
 955   std::atomic<int> result{1};
 956   std::atomic<std::thread::id> id;
 957
 958   std::thread t([&](Future<int>&& tf){
 959       auto n = tf.then([&](Try<int> && t) {
 960           id = std::this_thread::get_id();
 961           return t.value();
 962         });
 963       flag = true;
 964       result.store(n.wait().value());
 965     },
 966     std::move(f)
 967     );
 968   while(!flag){}
 969   EXPECT_EQ(result.load(), 1);
 970   p.setValue(42);
 971   t.join();
 972   // validate that the callback ended up executing in this thread, which
 973   // is more to ensure that this test actually tests what it should
 974   EXPECT_EQ(id, std::this_thread::get_id());
 975   EXPECT_EQ(result.load(), 42);
 976 }
 977
 978 struct MoveFlag {
 979   MoveFlag() = default;
 980   MoveFlag(const MoveFlag&) = delete;
 981   MoveFlag(MoveFlag&& other) noexcept {
 982     other.moved = true;
 983   }
 984   bool moved{false};
 985 };
 986
 987 TEST(Future, waitReplacesSelf) {
 988   // wait
 989   {
 990     // lvalue
 991     auto f1 = makeFuture(MoveFlag());
 992     f1.wait();
 993     EXPECT_FALSE(f1.value().moved);
 994
 995     // rvalue
 996     auto f2 = makeFuture(MoveFlag()).wait();
 997     EXPECT_FALSE(f2.value().moved);
 998   }
 999
1000   // wait(Duration)
1001   {
1002     // lvalue
1003     auto f1 = makeFuture(MoveFlag());
1004     f1.wait(milliseconds(1));
1005     EXPECT_FALSE(f1.value().moved);
1006
1007     // rvalue
1008     auto f2 = makeFuture(MoveFlag()).wait(milliseconds(1));
1009     EXPECT_FALSE(f2.value().moved);
1010   }
1011
1012   // waitVia
1013   {
1014     folly::EventBase eb;
1015     // lvalue
1016     auto f1 = makeFuture(MoveFlag());
1017     f1.waitVia(&eb);
1018     EXPECT_FALSE(f1.value().moved);
1019
1020     // rvalue
1021     auto f2 = makeFuture(MoveFlag()).waitVia(&eb);
1022     EXPECT_FALSE(f2.value().moved);
1023   }
1024 }
1025
1026 TEST(Future, waitWithDuration) {
1027  {
1028   Promise<int> p;
1029   Future<int> f = p.getFuture();
1030   f.wait(milliseconds(1));
1031   EXPECT_FALSE(f.isReady());
1032   p.setValue(1);
1033   EXPECT_TRUE(f.isReady());
1034  }
1035  {
1036   Promise<int> p;
1037   Future<int> f = p.getFuture();
1038   p.setValue(1);
1039   f.wait(milliseconds(1));
1040   EXPECT_TRUE(f.isReady());
1041  }
1042  {
1043   vector<Future<bool>> v_fb;
1044   v_fb.push_back(makeFuture(true));
1045   v_fb.push_back(makeFuture(false));
1046   auto f = whenAll(v_fb.begin(), v_fb.end());
1047   f.wait(milliseconds(1));
1048   EXPECT_TRUE(f.isReady());
1049   EXPECT_EQ(2, f.value().size());
1050  }
1051  {
1052   vector<Future<bool>> v_fb;
1053   Promise<bool> p1;
1054   Promise<bool> p2;
1055   v_fb.push_back(p1.getFuture());
1056   v_fb.push_back(p2.getFuture());
1057   auto f = whenAll(v_fb.begin(), v_fb.end());
1058   f.wait(milliseconds(1));
1059   EXPECT_FALSE(f.isReady());
1060   p1.setValue(true);
1061   EXPECT_FALSE(f.isReady());
1062   p2.setValue(true);
1063   EXPECT_TRUE(f.isReady());
1064  }
1065  {
1066   auto f = makeFuture().wait(milliseconds(1));
1067   EXPECT_TRUE(f.isReady());
1068  }
1069
1070  {
1071    Promise<void> p;
1072    auto start = std::chrono::steady_clock::now();
1073    auto f = p.getFuture().wait(milliseconds(100));
1074    auto elapsed = std::chrono::steady_clock::now() - start;
1075    EXPECT_GE(elapsed, milliseconds(100));
1076    EXPECT_FALSE(f.isReady());
1077    p.setValue();
1078    EXPECT_TRUE(f.isReady());
1079  }
1080
1081  {
1082    // Try to trigger the race where the resultant Future is not yet complete
1083    // even if we didn't hit the timeout, and make sure we deal with it properly
1084    Promise<void> p;
1085    folly::Baton<> b;
1086    auto t = std::thread([&]{
1087      b.post();
1088      /* sleep override */ std::this_thread::sleep_for(milliseconds(100));
1089      p.setValue();
1090    });
1091    b.wait();
1092    auto f = p.getFuture().wait(std::chrono::seconds(3600));
1093    EXPECT_TRUE(f.isReady());
1094    t.join();
1095  }
1096 }
1097
1098 class DummyDrivableExecutor : public DrivableExecutor {
1099  public:
1100   void add(Func f) override {}
1101   void drive() override { ran = true; }
1102   bool ran{false};
1103 };
1104
1105 TEST(Future, getVia) {
1106   {
1107     // non-void
1108     ManualExecutor x;
1109     auto f = via(&x).then([]{ return true; });
1110     EXPECT_TRUE(f.getVia(&x));
1111   }
1112
1113   {
1114     // void
1115     ManualExecutor x;
1116     auto f = via(&x).then();
1117     f.getVia(&x);
1118   }
1119
1120   {
1121     DummyDrivableExecutor x;
1122     auto f = makeFuture(true);
1123     EXPECT_TRUE(f.getVia(&x));
1124     EXPECT_FALSE(x.ran);
1125   }
1126 }
1127
1128 TEST(Future, waitVia) {
1129   {
1130     ManualExecutor x;
1131     auto f = via(&x).then();
1132     EXPECT_FALSE(f.isReady());
1133     f.waitVia(&x);
1134     EXPECT_TRUE(f.isReady());
1135   }
1136
1137   {
1138     // try rvalue as well
1139     ManualExecutor x;
1140     auto f = via(&x).then().waitVia(&x);
1141     EXPECT_TRUE(f.isReady());
1142   }
1143
1144   {
1145     DummyDrivableExecutor x;
1146     makeFuture(true).waitVia(&x);
1147     EXPECT_FALSE(x.ran);
1148   }
1149 }
1150
1151 TEST(Future, viaRaces) {
1152   ManualExecutor x;
1153   Promise<void> p;
1154   auto tid = std::this_thread::get_id();
1155   bool done = false;
1156
1157   std::thread t1([&] {
1158     p.getFuture()
1159       .via(&x)
1160       .then([&](Try<void>&&) { EXPECT_EQ(tid, std::this_thread::get_id()); })
1161       .then([&](Try<void>&&) { EXPECT_EQ(tid, std::this_thread::get_id()); })
1162       .then([&](Try<void>&&) { done = true; });
1163   });
1164
1165   std::thread t2([&] {
1166     p.setValue();
1167   });
1168
1169   while (!done) x.run();
1170   t1.join();
1171   t2.join();
1172 }
1173
1174 TEST(Future, getFuture_after_setValue) {
1175   Promise<int> p;
1176   p.setValue(42);
1177   EXPECT_EQ(42, p.getFuture().value());
1178 }
1179
1180 TEST(Future, getFuture_after_setException) {
1181   Promise<void> p;
1182   p.fulfil([]() -> void { throw std::logic_error("foo"); });
1183   EXPECT_THROW(p.getFuture().value(), std::logic_error);
1184 }
1185
1186 TEST(Future, detachRace) {
1187   // Task #5438209
1188   // This test is designed to detect a race that was in Core::detachOne()
1189   // where detached_ was incremented and then tested, and that
1190   // allowed a race where both Promise and Future would think they were the
1191   // second and both try to delete. This showed up at scale but was very
1192   // difficult to reliably repro in a test. As it is, this only fails about
1193   // once in every 1,000 executions. Doing this 1,000 times is going to make a
1194   // slow test so I won't do that but if it ever fails, take it seriously, and
1195   // run the test binary with "--gtest_repeat=10000 --gtest_filter=*detachRace"
1196   // (Don't forget to enable ASAN)
1197   auto p = folly::make_unique<Promise<bool>>();
1198   auto f = folly::make_unique<Future<bool>>(p->getFuture());
1199   folly::Baton<> baton;
1200   std::thread t1([&]{
1201     baton.post();
1202     p.reset();
1203   });
1204   baton.wait();
1205   f.reset();
1206   t1.join();
1207 }
1208
1209 class TestData : public RequestData {
1210  public:
1211   explicit TestData(int data) : data_(data) {}
1212   virtual ~TestData() {}
1213   int data_;
1214 };
1215
1216 TEST(Future, context) {
1217
1218   // Start a new context
1219   RequestContext::create();
1220
1221   EXPECT_EQ(nullptr, RequestContext::get()->getContextData("test"));
1222
1223   // Set some test data
1224   RequestContext::get()->setContextData(
1225     "test",
1226     std::unique_ptr<TestData>(new TestData(10)));
1227
1228   // Start a future
1229   Promise<void> p;
1230   auto future = p.getFuture().then([&]{
1231     // Check that the context followed the future
1232     EXPECT_TRUE(RequestContext::get() != nullptr);
1233     auto a = dynamic_cast<TestData*>(
1234       RequestContext::get()->getContextData("test"));
1235     auto data = a->data_;
1236     EXPECT_EQ(10, data);
1237   });
1238
1239   // Clear the context
1240   RequestContext::setContext(nullptr);
1241
1242   EXPECT_EQ(nullptr, RequestContext::get()->getContextData("test"));
1243
1244   // Fulfil the promise
1245   p.setValue();
1246 }
1247
1248
1249 // This only fails about 1 in 1k times when the bug is present :(
1250 TEST(Future, t5506504) {
1251   ThreadExecutor x;
1252
1253   auto fn = [&x]{
1254     auto promises = std::make_shared<vector<Promise<void>>>(4);
1255     vector<Future<void>> futures;
1256
1257     for (auto& p : *promises) {
1258       futures.emplace_back(
1259         p.getFuture()
1260         .via(&x)
1261         .then([](Try<void>&&){}));
1262     }
1263
1264     x.waitForStartup();
1265     x.add([promises]{
1266       for (auto& p : *promises) p.setValue();
1267     });
1268
1269     return whenAll(futures.begin(), futures.end());
1270   };
1271
1272   fn().wait();
1273 }
1274
1275 // Test of handling of a circular dependency. It's never recommended
1276 // to have one because of possible memory leaks. Here we test that
1277 // we can handle freeing of the Future while it is running.
1278 TEST(Future, CircularDependencySharedPtrSelfReset) {
1279   Promise<int64_t> promise;
1280   auto ptr = std::make_shared<Future<int64_t>>(promise.getFuture());
1281
1282   ptr->then(
1283     [ptr] (folly::Try<int64_t>&& uid) mutable {
1284       EXPECT_EQ(1, ptr.use_count());
1285
1286       // Leaving no references to ourselves.
1287       ptr.reset();
1288       EXPECT_EQ(0, ptr.use_count());
1289     }
1290   );
1291
1292   EXPECT_EQ(2, ptr.use_count());
1293
1294   ptr.reset();
1295
1296   promise.fulfil([]{return 1l;});
1297 }
1298
1299 TEST(Future, Constructor) {
1300   auto f1 = []() -> Future<int> { return Future<int>(3); }();
1301   EXPECT_EQ(f1.value(), 3);
1302   auto f2 = []() -> Future<void> { return Future<void>(); }();
1303   EXPECT_NO_THROW(f2.value());
1304 }
1305
1306 TEST(Future, ImplicitConstructor) {
1307   auto f1 = []() -> Future<int> { return 3; }();
1308   EXPECT_EQ(f1.value(), 3);
1309   // Unfortunately, the C++ standard does not allow the
1310   // following implicit conversion to work:
1311   //auto f2 = []() -> Future<void> { }();
1312 }
1313
1314 TEST(Future, via_then_get_was_racy) {
1315   ThreadExecutor x;
1316   std::unique_ptr<int> val = folly::via(&x)
1317     .then([] { return folly::make_unique<int>(42); })
1318     .get();
1319   ASSERT_TRUE(!!val);
1320   EXPECT_EQ(42, *val);
1321 }
1322
1323 TEST(Future, ensure) {
1324   size_t count = 0;
1325   auto cob = [&]{ count++; };
1326   auto f = makeFuture(42)
1327     .ensure(cob)
1328     .then([](int) { throw std::runtime_error("ensure"); })
1329     .ensure(cob);
1330
1331   EXPECT_THROW(f.get(), std::runtime_error);
1332   EXPECT_EQ(2, count);
1333 }
1334
1335 TEST(Future, willEqual) {
1336     //both p1 and p2 already fulfilled
1337     {
1338     Promise<int> p1;
1339     Promise<int> p2;
1340     p1.setValue(27);
1341     p2.setValue(27);
1342     auto f1 = p1.getFuture();
1343     auto f2 = p2.getFuture();
1344     EXPECT_TRUE(f1.willEqual(f2).get());
1345     }{
1346     Promise<int> p1;
1347     Promise<int> p2;
1348     p1.setValue(27);
1349     p2.setValue(36);
1350     auto f1 = p1.getFuture();
1351     auto f2 = p2.getFuture();
1352     EXPECT_FALSE(f1.willEqual(f2).get());
1353     }
1354     //both p1 and p2 not yet fulfilled
1355     {
1356     Promise<int> p1;
1357     Promise<int> p2;
1358     auto f1 = p1.getFuture();
1359     auto f2 = p2.getFuture();
1360     auto f3 = f1.willEqual(f2);
1361     p1.setValue(27);
1362     p2.setValue(27);
1363     EXPECT_TRUE(f3.get());
1364     }{
1365     Promise<int> p1;
1366     Promise<int> p2;
1367     auto f1 = p1.getFuture();
1368     auto f2 = p2.getFuture();
1369     auto f3 = f1.willEqual(f2);
1370     p1.setValue(27);
1371     p2.setValue(36);
1372     EXPECT_FALSE(f3.get());
1373     }
1374     //p1 already fulfilled, p2 not yet fulfilled
1375     {
1376     Promise<int> p1;
1377     Promise<int> p2;
1378     p1.setValue(27);
1379     auto f1 = p1.getFuture();
1380     auto f2 = p2.getFuture();
1381     auto f3 = f1.willEqual(f2);
1382     p2.setValue(27);
1383     EXPECT_TRUE(f3.get());
1384     }{
1385     Promise<int> p1;
1386     Promise<int> p2;
1387     p1.setValue(27);
1388     auto f1 = p1.getFuture();
1389     auto f2 = p2.getFuture();
1390     auto f3 = f1.willEqual(f2);
1391     p2.setValue(36);
1392     EXPECT_FALSE(f3.get());
1393     }
1394     //p2 already fulfilled, p1 not yet fulfilled
1395     {
1396     Promise<int> p1;
1397     Promise<int> p2;
1398     p2.setValue(27);
1399     auto f1 = p1.getFuture();
1400     auto f2 = p2.getFuture();
1401     auto f3 = f1.willEqual(f2);
1402     p1.setValue(27);
1403     EXPECT_TRUE(f3.get());
1404     }{
1405     Promise<int> p1;
1406     Promise<int> p2;
1407     p2.setValue(36);
1408     auto f1 = p1.getFuture();
1409     auto f2 = p2.getFuture();
1410     auto f3 = f1.willEqual(f2);
1411     p1.setValue(27);
1412     EXPECT_FALSE(f3.get());
1413     }
1414 }
1415
1416 // Unwrap tests.
1417
1418 // A simple scenario for the unwrap call, when the promise was fulfilled
1419 // before calling to unwrap.
1420 TEST(Future, Unwrap_SimpleScenario) {
1421   Future<int> encapsulated_future = makeFuture(5484);
1422   Future<Future<int>> future = makeFuture(std::move(encapsulated_future));
1423   EXPECT_EQ(5484, future.unwrap().value());
1424 }
1425
1426 // Makes sure that unwrap() works when chaning Future's commands.
1427 TEST(Future, Unwrap_ChainCommands) {
1428   Future<Future<int>> future = makeFuture(makeFuture(5484));
1429   auto unwrapped = future.unwrap().then([](int i){ return i; });
1430   EXPECT_EQ(5484, unwrapped.value());
1431 }
1432
1433 // Makes sure that the unwrap call also works when the promise was not yet
1434 // fulfilled, and that the returned Future<T> becomes ready once the promise
1435 // is fulfilled.
1436 TEST(Future, Unwrap_FutureNotReady) {
1437   Promise<Future<int>> p;
1438   Future<Future<int>> future = p.getFuture();
1439   Future<int> unwrapped = future.unwrap();
1440   // Sanity - should not be ready before the promise is fulfilled.
1441   ASSERT_FALSE(unwrapped.isReady());
1442   // Fulfill the promise and make sure the unwrapped future is now ready.
1443   p.setValue(makeFuture(5484));
1444   ASSERT_TRUE(unwrapped.isReady());
1445   EXPECT_EQ(5484, unwrapped.value());
1446 }
1447
1448 TEST(Reduce, Basic) {
1449   auto makeFutures = [](int count) {
1450     std::vector<Future<int>> fs;
1451     for (int i = 1; i <= count; ++i) {
1452       fs.emplace_back(makeFuture(i));
1453     }
1454     return fs;
1455   };
1456
1457   // Empty (Try)
1458   {
1459     auto fs = makeFutures(0);
1460
1461     Future<double> f1 = reduce(fs.begin(), fs.end(), 1.2,
1462       [](double a, Try<int>&& b){
1463         return a + *b + 0.1;
1464       });
1465     EXPECT_EQ(1.2, f1.get());
1466   }
1467
1468   // One (Try)
1469   {
1470     auto fs = makeFutures(1);
1471
1472     Future<double> f1 = reduce(fs.begin(), fs.end(), 0.0,
1473       [](double a, Try<int>&& b){
1474         return a + *b + 0.1;
1475       });
1476     EXPECT_EQ(1.1, f1.get());
1477   }
1478
1479   // Returning values (Try)
1480   {
1481     auto fs = makeFutures(3);
1482
1483     Future<double> f1 = reduce(fs.begin(), fs.end(), 0.0,
1484       [](double a, Try<int>&& b){
1485         return a + *b + 0.1;
1486       });
1487     EXPECT_EQ(6.3, f1.get());
1488   }
1489
1490   // Returning values
1491   {
1492     auto fs = makeFutures(3);
1493
1494     Future<double> f1 = reduce(fs.begin(), fs.end(), 0.0,
1495       [](double a, int&& b){
1496         return a + b + 0.1;
1497       });
1498     EXPECT_EQ(6.3, f1.get());
1499   }
1500
1501   // Returning futures (Try)
1502   {
1503     auto fs = makeFutures(3);
1504
1505     Future<double> f2 = reduce(fs.begin(), fs.end(), 0.0,
1506       [](double a, Try<int>&& b){
1507         return makeFuture<double>(a + *b + 0.1);
1508       });
1509     EXPECT_EQ(6.3, f2.get());
1510   }
1511
1512   // Returning futures
1513   {
1514     auto fs = makeFutures(3);
1515
1516     Future<double> f2 = reduce(fs.begin(), fs.end(), 0.0,
1517       [](double a, int&& b){
1518         return makeFuture<double>(a + b + 0.1);
1519       });
1520     EXPECT_EQ(6.3, f2.get());
1521   }
1522 }