libcxx/test/std/utilities/optional/optional.monadic/and_then.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
  10
  11 // XFAIL: availability-bad_optional_access-missing && !no-exceptions
  12
  13 // <optional>
  14
  15 // template<class F> constexpr auto and_then(F&&) &;
  16 // template<class F> constexpr auto and_then(F&&) &&;
  17 // template<class F> constexpr auto and_then(F&&) const&;
  18 // template<class F> constexpr auto and_then(F&&) const&&;
  19
  20 #include <cassert>
  21 #include <optional>
  22
  23 #include "test_macros.h"
  24
  25 struct LVal {
  26   constexpr std::optional<int> operator()(int&) { return 1; }
  27   std::optional<int> operator()(const int&) = delete;
  28   std::optional<int> operator()(int&&) = delete;
  29   std::optional<int> operator()(const int&&) = delete;
  30 };
  31
  32 struct CLVal {
  33   std::optional<int> operator()(int&) = delete;
  34   constexpr std::optional<int> operator()(const int&) { return 1; }
  35   std::optional<int> operator()(int&&) = delete;
  36   std::optional<int> operator()(const int&&) = delete;
  37 };
  38
  39 struct RVal {
  40   std::optional<int> operator()(int&) = delete;
  41   std::optional<int> operator()(const int&) = delete;
  42   constexpr std::optional<int> operator()(int&&) { return 1; }
  43   std::optional<int> operator()(const int&&) = delete;
  44 };
  45
  46 struct CRVal {
  47   std::optional<int> operator()(int&) = delete;
  48   std::optional<int> operator()(const int&) = delete;
  49   std::optional<int> operator()(int&&) = delete;
  50   constexpr std::optional<int> operator()(const int&&) { return 1; }
  51 };
  52
  53 struct RefQual {
  54   constexpr std::optional<int> operator()(int) & { return 1; }
  55   std::optional<int> operator()(int) const& = delete;
  56   std::optional<int> operator()(int) && = delete;
  57   std::optional<int> operator()(int) const&& = delete;
  58 };
  59
  60 struct CRefQual {
  61   std::optional<int> operator()(int) & = delete;
  62   constexpr std::optional<int> operator()(int) const& { return 1; }
  63   std::optional<int> operator()(int) && = delete;
  64   std::optional<int> operator()(int) const&& = delete;
  65 };
  66
  67 struct RVRefQual {
  68   std::optional<int> operator()(int) & = delete;
  69   std::optional<int> operator()(int) const& = delete;
  70   constexpr std::optional<int> operator()(int) && { return 1; }
  71   std::optional<int> operator()(int) const&& = delete;
  72 };
  73
  74 struct RVCRefQual {
  75   std::optional<int> operator()(int) & = delete;
  76   std::optional<int> operator()(int) const& = delete;
  77   std::optional<int> operator()(int) && = delete;
  78   constexpr std::optional<int> operator()(int) const&& { return 1; }
  79 };
  80
  81 struct NOLVal {
  82   constexpr std::optional<int> operator()(int&) { return std::nullopt; }
  83   std::optional<int> operator()(const int&) = delete;
  84   std::optional<int> operator()(int&&) = delete;
  85   std::optional<int> operator()(const int&&) = delete;
  86 };
  87
  88 struct NOCLVal {
  89   std::optional<int> operator()(int&) = delete;
  90   constexpr std::optional<int> operator()(const int&) { return std::nullopt; }
  91   std::optional<int> operator()(int&&) = delete;
  92   std::optional<int> operator()(const int&&) = delete;
  93 };
  94
  95 struct NORVal {
  96   std::optional<int> operator()(int&) = delete;
  97   std::optional<int> operator()(const int&) = delete;
  98   constexpr std::optional<int> operator()(int&&) { return std::nullopt; }
  99   std::optional<int> operator()(const int&&) = delete;
 100 };
 101
 102 struct NOCRVal {
 103   std::optional<int> operator()(int&) = delete;
 104   std::optional<int> operator()(const int&) = delete;
 105   std::optional<int> operator()(int&&) = delete;
 106   constexpr std::optional<int> operator()(const int&&) { return std::nullopt; }
 107 };
 108
 109 struct NORefQual {
 110   constexpr std::optional<int> operator()(int) & { return std::nullopt; }
 111   std::optional<int> operator()(int) const& = delete;
 112   std::optional<int> operator()(int) && = delete;
 113   std::optional<int> operator()(int) const&& = delete;
 114 };
 115
 116 struct NOCRefQual {
 117   std::optional<int> operator()(int) & = delete;
 118   constexpr std::optional<int> operator()(int) const& { return std::nullopt; }
 119   std::optional<int> operator()(int) && = delete;
 120   std::optional<int> operator()(int) const&& = delete;
 121 };
 122
 123 struct NORVRefQual {
 124   std::optional<int> operator()(int) & = delete;
 125   std::optional<int> operator()(int) const& = delete;
 126   constexpr std::optional<int> operator()(int) && { return std::nullopt; }
 127   std::optional<int> operator()(int) const&& = delete;
 128 };
 129
 130 struct NORVCRefQual {
 131   std::optional<int> operator()(int) & = delete;
 132   std::optional<int> operator()(int) const& = delete;
 133   std::optional<int> operator()(int) && = delete;
 134   constexpr std::optional<int> operator()(int) const&& { return std::nullopt; }
 135 };
 136
 137 struct NoCopy {
 138   NoCopy() = default;
 139   NoCopy(const NoCopy&) { assert(false); }
 140   std::optional<int> operator()(const NoCopy&&) { return 1; }
 141 };
 142
 143 struct NonConst {
 144   std::optional<int> non_const() { return 1; }
 145 };
 146
 147 constexpr void test_val_types() {
 148   // Test & overload
 149   {
 150     // Without & qualifier on F's operator()
 151     {
 152       std::optional<int> i{0};
 153       assert(i.and_then(LVal{}) == 1);
 154       assert(i.and_then(NOLVal{}) == std::nullopt);
 155       ASSERT_SAME_TYPE(decltype(i.and_then(LVal{})), std::optional<int>);
 156     }
 157
 158     //With & qualifier on F's operator()
 159     {
 160       std::optional<int> i{0};
 161       RefQual l{};
 162       assert(i.and_then(l) == 1);
 163       NORefQual nl{};
 164       assert(i.and_then(nl) == std::nullopt);
 165       ASSERT_SAME_TYPE(decltype(i.and_then(l)), std::optional<int>);
 166     }
 167   }
 168
 169   // Test const& overload
 170   {
 171     // Without & qualifier on F's operator()
 172     {
 173       const std::optional<int> i{0};
 174       assert(i.and_then(CLVal{}) == 1);
 175       assert(i.and_then(NOCLVal{}) == std::nullopt);
 176       ASSERT_SAME_TYPE(decltype(i.and_then(CLVal{})), std::optional<int>);
 177     }
 178
 179     //With & qualifier on F's operator()
 180     {
 181       const std::optional<int> i{0};
 182       const CRefQual l{};
 183       assert(i.and_then(l) == 1);
 184       const NOCRefQual nl{};
 185       assert(i.and_then(nl) == std::nullopt);
 186       ASSERT_SAME_TYPE(decltype(i.and_then(l)), std::optional<int>);
 187     }
 188   }
 189
 190   // Test && overload
 191   {
 192     // Without & qualifier on F's operator()
 193     {
 194       std::optional<int> i{0};
 195       assert(std::move(i).and_then(RVal{}) == 1);
 196       assert(std::move(i).and_then(NORVal{}) == std::nullopt);
 197       ASSERT_SAME_TYPE(decltype(std::move(i).and_then(RVal{})), std::optional<int>);
 198     }
 199
 200     //With & qualifier on F's operator()
 201     {
 202       std::optional<int> i{0};
 203       assert(i.and_then(RVRefQual{}) == 1);
 204       assert(i.and_then(NORVRefQual{}) == std::nullopt);
 205       ASSERT_SAME_TYPE(decltype(i.and_then(RVRefQual{})), std::optional<int>);
 206     }
 207   }
 208
 209   // Test const&& overload
 210   {
 211     // Without & qualifier on F's operator()
 212     {
 213       const std::optional<int> i{0};
 214       assert(std::move(i).and_then(CRVal{}) == 1);
 215       assert(std::move(i).and_then(NOCRVal{}) == std::nullopt);
 216       ASSERT_SAME_TYPE(decltype(std::move(i).and_then(CRVal{})), std::optional<int>);
 217     }
 218
 219     //With & qualifier on F's operator()
 220     {
 221       const std::optional<int> i{0};
 222       const RVCRefQual l{};
 223       assert(i.and_then(std::move(l)) == 1);
 224       const NORVCRefQual nl{};
 225       assert(i.and_then(std::move(nl)) == std::nullopt);
 226       ASSERT_SAME_TYPE(decltype(i.and_then(std::move(l))), std::optional<int>);
 227     }
 228   }
 229 }
 230
 231 // check that the lambda body is not instantiated during overload resolution
 232 constexpr void test_sfinae() {
 233   std::optional<NonConst> opt{};
 234   auto l = [](auto&& x) { return x.non_const(); };
 235   opt.and_then(l);
 236   std::move(opt).and_then(l);
 237 }
 238
 239 constexpr bool test() {
 240   test_val_types();
 241   std::optional<int> opt{};
 242   const auto& copt = opt;
 243
 244   const auto never_called = [](int) {
 245     assert(false);
 246     return std::optional<int>{};
 247   };
 248
 249   opt.and_then(never_called);
 250   std::move(opt).and_then(never_called);
 251   copt.and_then(never_called);
 252   std::move(copt).and_then(never_called);
 253
 254   std::optional<NoCopy> nc;
 255   const auto& cnc = nc;
 256   std::move(cnc).and_then(NoCopy{});
 257   std::move(nc).and_then(NoCopy{});
 258
 259   return true;
 260 }
 261
 262 int main(int, char**) {
 263   test();
 264   static_assert(test());
 265   return 0;
 266 }