C++11 support

2017-10-02 20:18:40 +01:00
parent 74b06a5eb7
commit 4d0e92c5f6
3 changed files with 382 additions and 100 deletions
@@ -7,6 +7,10 @@
  constexpr bool TOKENPASTE2(rqure, __LINE__) = e;                             \
  REQUIRE(e);

+    constexpr int get_int(int) { return 42; }
+constexpr tl::optional<int> get_opt_int(int) { return 42; }
+
+
 // What is Clang Format up to?!
 TEST_CASE("Monadic operations",
          "[monadic]"){SECTION("map"){// lhs is empty
@@ -22,7 +26,7 @@ STATIC_REQUIRE((std::is_same<decltype(o2r), tl::optional<int>>::value));
 REQUIRE(o2r.value() == 42);

 struct rval_call_map {
-  auto operator()(int) && { return 42.0; };
+    double operator()(int) && { return 42.0; };
 };

 // ensure that function object is forwarded
@@ -56,8 +60,174 @@ auto f7 = tl::make_optional([](const int &i) { return; });
 auto o7r = o7.map(f7);
 STATIC_REQUIRE((std::is_same<decltype(o7r), tl::optional<tl::monostate>>::value));
 REQUIRE(o6r.has_value());
+
+// test each overload in turn
+tl::optional<int> o8 = 42;
+auto o8r = o8.map([](int){return 42;});
+REQUIRE(*o8r == 42);
+
+tl::optional<int> o9 = 42;
+auto o9r = o9.map([](int){return;});
+REQUIRE(o9r);
+
+tl::optional<int> o10 = 42;
+auto o10r = o10.map(tl::make_optional([](int){return 42;}));
+REQUIRE(*o10r == 42);
+
+tl::optional<int> o11 = 42;
+auto o11r = o11.map(tl::make_optional([](int){return;}));
+REQUIRE(o11r);
+
+tl::optional<int> o12 = 42;
+auto o12r = std::move(o12).map([](int){return 42;});
+REQUIRE(*o12r == 42);
+
+tl::optional<int> o13 = 42;
+auto o13r = std::move(o13).map([](int){return;});
+REQUIRE(o13r);
+
+tl::optional<int> o14 = 42;
+auto o14r = std::move(o14).map(tl::make_optional([](int){return 42;}));
+REQUIRE(*o14r == 42);
+
+tl::optional<int> o15 = 42;
+auto o15r = std::move(o15).map(tl::make_optional([](int){return;}));
+REQUIRE(o15r);
+
+const tl::optional<int> o16 = 42;
+auto o16r = o16.map([](int){return 42;});
+REQUIRE(*o16r == 42);
+
+const tl::optional<int> o17 = 42;
+auto o17r = o17.map([](int){return;});
+REQUIRE(o17r);
+
+const tl::optional<int> o18 = 42;
+auto o18r = o18.map(tl::make_optional([](int){return 42;}));
+REQUIRE(*o18r == 42);
+
+const tl::optional<int> o19 = 42;
+auto o19r = o19.map(tl::make_optional([](int){return;}));
+REQUIRE(o19r);
+
+const tl::optional<int> o20 = 42;
+auto o20r = std::move(o20).map([](int){return 42;});
+REQUIRE(*o20r == 42);
+
+const tl::optional<int> o21 = 42;
+auto o21r = std::move(o21).map([](int){return;});
+REQUIRE(o21r);
+
+const tl::optional<int> o22 = 42;
+auto o22r = std::move(o22).map(tl::make_optional([](int){return 42;}));
+REQUIRE(*o22r == 42);
+
+const tl::optional<int> o23 = 42;
+auto o23r = std::move(o23).map(tl::make_optional([](int){return;}));
+REQUIRE(o23r);
+
+tl::optional<int> o24 = tl::nullopt;
+auto o24r = o24.map([](int){return 42;});
+REQUIRE(!o24r);
+
+tl::optional<int> o25 = tl::nullopt;
+auto o25r = o25.map([](int){return;});
+REQUIRE(!o25r);
+
+tl::optional<int> o26 = tl::nullopt;
+auto o26r = o26.map(tl::make_optional([](int){return 42;}));
+REQUIRE(!o26r);
+
+tl::optional<int> o27 = tl::nullopt;
+auto o27r = o27.map(tl::make_optional([](int){return;}));
+REQUIRE(!o27r);
+
+tl::optional<int> o28 = tl::nullopt;
+auto o28r = std::move(o28).map([](int){return 42;});
+REQUIRE(!o28r);
+
+tl::optional<int> o29 = tl::nullopt;
+auto o29r = std::move(o29).map([](int){return;});
+REQUIRE(!o29r);
+
+tl::optional<int> o30 = tl::nullopt;
+auto o30r = std::move(o30).map(tl::make_optional([](int){return 42;}));
+REQUIRE(!o30r);
+
+tl::optional<int> o31 = tl::nullopt;
+auto o31r = std::move(o31).map(tl::make_optional([](int){return;}));
+REQUIRE(!o31r);
+
+const tl::optional<int> o32 = tl::nullopt;
+auto o32r = o32.map([](int){return 42;});
+REQUIRE(!o32r);
+
+const tl::optional<int> o33 = tl::nullopt;
+auto o33r = o33.map([](int){return;});
+REQUIRE(!o33r);
+
+const tl::optional<int> o34 = tl::nullopt;
+auto o34r = o34.map(tl::make_optional([](int){return 42;}));
+REQUIRE(!o34r);
+
+const tl::optional<int> o35 = tl::nullopt;
+auto o35r = o35.map(tl::make_optional([](int){return;}));
+REQUIRE(!o35r);
+
+const tl::optional<int> o36 = tl::nullopt;
+auto o36r = std::move(o36).map([](int){return 42;});
+REQUIRE(!o36r);
+
+const tl::optional<int> o37 = tl::nullopt;
+auto o37r = std::move(o37).map([](int){return;});
+REQUIRE(!o37r);
+
+const tl::optional<int> o38 = tl::nullopt;
+auto o38r = std::move(o38).map(tl::make_optional([](int){return 42;}));
+REQUIRE(!o38r);
+
+const tl::optional<int> o39 = tl::nullopt;
+auto o39r = std::move(o39).map(tl::make_optional([](int){return;}));
+REQUIRE(!o39r);
 }

+
+SECTION("map constexpr") {
+// test each overload in turn
+constexpr tl::optional<int> o16 = 42;
+constexpr auto o16r = o16.map(get_int);
+STATIC_REQUIRE(*o16r == 42);
+
+constexpr tl::optional<int> o18 = 42;
+constexpr auto opt_int = tl::make_optional(get_int);
+constexpr auto o18r = o18.map(opt_int);
+STATIC_REQUIRE(*o18r == 42);
+
+constexpr tl::optional<int> o20 = 42;
+constexpr auto o20r = std::move(o20).map(get_int);
+STATIC_REQUIRE(*o20r == 42);
+
+constexpr tl::optional<int> o22 = 42;
+constexpr auto o22r = std::move(o22).map(opt_int);
+STATIC_REQUIRE(*o22r == 42);
+
+constexpr tl::optional<int> o32 = tl::nullopt;
+constexpr auto o32r = o32.map(get_int);
+STATIC_REQUIRE(!o32r);
+
+constexpr tl::optional<int> o34 = tl::nullopt;
+constexpr auto o34r = o34.map(opt_int);
+STATIC_REQUIRE(!o34r);
+
+constexpr tl::optional<int> o36 = tl::nullopt;
+constexpr auto o36r = std::move(o36).map(get_int);
+STATIC_REQUIRE(!o36r);
+
+constexpr tl::optional<int> o38 = tl::nullopt;
+constexpr auto o38r = std::move(o38).map(opt_int);
+STATIC_REQUIRE(!o38r);
+    }
+
 SECTION("bind") {

  // lhs is empty
@@ -85,7 +255,7 @@ SECTION("bind") {
  REQUIRE(!o4r);

  struct rval_call_bind {
-    auto operator()(int) && { return tl::optional<double>(42.0); };
+      tl::optional<double> operator()(int) && { return tl::optional<double>(42.0); };
  };

  // ensure that function object is forwarded
@@ -106,6 +276,122 @@ SECTION("bind") {
  auto o7r = o7.bind([](const int &i) { return tl::optional<double>(i); });
  STATIC_REQUIRE((std::is_same<decltype(o7r), tl::optional<double>>::value));
  REQUIRE(o7r.value() == 42);
+
+  // test each overload in turn
+  tl::optional<int> o8 = 42;
+  auto o8r = o8.bind([](int i) { return tl::make_optional(42); });
+  REQUIRE(*o8r == 42);
+
+  tl::optional<int> o9 = 42;
+  auto o9r = std::move(o9).bind([](int i) { return tl::make_optional(42); });
+  REQUIRE(*o9r == 42);
+
+  const tl::optional<int> o10 = 42;
+  auto o10r = o10.bind([](int i) { return tl::make_optional(42); });
+  REQUIRE(*o10r == 42);
+
+  const tl::optional<int> o11 = 42;
+  auto o11r = std::move(o11).bind([](int i) { return tl::make_optional(42); });
+  REQUIRE(*o11r == 42);
+
+  tl::optional<int> o12 = 42;
+  auto o12r = o12.bind([](int i) { return tl::make_optional(42); }, []{return;});
+  REQUIRE(*o12r == 42);
+
+  tl::optional<int> o13 = 42;
+  auto o13r = std::move(o13).bind([](int i) { return tl::make_optional(42); }, []{return;});
+  REQUIRE(*o13r == 42);
+
+  const tl::optional<int> o14 = 42;
+  auto o14r = o14.bind([](int i) { return tl::make_optional(42); }, []{return;});
+  REQUIRE(*o14r == 42);
+
+  const tl::optional<int> o15 = 42;
+  auto o15r = std::move(o15).bind([](int i) { return tl::make_optional(42); }, []{return;});
+  REQUIRE(*o15r == 42);
+
+  tl::optional<int> o16 = tl::nullopt;
+  auto o16r = o16.bind([](int i) { return tl::make_optional(42); });
+  REQUIRE(!o16r);
+
+  tl::optional<int> o17 = tl::nullopt;
+  auto o17r = std::move(o17).bind([](int i) { return tl::make_optional(42); });
+  REQUIRE(!o17r);
+
+  const tl::optional<int> o18 = tl::nullopt;
+  auto o18r = o18.bind([](int i) { return tl::make_optional(42); });
+  REQUIRE(!o18r);
+
+  const tl::optional<int> o19 = tl::nullopt;
+  auto o19r = std::move(o19).bind([](int i) { return tl::make_optional(42); });
+  REQUIRE(!o19r);
+
+  tl::optional<int> o20 = tl::nullopt;
+  bool c20 = false;
+  auto o20r = o20.bind([](int i) { return tl::make_optional(42); }, [&]{c20 = true;});
+  REQUIRE(!o20r);
+  REQUIRE(!c20);
+
+  tl::optional<int> o21 = tl::nullopt;
+  bool c21 = false;
+  auto o21r = std::move(o21).bind([](int i) { return tl::make_optional(42); }, [&]{c21 = true;});
+  REQUIRE(!o21r);
+  REQUIRE(!c21);
+
+  const tl::optional<int> o22 = tl::nullopt;
+  bool c22 = false;
+  auto o22r = o22.bind([](int i) { return tl::make_optional(42); }, [&]{c22 = true;});
+  REQUIRE(!o22r);
+  REQUIRE(!c22);
+
+  const tl::optional<int> o23 = tl::nullopt;
+  bool c23 = false;
+  auto o23r = std::move(o23).bind([](int i) { return tl::make_optional(42); }, [&]{c23 = true;});
+  REQUIRE(!o23r);
+  REQUIRE(!c23);
+
+  tl::optional<int> o24 = 42;
+  bool c24 = false;
+  auto o24r = o24.bind([](int i) { return tl::optional<int>{tl::nullopt}; }, [&]{c24 = true;});
+  REQUIRE(!o24r);
+  REQUIRE(c24);
+
+  tl::optional<int> o25 = 42;
+  bool c25 = false;
+  auto o25r = std::move(o25).bind([](int i) { return tl::optional<int>{tl::nullopt}; }, [&]{c25 = true;});
+  REQUIRE(!o25r);
+  REQUIRE(c25);
+
+  const tl::optional<int> o26 = 42;
+  bool c26 = false;
+  auto o26r = o26.bind([](int i) { return tl::optional<int>{tl::nullopt};}, [&]{c26 = true;});
+  REQUIRE(!o26r);
+  REQUIRE(c26);
+
+  const tl::optional<int> o27 = 42;
+  bool c27 = false;
+  auto o27r = std::move(o27).bind([](int i) { return tl::optional<int>{tl::nullopt};}, [&]{c27 = true;});
+  REQUIRE(!o27r);
+  REQUIRE(c27);
+
+}
+
+SECTION("constexpr bind") {
+    constexpr tl::optional<int> o10 = 42;
+    constexpr auto o10r = o10.bind(get_opt_int);
+  REQUIRE(*o10r == 42);
+
+  constexpr tl::optional<int> o11 = 42;
+  constexpr auto o11r = std::move(o11).bind(get_opt_int);
+  REQUIRE(*o11r == 42);
+
+  constexpr tl::optional<int> o18 = tl::nullopt;
+  constexpr auto o18r = o18.bind(get_opt_int);
+  REQUIRE(!o18r);
+
+  constexpr tl::optional<int> o19 = tl::nullopt;
+  constexpr auto o19r = std::move(o19).bind(get_opt_int);
+  REQUIRE(!o19r);
 }
 }
 ;