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