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