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