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