folly/futures/test/FutureTest.cpp

   1 /*
   2  * Copyright 2014 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/MPMCQueue.h>
  32
  33 #include <folly/io/async/EventBase.h>
  34 #include <folly/io/async/Request.h>
  35
  36 using namespace folly;
  37 using std::pair;
  38 using std::string;
  39 using std::unique_ptr;
  40 using std::vector;
  41 using std::chrono::milliseconds;
  42
  43 #define EXPECT_TYPE(x, T) \
  44   EXPECT_TRUE((std::is_same<decltype(x), T>::value))
  45
  46 /// Simple executor that does work in another thread
  47 class ThreadExecutor : public Executor {
  48   folly::MPMCQueue<Func> funcs;
  49   std::atomic<bool> done {false};
  50   std::thread worker;
  51   folly::Baton<> baton;
  52
  53   void work() {
  54     baton.post();
  55     Func fn;
  56     while (!done) {
  57       while (!funcs.isEmpty()) {
  58         funcs.blockingRead(fn);
  59         fn();
  60       }
  61     }
  62   }
  63
  64  public:
  65   explicit ThreadExecutor(size_t n = 1024)
  66     : funcs(n), worker(std::bind(&ThreadExecutor::work, this)) {}
  67
  68   ~ThreadExecutor() {
  69     done = true;
  70     funcs.write([]{});
  71     worker.join();
  72   }
  73
  74   void add(Func fn) override {
  75     funcs.blockingWrite(std::move(fn));
  76   }
  77
  78   void waitForStartup() {
  79     baton.wait();
  80   }
  81 };
  82
  83 typedef FutureException eggs_t;
  84 static eggs_t eggs("eggs");
  85
  86 // Core
  87
  88 TEST(Future, coreSize) {
  89   // If this number goes down, it's fine!
  90   // If it goes up, please seek professional advice ;-)
  91   EXPECT_EQ(128, sizeof(detail::Core<void>));
  92 }
  93
  94 // Future
  95
  96 TEST(Future, onError) {
  97   bool theFlag = false;
  98   auto flag = [&]{ theFlag = true; };
  99 #define EXPECT_FLAG() \
 100   do { \
 101     EXPECT_TRUE(theFlag); \
 102     theFlag = false; \
 103   } while(0);
 104
 105 #define EXPECT_NO_FLAG() \
 106   do { \
 107     EXPECT_FALSE(theFlag); \
 108     theFlag = false; \
 109   } while(0);
 110
 111   // By reference
 112   {
 113     auto f = makeFuture()
 114       .then([] { throw eggs; })
 115       .onError([&] (eggs_t& e) { flag(); });
 116     EXPECT_FLAG();
 117     EXPECT_NO_THROW(f.value());
 118   }
 119
 120   {
 121     auto f = makeFuture()
 122       .then([] { throw eggs; })
 123       .onError([&] (eggs_t& e) { flag(); return makeFuture(); });
 124     EXPECT_FLAG();
 125     EXPECT_NO_THROW(f.value());
 126   }
 127
 128   // By value
 129   {
 130     auto f = makeFuture()
 131       .then([] { throw eggs; })
 132       .onError([&] (eggs_t e) { flag(); });
 133     EXPECT_FLAG();
 134     EXPECT_NO_THROW(f.value());
 135   }
 136
 137   {
 138     auto f = makeFuture()
 139       .then([] { throw eggs; })
 140       .onError([&] (eggs_t e) { flag(); return makeFuture(); });
 141     EXPECT_FLAG();
 142     EXPECT_NO_THROW(f.value());
 143   }
 144
 145   // Polymorphic
 146   {
 147     auto f = makeFuture()
 148       .then([] { throw eggs; })
 149       .onError([&] (std::exception& e) { flag(); });
 150     EXPECT_FLAG();
 151     EXPECT_NO_THROW(f.value());
 152   }
 153
 154   {
 155     auto f = makeFuture()
 156       .then([] { throw eggs; })
 157       .onError([&] (std::exception& e) { flag(); return makeFuture(); });
 158     EXPECT_FLAG();
 159     EXPECT_NO_THROW(f.value());
 160   }
 161
 162   // Non-exceptions
 163   {
 164     auto f = makeFuture()
 165       .then([] { throw -1; })
 166       .onError([&] (int e) { flag(); });
 167     EXPECT_FLAG();
 168     EXPECT_NO_THROW(f.value());
 169   }
 170
 171   {
 172     auto f = makeFuture()
 173       .then([] { throw -1; })
 174       .onError([&] (int e) { flag(); return makeFuture(); });
 175     EXPECT_FLAG();
 176     EXPECT_NO_THROW(f.value());
 177   }
 178
 179   // Mutable lambda
 180   {
 181     auto f = makeFuture()
 182       .then([] { throw eggs; })
 183       .onError([&] (eggs_t& e) mutable { flag(); });
 184     EXPECT_FLAG();
 185     EXPECT_NO_THROW(f.value());
 186   }
 187
 188   {
 189     auto f = makeFuture()
 190       .then([] { throw eggs; })
 191       .onError([&] (eggs_t& e) mutable { flag(); return makeFuture(); });
 192     EXPECT_FLAG();
 193     EXPECT_NO_THROW(f.value());
 194   }
 195
 196   // No throw
 197   {
 198     auto f = makeFuture()
 199       .then([] { return 42; })
 200       .onError([&] (eggs_t& e) { flag(); return -1; });
 201     EXPECT_NO_FLAG();
 202     EXPECT_EQ(42, f.value());
 203   }
 204
 205   {
 206     auto f = makeFuture()
 207       .then([] { return 42; })
 208       .onError([&] (eggs_t& e) { flag(); return makeFuture<int>(-1); });
 209     EXPECT_NO_FLAG();
 210     EXPECT_EQ(42, f.value());
 211   }
 212
 213   // Catch different exception
 214   {
 215     auto f = makeFuture()
 216       .then([] { throw eggs; })
 217       .onError([&] (std::runtime_error& e) { flag(); });
 218     EXPECT_NO_FLAG();
 219     EXPECT_THROW(f.value(), eggs_t);
 220   }
 221
 222   {
 223     auto f = makeFuture()
 224       .then([] { throw eggs; })
 225       .onError([&] (std::runtime_error& e) { flag(); return makeFuture(); });
 226     EXPECT_NO_FLAG();
 227     EXPECT_THROW(f.value(), eggs_t);
 228   }
 229
 230   // Returned value propagates
 231   {
 232     auto f = makeFuture()
 233       .then([] { throw eggs; return 0; })
 234       .onError([&] (eggs_t& e) { return 42; });
 235     EXPECT_EQ(42, f.value());
 236   }
 237
 238   // Returned future propagates
 239   {
 240     auto f = makeFuture()
 241       .then([] { throw eggs; return 0; })
 242       .onError([&] (eggs_t& e) { return makeFuture<int>(42); });
 243     EXPECT_EQ(42, f.value());
 244   }
 245
 246   // Throw in callback
 247   {
 248     auto f = makeFuture()
 249       .then([] { throw eggs; return 0; })
 250       .onError([&] (eggs_t& e) { throw e; return -1; });
 251     EXPECT_THROW(f.value(), eggs_t);
 252   }
 253
 254   {
 255     auto f = makeFuture()
 256       .then([] { throw eggs; return 0; })
 257       .onError([&] (eggs_t& e) { throw e; return makeFuture<int>(-1); });
 258     EXPECT_THROW(f.value(), eggs_t);
 259   }
 260 }
 261
 262 TEST(Future, try) {
 263   class A {
 264    public:
 265     A(int x) : x_(x) {}
 266
 267     int x() const {
 268       return x_;
 269     }
 270    private:
 271     int x_;
 272   };
 273
 274   A a(5);
 275   Try<A> t_a(std::move(a));
 276
 277   Try<void> t_void;
 278
 279   EXPECT_EQ(5, t_a.value().x());
 280 }
 281
 282 TEST(Future, special) {
 283   EXPECT_FALSE(std::is_copy_constructible<Future<int>>::value);
 284   EXPECT_FALSE(std::is_copy_assignable<Future<int>>::value);
 285   EXPECT_TRUE(std::is_move_constructible<Future<int>>::value);
 286   EXPECT_TRUE(std::is_move_assignable<Future<int>>::value);
 287 }
 288
 289 TEST(Future, then) {
 290   auto f = makeFuture<string>("0")
 291     .then([](){ return makeFuture<string>("1"); })
 292     .then([](Try<string>&& t) { return makeFuture(t.value() + ";2"); })
 293     .then([](const Try<string>&& t) { return makeFuture(t.value() + ";3"); })
 294     .then([](Try<string>& t) { return makeFuture(t.value() + ";4"); })
 295     .then([](const Try<string>& t) { return makeFuture(t.value() + ";5"); })
 296     .then([](Try<string> t) { return makeFuture(t.value() + ";6"); })
 297     .then([](const Try<string> t) { return makeFuture(t.value() + ";7"); })
 298     .then([](string&& s) { return makeFuture(s + ";8"); })
 299     .then([](const string&& s) { return makeFuture(s + ";9"); })
 300     .then([](string& s) { return makeFuture(s + ";10"); })
 301     .then([](const string& s) { return makeFuture(s + ";11"); })
 302     .then([](string s) { return makeFuture(s + ";12"); })
 303     .then([](const string s) { return makeFuture(s + ";13"); })
 304   ;
 305   EXPECT_EQ(f.value(), "1;2;3;4;5;6;7;8;9;10;11;12;13");
 306 }
 307
 308 TEST(Future, thenTry) {
 309   bool flag = false;
 310
 311   makeFuture<int>(42).then([&](Try<int>&& t) {
 312                               flag = true;
 313                               EXPECT_EQ(42, t.value());
 314                             });
 315   EXPECT_TRUE(flag); flag = false;
 316
 317   makeFuture<int>(42)
 318     .then([](Try<int>&& t) { return t.value(); })
 319     .then([&](Try<int>&& t) { flag = true; EXPECT_EQ(42, t.value()); });
 320   EXPECT_TRUE(flag); flag = false;
 321
 322   makeFuture().then([&](Try<void>&& t) { flag = true; t.value(); });
 323   EXPECT_TRUE(flag); flag = false;
 324
 325   Promise<void> p;
 326   auto f = p.getFuture().then([&](Try<void>&& t) { flag = true; });
 327   EXPECT_FALSE(flag);
 328   EXPECT_FALSE(f.isReady());
 329   p.setValue();
 330   EXPECT_TRUE(flag);
 331   EXPECT_TRUE(f.isReady());
 332 }
 333
 334 TEST(Future, thenValue) {
 335   bool flag = false;
 336   makeFuture<int>(42).then([&](int i){
 337     EXPECT_EQ(42, i);
 338     flag = true;
 339   });
 340   EXPECT_TRUE(flag); flag = false;
 341
 342   makeFuture<int>(42)
 343     .then([](int i){ return i; })
 344     .then([&](int i) { flag = true; EXPECT_EQ(42, i); });
 345   EXPECT_TRUE(flag); flag = false;
 346
 347   makeFuture().then([&]{
 348     flag = true;
 349   });
 350   EXPECT_TRUE(flag); flag = false;
 351
 352   auto f = makeFuture<int>(eggs).then([&](int i){});
 353   EXPECT_THROW(f.value(), eggs_t);
 354
 355   f = makeFuture<void>(eggs).then([&]{});
 356   EXPECT_THROW(f.value(), eggs_t);
 357 }
 358
 359 TEST(Future, thenValueFuture) {
 360   bool flag = false;
 361   makeFuture<int>(42)
 362     .then([](int i){ return makeFuture<int>(std::move(i)); })
 363     .then([&](Try<int>&& t) { flag = true; EXPECT_EQ(42, t.value()); });
 364   EXPECT_TRUE(flag); flag = false;
 365
 366   makeFuture()
 367     .then([]{ return makeFuture(); })
 368     .then([&](Try<void>&& t) { flag = true; });
 369   EXPECT_TRUE(flag); flag = false;
 370 }
 371
 372 static string doWorkStatic(Try<string>&& t) {
 373   return t.value() + ";static";
 374 }
 375
 376 TEST(Future, thenFunction) {
 377   struct Worker {
 378     string doWork(Try<string>&& t) {
 379       return t.value() + ";class";
 380     }
 381     static string doWorkStatic(Try<string>&& t) {
 382       return t.value() + ";class-static";
 383     }
 384   } w;
 385
 386   auto f = makeFuture<string>("start")
 387     .then(doWorkStatic)
 388     .then(Worker::doWorkStatic)
 389     .then(&Worker::doWork, &w);
 390
 391   EXPECT_EQ(f.value(), "start;static;class-static;class");
 392 }
 393
 394 static Future<string> doWorkStaticFuture(Try<string>&& t) {
 395   return makeFuture(t.value() + ";static");
 396 }
 397
 398 TEST(Future, thenFunctionFuture) {
 399   struct Worker {
 400     Future<string> doWorkFuture(Try<string>&& t) {
 401       return makeFuture(t.value() + ";class");
 402     }
 403     static Future<string> doWorkStaticFuture(Try<string>&& t) {
 404       return makeFuture(t.value() + ";class-static");
 405     }
 406   } w;
 407
 408   auto f = makeFuture<string>("start")
 409     .then(doWorkStaticFuture)
 410     .then(Worker::doWorkStaticFuture)
 411     .then(&Worker::doWorkFuture, &w);
 412
 413   EXPECT_EQ(f.value(), "start;static;class-static;class");
 414 }
 415
 416 TEST(Future, thenBind) {
 417   auto l = []() {
 418     return makeFuture("bind");
 419   };
 420   auto b = std::bind(l);
 421   auto f = makeFuture().then(std::move(b));
 422   EXPECT_EQ(f.value(), "bind");
 423 }
 424
 425 TEST(Future, thenBindTry) {
 426   auto l = [](Try<string>&& t) {
 427     return makeFuture(t.value() + ";bind");
 428   };
 429   auto b = std::bind(l, std::placeholders::_1);
 430   auto f = makeFuture<string>("start").then(std::move(b));
 431
 432   EXPECT_EQ(f.value(), "start;bind");
 433 }
 434
 435 TEST(Future, value) {
 436   auto f = makeFuture(unique_ptr<int>(new int(42)));
 437   auto up = std::move(f.value());
 438   EXPECT_EQ(42, *up);
 439
 440   EXPECT_THROW(makeFuture<int>(eggs).value(), eggs_t);
 441 }
 442
 443 TEST(Future, isReady) {
 444   Promise<int> p;
 445   auto f = p.getFuture();
 446   EXPECT_FALSE(f.isReady());
 447   p.setValue(42);
 448   EXPECT_TRUE(f.isReady());
 449   }
 450
 451 TEST(Future, futureNotReady) {
 452   Promise<int> p;
 453   Future<int> f = p.getFuture();
 454   EXPECT_THROW(f.value(), eggs_t);
 455 }
 456
 457 TEST(Future, hasException) {
 458   EXPECT_TRUE(makeFuture<int>(eggs).getTry().hasException());
 459   EXPECT_FALSE(makeFuture(42).getTry().hasException());
 460 }
 461
 462 TEST(Future, hasValue) {
 463   EXPECT_TRUE(makeFuture(42).getTry().hasValue());
 464   EXPECT_FALSE(makeFuture<int>(eggs).getTry().hasValue());
 465 }
 466
 467 TEST(Future, makeFuture) {
 468   EXPECT_TYPE(makeFuture(42), Future<int>);
 469   EXPECT_EQ(42, makeFuture(42).value());
 470
 471   EXPECT_TYPE(makeFuture<float>(42), Future<float>);
 472   EXPECT_EQ(42, makeFuture<float>(42).value());
 473
 474   auto fun = [] { return 42; };
 475   EXPECT_TYPE(makeFutureTry(fun), Future<int>);
 476   EXPECT_EQ(42, makeFutureTry(fun).value());
 477
 478   auto failfun = []() -> int { throw eggs; };
 479   EXPECT_TYPE(makeFutureTry(failfun), Future<int>);
 480   EXPECT_THROW(makeFutureTry(failfun).value(), eggs_t);
 481
 482   EXPECT_TYPE(makeFuture(), Future<void>);
 483 }
 484
 485 // Promise
 486
 487 TEST(Promise, special) {
 488   EXPECT_FALSE(std::is_copy_constructible<Promise<int>>::value);
 489   EXPECT_FALSE(std::is_copy_assignable<Promise<int>>::value);
 490   EXPECT_TRUE(std::is_move_constructible<Promise<int>>::value);
 491   EXPECT_TRUE(std::is_move_assignable<Promise<int>>::value);
 492 }
 493
 494 TEST(Promise, getFuture) {
 495   Promise<int> p;
 496   Future<int> f = p.getFuture();
 497   EXPECT_FALSE(f.isReady());
 498 }
 499
 500 TEST(Promise, setValue) {
 501   Promise<int> fund;
 502   auto ffund = fund.getFuture();
 503   fund.setValue(42);
 504   EXPECT_EQ(42, ffund.value());
 505
 506   struct Foo {
 507     string name;
 508     int value;
 509   };
 510
 511   Promise<Foo> pod;
 512   auto fpod = pod.getFuture();
 513   Foo f = {"the answer", 42};
 514   pod.setValue(f);
 515   Foo f2 = fpod.value();
 516   EXPECT_EQ(f.name, f2.name);
 517   EXPECT_EQ(f.value, f2.value);
 518
 519   pod = Promise<Foo>();
 520   fpod = pod.getFuture();
 521   pod.setValue(std::move(f2));
 522   Foo f3 = fpod.value();
 523   EXPECT_EQ(f.name, f3.name);
 524   EXPECT_EQ(f.value, f3.value);
 525
 526   Promise<unique_ptr<int>> mov;
 527   auto fmov = mov.getFuture();
 528   mov.setValue(unique_ptr<int>(new int(42)));
 529   unique_ptr<int> ptr = std::move(fmov.value());
 530   EXPECT_EQ(42, *ptr);
 531
 532   Promise<void> v;
 533   auto fv = v.getFuture();
 534   v.setValue();
 535   EXPECT_TRUE(fv.isReady());
 536 }
 537
 538 TEST(Promise, setException) {
 539   {
 540     Promise<void> p;
 541     auto f = p.getFuture();
 542     p.setException(eggs);
 543     EXPECT_THROW(f.value(), eggs_t);
 544   }
 545   {
 546     Promise<void> p;
 547     auto f = p.getFuture();
 548     try {
 549       throw eggs;
 550     } catch (...) {
 551       p.setException(exception_wrapper(std::current_exception()));
 552     }
 553     EXPECT_THROW(f.value(), eggs_t);
 554   }
 555 }
 556
 557 TEST(Promise, fulfil) {
 558   {
 559     Promise<int> p;
 560     auto f = p.getFuture();
 561     p.fulfil([] { return 42; });
 562     EXPECT_EQ(42, f.value());
 563   }
 564   {
 565     Promise<int> p;
 566     auto f = p.getFuture();
 567     p.fulfil([]() -> int { throw eggs; });
 568     EXPECT_THROW(f.value(), eggs_t);
 569   }
 570 }
 571
 572 TEST(Future, finish) {
 573   auto x = std::make_shared<int>(0);
 574   {
 575     Promise<int> p;
 576     auto f = p.getFuture().then([x](Try<int>&& t) { *x = t.value(); });
 577
 578     // The callback hasn't executed
 579     EXPECT_EQ(0, *x);
 580
 581     // The callback has a reference to x
 582     EXPECT_EQ(2, x.use_count());
 583
 584     p.setValue(42);
 585
 586     // the callback has executed
 587     EXPECT_EQ(42, *x);
 588   }
 589   // the callback has been destructed
 590   // and has released its reference to x
 591   EXPECT_EQ(1, x.use_count());
 592 }
 593
 594 TEST(Future, unwrap) {
 595   Promise<int> a;
 596   Promise<int> b;
 597
 598   auto fa = a.getFuture();
 599   auto fb = b.getFuture();
 600
 601   bool flag1 = false;
 602   bool flag2 = false;
 603
 604   // do a, then do b, and get the result of a + b.
 605   Future<int> f = fa.then([&](Try<int>&& ta) {
 606     auto va = ta.value();
 607     flag1 = true;
 608     return fb.then([va, &flag2](Try<int>&& tb) {
 609       flag2 = true;
 610       return va + tb.value();
 611     });
 612   });
 613
 614   EXPECT_FALSE(flag1);
 615   EXPECT_FALSE(flag2);
 616   EXPECT_FALSE(f.isReady());
 617
 618   a.setValue(3);
 619   EXPECT_TRUE(flag1);
 620   EXPECT_FALSE(flag2);
 621   EXPECT_FALSE(f.isReady());
 622
 623   b.setValue(4);
 624   EXPECT_TRUE(flag1);
 625   EXPECT_TRUE(flag2);
 626   EXPECT_EQ(7, f.value());
 627 }
 628
 629 TEST(Future, whenAll) {
 630   // returns a vector variant
 631   {
 632     vector<Promise<int>> promises(10);
 633     vector<Future<int>> futures;
 634
 635     for (auto& p : promises)
 636       futures.push_back(p.getFuture());
 637
 638     auto allf = whenAll(futures.begin(), futures.end());
 639
 640     random_shuffle(promises.begin(), promises.end());
 641     for (auto& p : promises) {
 642       EXPECT_FALSE(allf.isReady());
 643       p.setValue(42);
 644     }
 645
 646     EXPECT_TRUE(allf.isReady());
 647     auto& results = allf.value();
 648     for (auto& t : results) {
 649       EXPECT_EQ(42, t.value());
 650     }
 651   }
 652
 653   // check error semantics
 654   {
 655     vector<Promise<int>> promises(4);
 656     vector<Future<int>> futures;
 657
 658     for (auto& p : promises)
 659       futures.push_back(p.getFuture());
 660
 661     auto allf = whenAll(futures.begin(), futures.end());
 662
 663
 664     promises[0].setValue(42);
 665     promises[1].setException(eggs);
 666
 667     EXPECT_FALSE(allf.isReady());
 668
 669     promises[2].setValue(42);
 670
 671     EXPECT_FALSE(allf.isReady());
 672
 673     promises[3].setException(eggs);
 674
 675     EXPECT_TRUE(allf.isReady());
 676     EXPECT_FALSE(allf.getTry().hasException());
 677
 678     auto& results = allf.value();
 679     EXPECT_EQ(42, results[0].value());
 680     EXPECT_TRUE(results[1].hasException());
 681     EXPECT_EQ(42, results[2].value());
 682     EXPECT_TRUE(results[3].hasException());
 683   }
 684
 685   // check that futures are ready in then()
 686   {
 687     vector<Promise<void>> promises(10);
 688     vector<Future<void>> futures;
 689
 690     for (auto& p : promises)
 691       futures.push_back(p.getFuture());
 692
 693     auto allf = whenAll(futures.begin(), futures.end())
 694       .then([](Try<vector<Try<void>>>&& ts) {
 695         for (auto& f : ts.value())
 696           f.value();
 697       });
 698
 699     random_shuffle(promises.begin(), promises.end());
 700     for (auto& p : promises)
 701       p.setValue();
 702     EXPECT_TRUE(allf.isReady());
 703   }
 704 }
 705
 706
 707 TEST(Future, whenAny) {
 708   {
 709     vector<Promise<int>> promises(10);
 710     vector<Future<int>> futures;
 711
 712     for (auto& p : promises)
 713       futures.push_back(p.getFuture());
 714
 715     for (auto& f : futures) {
 716       EXPECT_FALSE(f.isReady());
 717     }
 718
 719     auto anyf = whenAny(futures.begin(), futures.end());
 720
 721     /* futures were moved in, so these are invalid now */
 722     EXPECT_FALSE(anyf.isReady());
 723
 724     promises[7].setValue(42);
 725     EXPECT_TRUE(anyf.isReady());
 726     auto& idx_fut = anyf.value();
 727
 728     auto i = idx_fut.first;
 729     EXPECT_EQ(7, i);
 730
 731     auto& f = idx_fut.second;
 732     EXPECT_EQ(42, f.value());
 733   }
 734
 735   // error
 736   {
 737     vector<Promise<void>> promises(10);
 738     vector<Future<void>> futures;
 739
 740     for (auto& p : promises)
 741       futures.push_back(p.getFuture());
 742
 743     for (auto& f : futures) {
 744       EXPECT_FALSE(f.isReady());
 745     }
 746
 747     auto anyf = whenAny(futures.begin(), futures.end());
 748
 749     EXPECT_FALSE(anyf.isReady());
 750
 751     promises[3].setException(eggs);
 752     EXPECT_TRUE(anyf.isReady());
 753     EXPECT_TRUE(anyf.value().second.hasException());
 754   }
 755
 756   // then()
 757   {
 758     vector<Promise<int>> promises(10);
 759     vector<Future<int>> futures;
 760
 761     for (auto& p : promises)
 762       futures.push_back(p.getFuture());
 763
 764     auto anyf = whenAny(futures.begin(), futures.end())
 765       .then([](pair<size_t, Try<int>> p) {
 766         EXPECT_EQ(42, p.second.value());
 767       });
 768
 769     promises[3].setValue(42);
 770     EXPECT_TRUE(anyf.isReady());
 771   }
 772 }
 773
 774
 775 TEST(when, already_completed) {
 776   {
 777     vector<Future<void>> fs;
 778     for (int i = 0; i < 10; i++)
 779       fs.push_back(makeFuture());
 780
 781     whenAll(fs.begin(), fs.end())
 782       .then([&](vector<Try<void>> ts) {
 783         EXPECT_EQ(fs.size(), ts.size());
 784       });
 785   }
 786   {
 787     vector<Future<int>> fs;
 788     for (int i = 0; i < 10; i++)
 789       fs.push_back(makeFuture(i));
 790
 791     whenAny(fs.begin(), fs.end())
 792       .then([&](pair<size_t, Try<int>> p) {
 793         EXPECT_EQ(p.first, p.second.value());
 794       });
 795   }
 796 }
 797
 798 TEST(when, whenN) {
 799   vector<Promise<void>> promises(10);
 800   vector<Future<void>> futures;
 801
 802   for (auto& p : promises)
 803     futures.push_back(p.getFuture());
 804
 805   bool flag = false;
 806   size_t n = 3;
 807   whenN(futures.begin(), futures.end(), n)
 808     .then([&](vector<pair<size_t, Try<void>>> v) {
 809       flag = true;
 810       EXPECT_EQ(n, v.size());
 811       for (auto& tt : v)
 812         EXPECT_TRUE(tt.second.hasValue());
 813     });
 814
 815   promises[0].setValue();
 816   EXPECT_FALSE(flag);
 817   promises[1].setValue();
 818   EXPECT_FALSE(flag);
 819   promises[2].setValue();
 820   EXPECT_TRUE(flag);
 821 }
 822
 823 /* Ensure that we can compile when_{all,any} with folly::small_vector */
 824 TEST(when, small_vector) {
 825
 826   static_assert(!FOLLY_IS_TRIVIALLY_COPYABLE(Future<void>),
 827                 "Futures should not be trivially copyable");
 828   static_assert(!FOLLY_IS_TRIVIALLY_COPYABLE(Future<int>),
 829                 "Futures should not be trivially copyable");
 830
 831   using folly::small_vector;
 832   {
 833     small_vector<Future<void>> futures;
 834
 835     for (int i = 0; i < 10; i++)
 836       futures.push_back(makeFuture());
 837
 838     auto anyf = whenAny(futures.begin(), futures.end());
 839   }
 840
 841   {
 842     small_vector<Future<void>> futures;
 843
 844     for (int i = 0; i < 10; i++)
 845       futures.push_back(makeFuture());
 846
 847     auto allf = whenAll(futures.begin(), futures.end());
 848   }
 849 }
 850
 851 TEST(Future, whenAllVariadic) {
 852   Promise<bool> pb;
 853   Promise<int> pi;
 854   Future<bool> fb = pb.getFuture();
 855   Future<int> fi = pi.getFuture();
 856   bool flag = false;
 857   whenAll(std::move(fb), std::move(fi))
 858     .then([&](std::tuple<Try<bool>, Try<int>> tup) {
 859       flag = true;
 860       EXPECT_TRUE(std::get<0>(tup).hasValue());
 861       EXPECT_EQ(std::get<0>(tup).value(), true);
 862       EXPECT_TRUE(std::get<1>(tup).hasValue());
 863       EXPECT_EQ(std::get<1>(tup).value(), 42);
 864     });
 865   pb.setValue(true);
 866   EXPECT_FALSE(flag);
 867   pi.setValue(42);
 868   EXPECT_TRUE(flag);
 869 }
 870
 871 TEST(Future, whenAllVariadicReferences) {
 872   Promise<bool> pb;
 873   Promise<int> pi;
 874   Future<bool> fb = pb.getFuture();
 875   Future<int> fi = pi.getFuture();
 876   bool flag = false;
 877   whenAll(fb, fi)
 878     .then([&](std::tuple<Try<bool>, Try<int>> tup) {
 879       flag = true;
 880       EXPECT_TRUE(std::get<0>(tup).hasValue());
 881       EXPECT_EQ(std::get<0>(tup).value(), true);
 882       EXPECT_TRUE(std::get<1>(tup).hasValue());
 883       EXPECT_EQ(std::get<1>(tup).value(), 42);
 884     });
 885   pb.setValue(true);
 886   EXPECT_FALSE(flag);
 887   pi.setValue(42);
 888   EXPECT_TRUE(flag);
 889 }
 890
 891 TEST(Future, whenAll_none) {
 892   vector<Future<int>> fs;
 893   auto f = whenAll(fs.begin(), fs.end());
 894   EXPECT_TRUE(f.isReady());
 895 }
 896
 897 TEST(Future, throwCaughtInImmediateThen) {
 898   // Neither of these should throw "Promise already satisfied"
 899   makeFuture().then(
 900     [=](Try<void>&&) -> int { throw std::exception(); });
 901   makeFuture().then(
 902     [=](Try<void>&&) -> Future<int> { throw std::exception(); });
 903 }
 904
 905 TEST(Future, throwIfFailed) {
 906   makeFuture<void>(eggs)
 907     .then([=](Try<void>&& t) {
 908       EXPECT_THROW(t.throwIfFailed(), eggs_t);
 909     });
 910   makeFuture()
 911     .then([=](Try<void>&& t) {
 912       EXPECT_NO_THROW(t.throwIfFailed());
 913     });
 914
 915   makeFuture<int>(eggs)
 916     .then([=](Try<int>&& t) {
 917       EXPECT_THROW(t.throwIfFailed(), eggs_t);
 918     });
 919   makeFuture<int>(42)
 920     .then([=](Try<int>&& t) {
 921       EXPECT_NO_THROW(t.throwIfFailed());
 922     });
 923 }
 924
 925 TEST(Future, waitImmediate) {
 926   makeFuture().wait();
 927   auto done = makeFuture(42).wait().value();
 928   EXPECT_EQ(42, done);
 929
 930   vector<int> v{1,2,3};
 931   auto done_v = makeFuture(v).wait().value();
 932   EXPECT_EQ(v.size(), done_v.size());
 933   EXPECT_EQ(v, done_v);
 934
 935   vector<Future<void>> v_f;
 936   v_f.push_back(makeFuture());
 937   v_f.push_back(makeFuture());
 938   auto done_v_f = whenAll(v_f.begin(), v_f.end()).wait().value();
 939   EXPECT_EQ(2, done_v_f.size());
 940
 941   vector<Future<bool>> v_fb;
 942   v_fb.push_back(makeFuture(true));
 943   v_fb.push_back(makeFuture(false));
 944   auto fut = whenAll(v_fb.begin(), v_fb.end());
 945   auto done_v_fb = std::move(fut.wait().value());
 946   EXPECT_EQ(2, done_v_fb.size());
 947 }
 948
 949 TEST(Future, wait) {
 950   Promise<int> p;
 951   Future<int> f = p.getFuture();
 952   std::atomic<bool> flag{false};
 953   std::atomic<int> result{1};
 954   std::atomic<std::thread::id> id;
 955
 956   std::thread t([&](Future<int>&& tf){
 957       auto n = tf.then([&](Try<int> && t) {
 958           id = std::this_thread::get_id();
 959           return t.value();
 960         });
 961       flag = true;
 962       result.store(n.wait().value());
 963     },
 964     std::move(f)
 965     );
 966   while(!flag){}
 967   EXPECT_EQ(result.load(), 1);
 968   p.setValue(42);
 969   t.join();
 970   // validate that the callback ended up executing in this thread, which
 971   // is more to ensure that this test actually tests what it should
 972   EXPECT_EQ(id, std::this_thread::get_id());
 973   EXPECT_EQ(result.load(), 42);
 974 }
 975
 976 struct MoveFlag {
 977   MoveFlag() = default;
 978   MoveFlag(const MoveFlag&) = delete;
 979   MoveFlag(MoveFlag&& other) noexcept {
 980     other.moved = true;
 981   }
 982   bool moved{false};
 983 };
 984
 985 TEST(Future, waitReplacesSelf) {
 986   // wait
 987   {
 988     // lvalue
 989     auto f1 = makeFuture(MoveFlag());
 990     f1.wait();
 991     EXPECT_FALSE(f1.value().moved);
 992
 993     // rvalue
 994     auto f2 = makeFuture(MoveFlag()).wait();
 995     EXPECT_FALSE(f2.value().moved);
 996   }
 997
 998   // wait(Duration)
 999   {
1000     // lvalue
1001     auto f1 = makeFuture(MoveFlag());
1002     f1.wait(milliseconds(1));
1003     EXPECT_FALSE(f1.value().moved);
1004
1005     // rvalue
1006     auto f2 = makeFuture(MoveFlag()).wait(milliseconds(1));
1007     EXPECT_FALSE(f2.value().moved);
1008   }
1009
1010   // waitVia
1011   {
1012     folly::EventBase eb;
1013     // lvalue
1014     auto f1 = makeFuture(MoveFlag());
1015     f1.waitVia(&eb);
1016     EXPECT_FALSE(f1.value().moved);
1017
1018     // rvalue
1019     auto f2 = makeFuture(MoveFlag()).waitVia(&eb);
1020     EXPECT_FALSE(f2.value().moved);
1021   }
1022 }
1023
1024 TEST(Future, waitWithDuration) {
1025  {
1026   Promise<int> p;
1027   Future<int> f = p.getFuture();
1028   f.wait(milliseconds(1));
1029   EXPECT_FALSE(f.isReady());
1030   p.setValue(1);
1031   EXPECT_TRUE(f.isReady());
1032  }
1033  {
1034   Promise<int> p;
1035   Future<int> f = p.getFuture();
1036   p.setValue(1);
1037   f.wait(milliseconds(1));
1038   EXPECT_TRUE(f.isReady());
1039  }
1040  {
1041   vector<Future<bool>> v_fb;
1042   v_fb.push_back(makeFuture(true));
1043   v_fb.push_back(makeFuture(false));
1044   auto f = whenAll(v_fb.begin(), v_fb.end());
1045   f.wait(milliseconds(1));
1046   EXPECT_TRUE(f.isReady());
1047   EXPECT_EQ(2, f.value().size());
1048  }
1049  {
1050   vector<Future<bool>> v_fb;
1051   Promise<bool> p1;
1052   Promise<bool> p2;
1053   v_fb.push_back(p1.getFuture());
1054   v_fb.push_back(p2.getFuture());
1055   auto f = whenAll(v_fb.begin(), v_fb.end());
1056   f.wait(milliseconds(1));
1057   EXPECT_FALSE(f.isReady());
1058   p1.setValue(true);
1059   EXPECT_FALSE(f.isReady());
1060   p2.setValue(true);
1061   EXPECT_TRUE(f.isReady());
1062  }
1063  {
1064   auto f = makeFuture().wait(milliseconds(1));
1065   EXPECT_TRUE(f.isReady());
1066  }
1067
1068  {
1069    Promise<void> p;
1070    auto start = std::chrono::steady_clock::now();
1071    auto f = p.getFuture().wait(milliseconds(100));
1072    auto elapsed = std::chrono::steady_clock::now() - start;
1073    EXPECT_GE(elapsed, milliseconds(100));
1074    EXPECT_FALSE(f.isReady());
1075    p.setValue();
1076    EXPECT_TRUE(f.isReady());
1077  }
1078
1079  {
1080    // Try to trigger the race where the resultant Future is not yet complete
1081    // even if we didn't hit the timeout, and make sure we deal with it properly
1082    Promise<void> p;
1083    folly::Baton<> b;
1084    auto t = std::thread([&]{
1085      b.post();
1086      /* sleep override */ std::this_thread::sleep_for(milliseconds(100));
1087      p.setValue();
1088    });
1089    b.wait();
1090    auto f = p.getFuture().wait(std::chrono::seconds(3600));
1091    EXPECT_TRUE(f.isReady());
1092    t.join();
1093  }
1094 }
1095
1096 class DummyDrivableExecutor : public DrivableExecutor {
1097  public:
1098   void add(Func f) override {}
1099   void drive() override { ran = true; }
1100   bool ran{false};
1101 };
1102
1103 TEST(Future, getVia) {
1104   {
1105     // non-void
1106     ManualExecutor x;
1107     auto f = via(&x).then([]{ return true; });
1108     EXPECT_TRUE(f.getVia(&x));
1109   }
1110
1111   {
1112     // void
1113     ManualExecutor x;
1114     auto f = via(&x).then();
1115     f.getVia(&x);
1116   }
1117
1118   {
1119     DummyDrivableExecutor x;
1120     auto f = makeFuture(true);
1121     EXPECT_TRUE(f.getVia(&x));
1122     EXPECT_FALSE(x.ran);
1123   }
1124 }
1125
1126 TEST(Future, waitVia) {
1127   {
1128     ManualExecutor x;
1129     auto f = via(&x).then();
1130     EXPECT_FALSE(f.isReady());
1131     f.waitVia(&x);
1132     EXPECT_TRUE(f.isReady());
1133   }
1134
1135   {
1136     // try rvalue as well
1137     ManualExecutor x;
1138     auto f = via(&x).then().waitVia(&x);
1139     EXPECT_TRUE(f.isReady());
1140   }
1141
1142   {
1143     DummyDrivableExecutor x;
1144     makeFuture(true).waitVia(&x);
1145     EXPECT_FALSE(x.ran);
1146   }
1147 }
1148
1149 TEST(Future, viaRaces) {
1150   ManualExecutor x;
1151   Promise<void> p;
1152   auto tid = std::this_thread::get_id();
1153   bool done = false;
1154
1155   std::thread t1([&] {
1156     p.getFuture()
1157       .via(&x)
1158       .then([&](Try<void>&&) { EXPECT_EQ(tid, std::this_thread::get_id()); })
1159       .then([&](Try<void>&&) { EXPECT_EQ(tid, std::this_thread::get_id()); })
1160       .then([&](Try<void>&&) { done = true; });
1161   });
1162
1163   std::thread t2([&] {
1164     p.setValue();
1165   });
1166
1167   while (!done) x.run();
1168   t1.join();
1169   t2.join();
1170 }
1171
1172 TEST(Future, getFuture_after_setValue) {
1173   Promise<int> p;
1174   p.setValue(42);
1175   EXPECT_EQ(42, p.getFuture().value());
1176 }
1177
1178 TEST(Future, getFuture_after_setException) {
1179   Promise<void> p;
1180   p.fulfil([]() -> void { throw std::logic_error("foo"); });
1181   EXPECT_THROW(p.getFuture().value(), std::logic_error);
1182 }
1183
1184 TEST(Future, detachRace) {
1185   // Task #5438209
1186   // This test is designed to detect a race that was in Core::detachOne()
1187   // where detached_ was incremented and then tested, and that
1188   // allowed a race where both Promise and Future would think they were the
1189   // second and both try to delete. This showed up at scale but was very
1190   // difficult to reliably repro in a test. As it is, this only fails about
1191   // once in every 1,000 executions. Doing this 1,000 times is going to make a
1192   // slow test so I won't do that but if it ever fails, take it seriously, and
1193   // run the test binary with "--gtest_repeat=10000 --gtest_filter=*detachRace"
1194   // (Don't forget to enable ASAN)
1195   auto p = folly::make_unique<Promise<bool>>();
1196   auto f = folly::make_unique<Future<bool>>(p->getFuture());
1197   folly::Baton<> baton;
1198   std::thread t1([&]{
1199     baton.post();
1200     p.reset();
1201   });
1202   baton.wait();
1203   f.reset();
1204   t1.join();
1205 }
1206
1207 class TestData : public RequestData {
1208  public:
1209   explicit TestData(int data) : data_(data) {}
1210   virtual ~TestData() {}
1211   int data_;
1212 };
1213
1214 TEST(Future, context) {
1215
1216   // Start a new context
1217   RequestContext::create();
1218
1219   EXPECT_EQ(nullptr, RequestContext::get()->getContextData("test"));
1220
1221   // Set some test data
1222   RequestContext::get()->setContextData(
1223     "test",
1224     std::unique_ptr<TestData>(new TestData(10)));
1225
1226   // Start a future
1227   Promise<void> p;
1228   auto future = p.getFuture().then([&]{
1229     // Check that the context followed the future
1230     EXPECT_TRUE(RequestContext::get() != nullptr);
1231     auto a = dynamic_cast<TestData*>(
1232       RequestContext::get()->getContextData("test"));
1233     auto data = a->data_;
1234     EXPECT_EQ(10, data);
1235   });
1236
1237   // Clear the context
1238   RequestContext::setContext(nullptr);
1239
1240   EXPECT_EQ(nullptr, RequestContext::get()->getContextData("test"));
1241
1242   // Fulfil the promise
1243   p.setValue();
1244 }
1245
1246
1247 // This only fails about 1 in 1k times when the bug is present :(
1248 TEST(Future, t5506504) {
1249   ThreadExecutor x;
1250
1251   auto fn = [&x]{
1252     auto promises = std::make_shared<vector<Promise<void>>>(4);
1253     vector<Future<void>> futures;
1254
1255     for (auto& p : *promises) {
1256       futures.emplace_back(
1257         p.getFuture()
1258         .via(&x)
1259         .then([](Try<void>&&){}));
1260     }
1261
1262     x.waitForStartup();
1263     x.add([promises]{
1264       for (auto& p : *promises) p.setValue();
1265     });
1266
1267     return whenAll(futures.begin(), futures.end());
1268   };
1269
1270   fn().wait();
1271 }
1272
1273 // Test of handling of a circular dependency. It's never recommended
1274 // to have one because of possible memory leaks. Here we test that
1275 // we can handle freeing of the Future while it is running.
1276 TEST(Future, CircularDependencySharedPtrSelfReset) {
1277   Promise<int64_t> promise;
1278   auto ptr = std::make_shared<Future<int64_t>>(promise.getFuture());
1279
1280   ptr->then(
1281     [ptr] (folly::Try<int64_t>&& uid) mutable {
1282       EXPECT_EQ(1, ptr.use_count());
1283
1284       // Leaving no references to ourselves.
1285       ptr.reset();
1286       EXPECT_EQ(0, ptr.use_count());
1287     }
1288   );
1289
1290   EXPECT_EQ(2, ptr.use_count());
1291
1292   ptr.reset();
1293
1294   promise.fulfil([]{return 1l;});
1295 }
1296
1297 TEST(Future, Constructor) {
1298   auto f1 = []() -> Future<int> { return Future<int>(3); }();
1299   EXPECT_EQ(f1.value(), 3);
1300   auto f2 = []() -> Future<void> { return Future<void>(); }();
1301   EXPECT_NO_THROW(f2.value());
1302 }
1303
1304 TEST(Future, ImplicitConstructor) {
1305   auto f1 = []() -> Future<int> { return 3; }();
1306   EXPECT_EQ(f1.value(), 3);
1307   // Unfortunately, the C++ standard does not allow the
1308   // following implicit conversion to work:
1309   //auto f2 = []() -> Future<void> { }();
1310 }
1311
1312 TEST(Future, via_then_get_was_racy) {
1313   ThreadExecutor x;
1314   std::unique_ptr<int> val = folly::via(&x)
1315     .then([] { return folly::make_unique<int>(42); })
1316     .get();
1317   ASSERT_TRUE(!!val);
1318   EXPECT_EQ(42, *val);
1319 }