folly/futures/test/ThenTest.cpp

   1 /*
   2  * Copyright 2016 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/Future.h>
  18 #include <folly/portability/GTest.h>
  19
  20 #include <thread>
  21
  22 using namespace folly;
  23
  24 struct Widget {
  25   int v_, copied_, moved_;
  26   /* implicit */ Widget(int v) : v_(v), copied_(0), moved_(0) {}
  27   Widget(const Widget& other)
  28     : v_(other.v_), copied_(other.copied_ + 1), moved_(other.moved_) {}
  29   Widget(Widget&& other) noexcept
  30     : v_(other.v_), copied_(other.copied_), moved_(other.moved_ + 1) {}
  31   Widget& operator=(const Widget& /* other */) {
  32     throw std::logic_error("unexpected copy assignment");
  33   }
  34   Widget& operator=(Widget&& /* other */) {
  35     throw std::logic_error("unexpected move assignment");
  36   }
  37 };
  38
  39 TEST(Then, tryConstructor) {
  40   auto t = Try<Widget>(23);
  41   EXPECT_EQ(t.value().v_, 23);
  42   EXPECT_EQ(t.value().copied_, 0);
  43   EXPECT_EQ(t.value().moved_, 1);
  44 }
  45
  46 TEST(Then, makeFuture) {
  47   auto future = makeFuture<Widget>(23);
  48   EXPECT_EQ(future.value().v_, 23);
  49   EXPECT_EQ(future.value().copied_, 0);
  50   EXPECT_EQ(future.value().moved_, 2);
  51 }
  52
  53 TEST(Then, tryConstRValueReference) {
  54   auto future = makeFuture<Widget>(23).then(
  55     [](const Try<Widget>&& t) {
  56       EXPECT_EQ(t.value().copied_, 0);
  57       EXPECT_EQ(t.value().moved_, 2);
  58       return t.value().v_;
  59     });
  60   EXPECT_EQ(future.value(), 23);
  61 }
  62
  63 TEST(Then, tryRValueReference) {
  64   auto future = makeFuture<Widget>(23).then(
  65     [](Try<Widget>&& t) {
  66       EXPECT_EQ(t.value().copied_, 0);
  67       EXPECT_EQ(t.value().moved_, 2);
  68       return t.value().v_;
  69     });
  70   EXPECT_EQ(future.value(), 23);
  71 }
  72
  73 TEST(Then, tryLValueReference) {
  74   auto future = makeFuture<Widget>(23).then(
  75     [](Try<Widget>& t) {
  76       EXPECT_EQ(t.value().copied_, 0);
  77       EXPECT_EQ(t.value().moved_, 2);
  78       return t.value().v_;
  79     });
  80   EXPECT_EQ(future.value(), 23);
  81 }
  82
  83 TEST(Then, tryConstLValueReference) {
  84   auto future = makeFuture<Widget>(23).then(
  85     [](const Try<Widget>& t) {
  86       EXPECT_EQ(t.value().copied_, 0);
  87       EXPECT_EQ(t.value().moved_, 2);
  88       return t.value().v_;
  89     });
  90   EXPECT_EQ(future.value(), 23);
  91 }
  92
  93 TEST(Then, tryValue) {
  94   auto future = makeFuture<Widget>(23).then(
  95     [](Try<Widget> t) {
  96       EXPECT_EQ(t.value().copied_, 0);
  97       EXPECT_EQ(t.value().moved_, 3);
  98       return t.value().v_;
  99     });
 100   EXPECT_EQ(future.value(), 23);
 101 }
 102
 103 TEST(Then, tryConstValue) {
 104   auto future = makeFuture<Widget>(23).then(
 105     [](const Try<Widget> t) {
 106       EXPECT_EQ(t.value().copied_, 0);
 107       EXPECT_EQ(t.value().moved_, 3);
 108       return t.value().v_;
 109     });
 110   EXPECT_EQ(future.value(), 23);
 111 }
 112
 113 TEST(Then, constRValueReference) {
 114   auto future = makeFuture<Widget>(23).then(
 115     [](const Widget&& w) {
 116       EXPECT_EQ(w.copied_, 0);
 117       EXPECT_EQ(w.moved_, 2);
 118       return w.v_;
 119     });
 120   EXPECT_EQ(future.value(), 23);
 121 }
 122
 123 TEST(Then, rValueReference) {
 124   auto future = makeFuture<Widget>(23).then(
 125     [](Widget&& w) {
 126       EXPECT_EQ(w.copied_, 0);
 127       EXPECT_EQ(w.moved_, 2);
 128       return w.v_;
 129     });
 130   EXPECT_EQ(future.value(), 23);
 131 }
 132
 133 TEST(Then, lValueReference) {
 134   auto future = makeFuture<Widget>(23).then(
 135     [](Widget& w) {
 136       EXPECT_EQ(w.copied_, 0);
 137       EXPECT_EQ(w.moved_, 2);
 138       return w.v_;
 139     });
 140   EXPECT_EQ(future.value(), 23);
 141 }
 142
 143 TEST(Then, constLValueReference) {
 144   auto future = makeFuture<Widget>(23).then(
 145     [](const Widget& w) {
 146       EXPECT_EQ(w.copied_, 0);
 147       EXPECT_EQ(w.moved_, 2);
 148       return w.v_;
 149     });
 150   EXPECT_EQ(future.value(), 23);
 151 }
 152
 153 TEST(Then, value) {
 154   auto future = makeFuture<Widget>(23).then(
 155     [](Widget w) {
 156       EXPECT_EQ(w.copied_, 0);
 157       EXPECT_EQ(w.moved_, 3);
 158       return w.v_;
 159     });
 160   EXPECT_EQ(future.value(), 23);
 161 }
 162
 163 TEST(Then, constValue) {
 164   auto future = makeFuture<Widget>(23).then(
 165     [](const Widget w) {
 166       EXPECT_EQ(w.copied_, 0);
 167       EXPECT_EQ(w.moved_, 3);
 168       return w.v_;
 169     });
 170   EXPECT_EQ(future.value(), 23);
 171 }
 172
 173 TEST(Then, voidThenShouldPropagateExceptions) {
 174   EXPECT_FALSE(makeFuture(42).then().hasException());
 175   EXPECT_TRUE(makeFuture<int>(std::runtime_error("err"))
 176              .then().hasException());
 177 }