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