From 4b22ab1ba615230b2781b7ab9e7ec5351cfb5024 Mon Sep 17 00:00:00 2001
From: Simon Brand <tartanllama@gmail.com>
Date: Wed, 1 May 2019 09:39:41 +0100
Subject: [PATCH] Add transform tests

---
 tests/extensions.cpp | 139 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 139 insertions(+)

diff --git a/tests/extensions.cpp b/tests/extensions.cpp
index 55ca613..d97687e 100644
--- a/tests/extensions.cpp
+++ b/tests/extensions.cpp
@@ -152,6 +152,145 @@ TEST_CASE("Monadic operations", "[monadic]") {
 #endif
   }
 
+  SECTION("transform") { // lhs is empty
+    tl::optional<int> o1;
+    auto o1r = o1.transform([](int i) { return i + 2; });
+    STATIC_REQUIRE((std::is_same<decltype(o1r), tl::optional<int>>::value));
+    REQUIRE(!o1r);
+
+    // lhs has value
+    tl::optional<int> o2 = 40;
+    auto o2r = o2.transform([](int i) { return i + 2; });
+    STATIC_REQUIRE((std::is_same<decltype(o2r), tl::optional<int>>::value));
+    REQUIRE(o2r.value() == 42);
+
+    struct rval_call_transform {
+      double operator()(int) && { return 42.0; };
+    };
+
+    // ensure that function object is forwarded
+    tl::optional<int> o3 = 42;
+    auto o3r = o3.transform(rval_call_transform{});
+    STATIC_REQUIRE((std::is_same<decltype(o3r), tl::optional<double>>::value));
+    REQUIRE(o3r.value() == 42);
+
+    // ensure that lhs is forwarded
+    tl::optional<int> o4 = 40;
+    auto o4r = std::move(o4).transform([](int&& i) { return i + 2; });
+    STATIC_REQUIRE((std::is_same<decltype(o4r), tl::optional<int>>::value));
+    REQUIRE(o4r.value() == 42);
+
+    // ensure that lhs is const-propagated
+    const tl::optional<int> o5 = 40;
+    auto o5r = o5.transform([](const int& i) { return i + 2; });
+    STATIC_REQUIRE((std::is_same<decltype(o5r), tl::optional<int>>::value));
+    REQUIRE(o5r.value() == 42);
+
+    // test void return
+    tl::optional<int> o7 = 40;
+    auto f7 = [](const int& i) { return; };
+    auto o7r = o7.transform(f7);
+    STATIC_REQUIRE(
+      (std::is_same<decltype(o7r), tl::optional<tl::monostate>>::value));
+    REQUIRE(o7r.has_value());
+
+    // test each overload in turn
+    tl::optional<int> o8 = 42;
+    auto o8r = o8.transform([](int) { return 42; });
+    REQUIRE(*o8r == 42);
+
+    tl::optional<int> o9 = 42;
+    auto o9r = o9.transform([](int) { return; });
+    REQUIRE(o9r);
+
+    tl::optional<int> o12 = 42;
+    auto o12r = std::move(o12).transform([](int) { return 42; });
+    REQUIRE(*o12r == 42);
+
+    tl::optional<int> o13 = 42;
+    auto o13r = std::move(o13).transform([](int) { return; });
+    REQUIRE(o13r);
+
+    const tl::optional<int> o16 = 42;
+    auto o16r = o16.transform([](int) { return 42; });
+    REQUIRE(*o16r == 42);
+
+    const tl::optional<int> o17 = 42;
+    auto o17r = o17.transform([](int) { return; });
+    REQUIRE(o17r);
+
+    const tl::optional<int> o20 = 42;
+    auto o20r = std::move(o20).transform([](int) { return 42; });
+    REQUIRE(*o20r == 42);
+
+    const tl::optional<int> o21 = 42;
+    auto o21r = std::move(o21).transform([](int) { return; });
+    REQUIRE(o21r);
+
+    tl::optional<int> o24 = tl::nullopt;
+    auto o24r = o24.transform([](int) { return 42; });
+    REQUIRE(!o24r);
+
+    tl::optional<int> o25 = tl::nullopt;
+    auto o25r = o25.transform([](int) { return; });
+    REQUIRE(!o25r);
+
+    tl::optional<int> o28 = tl::nullopt;
+    auto o28r = std::move(o28).transform([](int) { return 42; });
+    REQUIRE(!o28r);
+
+    tl::optional<int> o29 = tl::nullopt;
+    auto o29r = std::move(o29).transform([](int) { return; });
+    REQUIRE(!o29r);
+
+    const tl::optional<int> o32 = tl::nullopt;
+    auto o32r = o32.transform([](int) { return 42; });
+    REQUIRE(!o32r);
+
+    const tl::optional<int> o33 = tl::nullopt;
+    auto o33r = o33.transform([](int) { return; });
+    REQUIRE(!o33r);
+
+    const tl::optional<int> o36 = tl::nullopt;
+    auto o36r = std::move(o36).transform([](int) { return 42; });
+    REQUIRE(!o36r);
+
+    const tl::optional<int> o37 = tl::nullopt;
+    auto o37r = std::move(o37).transform([](int) { return; });
+    REQUIRE(!o37r);
+
+    // callable which returns a reference
+    tl::optional<int> o38 = 42;
+    auto o38r = o38.transform([](int& i) -> const int& { return i; });
+    REQUIRE(o38r);
+    REQUIRE(*o38r == 42);
+
+    int i = 42;
+    tl::optional<int&> o39 = i;
+    o39.transform([](int& x) {x = 12; });
+    REQUIRE(i == 12);
+  }
+
+  SECTION("transform constexpr") {
+#if !defined(_MSC_VER) && defined(TL_OPTIONAL_CXX14)
+    // test each overload in turn
+    constexpr tl::optional<int> o16 = 42;
+    constexpr auto o16r = o16.transform(get_int);
+    STATIC_REQUIRE(*o16r == 42);
+
+    constexpr tl::optional<int> o20 = 42;
+    constexpr auto o20r = std::move(o20).transform(get_int);
+    STATIC_REQUIRE(*o20r == 42);
+
+    constexpr tl::optional<int> o32 = tl::nullopt;
+    constexpr auto o32r = o32.transform(get_int);
+    STATIC_REQUIRE(!o32r);
+    constexpr tl::optional<int> o36 = tl::nullopt;
+    constexpr auto o36r = std::move(o36).transform(get_int);
+    STATIC_REQUIRE(!o36r);
+#endif
+  }
+
   SECTION("and_then") {
 
     // lhs is empty