react-native-windows 0.84.0 → 0.84.1

package/external/folly/folly/functional/test/ApplyTupleTest.cpp

@@ -0,0 +1,549 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/functional/ApplyTuple.h>
+
+#include <algorithm>
+#include <array>
+#include <iostream>
+#include <memory>
+#include <utility>
+
+#include <folly/Overload.h>
+#include <folly/portability/GTest.h>
+
+namespace {
+
+void func(int a, int b, double c) {
+  EXPECT_EQ(a, 1);
+  EXPECT_EQ(b, 2);
+  EXPECT_EQ(c, 3.0);
+}
+
+struct Wat {
+  void func(int a, int b, double c) { ::func(a, b, c); }
+
+  double retVal(int a, double b) { return a + b; }
+
+  Wat() {}
+  Wat(Wat const&) = delete;
+
+  int foo;
+};
+
+struct Overloaded {
+  int func(int) { return 0; }
+  bool func(bool) { return true; }
+};
+
+struct Func {
+  int operator()() const { return 1; }
+};
+
+struct CopyCount {
+  CopyCount() {}
+  CopyCount(CopyCount const&) { std::cout << "copy count copy ctor\n"; }
+};
+
+void anotherFunc(CopyCount const&) {}
+
+std::function<void(int, int, double)> makeFunc() {
+  return &func;
+}
+
+struct GuardObjBase {
+  GuardObjBase(GuardObjBase&&) noexcept {}
+  GuardObjBase() {}
+  GuardObjBase(GuardObjBase const&) = delete;
+  GuardObjBase& operator=(GuardObjBase const&) = delete;
+};
+
+template <class F, class Tuple>
+struct GuardObj : GuardObjBase {
+  explicit GuardObj(F&& f, Tuple&& args)
+      : f_(std::forward<F>(f)), args_(std::forward<Tuple>(args)) {}
+  GuardObj(GuardObj&& g) noexcept
+      : GuardObjBase(std::move(g)),
+        f_(std::move(g.f_)),
+        args_(std::move(g.args_)) {}
+
+  ~GuardObj() { folly::apply(f_, args_); }
+
+  GuardObj(const GuardObj&) = delete;
+  GuardObj& operator=(const GuardObj&) = delete;
+
+ private:
+  F f_;
+  Tuple args_;
+};
+
+template <class F, class... Args>
+GuardObj<typename std::decay<F>::type, std::tuple<Args...>> guard(
+    F&& f, Args&&... args) {
+  return GuardObj<typename std::decay<F>::type, std::tuple<Args...>>(
+      std::forward<F>(f), std::tuple<Args...>(std::forward<Args>(args)...));
+}
+
+struct Mover {
+  Mover() {}
+  Mover(Mover&&) noexcept {}
+  Mover(const Mover&) = delete;
+  Mover& operator=(const Mover&) = delete;
+};
+
+void move_only_func(Mover&&) {}
+
+} // namespace
+
+TEST(ApplyTuple, Test) {
+  auto argsTuple = std::make_tuple(1, 2, 3.0);
+  auto func2 = func;
+  folly::apply(func2, argsTuple);
+  folly::apply(func, argsTuple);
+  folly::apply(func, std::make_tuple(1, 2, 3.0));
+  folly::apply(makeFunc(), std::make_tuple(1, 2, 3.0));
+  folly::apply(makeFunc(), argsTuple);
+
+  std::unique_ptr<Wat> wat(new Wat);
+  folly::apply(&Wat::func, std::make_tuple(wat.get(), 1, 2, 3.0));
+  auto argsTuple2 = std::make_tuple(wat.get(), 1, 2, 3.0);
+  folly::apply(&Wat::func, argsTuple2);
+
+  EXPECT_EQ(
+      10.0, folly::apply(&Wat::retVal, std::make_tuple(wat.get(), 1, 9.0)));
+
+  auto test = guard(func, 1, 2, 3.0);
+  CopyCount cpy;
+  auto test2 = guard(anotherFunc, cpy);
+  auto test3 = guard(anotherFunc, std::cref(cpy));
+
+  Overloaded ovl;
+  EXPECT_EQ(
+      0,
+      folly::apply(
+          static_cast<int (Overloaded::*)(int)>(&Overloaded::func),
+          std::make_tuple(&ovl, 12)));
+  EXPECT_EQ(
+      /* do not code-mode to EXPECT_TRUE */ true,
+      folly::apply(
+          static_cast<bool (Overloaded::*)(bool)>(&Overloaded::func),
+          std::make_tuple(&ovl, false)));
+
+  int x = folly::apply(std::plus<int>(), std::make_tuple(12, 12));
+  EXPECT_EQ(24, x);
+
+  Mover m;
+  folly::apply(
+      move_only_func, std::forward_as_tuple(std::forward<Mover>(Mover())));
+  const auto tuple3 = std::make_tuple(1, 2, 3.0);
+  folly::apply(func, tuple3);
+}
+
+TEST(ApplyTuple, Mutable) {
+  auto argsTuple = std::make_tuple(1, 2, 3.0);
+
+  folly::apply(
+      [](int a, int b, double c) mutable { func(a, b, c); }, argsTuple);
+}
+
+TEST(ApplyTuple, ConstOverloads) {
+  struct ConstOverloaded {
+    ConstOverloaded() {}
+    int operator()() { return 101; }
+    int operator()() const { return 102; }
+  };
+
+  ConstOverloaded covl;
+
+  // call operator()()
+  EXPECT_EQ(folly::apply(covl, std::make_tuple()), 101);
+  EXPECT_EQ(folly::apply(std::ref(covl), std::make_tuple()), 101);
+  EXPECT_EQ(folly::apply(std::move(covl), std::make_tuple()), 101);
+
+  // call operator()() const
+  EXPECT_EQ(
+      folly::apply(const_cast<ConstOverloaded const&>(covl), std::make_tuple()),
+      102);
+  EXPECT_EQ(folly::apply(std::cref(covl), std::make_tuple()), 102);
+}
+
+TEST(ApplyTuple, RefOverloads) {
+  struct RefOverloaded {
+    RefOverloaded() {}
+    int operator()() & { return 201; }
+    int operator()() const& { return 202; }
+    int operator()() && { return 203; }
+  };
+
+  RefOverloaded rovl;
+
+  // call operator()() &
+  EXPECT_EQ(folly::apply(rovl, std::make_tuple()), 201);
+  EXPECT_EQ(folly::apply(std::ref(rovl), std::make_tuple()), 201);
+
+  // call operator()() const &
+  EXPECT_EQ(
+      folly::apply(const_cast<RefOverloaded const&>(rovl), std::make_tuple()),
+      202);
+  EXPECT_EQ(folly::apply(std::cref(rovl), std::make_tuple()), 202);
+
+  // call operator()() &&
+  EXPECT_EQ(folly::apply(std::move(rovl), std::make_tuple()), 203);
+}
+
+struct MemberFunc {
+  int x;
+  int getX() const { return x; }
+  void setX(int xx) { x = xx; }
+};
+
+TEST(ApplyTuple, MemberFunction) {
+  MemberFunc mf;
+  mf.x = 123;
+
+  // call getter
+  EXPECT_EQ(folly::apply(&MemberFunc::getX, std::make_tuple(&mf)), 123);
+
+  // call setter
+  folly::apply(&MemberFunc::setX, std::make_tuple(&mf, 234));
+  EXPECT_EQ(mf.x, 234);
+  EXPECT_EQ(folly::apply(&MemberFunc::getX, std::make_tuple(&mf)), 234);
+}
+
+TEST(ApplyTuple, MemberFunctionWithRefWrapper) {
+  MemberFunc mf;
+  mf.x = 234;
+
+  EXPECT_EQ(
+      folly::apply(&MemberFunc::getX, std::make_tuple(std::ref(mf))), 234);
+}
+
+TEST(ApplyTuple, MemberFunctionWithConstPointer) {
+  MemberFunc mf;
+  mf.x = 234;
+
+  EXPECT_EQ(
+      folly::apply(
+          &MemberFunc::getX,
+          std::make_tuple(const_cast<MemberFunc const*>(&mf))),
+      234);
+}
+
+TEST(ApplyTuple, MemberFunctionWithSharedPtr) {
+  MemberFunc mf;
+  mf.x = 234;
+
+  EXPECT_EQ(
+      folly::apply(
+          &MemberFunc::getX, std::make_tuple(std::make_shared<MemberFunc>(mf))),
+      234);
+}
+
+TEST(ApplyTuple, MemberFunctionWithUniquePtr) {
+  MemberFunc mf;
+  mf.x = 234;
+
+  EXPECT_EQ(
+      folly::apply(
+          &MemberFunc::getX, std::make_tuple(std::make_unique<MemberFunc>(mf))),
+      234);
+}
+
+TEST(ApplyTuple, Array) {
+  folly::apply(func, std::array<int, 3>{{1, 2, 3}});
+  folly::apply(func, std::array<double, 3>{{1, 2, 3}});
+}
+
+TEST(ApplyTuple, Pair) {
+  auto add = [](int x, int y) { return x + y; };
+
+  EXPECT_EQ(folly::apply(add, std::pair<int, int>{1200, 34}), 1234);
+}
+
+TEST(ApplyTuple, MultipleTuples) {
+  auto add = [](int x, int y, int z) { return x * 100 + y * 10 + z; };
+
+  EXPECT_EQ(123, folly::apply(add, std::make_tuple(1, 2, 3)));
+  EXPECT_EQ(
+      123,
+      folly::apply(
+          add, std::tuple_cat(std::make_tuple(1, 2, 3), std::make_tuple())));
+  EXPECT_EQ(
+      123,
+      folly::apply(
+          add, std::tuple_cat(std::make_tuple(1, 2), std::make_tuple(3))));
+  EXPECT_EQ(
+      123,
+      folly::apply(
+          add, std::tuple_cat(std::make_tuple(1), std::make_tuple(2, 3))));
+  EXPECT_EQ(
+      123,
+      folly::apply(
+          add, std::tuple_cat(std::make_tuple(), std::make_tuple(1, 2, 3))));
+
+  EXPECT_EQ(
+      123,
+      folly::apply(
+          add,
+          std::tuple_cat(
+              std::make_tuple(1, 2, 3), std::make_tuple(), std::make_tuple())));
+  EXPECT_EQ(
+      123,
+      folly::apply(
+          add,
+          std::tuple_cat(
+              std::make_tuple(1), std::make_tuple(2), std::make_tuple(3))));
+  EXPECT_EQ(
+      123,
+      folly::apply(
+          add,
+          std::tuple_cat(
+              std::make_tuple(1), std::make_tuple(), std::make_tuple(2, 3))));
+}
+
+TEST(ApplyTuple, UncurryCopyMove) {
+  std::string separator = "================================\n";
+  auto formatRow = folly::uncurry([=](std::string a, std::string b) {
+    // capture separator by copy
+    return separator + a + "\n" + b + "\n" + separator;
+  });
+  auto row = std::make_tuple("hello", "world");
+  auto expected = separator + "hello\nworld\n" + separator;
+  EXPECT_EQ(expected, formatRow(row));
+  auto formatRowCopy = formatRow;
+  EXPECT_EQ(expected, formatRowCopy(row));
+  auto formatRowMove = std::move(formatRow);
+  EXPECT_EQ(expected, formatRowMove(row));
+
+  // capture value moved out from formatRow
+  EXPECT_NE(expected, formatRow(row));
+}
+
+TEST(ApplyTuple, Uncurry) {
+  EXPECT_EQ(42, folly::uncurry([](int x, int y) {
+              return x * y;
+            })(std::pair<int, int>(6, 7)));
+  EXPECT_EQ(42, folly::uncurry([](int&& x, int&& y) {
+              return x * y;
+            })(std::pair<int&&, int&&>(6, 7)));
+  EXPECT_EQ(42, folly::uncurry([](int&& x, int&& y) {
+              return x * y;
+            })(std::pair<int&&, int&&>(6, 7)));
+
+  std::string long1 = "a long string exceeding small string size";
+  std::string long2 = "and here is another one!";
+  std::string expected = long1 + long2;
+
+  auto cat = folly::uncurry(
+      [](std::string a, std::string b) { return std::move(a) + std::move(b); });
+
+  EXPECT_EQ(expected, cat(std::make_pair(long1, long2)));
+  EXPECT_FALSE(long1.empty());
+  EXPECT_FALSE(long2.empty());
+  EXPECT_EQ(expected, cat(std::tie(long1, long2)));
+  EXPECT_FALSE(long1.empty());
+  EXPECT_FALSE(long2.empty());
+  EXPECT_EQ(
+      expected, cat(std::forward_as_tuple(std::move(long1), std::move(long2))));
+  EXPECT_TRUE(long1.empty());
+  EXPECT_TRUE(long2.empty());
+}
+
+TEST(ApplyTuple, UncurryStdFind) {
+  std::vector<std::pair<int, int>> v{{1, 9}, {2, 8}, {3, 7}, {4, 6}, {5, 5}};
+  EXPECT_EQ(
+      3, std::count_if(v.begin(), v.end(), folly::uncurry([](int a, int b) {
+                         return b % a == 0;
+                       })));
+}
+
+namespace {
+struct S {
+  template <typename... Args>
+  explicit S(Args&&... args) : tuple_(std::forward<Args>(args)...) {}
+
+  std::tuple<int, double, std::string> tuple_;
+};
+} // namespace
+
+TEST(MakeIndexSequenceFromTuple, Basic) {
+  using folly::index_sequence_for_tuple;
+  using OneElementTuple = std::tuple<int>;
+  using TwoElementTuple = std::tuple<int>;
+
+  EXPECT_TRUE((std::is_same<
+               index_sequence_for_tuple<OneElementTuple>,
+               std::index_sequence<0>>::value));
+  EXPECT_TRUE((std::is_same<
+               index_sequence_for_tuple<const OneElementTuple>,
+               std::index_sequence<0>>::value));
+
+  EXPECT_TRUE((std::is_same<
+               index_sequence_for_tuple<TwoElementTuple>,
+               std::index_sequence<0>>::value));
+  EXPECT_TRUE((std::is_same<
+               index_sequence_for_tuple<const TwoElementTuple>,
+               std::index_sequence<0>>::value));
+}
+
+TEST(ApplyResult, Basic) {
+  {
+    auto f = [](auto) -> int { return {}; };
+    using F = decltype(f);
+    EXPECT_TRUE(
+        (std::is_same<folly::apply_result_t<F, std::tuple<int>>, int>{}));
+  }
+
+  {
+    auto f = folly::overload(
+        [](int) {},
+        [](double) -> double { return {}; },
+        [](int, int) -> int { return {}; });
+    using F = decltype(f);
+
+    EXPECT_TRUE(
+        (std::is_same<folly::apply_result_t<F, std::tuple<int>>, void>::value));
+    EXPECT_TRUE(
+        (std::is_same<folly::apply_result_t<F, std::tuple<double>>, double>::
+             value));
+    EXPECT_TRUE(
+        (std::is_same<folly::apply_result_t<F, std::tuple<int, int>>, int>::
+             value));
+  }
+}
+
+TEST(IsApplicable, Basic) {
+  {
+    auto f = [] {};
+    using F = decltype(f);
+    EXPECT_TRUE((folly::is_applicable_v<F, std::tuple<>>));
+    EXPECT_FALSE((folly::is_applicable_v<F, std::tuple<int>>));
+  }
+  {
+    auto f = folly::overload([](int) {}, [](double) -> double { return {}; });
+    using F = decltype(f);
+    EXPECT_TRUE((folly::is_applicable_v<F, std::tuple<double>>));
+    EXPECT_TRUE((folly::is_applicable_v<F, std::tuple<int>>));
+    EXPECT_FALSE((folly::is_applicable_v<F, std::tuple<>>));
+    EXPECT_FALSE((folly::is_applicable_v<F, std::tuple<int, double>>));
+  }
+}
+
+TEST(IsNothrowApplicable, Basic) {
+  {
+    auto f = []() noexcept {};
+    using F = decltype(f);
+    EXPECT_TRUE((folly::is_nothrow_applicable_v<F, std::tuple<>>));
+    EXPECT_FALSE((folly::is_nothrow_applicable_v<F, std::tuple<int>>));
+  }
+  {
+    auto f = folly::overload(
+        [](int) noexcept {}, [](double) -> double { return {}; });
+    using F = decltype(f);
+    EXPECT_FALSE((folly::is_nothrow_applicable_v<F, std::tuple<double>>));
+    EXPECT_TRUE((folly::is_nothrow_applicable_v<F, std::tuple<int>>));
+    EXPECT_FALSE((folly::is_nothrow_applicable_v<F, std::tuple<>>));
+    EXPECT_FALSE((folly::is_nothrow_applicable_v<F, std::tuple<int, double>>));
+  }
+}
+
+TEST(IsApplicableR, Basic) {
+  {
+    auto f = []() -> int { return {}; };
+    using F = decltype(f);
+    EXPECT_TRUE((folly::is_applicable_r_v<double, F, std::tuple<>>));
+    EXPECT_FALSE((folly::is_applicable_r_v<double, F, std::tuple<int>>));
+  }
+  {
+    auto f = folly::overload(
+        [](int) noexcept {}, [](double) -> double { return {}; });
+    using F = decltype(f);
+    EXPECT_TRUE((folly::is_applicable_r_v<float, F, std::tuple<double>>));
+    EXPECT_TRUE((folly::is_applicable_r_v<void, F, std::tuple<int>>));
+    EXPECT_FALSE((folly::is_applicable_r_v<void, F, std::tuple<>>));
+    EXPECT_FALSE(
+        (folly::is_applicable_r_v<double, F, std::tuple<int, double>>));
+  }
+}
+
+TEST(IsNothrowApplicableR, Basic) {
+  {
+    auto f = []() noexcept -> int { return {}; };
+    using F = decltype(f);
+    EXPECT_TRUE((folly::is_nothrow_applicable_r_v<double, F, std::tuple<>>));
+    EXPECT_FALSE(
+        (folly::is_nothrow_applicable_r_v<double, F, std::tuple<int>>));
+  }
+  {
+    auto f = folly::overload(
+        [](int) noexcept {}, [](double) -> double { return {}; });
+    using F = decltype(f);
+    EXPECT_FALSE(
+        (folly::is_nothrow_applicable_r_v<float, F, std::tuple<double>>));
+    EXPECT_TRUE((folly::is_nothrow_applicable_r_v<void, F, std::tuple<int>>));
+    EXPECT_FALSE((folly::is_nothrow_applicable_r_v<void, F, std::tuple<>>));
+    EXPECT_FALSE(
+        (folly::is_nothrow_applicable_r_v<double, F, std::tuple<int, double>>));
+  }
+}
+
+TEST(ForwardTuple, Basic) {
+  auto tuple = std::make_tuple(1, 2.0);
+
+  EXPECT_TRUE((std::is_same<
+               decltype(folly::forward_tuple(tuple)),
+               std::tuple<int&, double&>>::value));
+  EXPECT_EQ(folly::forward_tuple(tuple), tuple);
+  EXPECT_TRUE((std::is_same<
+               decltype(folly::forward_tuple(std::as_const(tuple))),
+               std::tuple<const int&, const double&>>::value));
+  EXPECT_EQ(folly::forward_tuple(std::as_const(tuple)), tuple);
+
+  EXPECT_TRUE((std::is_same<
+               decltype(folly::forward_tuple(std::move(tuple))),
+               std::tuple<int&&, double&&>>::value));
+  EXPECT_EQ(folly::forward_tuple(std::move(tuple)), tuple);
+#if defined(__GLIBCXX__) && (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE < 8)
+  constexpr bool before_lwg2485 = true;
+#else
+  constexpr bool before_lwg2485 = false;
+#endif
+  EXPECT_TRUE((std::is_same<
+               decltype(folly::forward_tuple(std::move(std::as_const(tuple)))),
+               std::conditional_t<
+                   before_lwg2485,
+                   std::tuple<const int&, const double&>,
+                   std::tuple<const int&&, const double&&>>>::value));
+  EXPECT_EQ(folly::forward_tuple(std::move(std::as_const(tuple))), tuple);
+
+  auto integer = 1;
+  auto floating_point = 2.0;
+  auto ref_tuple = std::forward_as_tuple(integer, std::move(floating_point));
+
+  EXPECT_TRUE((std::is_same<
+               decltype(folly::forward_tuple(ref_tuple)),
+               std::tuple<int&, double&>>::value));
+
+  EXPECT_TRUE((std::is_same<
+               decltype(folly::forward_tuple(std::move(ref_tuple))),
+               std::tuple<int&, double&&>>::value));
+
+  EXPECT_TRUE((std::is_same<
+               decltype(std::tuple_cat(
+                   folly::forward_tuple(tuple),
+                   folly::forward_tuple(std::move(tuple)))),
+               std::tuple<int&, double&, int&&, double&&>>::value));
+}

package/external/folly/folly/functional/test/BUCK

@@ -0,0 +1,57 @@
+load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
+
+oncall("fbcode_entropy_wardens_folly")
+
+cpp_unittest(
+    name = "apply_tuple_test",
+    srcs = ["ApplyTupleTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:overload",
+        "//folly/functional:apply_tuple",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "invoke_test",
+    srcs = ["InvokeTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:cpp_attributes",
+        "//folly/functional:invoke",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "partial_test",
+    srcs = ["PartialTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:function",
+        "//folly/functional:partial",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "protocol_test",
+    srcs = ["protocol_test.cpp"],
+    headers = [],
+    deps = [
+        "//folly:traits",
+        "//folly/functional:protocol",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "traits_test",
+    srcs = ["traits_test.cpp"],
+    headers = [],
+    deps = [
+        "//folly/functional:traits",
+        "//folly/portability:gtest",
+    ],
+)