intermediate changes

ref:cde9a383711a11544ce7e107a78147fb96cc4029

1 files changed, 82 insertions, 0 deletions

diff --git a/util/generic/overloaded_ut.cpp b/util/generic/overloaded_ut.cpp
new file mode 100644
index 0000000000..f3d73895ad
--- /dev/null
+++ b/util/generic/overloaded_ut.cpp
@@ -0,0 +1,82 @@
+#include <util/generic/overloaded.h>
+
+#include <library/cpp/testing/unittest/registar.h>
+
+#include <util/generic/variant.h>
+#include <util/generic/algorithm.h>
+
+#include <tuple>
+
+namespace {
+    struct TType1 {};
+    struct TType2 {};
+    struct TType3 {};
+}
+
+Y_UNIT_TEST_SUITE(TOverloadedTest) {
+    Y_UNIT_TEST(StaticTest) {
+        auto f = TOverloaded{
+            [](const TType1&) {},
+            [](const TType2&) {},
+            [](const TType3&) {}};
+        using F = decltype(f);
+        static_assert(std::is_invocable_v<F, TType1>);
+        static_assert(std::is_invocable_v<F, TType2>);
+        static_assert(std::is_invocable_v<F, TType3>);
+        static_assert(!std::is_invocable_v<F, int>);
+        static_assert(!std::is_invocable_v<F, double>);
+    }
+
+    Y_UNIT_TEST(VariantTest) {
+        std::variant<int, double, TType1> v = 5;
+        int res = 0;
+        std::visit(TOverloaded{
+                       [&](int val) { res = val; },
+                       [&](double) { res = -1; },
+                       [&](TType1) { res = -1; }},
+                   v);
+        UNIT_ASSERT_VALUES_EQUAL(res, 5);
+    }
+
+    Y_UNIT_TEST(TupleTest) {
+        std::tuple<int, double, bool, int> t{5, 3.14, true, 20};
+        TString res;
+
+        ForEach(t, TOverloaded{
+                       [&](int val) { res += "(int) " + ToString(val) + ' '; },
+                       [&](double val) { res += "(double) " + ToString(val) + ' '; },
+                       [&](bool val) { res += "(bool) " + ToString(val) + ' '; },
+                   });
+
+        UNIT_ASSERT_VALUES_EQUAL(res, "(int) 5 (double) 3.14 (bool) 1 (int) 20 ");
+    }
+
+    Y_UNIT_TEST(ImplicitConversionsTest) {
+        using TTestVariant = std::variant<int, double, char>;
+
+        // Purposefully exhibit inexact overload matched with implicit type
+        // conversions
+
+        // All cases implicitly cast to int
+        auto matchAsInt = [](TTestVariant var) {
+            return std::visit(TOverloaded{
+                                  [](int val) { return val; },
+                              }, var);
+        };
+
+        UNIT_ASSERT_VALUES_EQUAL(matchAsInt(TTestVariant{17.77}), 17);
+        UNIT_ASSERT_VALUES_EQUAL(matchAsInt(TTestVariant{12345}), 12345);
+        UNIT_ASSERT_VALUES_EQUAL(matchAsInt(TTestVariant{'X'}), 88);
+
+        // All cases implicitly cast to double
+        auto matchAsDouble = [](TTestVariant var) {
+            return std::visit(TOverloaded{
+                                  [](double val) { return val; },
+                              }, var);
+        };
+
+        UNIT_ASSERT_VALUES_EQUAL(matchAsDouble(TTestVariant{17.77}), 17.77);
+        UNIT_ASSERT_VALUES_EQUAL(matchAsDouble(TTestVariant{12345}), 12345.0);
+        UNIT_ASSERT_VALUES_EQUAL(matchAsDouble(TTestVariant{'X'}), 88.0);
+    }
+}