folly/futures/test/FutureSplitterTest.cpp

   1 /*
   2  * Copyright 2017 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 <folly/futures/FutureSplitter.h>
  18 #include <folly/portability/GTest.h>
  19
  20 using namespace folly;
  21
  22 TEST(FutureSplitter, splitFutureSuccess) {
  23   Promise<int> p;
  24   FutureSplitter<int> sp(p.getFuture());
  25   auto f1 = sp.getFuture();
  26   EXPECT_FALSE(f1.isReady());
  27   p.setValue(1);
  28   EXPECT_TRUE(f1.isReady());
  29   EXPECT_TRUE(f1.hasValue());
  30   auto f2 = sp.getFuture();
  31   EXPECT_TRUE(f2.isReady());
  32   EXPECT_TRUE(f2.hasValue());
  33 }
  34
  35 TEST(FutureSplitter, splitFutureCopyable) {
  36   Promise<int> p;
  37   FutureSplitter<int> sp1(p.getFuture());
  38   FutureSplitter<int> sp2(sp1);
  39   auto f1 = sp1.getFuture();
  40   EXPECT_FALSE(f1.isReady());
  41   p.setValue(1);
  42   EXPECT_TRUE(f1.isReady());
  43   EXPECT_TRUE(f1.hasValue());
  44   auto f2 = sp2.getFuture();
  45   EXPECT_TRUE(f2.isReady());
  46   EXPECT_TRUE(f2.hasValue());
  47   FutureSplitter<int> sp3(sp1);
  48   auto f3 = sp3.getFuture();
  49   EXPECT_TRUE(f3.isReady());
  50   EXPECT_TRUE(f3.hasValue());
  51 }
  52
  53 TEST(FutureSplitter, splitFutureMovable) {
  54   Promise<int> p;
  55   FutureSplitter<int> sp1(p.getFuture());
  56   auto f1 = sp1.getFuture();
  57   FutureSplitter<int> sp2(std::move(sp1));
  58   EXPECT_FALSE(f1.isReady());
  59   p.setValue(1);
  60   EXPECT_TRUE(f1.isReady());
  61   EXPECT_TRUE(f1.hasValue());
  62   auto f2 = sp2.getFuture();
  63   EXPECT_TRUE(f2.isReady());
  64   EXPECT_TRUE(f2.hasValue());
  65   FutureSplitter<int> sp3(std::move(sp2));
  66   auto f3 = sp3.getFuture();
  67   EXPECT_TRUE(f3.isReady());
  68   EXPECT_TRUE(f3.hasValue());
  69 }
  70
  71 TEST(FutureSplitter, splitFutureCopyAssignable) {
  72   Promise<int> p;
  73   FutureSplitter<int> sp1(p.getFuture());
  74   FutureSplitter<int> sp2{};
  75   sp2 = sp1;
  76   auto f1 = sp1.getFuture();
  77   EXPECT_FALSE(f1.isReady());
  78   p.setValue(1);
  79   EXPECT_TRUE(f1.isReady());
  80   EXPECT_TRUE(f1.hasValue());
  81   auto f2 = sp2.getFuture();
  82   EXPECT_TRUE(f2.isReady());
  83   EXPECT_TRUE(f2.hasValue());
  84   FutureSplitter<int> sp3(sp1);
  85   auto f3 = sp3.getFuture();
  86   EXPECT_TRUE(f3.isReady());
  87   EXPECT_TRUE(f3.hasValue());
  88 }
  89
  90 TEST(FutureSplitter, splitFutureMoveAssignable) {
  91   Promise<int> p;
  92   FutureSplitter<int> sp1(p.getFuture());
  93   auto f1 = sp1.getFuture();
  94   FutureSplitter<int> sp2{};
  95   sp2 = std::move(sp1);
  96   EXPECT_FALSE(f1.isReady());
  97   p.setValue(1);
  98   EXPECT_TRUE(f1.isReady());
  99   EXPECT_TRUE(f1.hasValue());
 100   auto f2 = sp2.getFuture();
 101   EXPECT_TRUE(f2.isReady());
 102   EXPECT_TRUE(f2.hasValue());
 103   FutureSplitter<int> sp3(std::move(sp2));
 104   auto f3 = sp3.getFuture();
 105   EXPECT_TRUE(f3.isReady());
 106   EXPECT_TRUE(f3.hasValue());
 107 }
 108
 109 TEST(FutureSplitter, splitFutureScope) {
 110   Promise<int> p;
 111   auto pSP = make_unique<FutureSplitter<int>>(p.getFuture());
 112   auto f1 = pSP->getFuture();
 113   EXPECT_FALSE(f1.isReady());
 114   pSP.reset();
 115   EXPECT_NO_THROW(EXPECT_FALSE(f1.isReady()));
 116   p.setValue(1);
 117   EXPECT_TRUE(f1.isReady());
 118   EXPECT_TRUE(f1.hasValue());
 119   EXPECT_EQ(1, f1.get());
 120 }
 121
 122 TEST(FutureSplitter, splitFutureFailure) {
 123   Promise<int> p;
 124   FutureSplitter<int> sp(p.getFuture());
 125   auto f1 = sp.getFuture();
 126   EXPECT_FALSE(f1.isReady());
 127   try {
 128     throw std::runtime_error("Oops");
 129   } catch (...) {
 130     p.setException(exception_wrapper(std::current_exception()));
 131   }
 132   EXPECT_TRUE(f1.isReady());
 133   EXPECT_TRUE(f1.hasException());
 134   auto f2 = sp.getFuture();
 135   EXPECT_TRUE(f2.isReady());
 136   EXPECT_TRUE(f2.hasException());
 137 }