react-native-windows 0.84.0 → 0.84.2

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

@@ -0,0 +1,483 @@
+/*
+ * 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/Invoke.h>
+
+#include <folly/CppAttributes.h>
+#include <folly/portability/GTest.h>
+
+class InvokeTest : public testing::Test {};
+
+namespace {
+
+struct from_any {
+  template <typename T>
+  /* implicit */ from_any(T&&) {}
+};
+
+struct Cv {
+  /* implicit */ [[maybe_unused]] operator std::false_type() const;
+  /* implicit */ [[maybe_unused]] operator std::true_type() const noexcept;
+};
+
+struct ImmCv : Cv {
+  ImmCv(ImmCv const&) = delete;
+  ImmCv(ImmCv&&) = delete;
+  void operator=(ImmCv const&) = delete;
+  void operator=(ImmCv&&) = delete;
+};
+
+struct Fn {
+  char operator()(int, int) noexcept { return 'a'; }
+  int volatile&& operator()(int, char const*) { return std::move(x_); }
+  float operator()(float, float) { return 3.14; }
+  /* implicit */ [[maybe_unused]] Cv operator()(Cv*) noexcept;
+  /* implicit */ [[maybe_unused]] ImmCv operator()(ImmCv*) noexcept;
+  int volatile x_ = 17;
+};
+
+namespace invoker {
+
+FOLLY_CREATE_MEMBER_INVOKER_SUITE(test);
+
+}
+
+struct Obj {
+  char test(int, int) noexcept { return 'a'; }
+  int volatile&& test(int, char const*) { return std::move(x_); }
+  float test(float, float) { return 3.14; }
+  int volatile x_ = 17;
+};
+
+namespace x {
+struct Obj {};
+int go(Obj const&, int) noexcept {
+  return 3;
+}
+} // namespace x
+
+namespace y {
+struct Obj {};
+char go(Obj const&, char const*) {
+  return 'a';
+}
+} // namespace y
+
+namespace z {
+struct Obj {};
+} // namespace z
+[[maybe_unused]] float go(z::Obj const&, int) {
+  return 9;
+}
+
+namespace swappable {
+struct Obj {
+  int x_;
+};
+void swap(Obj&, Obj&) noexcept {} // no-op
+} // namespace swappable
+
+struct AltSwappable {};
+struct AltSwappableRet {};
+namespace unswappable {
+[[maybe_unused]] AltSwappableRet swap(AltSwappable&, AltSwappable&);
+} // namespace unswappable
+
+namespace invoker {
+
+FOLLY_CREATE_FREE_INVOKER_SUITE(go);
+FOLLY_CREATE_FREE_INVOKER_SUITE(swap, std, unswappable);
+FOLLY_CREATE_FREE_INVOKER_SUITE(no_such_thing);
+FOLLY_CREATE_QUAL_INVOKER_SUITE(std_swap, ::std::swap);
+
+} // namespace invoker
+
+} // namespace
+
+TEST_F(InvokeTest, invoke) {
+  Fn fn;
+
+  EXPECT_TRUE(noexcept(folly::invoke(fn, 1, 2)));
+  EXPECT_FALSE(noexcept(folly::invoke(fn, 1, "2")));
+
+  EXPECT_EQ('a', folly::invoke(fn, 1, 2));
+  EXPECT_EQ(17, folly::invoke(fn, 1, "2"));
+
+  using FnA = char (Fn::*)(int, int);
+  using FnB = int volatile && (Fn::*)(int, char const*);
+  EXPECT_EQ('a', folly::invoke(static_cast<FnA>(&Fn::operator()), fn, 1, 2));
+  EXPECT_EQ(17, folly::invoke(static_cast<FnB>(&Fn::operator()), fn, 1, "2"));
+}
+
+TEST_F(InvokeTest, invoke_result) {
+  EXPECT_TRUE(
+      (std::is_same<char, folly::invoke_result_t<Fn, int, char>>::value));
+  EXPECT_TRUE(
+      (std::is_same<int volatile&&, folly::invoke_result_t<Fn, int, char*>>::
+           value));
+}
+
+TEST_F(InvokeTest, is_invocable) {
+  EXPECT_TRUE((folly::is_invocable_v<Fn, int, char>));
+  EXPECT_TRUE((folly::is_invocable_v<Fn, int, char*>));
+  EXPECT_FALSE((folly::is_invocable_v<Fn, int>));
+  EXPECT_TRUE((folly::is_invocable_v<Fn, Cv*>));
+  EXPECT_TRUE((folly::is_invocable_v<Fn, ImmCv*>));
+}
+
+TEST_F(InvokeTest, is_invocable_r) {
+  EXPECT_TRUE((folly::is_invocable_r_v<int, Fn, int, char>));
+  EXPECT_TRUE((folly::is_invocable_r_v<int, Fn, int, char*>));
+  EXPECT_FALSE((folly::is_invocable_r_v<int, Fn, int>));
+  EXPECT_TRUE((folly::is_invocable_r_v<std::false_type, Fn, Cv*>));
+  EXPECT_TRUE((folly::is_invocable_r_v<std::true_type, Fn, Cv*>));
+  EXPECT_TRUE((folly::is_invocable_r_v<void, Fn, Cv*>));
+  EXPECT_TRUE((folly::is_invocable_r_v<ImmCv, Fn, ImmCv*>));
+  EXPECT_TRUE((folly::is_invocable_r_v<void, Fn, ImmCv*>));
+  EXPECT_TRUE((folly::is_invocable_r_v<std::false_type, Fn, ImmCv*>));
+  EXPECT_TRUE((folly::is_invocable_r_v<std::true_type, Fn, ImmCv*>));
+}
+
+TEST_F(InvokeTest, is_nothrow_invocable) {
+  EXPECT_TRUE((folly::is_nothrow_invocable_v<Fn, int, char>));
+  EXPECT_FALSE((folly::is_nothrow_invocable_v<Fn, int, char*>));
+  EXPECT_FALSE((folly::is_nothrow_invocable_v<Fn, int>));
+  EXPECT_TRUE((folly::is_nothrow_invocable_v<Fn, Cv*>));
+  EXPECT_TRUE((folly::is_nothrow_invocable_v<Fn, ImmCv*>));
+}
+
+TEST_F(InvokeTest, is_nothrow_invocable_r) {
+  EXPECT_TRUE((folly::is_nothrow_invocable_r_v<int, Fn, int, char>));
+  EXPECT_FALSE((folly::is_nothrow_invocable_r_v<int, Fn, int, char*>));
+  EXPECT_FALSE((folly::is_nothrow_invocable_r_v<int, Fn, int>));
+  EXPECT_FALSE((folly::is_nothrow_invocable_r_v<std::false_type, Fn, Cv*>));
+  EXPECT_TRUE((folly::is_nothrow_invocable_r_v<std::true_type, Fn, Cv*>));
+  EXPECT_TRUE((folly::is_nothrow_invocable_r_v<void, Fn, Cv*>));
+  EXPECT_TRUE((folly::is_nothrow_invocable_r_v<ImmCv, Fn, ImmCv*>));
+  EXPECT_TRUE((folly::is_nothrow_invocable_r_v<void, Fn, ImmCv*>));
+  EXPECT_FALSE((folly::is_nothrow_invocable_r_v<int, Fn, ImmCv*>));
+  EXPECT_FALSE((folly::is_nothrow_invocable_r_v<std::false_type, Fn, ImmCv*>));
+  EXPECT_TRUE((folly::is_nothrow_invocable_r_v<std::true_type, Fn, ImmCv*>));
+}
+
+TEST_F(InvokeTest, free_invoke) {
+  using traits = folly::invoke_traits<decltype(invoker::go)>;
+
+  x::Obj x_;
+  y::Obj y_;
+
+  EXPECT_TRUE(noexcept(traits::invoke(x_, 3)));
+  EXPECT_FALSE(noexcept(traits::invoke(y_, "hello")));
+
+  EXPECT_EQ(3, traits::invoke(x_, 3));
+  EXPECT_EQ('a', traits::invoke(y_, "hello"));
+}
+
+TEST_F(InvokeTest, free_invoke_result) {
+  using traits = folly::invoke_traits<decltype(invoker::go)>;
+
+  EXPECT_TRUE((std::is_same<int, traits::invoke_result_t<x::Obj, int>>::value));
+  EXPECT_TRUE((
+      std::is_same<char, traits::invoke_result_t<y::Obj, char const*>>::value));
+}
+
+TEST_F(InvokeTest, free_is_invocable) {
+  using traits = folly::invoke_traits<decltype(invoker::go)>;
+
+  EXPECT_TRUE((traits::is_invocable_v<x::Obj, int>));
+  EXPECT_TRUE((traits::is_invocable_v<y::Obj, char const*>));
+  EXPECT_FALSE((traits::is_invocable_v<z::Obj, int>));
+  EXPECT_FALSE((traits::is_invocable_v<float>));
+}
+
+TEST_F(InvokeTest, free_is_invocable_r) {
+  using traits = folly::invoke_traits<decltype(invoker::go)>;
+
+  EXPECT_TRUE((traits::is_invocable_r_v<int, x::Obj, int>));
+  EXPECT_TRUE((traits::is_invocable_r_v<char, y::Obj, char const*>));
+  EXPECT_FALSE((traits::is_invocable_r_v<float, z::Obj, int>));
+  EXPECT_FALSE((traits::is_invocable_r_v<from_any, float>));
+}
+
+TEST_F(InvokeTest, free_is_nothrow_invocable) {
+  using traits = folly::invoke_traits<decltype(invoker::go)>;
+
+  EXPECT_TRUE((traits::is_nothrow_invocable_v<x::Obj, int>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_v<y::Obj, char const*>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_v<z::Obj, int>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_v<float>));
+}
+
+TEST_F(InvokeTest, free_is_nothrow_invocable_r) {
+  using traits = folly::invoke_traits<decltype(invoker::go)>;
+
+  EXPECT_TRUE((traits::is_nothrow_invocable_r_v<int, x::Obj, int>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_r_v<char, y::Obj, char const*>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_r_v<float, z::Obj, int>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_r_v<from_any, float>));
+}
+
+TEST_F(InvokeTest, free_invoke_swap) {
+  using traits = folly::invoke_traits<decltype(invoker::swap)>;
+
+  int a = 3;
+  int b = 4;
+
+  traits::invoke(a, b);
+  EXPECT_EQ(4, a);
+  EXPECT_EQ(3, b);
+
+  swappable::Obj x{3};
+  swappable::Obj y{4};
+
+  traits::invoke(x, y);
+  EXPECT_EQ(3, x.x_);
+  EXPECT_EQ(4, y.x_);
+
+  std::swap(x, y);
+  EXPECT_EQ(4, x.x_);
+  EXPECT_EQ(3, y.x_);
+
+  EXPECT_TRUE((
+      traits::is_invocable_r_v<AltSwappableRet, AltSwappable&, AltSwappable&>));
+}
+
+TEST_F(InvokeTest, qual_invoke_swap) {
+  using traits = folly::invoke_traits<decltype(invoker::std_swap)>;
+
+  int a = 3;
+  int b = 4;
+
+  traits::invoke(a, b);
+  EXPECT_EQ(4, a);
+  EXPECT_EQ(3, b);
+
+  swappable::Obj x{3};
+  swappable::Obj y{4};
+
+  traits::invoke(x, y);
+  EXPECT_EQ(4, x.x_);
+  EXPECT_EQ(3, y.x_);
+
+  std::swap(x, y);
+  EXPECT_EQ(3, x.x_);
+  EXPECT_EQ(4, y.x_);
+}
+
+TEST_F(InvokeTest, invoke_qual) {
+  auto go = FOLLY_INVOKE_QUAL(::std::swap);
+
+  int a = 3;
+  int b = 4;
+  EXPECT_TRUE(noexcept(go(a, b)));
+
+  go(a, b);
+  EXPECT_EQ(4, a);
+  EXPECT_EQ(3, b);
+}
+
+TEST_F(InvokeTest, member_invoke) {
+  using traits = folly::invoke_traits<decltype(invoker::test)>;
+
+  Obj fn;
+
+  EXPECT_TRUE(noexcept(traits::invoke(fn, 1, 2)));
+  EXPECT_FALSE(noexcept(traits::invoke(fn, 1, "2")));
+
+  EXPECT_EQ('a', traits::invoke(fn, 1, 2));
+  EXPECT_EQ(17, traits::invoke(fn, 1, "2"));
+}
+
+TEST_F(InvokeTest, member_invoke_result) {
+  using traits = folly::invoke_traits<invoker::test_fn>;
+
+  EXPECT_TRUE(
+      (std::is_same<char, traits::invoke_result_t<Obj, int, char>>::value));
+  EXPECT_TRUE(
+      (std::is_same<int volatile&&, traits::invoke_result_t<Obj, int, char*>>::
+           value));
+}
+
+TEST_F(InvokeTest, member_is_invocable) {
+  using traits = folly::invoke_traits<decltype(invoker::test)>;
+
+  EXPECT_TRUE((traits::is_invocable_v<Obj, int, char>));
+  EXPECT_TRUE((traits::is_invocable_v<Obj, int, char*>));
+  EXPECT_FALSE((traits::is_invocable_v<Obj, int>));
+}
+
+TEST_F(InvokeTest, member_is_invocable_r) {
+  using traits = folly::invoke_traits<decltype(invoker::test)>;
+
+  EXPECT_TRUE((traits::is_invocable_r_v<int, Obj, int, char>));
+  EXPECT_TRUE((traits::is_invocable_r_v<int, Obj, int, char*>));
+  EXPECT_FALSE((traits::is_invocable_r_v<int, Obj, int>));
+}
+
+TEST_F(InvokeTest, member_is_nothrow_invocable) {
+  using traits = folly::invoke_traits<decltype(invoker::test)>;
+
+  EXPECT_TRUE((traits::is_nothrow_invocable_v<Obj, int, char>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_v<Obj, int, char*>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_v<Obj, int>));
+}
+
+TEST_F(InvokeTest, member_is_nothrow_invocable_r) {
+  using traits = folly::invoke_traits<decltype(invoker::test)>;
+
+  EXPECT_TRUE((traits::is_nothrow_invocable_r_v<int, Obj, int, char>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_r_v<int, Obj, int, char*>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_r_v<int, Obj, int>));
+}
+
+TEST_F(InvokeTest, invoke_member) {
+  auto test = FOLLY_INVOKE_MEMBER(test);
+
+  Obj fn;
+
+  EXPECT_TRUE(noexcept(test(fn, 1, 2)));
+  EXPECT_FALSE(noexcept(test(fn, 1, "2")));
+
+  EXPECT_EQ('a', test(fn, 1, 2));
+  EXPECT_EQ(17, test(fn, 1, "2"));
+}
+
+namespace {
+
+namespace invoker {
+
+FOLLY_CREATE_STATIC_MEMBER_INVOKER_SUITE(stat);
+
+}
+
+} // namespace
+
+TEST_F(InvokeTest, static_member_invoke) {
+  struct HasStat {
+    static char stat(int, int) noexcept { return 'a'; }
+    static int volatile&& stat(int, char const*) {
+      static int volatile x_ = 17;
+      return std::move(x_);
+    }
+    static float stat(float, float) { return 3.14; }
+  };
+  using traits = folly::invoke_traits<decltype(invoker::stat<HasStat>)>;
+
+  EXPECT_TRUE((traits::is_invocable_v<int, char>));
+  EXPECT_TRUE((traits::is_invocable_v<int, char>));
+  EXPECT_TRUE((traits::is_invocable_v<int, char*>));
+  EXPECT_FALSE((traits::is_invocable_v<int>));
+
+  EXPECT_TRUE((traits::is_invocable_r_v<int, int, char>));
+  EXPECT_TRUE((traits::is_invocable_r_v<int, int, char*>));
+  EXPECT_FALSE((traits::is_invocable_r_v<int, int>));
+
+  EXPECT_TRUE((traits::is_nothrow_invocable_v<int, char>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_v<int, char*>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_v<int>));
+
+  EXPECT_TRUE((traits::is_nothrow_invocable_r_v<int, int, char>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_r_v<int, int, char*>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_r_v<int, int>));
+}
+
+TEST_F(InvokeTest, static_member_no_invoke) {
+  struct HasNoStat {};
+
+  using traits = folly::invoke_traits<decltype(invoker::stat<HasNoStat>)>;
+
+  EXPECT_FALSE((traits::is_invocable_v<>));
+  EXPECT_FALSE((traits::is_invocable_v<int>));
+
+  EXPECT_FALSE((traits::is_invocable_r_v<int>));
+  EXPECT_FALSE((traits::is_invocable_r_v<int, int>));
+
+  EXPECT_FALSE((traits::is_nothrow_invocable_v<>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_v<int>));
+
+  EXPECT_FALSE((traits::is_nothrow_invocable_r_v<int>));
+  EXPECT_FALSE((traits::is_nothrow_invocable_r_v<int, int>));
+}
+
+TEST_F(InvokeTest, invoke_first_match) {
+  struct a {
+    [[maybe_unused]] void operator()(int) const;
+  };
+  struct b {
+    [[maybe_unused]] void operator()(int) const;
+  };
+  struct c {
+    [[maybe_unused]] void operator()() const;
+  };
+  using inv = folly::invoke_first_match<a, b, c>;
+  EXPECT_TRUE((folly::is_invocable_v<inv const&, int>));
+  EXPECT_TRUE((folly::is_invocable_v<inv const&>));
+  EXPECT_FALSE((folly::is_invocable_v<inv const&, int, int>));
+}
+
+namespace {
+
+struct TestCustomisationPointFn {
+  template <typename T, typename U>
+  constexpr auto operator()(T&& t, U&& u) const noexcept(
+      folly::is_nothrow_tag_invocable_v<TestCustomisationPointFn, T, U>)
+      -> folly::tag_invoke_result_t<TestCustomisationPointFn, T, U> {
+    return folly::tag_invoke(*this, static_cast<T&&>(t), static_cast<U&&>(u));
+  }
+};
+
+FOLLY_DEFINE_CPO(TestCustomisationPointFn, testCustomisationPoint)
+
+struct TypeA {
+  constexpr friend int tag_invoke(
+      folly::cpo_t<testCustomisationPoint>, const TypeA&, int value) {
+    return value * 2;
+  }
+  constexpr friend bool tag_invoke(
+      folly::cpo_t<testCustomisationPoint>, const TypeA&, bool value) noexcept {
+    return !value;
+  }
+};
+
+} // namespace
+
+static_assert(
+    folly::is_invocable<decltype(testCustomisationPoint), TypeA, int>::value);
+static_assert(
+    !folly::is_invocable<decltype(testCustomisationPoint), TypeA, TypeA>::
+        value);
+static_assert(
+    folly::is_nothrow_invocable<decltype(testCustomisationPoint), TypeA, bool>::
+        value);
+static_assert(
+    !folly::is_nothrow_invocable<decltype(testCustomisationPoint), TypeA, int>::
+        value);
+static_assert(
+    std::is_same<
+        folly::invoke_result_t<decltype(testCustomisationPoint), TypeA, int>,
+        int>::value);
+
+// Test that the CPO forwards through constexpr-ness of the
+// customisations by evaluating the CPO in a static_assert()
+// which forces compile-time evaluation.
+static_assert(testCustomisationPoint(TypeA{}, 10) == 20);
+static_assert(!testCustomisationPoint(TypeA{}, true));
+
+TEST_F(InvokeTest, TagInvokeCustomisationPoint) {
+  const TypeA a;
+  EXPECT_EQ(10, testCustomisationPoint(a, 5));
+  EXPECT_EQ(false, testCustomisationPoint(a, true));
+}

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

@@ -0,0 +1,141 @@
+/*
+ * 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/Partial.h>
+
+#include <memory>
+
+#include <folly/Function.h>
+#include <folly/portability/GTest.h>
+
+using folly::partial;
+
+int add3(int x, int y, int z) {
+  return 100 * x + 10 * y + z;
+}
+
+TEST(Partial, Simple) {
+  auto p0 = partial(&add3);
+  EXPECT_EQ(123, p0(1, 2, 3));
+
+  auto p1 = partial(&add3, 2);
+  EXPECT_EQ(234, p1(3, 4));
+
+  auto p2 = partial(&add3, 3, 4);
+  EXPECT_EQ(345, p2(5));
+
+  auto p3 = partial(&add3, 4, 5, 6);
+  EXPECT_EQ(456, p3());
+}
+
+struct Foo {
+  int method(int& x, int& y, int& z) { return 1000 + 100 * x + 10 * y + z; }
+  int constMethod(int const& x, int const& y, int const& z) const {
+    return 2000 + 100 * x + 10 * y + z;
+  }
+  int tempMethod(int&& x, int&& y, int&& z) {
+    return 3000 + 100 * x + 10 * y + z;
+  }
+};
+
+TEST(Partial, ReferenceArguments) {
+  auto p0 = partial(&Foo::method, Foo{}, 2, 3);
+  int four = 4;
+  EXPECT_EQ(1234, p0(four));
+
+  auto const p1 = partial(&Foo::constMethod, Foo{}, 3, 4);
+  EXPECT_EQ(2345, p1(5));
+
+  auto p2 = partial(&Foo::tempMethod, Foo{}, 4, 5);
+  EXPECT_EQ(3456, std::move(p2)(6));
+}
+
+struct RefQualifiers {
+  int operator()(int x, int y, int z) & { return 1000 + 100 * x + 10 * y + z; }
+  int operator()(int x, int y, int z) const& {
+    return 2000 + 100 * x + 10 * y + z;
+  }
+  int operator()(int x, int y, int z) && { return 3000 + 100 * x + 10 * y + z; }
+};
+
+TEST(Partial, RefQualifiers) {
+  auto p = partial(RefQualifiers{});
+  auto const& pconst = p;
+
+  EXPECT_EQ(1234, p(2, 3, 4));
+  EXPECT_EQ(2345, pconst(3, 4, 5));
+  EXPECT_EQ(3456, std::move(p)(4, 5, 6));
+}
+
+struct RefQualifiers2 {
+  int operator()(int& x, int const& y, int z) & {
+    return 1000 + 100 * x + 10 * y + z;
+  }
+  int operator()(int const& x, int y, int z) const& {
+    return 2000 + 100 * x + 10 * y + z;
+  }
+  int operator()(int&& x, int const& y, int z) && {
+    return 3000 + 100 * x + 10 * y + z;
+  }
+};
+
+TEST(Partial, RefQualifiers2) {
+  auto p = partial(RefQualifiers2{}, 9, 8);
+  auto const& pconst = p;
+
+  EXPECT_EQ(1984, p(4));
+  EXPECT_EQ(2985, pconst(5));
+  EXPECT_EQ(3986, std::move(p)(6));
+}
+
+std::unique_ptr<int> calc_uptr(std::unique_ptr<int> x, std::unique_ptr<int> y) {
+  *x = 100 * *x + 10 * *y;
+  return x;
+}
+
+TEST(Partial, MoveOnly) {
+  auto five = std::make_unique<int>(5);
+  auto six = std::make_unique<int>(6);
+
+  // create a partial object which holds a pointer to the `calc_uptr` function
+  // and a `unique_ptr<int>` for the first argument
+  auto p = partial(&calc_uptr, std::move(five));
+
+  // `five` should be moved out of
+  EXPECT_FALSE(five);
+
+  // call to the partial object as rvalue, which allows the call to consume
+  // captured data (here: the `unique_ptr<int>` storing 5), and pass it
+  // the other `unique_ptr`
+  auto result = std::move(p)(std::move(six));
+
+  // ...which now should be moved out of
+  EXPECT_FALSE(six);
+
+  EXPECT_EQ(560, *result);
+}
+
+TEST(Partial, WrapInStdFunction) {
+  auto p1 = partial(&add3, 2);
+  std::function<int(int, int)> func = p1;
+  EXPECT_EQ(234, func(3, 4));
+}
+
+TEST(Partial, WrapInFollyFunction) {
+  auto p1 = partial(&add3, 2);
+  folly::Function<int(int, int)> func = p1;
+  EXPECT_EQ(234, func(3, 4));
+}