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, setWith) {
 621   {
 622     Promise<int> p;
 623     auto f = p.getFuture();
 624     p.setWith([] { return 42; });
 625     EXPECT_EQ(42, f.value());
 626   }
 627   {
 628     Promise<int> p;
 629     auto f = p.getFuture();
 630     p.setWith([]() -> 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 TEST(Future, collect) {
 770   // success case
 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     auto allf = collect(futures.begin(), futures.end());
 779
 780     random_shuffle(promises.begin(), promises.end());
 781     for (auto& p : promises) {
 782       EXPECT_FALSE(allf.isReady());
 783       p.setValue(42);
 784     }
 785
 786     EXPECT_TRUE(allf.isReady());
 787     for (auto i : allf.value()) {
 788       EXPECT_EQ(42, i);
 789     }
 790   }
 791
 792   // failure case
 793   {
 794     vector<Promise<int>> promises(10);
 795     vector<Future<int>> futures;
 796
 797     for (auto& p : promises)
 798       futures.push_back(p.getFuture());
 799
 800     auto allf = collect(futures.begin(), futures.end());
 801
 802     random_shuffle(promises.begin(), promises.end());
 803     for (int i = 0; i < 10; i++) {
 804       if (i < 5) {
 805         // everthing goes well so far...
 806         EXPECT_FALSE(allf.isReady());
 807         promises[i].setValue(42);
 808       } else if (i == 5) {
 809         // short circuit with an exception
 810         EXPECT_FALSE(allf.isReady());
 811         promises[i].setException(eggs);
 812         EXPECT_TRUE(allf.isReady());
 813       } else if (i < 8) {
 814         // don't blow up on further values
 815         EXPECT_TRUE(allf.isReady());
 816         promises[i].setValue(42);
 817       } else {
 818         // don't blow up on further exceptions
 819         EXPECT_TRUE(allf.isReady());
 820         promises[i].setException(eggs);
 821       }
 822     }
 823
 824     EXPECT_THROW(allf.value(), eggs_t);
 825   }
 826
 827   // void futures success case
 828   {
 829     vector<Promise<void>> promises(10);
 830     vector<Future<void>> futures;
 831
 832     for (auto& p : promises)
 833       futures.push_back(p.getFuture());
 834
 835     auto allf = collect(futures.begin(), futures.end());
 836
 837     random_shuffle(promises.begin(), promises.end());
 838     for (auto& p : promises) {
 839       EXPECT_FALSE(allf.isReady());
 840       p.setValue();
 841     }
 842
 843     EXPECT_TRUE(allf.isReady());
 844   }
 845
 846   // void futures failure case
 847   {
 848     vector<Promise<void>> promises(10);
 849     vector<Future<void>> futures;
 850
 851     for (auto& p : promises)
 852       futures.push_back(p.getFuture());
 853
 854     auto allf = collect(futures.begin(), futures.end());
 855
 856     random_shuffle(promises.begin(), promises.end());
 857     for (int i = 0; i < 10; i++) {
 858       if (i < 5) {
 859         // everthing goes well so far...
 860         EXPECT_FALSE(allf.isReady());
 861         promises[i].setValue();
 862       } else if (i == 5) {
 863         // short circuit with an exception
 864         EXPECT_FALSE(allf.isReady());
 865         promises[i].setException(eggs);
 866         EXPECT_TRUE(allf.isReady());
 867       } else if (i < 8) {
 868         // don't blow up on further values
 869         EXPECT_TRUE(allf.isReady());
 870         promises[i].setValue();
 871       } else {
 872         // don't blow up on further exceptions
 873         EXPECT_TRUE(allf.isReady());
 874         promises[i].setException(eggs);
 875       }
 876     }
 877
 878     EXPECT_THROW(allf.value(), eggs_t);
 879   }
 880
 881   // move only compiles
 882   {
 883     vector<Promise<unique_ptr<int>>> promises(10);
 884     vector<Future<unique_ptr<int>>> futures;
 885
 886     for (auto& p : promises)
 887       futures.push_back(p.getFuture());
 888
 889     collect(futures.begin(), futures.end());
 890   }
 891
 892 }
 893
 894 struct NotDefaultConstructible {
 895   NotDefaultConstructible() = delete;
 896   NotDefaultConstructible(int arg) : i(arg) {}
 897   int i;
 898 };
 899
 900 // We have a specialized implementation for non-default-constructible objects
 901 // Ensure that it works and preserves order
 902 TEST(Future, collectNotDefaultConstructible) {
 903   vector<Promise<NotDefaultConstructible>> promises(10);
 904   vector<Future<NotDefaultConstructible>> futures;
 905   vector<int> indices(10);
 906   std::iota(indices.begin(), indices.end(), 0);
 907   random_shuffle(indices.begin(), indices.end());
 908
 909   for (auto& p : promises)
 910     futures.push_back(p.getFuture());
 911
 912   auto allf = collect(futures.begin(), futures.end());
 913
 914   for (auto i : indices) {
 915     EXPECT_FALSE(allf.isReady());
 916     promises[i].setValue(NotDefaultConstructible(i));
 917   }
 918
 919   EXPECT_TRUE(allf.isReady());
 920   int i = 0;
 921   for (auto val : allf.value()) {
 922     EXPECT_EQ(i, val.i);
 923     i++;
 924   }
 925 }
 926
 927 TEST(Future, whenAny) {
 928   {
 929     vector<Promise<int>> promises(10);
 930     vector<Future<int>> futures;
 931
 932     for (auto& p : promises)
 933       futures.push_back(p.getFuture());
 934
 935     for (auto& f : futures) {
 936       EXPECT_FALSE(f.isReady());
 937     }
 938
 939     auto anyf = whenAny(futures.begin(), futures.end());
 940
 941     /* futures were moved in, so these are invalid now */
 942     EXPECT_FALSE(anyf.isReady());
 943
 944     promises[7].setValue(42);
 945     EXPECT_TRUE(anyf.isReady());
 946     auto& idx_fut = anyf.value();
 947
 948     auto i = idx_fut.first;
 949     EXPECT_EQ(7, i);
 950
 951     auto& f = idx_fut.second;
 952     EXPECT_EQ(42, f.value());
 953   }
 954
 955   // error
 956   {
 957     vector<Promise<void>> promises(10);
 958     vector<Future<void>> futures;
 959
 960     for (auto& p : promises)
 961       futures.push_back(p.getFuture());
 962
 963     for (auto& f : futures) {
 964       EXPECT_FALSE(f.isReady());
 965     }
 966
 967     auto anyf = whenAny(futures.begin(), futures.end());
 968
 969     EXPECT_FALSE(anyf.isReady());
 970
 971     promises[3].setException(eggs);
 972     EXPECT_TRUE(anyf.isReady());
 973     EXPECT_TRUE(anyf.value().second.hasException());
 974   }
 975
 976   // then()
 977   {
 978     vector<Promise<int>> promises(10);
 979     vector<Future<int>> futures;
 980
 981     for (auto& p : promises)
 982       futures.push_back(p.getFuture());
 983
 984     auto anyf = whenAny(futures.begin(), futures.end())
 985       .then([](pair<size_t, Try<int>> p) {
 986         EXPECT_EQ(42, p.second.value());
 987       });
 988
 989     promises[3].setValue(42);
 990     EXPECT_TRUE(anyf.isReady());
 991   }
 992 }
 993
 994
 995 TEST(when, already_completed) {
 996   {
 997     vector<Future<void>> fs;
 998     for (int i = 0; i < 10; i++)
 999       fs.push_back(makeFuture());
1000
1001     whenAll(fs.begin(), fs.end())
1002       .then([&](vector<Try<void>> ts) {
1003         EXPECT_EQ(fs.size(), ts.size());
1004       });
1005   }
1006   {
1007     vector<Future<int>> fs;
1008     for (int i = 0; i < 10; i++)
1009       fs.push_back(makeFuture(i));
1010
1011     whenAny(fs.begin(), fs.end())
1012       .then([&](pair<size_t, Try<int>> p) {
1013         EXPECT_EQ(p.first, p.second.value());
1014       });
1015   }
1016 }
1017
1018 TEST(when, whenN) {
1019   vector<Promise<void>> promises(10);
1020   vector<Future<void>> futures;
1021
1022   for (auto& p : promises)
1023     futures.push_back(p.getFuture());
1024
1025   bool flag = false;
1026   size_t n = 3;
1027   whenN(futures.begin(), futures.end(), n)
1028     .then([&](vector<pair<size_t, Try<void>>> v) {
1029       flag = true;
1030       EXPECT_EQ(n, v.size());
1031       for (auto& tt : v)
1032         EXPECT_TRUE(tt.second.hasValue());
1033     });
1034
1035   promises[0].setValue();
1036   EXPECT_FALSE(flag);
1037   promises[1].setValue();
1038   EXPECT_FALSE(flag);
1039   promises[2].setValue();
1040   EXPECT_TRUE(flag);
1041 }
1042
1043 /* Ensure that we can compile when_{all,any} with folly::small_vector */
1044 TEST(when, small_vector) {
1045
1046   static_assert(!FOLLY_IS_TRIVIALLY_COPYABLE(Future<void>),
1047                 "Futures should not be trivially copyable");
1048   static_assert(!FOLLY_IS_TRIVIALLY_COPYABLE(Future<int>),
1049                 "Futures should not be trivially copyable");
1050
1051   using folly::small_vector;
1052   {
1053     small_vector<Future<void>> futures;
1054
1055     for (int i = 0; i < 10; i++)
1056       futures.push_back(makeFuture());
1057
1058     auto anyf = whenAny(futures.begin(), futures.end());
1059   }
1060
1061   {
1062     small_vector<Future<void>> futures;
1063
1064     for (int i = 0; i < 10; i++)
1065       futures.push_back(makeFuture());
1066
1067     auto allf = whenAll(futures.begin(), futures.end());
1068   }
1069 }
1070
1071 TEST(Future, whenAllVariadic) {
1072   Promise<bool> pb;
1073   Promise<int> pi;
1074   Future<bool> fb = pb.getFuture();
1075   Future<int> fi = pi.getFuture();
1076   bool flag = false;
1077   whenAll(std::move(fb), std::move(fi))
1078     .then([&](std::tuple<Try<bool>, Try<int>> tup) {
1079       flag = true;
1080       EXPECT_TRUE(std::get<0>(tup).hasValue());
1081       EXPECT_EQ(std::get<0>(tup).value(), true);
1082       EXPECT_TRUE(std::get<1>(tup).hasValue());
1083       EXPECT_EQ(std::get<1>(tup).value(), 42);
1084     });
1085   pb.setValue(true);
1086   EXPECT_FALSE(flag);
1087   pi.setValue(42);
1088   EXPECT_TRUE(flag);
1089 }
1090
1091 TEST(Future, whenAllVariadicReferences) {
1092   Promise<bool> pb;
1093   Promise<int> pi;
1094   Future<bool> fb = pb.getFuture();
1095   Future<int> fi = pi.getFuture();
1096   bool flag = false;
1097   whenAll(fb, fi)
1098     .then([&](std::tuple<Try<bool>, Try<int>> tup) {
1099       flag = true;
1100       EXPECT_TRUE(std::get<0>(tup).hasValue());
1101       EXPECT_EQ(std::get<0>(tup).value(), true);
1102       EXPECT_TRUE(std::get<1>(tup).hasValue());
1103       EXPECT_EQ(std::get<1>(tup).value(), 42);
1104     });
1105   pb.setValue(true);
1106   EXPECT_FALSE(flag);
1107   pi.setValue(42);
1108   EXPECT_TRUE(flag);
1109 }
1110
1111 TEST(Future, whenAll_none) {
1112   vector<Future<int>> fs;
1113   auto f = whenAll(fs.begin(), fs.end());
1114   EXPECT_TRUE(f.isReady());
1115 }
1116
1117 TEST(Future, throwCaughtInImmediateThen) {
1118   // Neither of these should throw "Promise already satisfied"
1119   makeFuture().then(
1120     [=](Try<void>&&) -> int { throw std::exception(); });
1121   makeFuture().then(
1122     [=](Try<void>&&) -> Future<int> { throw std::exception(); });
1123 }
1124
1125 TEST(Future, throwIfFailed) {
1126   makeFuture<void>(eggs)
1127     .then([=](Try<void>&& t) {
1128       EXPECT_THROW(t.throwIfFailed(), eggs_t);
1129     });
1130   makeFuture()
1131     .then([=](Try<void>&& t) {
1132       EXPECT_NO_THROW(t.throwIfFailed());
1133     });
1134
1135   makeFuture<int>(eggs)
1136     .then([=](Try<int>&& t) {
1137       EXPECT_THROW(t.throwIfFailed(), eggs_t);
1138     });
1139   makeFuture<int>(42)
1140     .then([=](Try<int>&& t) {
1141       EXPECT_NO_THROW(t.throwIfFailed());
1142     });
1143 }
1144
1145 TEST(Future, waitImmediate) {
1146   makeFuture().wait();
1147   auto done = makeFuture(42).wait().value();
1148   EXPECT_EQ(42, done);
1149
1150   vector<int> v{1,2,3};
1151   auto done_v = makeFuture(v).wait().value();
1152   EXPECT_EQ(v.size(), done_v.size());
1153   EXPECT_EQ(v, done_v);
1154
1155   vector<Future<void>> v_f;
1156   v_f.push_back(makeFuture());
1157   v_f.push_back(makeFuture());
1158   auto done_v_f = whenAll(v_f.begin(), v_f.end()).wait().value();
1159   EXPECT_EQ(2, done_v_f.size());
1160
1161   vector<Future<bool>> v_fb;
1162   v_fb.push_back(makeFuture(true));
1163   v_fb.push_back(makeFuture(false));
1164   auto fut = whenAll(v_fb.begin(), v_fb.end());
1165   auto done_v_fb = std::move(fut.wait().value());
1166   EXPECT_EQ(2, done_v_fb.size());
1167 }
1168
1169 TEST(Future, wait) {
1170   Promise<int> p;
1171   Future<int> f = p.getFuture();
1172   std::atomic<bool> flag{false};
1173   std::atomic<int> result{1};
1174   std::atomic<std::thread::id> id;
1175
1176   std::thread t([&](Future<int>&& tf){
1177       auto n = tf.then([&](Try<int> && t) {
1178           id = std::this_thread::get_id();
1179           return t.value();
1180         });
1181       flag = true;
1182       result.store(n.wait().value());
1183     },
1184     std::move(f)
1185     );
1186   while(!flag){}
1187   EXPECT_EQ(result.load(), 1);
1188   p.setValue(42);
1189   t.join();
1190   // validate that the callback ended up executing in this thread, which
1191   // is more to ensure that this test actually tests what it should
1192   EXPECT_EQ(id, std::this_thread::get_id());
1193   EXPECT_EQ(result.load(), 42);
1194 }
1195
1196 struct MoveFlag {
1197   MoveFlag() = default;
1198   MoveFlag(const MoveFlag&) = delete;
1199   MoveFlag(MoveFlag&& other) noexcept {
1200     other.moved = true;
1201   }
1202   bool moved{false};
1203 };
1204
1205 TEST(Future, waitReplacesSelf) {
1206   // wait
1207   {
1208     // lvalue
1209     auto f1 = makeFuture(MoveFlag());
1210     f1.wait();
1211     EXPECT_FALSE(f1.value().moved);
1212
1213     // rvalue
1214     auto f2 = makeFuture(MoveFlag()).wait();
1215     EXPECT_FALSE(f2.value().moved);
1216   }
1217
1218   // wait(Duration)
1219   {
1220     // lvalue
1221     auto f1 = makeFuture(MoveFlag());
1222     f1.wait(milliseconds(1));
1223     EXPECT_FALSE(f1.value().moved);
1224
1225     // rvalue
1226     auto f2 = makeFuture(MoveFlag()).wait(milliseconds(1));
1227     EXPECT_FALSE(f2.value().moved);
1228   }
1229
1230   // waitVia
1231   {
1232     folly::EventBase eb;
1233     // lvalue
1234     auto f1 = makeFuture(MoveFlag());
1235     f1.waitVia(&eb);
1236     EXPECT_FALSE(f1.value().moved);
1237
1238     // rvalue
1239     auto f2 = makeFuture(MoveFlag()).waitVia(&eb);
1240     EXPECT_FALSE(f2.value().moved);
1241   }
1242 }
1243
1244 TEST(Future, waitWithDuration) {
1245  {
1246   Promise<int> p;
1247   Future<int> f = p.getFuture();
1248   f.wait(milliseconds(1));
1249   EXPECT_FALSE(f.isReady());
1250   p.setValue(1);
1251   EXPECT_TRUE(f.isReady());
1252  }
1253  {
1254   Promise<int> p;
1255   Future<int> f = p.getFuture();
1256   p.setValue(1);
1257   f.wait(milliseconds(1));
1258   EXPECT_TRUE(f.isReady());
1259  }
1260  {
1261   vector<Future<bool>> v_fb;
1262   v_fb.push_back(makeFuture(true));
1263   v_fb.push_back(makeFuture(false));
1264   auto f = whenAll(v_fb.begin(), v_fb.end());
1265   f.wait(milliseconds(1));
1266   EXPECT_TRUE(f.isReady());
1267   EXPECT_EQ(2, f.value().size());
1268  }
1269  {
1270   vector<Future<bool>> v_fb;
1271   Promise<bool> p1;
1272   Promise<bool> p2;
1273   v_fb.push_back(p1.getFuture());
1274   v_fb.push_back(p2.getFuture());
1275   auto f = whenAll(v_fb.begin(), v_fb.end());
1276   f.wait(milliseconds(1));
1277   EXPECT_FALSE(f.isReady());
1278   p1.setValue(true);
1279   EXPECT_FALSE(f.isReady());
1280   p2.setValue(true);
1281   EXPECT_TRUE(f.isReady());
1282  }
1283  {
1284   auto f = makeFuture().wait(milliseconds(1));
1285   EXPECT_TRUE(f.isReady());
1286  }
1287
1288  {
1289    Promise<void> p;
1290    auto start = std::chrono::steady_clock::now();
1291    auto f = p.getFuture().wait(milliseconds(100));
1292    auto elapsed = std::chrono::steady_clock::now() - start;
1293    EXPECT_GE(elapsed, milliseconds(100));
1294    EXPECT_FALSE(f.isReady());
1295    p.setValue();
1296    EXPECT_TRUE(f.isReady());
1297  }
1298
1299  {
1300    // Try to trigger the race where the resultant Future is not yet complete
1301    // even if we didn't hit the timeout, and make sure we deal with it properly
1302    Promise<void> p;
1303    folly::Baton<> b;
1304    auto t = std::thread([&]{
1305      b.post();
1306      /* sleep override */ std::this_thread::sleep_for(milliseconds(100));
1307      p.setValue();
1308    });
1309    b.wait();
1310    auto f = p.getFuture().wait(std::chrono::seconds(3600));
1311    EXPECT_TRUE(f.isReady());
1312    t.join();
1313  }
1314 }
1315
1316 class DummyDrivableExecutor : public DrivableExecutor {
1317  public:
1318   void add(Func f) override {}
1319   void drive() override { ran = true; }
1320   bool ran{false};
1321 };
1322
1323 TEST(Future, getVia) {
1324   {
1325     // non-void
1326     ManualExecutor x;
1327     auto f = via(&x).then([]{ return true; });
1328     EXPECT_TRUE(f.getVia(&x));
1329   }
1330
1331   {
1332     // void
1333     ManualExecutor x;
1334     auto f = via(&x).then();
1335     f.getVia(&x);
1336   }
1337
1338   {
1339     DummyDrivableExecutor x;
1340     auto f = makeFuture(true);
1341     EXPECT_TRUE(f.getVia(&x));
1342     EXPECT_FALSE(x.ran);
1343   }
1344 }
1345
1346 TEST(Future, waitVia) {
1347   {
1348     ManualExecutor x;
1349     auto f = via(&x).then();
1350     EXPECT_FALSE(f.isReady());
1351     f.waitVia(&x);
1352     EXPECT_TRUE(f.isReady());
1353   }
1354
1355   {
1356     // try rvalue as well
1357     ManualExecutor x;
1358     auto f = via(&x).then().waitVia(&x);
1359     EXPECT_TRUE(f.isReady());
1360   }
1361
1362   {
1363     DummyDrivableExecutor x;
1364     makeFuture(true).waitVia(&x);
1365     EXPECT_FALSE(x.ran);
1366   }
1367 }
1368
1369 TEST(Future, viaRaces) {
1370   ManualExecutor x;
1371   Promise<void> p;
1372   auto tid = std::this_thread::get_id();
1373   bool done = false;
1374
1375   std::thread t1([&] {
1376     p.getFuture()
1377       .via(&x)
1378       .then([&](Try<void>&&) { EXPECT_EQ(tid, std::this_thread::get_id()); })
1379       .then([&](Try<void>&&) { EXPECT_EQ(tid, std::this_thread::get_id()); })
1380       .then([&](Try<void>&&) { done = true; });
1381   });
1382
1383   std::thread t2([&] {
1384     p.setValue();
1385   });
1386
1387   while (!done) x.run();
1388   t1.join();
1389   t2.join();
1390 }
1391
1392 TEST(Future, getFuture_after_setValue) {
1393   Promise<int> p;
1394   p.setValue(42);
1395   EXPECT_EQ(42, p.getFuture().value());
1396 }
1397
1398 TEST(Future, getFuture_after_setException) {
1399   Promise<void> p;
1400   p.setWith([]() -> void { throw std::logic_error("foo"); });
1401   EXPECT_THROW(p.getFuture().value(), std::logic_error);
1402 }
1403
1404 TEST(Future, detachRace) {
1405   // Task #5438209
1406   // This test is designed to detect a race that was in Core::detachOne()
1407   // where detached_ was incremented and then tested, and that
1408   // allowed a race where both Promise and Future would think they were the
1409   // second and both try to delete. This showed up at scale but was very
1410   // difficult to reliably repro in a test. As it is, this only fails about
1411   // once in every 1,000 executions. Doing this 1,000 times is going to make a
1412   // slow test so I won't do that but if it ever fails, take it seriously, and
1413   // run the test binary with "--gtest_repeat=10000 --gtest_filter=*detachRace"
1414   // (Don't forget to enable ASAN)
1415   auto p = folly::make_unique<Promise<bool>>();
1416   auto f = folly::make_unique<Future<bool>>(p->getFuture());
1417   folly::Baton<> baton;
1418   std::thread t1([&]{
1419     baton.post();
1420     p.reset();
1421   });
1422   baton.wait();
1423   f.reset();
1424   t1.join();
1425 }
1426
1427 class TestData : public RequestData {
1428  public:
1429   explicit TestData(int data) : data_(data) {}
1430   virtual ~TestData() {}
1431   int data_;
1432 };
1433
1434 TEST(Future, context) {
1435
1436   // Start a new context
1437   RequestContext::create();
1438
1439   EXPECT_EQ(nullptr, RequestContext::get()->getContextData("test"));
1440
1441   // Set some test data
1442   RequestContext::get()->setContextData(
1443     "test",
1444     std::unique_ptr<TestData>(new TestData(10)));
1445
1446   // Start a future
1447   Promise<void> p;
1448   auto future = p.getFuture().then([&]{
1449     // Check that the context followed the future
1450     EXPECT_TRUE(RequestContext::get() != nullptr);
1451     auto a = dynamic_cast<TestData*>(
1452       RequestContext::get()->getContextData("test"));
1453     auto data = a->data_;
1454     EXPECT_EQ(10, data);
1455   });
1456
1457   // Clear the context
1458   RequestContext::setContext(nullptr);
1459
1460   EXPECT_EQ(nullptr, RequestContext::get()->getContextData("test"));
1461
1462   // Fulfill the promise
1463   p.setValue();
1464 }
1465
1466
1467 // This only fails about 1 in 1k times when the bug is present :(
1468 TEST(Future, t5506504) {
1469   ThreadExecutor x;
1470
1471   auto fn = [&x]{
1472     auto promises = std::make_shared<vector<Promise<void>>>(4);
1473     vector<Future<void>> futures;
1474
1475     for (auto& p : *promises) {
1476       futures.emplace_back(
1477         p.getFuture()
1478         .via(&x)
1479         .then([](Try<void>&&){}));
1480     }
1481
1482     x.waitForStartup();
1483     x.add([promises]{
1484       for (auto& p : *promises) p.setValue();
1485     });
1486
1487     return whenAll(futures.begin(), futures.end());
1488   };
1489
1490   fn().wait();
1491 }
1492
1493 // Test of handling of a circular dependency. It's never recommended
1494 // to have one because of possible memory leaks. Here we test that
1495 // we can handle freeing of the Future while it is running.
1496 TEST(Future, CircularDependencySharedPtrSelfReset) {
1497   Promise<int64_t> promise;
1498   auto ptr = std::make_shared<Future<int64_t>>(promise.getFuture());
1499
1500   ptr->then(
1501     [ptr] (folly::Try<int64_t>&& uid) mutable {
1502       EXPECT_EQ(1, ptr.use_count());
1503
1504       // Leaving no references to ourselves.
1505       ptr.reset();
1506       EXPECT_EQ(0, ptr.use_count());
1507     }
1508   );
1509
1510   EXPECT_EQ(2, ptr.use_count());
1511
1512   ptr.reset();
1513
1514   promise.setWith([]{return 1l;});
1515 }
1516
1517 TEST(Future, Constructor) {
1518   auto f1 = []() -> Future<int> { return Future<int>(3); }();
1519   EXPECT_EQ(f1.value(), 3);
1520   auto f2 = []() -> Future<void> { return Future<void>(); }();
1521   EXPECT_NO_THROW(f2.value());
1522 }
1523
1524 TEST(Future, ImplicitConstructor) {
1525   auto f1 = []() -> Future<int> { return 3; }();
1526   EXPECT_EQ(f1.value(), 3);
1527   // Unfortunately, the C++ standard does not allow the
1528   // following implicit conversion to work:
1529   //auto f2 = []() -> Future<void> { }();
1530 }
1531
1532 TEST(Future, thenDynamic) {
1533   // folly::dynamic has a constructor that takes any T, this test makes
1534   // sure that we call the then lambda with folly::dynamic and not
1535   // Try<folly::dynamic> because that then fails to compile
1536   Promise<folly::dynamic> p;
1537   Future<folly::dynamic> f = p.getFuture().then(
1538       [](const folly::dynamic& d) {
1539         return folly::dynamic(d.asInt() + 3);
1540       }
1541   );
1542   p.setValue(2);
1543   EXPECT_EQ(f.get(), 5);
1544 }
1545
1546 TEST(Future, via_then_get_was_racy) {
1547   ThreadExecutor x;
1548   std::unique_ptr<int> val = folly::via(&x)
1549     .then([] { return folly::make_unique<int>(42); })
1550     .get();
1551   ASSERT_TRUE(!!val);
1552   EXPECT_EQ(42, *val);
1553 }
1554
1555 TEST(Future, ensure) {
1556   size_t count = 0;
1557   auto cob = [&]{ count++; };
1558   auto f = makeFuture(42)
1559     .ensure(cob)
1560     .then([](int) { throw std::runtime_error("ensure"); })
1561     .ensure(cob);
1562
1563   EXPECT_THROW(f.get(), std::runtime_error);
1564   EXPECT_EQ(2, count);
1565 }
1566
1567 TEST(Future, willEqual) {
1568     //both p1 and p2 already fulfilled
1569     {
1570     Promise<int> p1;
1571     Promise<int> p2;
1572     p1.setValue(27);
1573     p2.setValue(27);
1574     auto f1 = p1.getFuture();
1575     auto f2 = p2.getFuture();
1576     EXPECT_TRUE(f1.willEqual(f2).get());
1577     }{
1578     Promise<int> p1;
1579     Promise<int> p2;
1580     p1.setValue(27);
1581     p2.setValue(36);
1582     auto f1 = p1.getFuture();
1583     auto f2 = p2.getFuture();
1584     EXPECT_FALSE(f1.willEqual(f2).get());
1585     }
1586     //both p1 and p2 not yet fulfilled
1587     {
1588     Promise<int> p1;
1589     Promise<int> p2;
1590     auto f1 = p1.getFuture();
1591     auto f2 = p2.getFuture();
1592     auto f3 = f1.willEqual(f2);
1593     p1.setValue(27);
1594     p2.setValue(27);
1595     EXPECT_TRUE(f3.get());
1596     }{
1597     Promise<int> p1;
1598     Promise<int> p2;
1599     auto f1 = p1.getFuture();
1600     auto f2 = p2.getFuture();
1601     auto f3 = f1.willEqual(f2);
1602     p1.setValue(27);
1603     p2.setValue(36);
1604     EXPECT_FALSE(f3.get());
1605     }
1606     //p1 already fulfilled, p2 not yet fulfilled
1607     {
1608     Promise<int> p1;
1609     Promise<int> p2;
1610     p1.setValue(27);
1611     auto f1 = p1.getFuture();
1612     auto f2 = p2.getFuture();
1613     auto f3 = f1.willEqual(f2);
1614     p2.setValue(27);
1615     EXPECT_TRUE(f3.get());
1616     }{
1617     Promise<int> p1;
1618     Promise<int> p2;
1619     p1.setValue(27);
1620     auto f1 = p1.getFuture();
1621     auto f2 = p2.getFuture();
1622     auto f3 = f1.willEqual(f2);
1623     p2.setValue(36);
1624     EXPECT_FALSE(f3.get());
1625     }
1626     //p2 already fulfilled, p1 not yet fulfilled
1627     {
1628     Promise<int> p1;
1629     Promise<int> p2;
1630     p2.setValue(27);
1631     auto f1 = p1.getFuture();
1632     auto f2 = p2.getFuture();
1633     auto f3 = f1.willEqual(f2);
1634     p1.setValue(27);
1635     EXPECT_TRUE(f3.get());
1636     }{
1637     Promise<int> p1;
1638     Promise<int> p2;
1639     p2.setValue(36);
1640     auto f1 = p1.getFuture();
1641     auto f2 = p2.getFuture();
1642     auto f3 = f1.willEqual(f2);
1643     p1.setValue(27);
1644     EXPECT_FALSE(f3.get());
1645     }
1646 }
1647
1648 // Unwrap tests.
1649
1650 // A simple scenario for the unwrap call, when the promise was fulfilled
1651 // before calling to unwrap.
1652 TEST(Future, Unwrap_SimpleScenario) {
1653   Future<int> encapsulated_future = makeFuture(5484);
1654   Future<Future<int>> future = makeFuture(std::move(encapsulated_future));
1655   EXPECT_EQ(5484, future.unwrap().value());
1656 }
1657
1658 // Makes sure that unwrap() works when chaning Future's commands.
1659 TEST(Future, Unwrap_ChainCommands) {
1660   Future<Future<int>> future = makeFuture(makeFuture(5484));
1661   auto unwrapped = future.unwrap().then([](int i){ return i; });
1662   EXPECT_EQ(5484, unwrapped.value());
1663 }
1664
1665 // Makes sure that the unwrap call also works when the promise was not yet
1666 // fulfilled, and that the returned Future<T> becomes ready once the promise
1667 // is fulfilled.
1668 TEST(Future, Unwrap_FutureNotReady) {
1669   Promise<Future<int>> p;
1670   Future<Future<int>> future = p.getFuture();
1671   Future<int> unwrapped = future.unwrap();
1672   // Sanity - should not be ready before the promise is fulfilled.
1673   ASSERT_FALSE(unwrapped.isReady());
1674   // Fulfill the promise and make sure the unwrapped future is now ready.
1675   p.setValue(makeFuture(5484));
1676   ASSERT_TRUE(unwrapped.isReady());
1677   EXPECT_EQ(5484, unwrapped.value());
1678 }
1679
1680 TEST(Reduce, Basic) {
1681   auto makeFutures = [](int count) {
1682     std::vector<Future<int>> fs;
1683     for (int i = 1; i <= count; ++i) {
1684       fs.emplace_back(makeFuture(i));
1685     }
1686     return fs;
1687   };
1688
1689   // Empty (Try)
1690   {
1691     auto fs = makeFutures(0);
1692
1693     Future<double> f1 = reduce(fs.begin(), fs.end(), 1.2,
1694       [](double a, Try<int>&& b){
1695         return a + *b + 0.1;
1696       });
1697     EXPECT_EQ(1.2, f1.get());
1698   }
1699
1700   // One (Try)
1701   {
1702     auto fs = makeFutures(1);
1703
1704     Future<double> f1 = reduce(fs.begin(), fs.end(), 0.0,
1705       [](double a, Try<int>&& b){
1706         return a + *b + 0.1;
1707       });
1708     EXPECT_EQ(1.1, f1.get());
1709   }
1710
1711   // Returning values (Try)
1712   {
1713     auto fs = makeFutures(3);
1714
1715     Future<double> f1 = reduce(fs.begin(), fs.end(), 0.0,
1716       [](double a, Try<int>&& b){
1717         return a + *b + 0.1;
1718       });
1719     EXPECT_EQ(6.3, f1.get());
1720   }
1721
1722   // Returning values
1723   {
1724     auto fs = makeFutures(3);
1725
1726     Future<double> f1 = reduce(fs.begin(), fs.end(), 0.0,
1727       [](double a, int&& b){
1728         return a + b + 0.1;
1729       });
1730     EXPECT_EQ(6.3, f1.get());
1731   }
1732
1733   // Returning futures (Try)
1734   {
1735     auto fs = makeFutures(3);
1736
1737     Future<double> f2 = reduce(fs.begin(), fs.end(), 0.0,
1738       [](double a, Try<int>&& b){
1739         return makeFuture<double>(a + *b + 0.1);
1740       });
1741     EXPECT_EQ(6.3, f2.get());
1742   }
1743
1744   // Returning futures
1745   {
1746     auto fs = makeFutures(3);
1747
1748     Future<double> f2 = reduce(fs.begin(), fs.end(), 0.0,
1749       [](double a, int&& b){
1750         return makeFuture<double>(a + b + 0.1);
1751       });
1752     EXPECT_EQ(6.3, f2.get());
1753   }
1754 }
1755
1756 TEST(Map, Basic) {
1757   Promise<int> p1;
1758   Promise<int> p2;
1759   Promise<int> p3;
1760
1761   std::vector<Future<int>> fs;
1762   fs.push_back(p1.getFuture());
1763   fs.push_back(p2.getFuture());
1764   fs.push_back(p3.getFuture());
1765
1766   int c = 0;
1767   auto fs2 = futures::map(fs.begin(), fs.end(), [&](int i){
1768     c += i;
1769   });
1770
1771   // Ensure we call the callbacks as the futures complete regardless of order
1772   p2.setValue(1);
1773   EXPECT_EQ(1, c);
1774   p3.setValue(1);
1775   EXPECT_EQ(2, c);
1776   p1.setValue(1);
1777   EXPECT_EQ(3, c);
1778
1779   EXPECT_TRUE(collect(fs2.begin(), fs2.end()).isReady());
1780 }