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