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