react-native-windows 0.84.0 → 0.84.2

package/external/folly/folly/lang/test/PrettyTest.cpp

@@ -0,0 +1,44 @@
+/*
+ * 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/lang/Pretty.h>
+
+#include <folly/portability/GTest.h>
+
+namespace folly {
+
+class PrettyTest : public testing::Test {};
+
+TEST_F(PrettyTest, example) {
+  constexpr auto const name = pretty_name<int>();
+  EXPECT_STREQ("int", name);
+}
+
+TEST_F(PrettyTest, example_msc) {
+  constexpr auto const tag = detail::pretty_tag_msc{};
+  constexpr auto const& name = "void __cdecl foo<int>(void)";
+  constexpr auto const info = detail::pretty_parse(tag, name);
+  EXPECT_EQ("int", detail::pretty_info_to<std::string>(info, name));
+}
+
+TEST_F(PrettyTest, example_gcc) {
+  constexpr auto const tag = detail::pretty_tag_gcc{};
+  constexpr auto const& name = "void foo() [T = int]";
+  constexpr auto const info = detail::pretty_parse(tag, name);
+  EXPECT_EQ("int", detail::pretty_info_to<std::string>(info, name));
+}
+
+} // namespace folly

package/external/folly/folly/lang/test/PropagateConstTest.cpp

@@ -0,0 +1,356 @@
+/*
+ * 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/lang/PropagateConst.h>
+
+#include <memory>
+
+#include <folly/portability/GTest.h>
+
+using namespace folly;
+
+class PropagateConstTest : public testing::Test {};
+
+//  force complete template instantiations
+template class folly::propagate_const<int*>;
+template class folly::propagate_const<std::unique_ptr<int>>;
+template class folly::propagate_const<std::shared_ptr<int>>;
+
+template <typename T>
+static bool is_const(T&&) {
+  return std::is_const<std::remove_reference_t<T>>::value;
+}
+
+template <typename T>
+using pc = propagate_const<T>;
+
+TEST_F(PropagateConstTest, construct_assign) {
+  struct Source {
+    int& operator*();
+    int* get();
+  };
+  struct Implicit {
+    int& operator*();
+    int* get();
+    /* implicit */ Implicit(Source) {}
+  };
+  struct Explicit {
+    int& operator*();
+    int* get();
+    explicit Explicit(Source) {}
+  };
+
+  EXPECT_TRUE((std::is_constructible<pc<Implicit>, Source>::value));
+  EXPECT_TRUE((std::is_constructible<pc<Explicit>, Source>::value));
+  EXPECT_TRUE((std::is_convertible<Source, pc<Implicit>>::value));
+  EXPECT_FALSE((std::is_convertible<Source, pc<Explicit>>::value));
+  EXPECT_TRUE((std::is_assignable<pc<Implicit>, Source>::value));
+  EXPECT_FALSE((std::is_assignable<pc<Explicit>, Source>::value));
+
+  EXPECT_TRUE((std::is_constructible<pc<Implicit>, pc<Source>>::value));
+  EXPECT_TRUE((std::is_constructible<pc<Explicit>, pc<Source>>::value));
+  EXPECT_TRUE((std::is_convertible<pc<Source>, pc<Implicit>>::value));
+  EXPECT_FALSE((std::is_convertible<pc<Source>, pc<Explicit>>::value));
+  EXPECT_TRUE((std::is_assignable<pc<Implicit>, pc<Source>>::value));
+  EXPECT_FALSE((std::is_assignable<pc<Explicit>, pc<Source>>::value));
+}
+
+TEST_F(PropagateConstTest, op_assign_move) {
+  auto ptr = pc<std::unique_ptr<int>>{std::make_unique<int>(1)};
+  EXPECT_EQ(*ptr, 1);
+
+  ptr = std::make_unique<int>(2);
+  EXPECT_EQ(*ptr, 2);
+}
+
+TEST_F(PropagateConstTest, get) {
+  int data[1] = {3};
+  auto a = data + 0;
+  auto pc_a = pc<int*>(a);
+
+  EXPECT_EQ(a, pc_a.get());
+  EXPECT_EQ(a, std::as_const(pc_a).get());
+  EXPECT_FALSE(is_const(*pc_a.get()));
+  EXPECT_TRUE(is_const(*std::as_const(pc_a).get()));
+}
+
+TEST_F(PropagateConstTest, op_indirect) {
+  int data[1] = {3};
+  auto a = data + 0;
+  auto pc_a = pc<int*>(a);
+
+  EXPECT_EQ(a, &*pc_a);
+  EXPECT_EQ(a, &*std::as_const(pc_a));
+  EXPECT_FALSE(is_const(*pc_a));
+  EXPECT_TRUE(is_const(*std::as_const(pc_a)));
+}
+
+TEST_F(PropagateConstTest, op_element_type_ptr) {
+  int data[1] = {3};
+  auto a = data + 0;
+  auto pc_a = pc<int*>(a);
+
+  EXPECT_EQ(a, static_cast<int*>(pc_a));
+  EXPECT_EQ(a, static_cast<int const*>(std::as_const(pc_a)));
+}
+
+TEST_F(PropagateConstTest, op_bool) {
+  int data[1] = {3};
+  auto a = data + 0;
+  auto pc_a = pc<int*>(a);
+  auto pc_0 = pc<int*>(nullptr);
+
+  EXPECT_TRUE(pc_a);
+  EXPECT_FALSE(pc_0);
+}
+
+TEST_F(PropagateConstTest, get_underlying) {
+  int data[1] = {3};
+  auto a = data + 0;
+  auto pc_a = pc<int*>(a);
+
+  EXPECT_EQ(a, get_underlying(pc_a));
+  EXPECT_EQ(a, get_underlying(std::as_const(pc_a)));
+  EXPECT_FALSE(is_const(get_underlying(pc_a)));
+  EXPECT_TRUE(is_const(get_underlying(std::as_const(pc_a))));
+  EXPECT_TRUE(&get_underlying(pc_a) == &get_underlying(std::as_const(pc_a)));
+}
+
+TEST_F(PropagateConstTest, swap) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  swap(pc_a, pc_b);
+  EXPECT_EQ(3, *pc_b);
+  EXPECT_EQ(4, *pc_a);
+
+  swap(pc_a, pc_b);
+  EXPECT_EQ(3, *pc_a);
+  EXPECT_EQ(4, *pc_b);
+}
+
+TEST_F(PropagateConstTest, op_equal_to) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  auto _ = [](auto&& x, auto&& y) { return x == y; };
+  EXPECT_TRUE(_(pc_a, pc_a));
+  EXPECT_FALSE(_(pc_a, pc_b));
+  EXPECT_FALSE(_(pc_a, nullptr));
+  EXPECT_TRUE(_(pc_a, a));
+  EXPECT_FALSE(_(pc_a, b));
+  EXPECT_TRUE(_(a, pc_a));
+  EXPECT_FALSE(_(b, pc_a));
+}
+
+TEST_F(PropagateConstTest, op_not_equal_to) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  auto _ = [](auto&& x, auto&& y) { return x != y; };
+  EXPECT_FALSE(_(pc_a, pc_a));
+  EXPECT_TRUE(_(pc_a, pc_b));
+  EXPECT_TRUE(_(pc_a, nullptr));
+  EXPECT_FALSE(_(pc_a, a));
+  EXPECT_TRUE(_(pc_a, b));
+  EXPECT_FALSE(_(a, pc_a));
+  EXPECT_TRUE(_(b, pc_a));
+}
+
+TEST_F(PropagateConstTest, op_less) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  auto _ = [](auto&& x, auto&& y) { return x < y; };
+  EXPECT_FALSE(_(pc_a, pc_a));
+  EXPECT_FALSE(_(pc_a, a));
+  EXPECT_FALSE(_(a, pc_a));
+  EXPECT_TRUE(_(pc_a, pc_b));
+  EXPECT_TRUE(_(pc_a, b));
+  EXPECT_TRUE(_(a, pc_b));
+  EXPECT_FALSE(_(pc_b, pc_a));
+  EXPECT_FALSE(_(pc_b, a));
+  EXPECT_FALSE(_(b, pc_a));
+  EXPECT_FALSE(_(pc_b, pc_b));
+  EXPECT_FALSE(_(pc_b, b));
+  EXPECT_FALSE(_(b, pc_b));
+}
+
+TEST_F(PropagateConstTest, op_greater) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  auto _ = [](auto&& x, auto&& y) { return x > y; };
+  EXPECT_FALSE(_(pc_a, pc_a));
+  EXPECT_FALSE(_(pc_a, a));
+  EXPECT_FALSE(_(a, pc_a));
+  EXPECT_FALSE(_(pc_a, pc_b));
+  EXPECT_FALSE(_(pc_a, b));
+  EXPECT_FALSE(_(a, pc_b));
+  EXPECT_TRUE(_(pc_b, pc_a));
+  EXPECT_TRUE(_(pc_b, a));
+  EXPECT_TRUE(_(b, pc_a));
+  EXPECT_FALSE(_(pc_b, pc_b));
+  EXPECT_FALSE(_(pc_b, b));
+  EXPECT_FALSE(_(b, pc_b));
+}
+
+TEST_F(PropagateConstTest, op_less_equal) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  auto _ = [](auto&& x, auto&& y) { return x <= y; };
+  EXPECT_TRUE(_(pc_a, pc_a));
+  EXPECT_TRUE(_(pc_a, a));
+  EXPECT_TRUE(_(a, pc_a));
+  EXPECT_TRUE(_(pc_a, pc_b));
+  EXPECT_TRUE(_(pc_a, b));
+  EXPECT_TRUE(_(a, pc_b));
+  EXPECT_FALSE(_(pc_b, pc_a));
+  EXPECT_FALSE(_(pc_b, a));
+  EXPECT_FALSE(_(b, pc_a));
+  EXPECT_TRUE(_(pc_b, pc_b));
+  EXPECT_TRUE(_(pc_b, b));
+  EXPECT_TRUE(_(b, pc_b));
+}
+
+TEST_F(PropagateConstTest, op_greater_equal) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  auto _ = [](auto&& x, auto&& y) { return x >= y; };
+  EXPECT_TRUE(_(pc_a, pc_a));
+  EXPECT_TRUE(_(pc_a, a));
+  EXPECT_TRUE(_(a, pc_a));
+  EXPECT_FALSE(_(pc_a, pc_b));
+  EXPECT_FALSE(_(pc_a, b));
+  EXPECT_FALSE(_(a, pc_b));
+  EXPECT_TRUE(_(pc_b, pc_a));
+  EXPECT_TRUE(_(pc_b, a));
+  EXPECT_TRUE(_(b, pc_a));
+  EXPECT_TRUE(_(pc_b, pc_b));
+  EXPECT_TRUE(_(pc_b, b));
+  EXPECT_TRUE(_(b, pc_b));
+}
+
+TEST_F(PropagateConstTest, hash) {
+  int data[1] = {3};
+  auto a = data + 0;
+  auto pc_a = pc<int*>(a);
+
+  EXPECT_EQ(std::hash<int*>()(a), std::hash<pc<int*>>()(pc_a));
+}
+
+TEST_F(PropagateConstTest, equal_to) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  auto _ = std::equal_to<pc<int*>>{};
+  EXPECT_TRUE(_(pc_a, pc_a));
+  EXPECT_FALSE(_(pc_a, pc_b));
+}
+
+TEST_F(PropagateConstTest, not_equal_to) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  auto _ = std::not_equal_to<pc<int*>>{};
+  EXPECT_FALSE(_(pc_a, pc_a));
+  EXPECT_TRUE(_(pc_a, pc_b));
+}
+
+TEST_F(PropagateConstTest, less) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  auto _ = std::less<pc<int*>>{};
+  EXPECT_FALSE(_(pc_a, pc_a));
+  EXPECT_TRUE(_(pc_a, pc_b));
+  EXPECT_FALSE(_(pc_b, pc_a));
+  EXPECT_FALSE(_(pc_b, pc_b));
+}
+
+TEST_F(PropagateConstTest, greater) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  auto _ = std::greater<pc<int*>>{};
+  EXPECT_FALSE(_(pc_a, pc_a));
+  EXPECT_FALSE(_(pc_a, pc_b));
+  EXPECT_TRUE(_(pc_b, pc_a));
+  EXPECT_FALSE(_(pc_b, pc_b));
+}
+
+TEST_F(PropagateConstTest, less_equal) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  auto _ = std::less_equal<pc<int*>>{};
+  EXPECT_TRUE(_(pc_a, pc_a));
+  EXPECT_TRUE(_(pc_a, pc_b));
+  EXPECT_FALSE(_(pc_b, pc_a));
+  EXPECT_TRUE(_(pc_b, pc_b));
+}
+
+TEST_F(PropagateConstTest, greater_equal) {
+  int data[2] = {3, 4};
+  auto a = data + 0;
+  auto b = data + 1;
+  auto pc_a = pc<int*>(a);
+  auto pc_b = pc<int*>(b);
+
+  auto _ = std::greater_equal<pc<int*>>{};
+  EXPECT_TRUE(_(pc_a, pc_a));
+  EXPECT_FALSE(_(pc_a, pc_b));
+  EXPECT_TRUE(_(pc_b, pc_a));
+  EXPECT_TRUE(_(pc_b, pc_b));
+}

package/external/folly/folly/lang/test/RValueReferenceWrapperTest.cpp

@@ -0,0 +1,85 @@
+/*
+ * 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/lang/RValueReferenceWrapper.h>
+
+#include <utility>
+
+#include <folly/portability/GTest.h>
+
+TEST(RvalueReferenceWrapper, MoveAndConvert) {
+  using folly::rvalue_reference_wrapper;
+
+  // Destructive moves.
+  int i1 = 0;
+  rvalue_reference_wrapper<int> rref1(std::move(i1));
+  ASSERT_TRUE(rref1.valid());
+  rvalue_reference_wrapper<int> rref0(std::move(rref1));
+  ASSERT_TRUE(rref0.valid());
+  ASSERT_FALSE(rref1.valid());
+  rref1 = std::move(rref0);
+  ASSERT_FALSE(rref0.valid());
+  ASSERT_TRUE(rref1.valid());
+  const int& r1 = std::move(rref1);
+  ASSERT_FALSE(rref1.valid());
+  ASSERT_EQ(&r1, &i1);
+
+  // Destructive unwrap to T&&.
+  int i2 = 0;
+  rvalue_reference_wrapper<int> rref2(std::move(i2));
+  int&& r2 = std::move(rref2);
+  ASSERT_EQ(&r2, &i2);
+
+  // Destructive unwrap to const T&.
+  const int i3 = 0;
+  rvalue_reference_wrapper<const int> rref3(std::move(i3));
+  const int& r3 = std::move(rref3);
+  ASSERT_EQ(&r3, &i3);
+
+  // Destructive unwrap to const T&&.
+  const int i4 = 0;
+  rvalue_reference_wrapper<const int> rref4(std::move(i4));
+  const int&& r4 = std::move(rref4);
+  ASSERT_EQ(&r4, &i4);
+
+  /*
+   * Things that intentionally do not compile. Copy construction, copy
+   * assignment, unwrap of lvalue reference to wrapper, const violations.
+   *
+  int i5;
+  const int i6 = 0;
+  rvalue_reference_wrapper<int> rref5(i5);
+  rvalue_reference_wrapper<const int> rref6(i6);
+  rref1 = rref5;
+  int& r5 = rref5;
+  const int& r6 = rref6;
+  int i7;
+  const rvalue_reference_wrapper<int> rref7(std::move(i7));
+  int& r7 = std::move(rref7);
+  */
+}
+
+TEST(RvalueReferenceWrapper, Call) {
+  int a = 4711, b, c;
+  auto callMe = [&](int x, const int& y, int&& z) -> int {
+    EXPECT_EQ(a, x);
+    EXPECT_EQ(&b, &y);
+    EXPECT_EQ(&c, &z);
+    return a;
+  };
+  int result = folly::rref(std::move(callMe))(a, b, std::move(c));
+  EXPECT_EQ(a, result);
+}

package/external/folly/folly/lang/test/SafeAssertTest.cpp

@@ -0,0 +1,75 @@
+/*
+ * 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/lang/SafeAssert.h>
+
+#include <glog/logging.h>
+
+#include <folly/Benchmark.h>
+#include <folly/Conv.h>
+#include <folly/lang/Keep.h>
+#include <folly/portability/GTest.h>
+
+extern "C" FOLLY_KEEP void check_folly_safe_check(bool cond) {
+  FOLLY_SAFE_CHECK(cond, "the condition failed");
+  folly::detail::keep_sink();
+}
+
+extern "C" FOLLY_KEEP void check_folly_safe_pcheck(bool cond) {
+  FOLLY_SAFE_PCHECK(cond, "the condition failed");
+  folly::detail::keep_sink();
+}
+
+// clang-format off
+[[noreturn]] void fail() {
+  FOLLY_SAFE_CHECK(0 + 0, "hello");
+}
+// clang-format on
+
+void succeed() {
+  FOLLY_SAFE_CHECK(1, "world");
+}
+
+TEST(SafeAssert, AssertionFailure) {
+  succeed();
+  EXPECT_DEATH(fail(), "Assertion failure: 0 \\+ 0");
+  EXPECT_DEATH(fail(), "Message: hello");
+}
+
+TEST(SafeAssert, AssertionFailureVariadicFormattedArgs) {
+  FOLLY_SAFE_CHECK(true);
+  EXPECT_DEATH( //
+      ([] { FOLLY_SAFE_CHECK(false); }()), //
+      "Assertion failure: false");
+  EXPECT_DEATH( //
+      ([] { FOLLY_SAFE_CHECK(false, 17ull, " < ", 18ull); }()), //
+      "Message: 17 < 18");
+}
+
+TEST(SafeAssert, AssertionFailureErrno) {
+  EXPECT_DEATH(
+      ([] { FOLLY_SAFE_PCHECK((errno = EINVAL) && false, "hello"); }()),
+      folly::to<std::string>("Error: ", EINVAL, " \\(EINVAL\\)"));
+  EXPECT_DEATH(
+      ([] { FOLLY_SAFE_PCHECK((errno = 999) && false, "hello"); }()),
+      folly::to<std::string>("Error: 999 \\(<unknown>\\)"));
+}
+
+TEST(SafeAssert, Fatal) {
+  EXPECT_DEATH( //
+      ([] { FOLLY_SAFE_FATAL("hello"); })(),
+      "Message: hello");
+}

package/external/folly/folly/lang/test/ThunkTest.cpp

@@ -0,0 +1,105 @@
+/*
+ * 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/lang/Thunk.h>
+
+#include <string>
+#include <string_view>
+
+#include <folly/Traits.h>
+#include <folly/portability/GTest.h>
+
+namespace folly::detail {
+
+class ThunkTest : public testing::Test {};
+
+TEST_F(ThunkTest, make_ruin) {
+  auto make0 = thunk::make<std::string>;
+  auto make1 = thunk::make<std::string, std::string_view>;
+  auto makeC = thunk::make_copy<std::string>;
+  auto makeM = thunk::make_move<std::string>;
+  auto ruin = thunk::ruin<std::string>;
+
+  {
+    auto str = make0();
+    EXPECT_EQ("", *(std::string*)str);
+    ruin(str);
+  }
+  {
+    auto str = make1("blargh");
+    EXPECT_EQ("blargh", *(std::string*)str);
+    ruin(str);
+  }
+  {
+    std::string const src{"blargh"};
+    auto str = makeC((void const*)&src);
+    EXPECT_EQ("blargh", *(std::string*)str);
+    ruin(str);
+    EXPECT_EQ("blargh", src);
+  }
+  {
+    std::string src{"blargh blargh blargh blargh"};
+    auto str = makeM((void*)&src);
+    EXPECT_EQ("blargh blargh blargh blargh", *(std::string*)str);
+    ruin(str);
+    EXPECT_EQ("", src);
+  }
+}
+
+TEST_F(ThunkTest, ctor_dtor) {
+  auto ctor0 = thunk::ctor<std::string>;
+  auto ctor1 = thunk::ctor<std::string, std::string_view>;
+  auto ctorC = thunk::ctor_copy<std::string>;
+  auto ctorM = thunk::ctor_move<std::string>;
+  auto dtor = thunk::dtor<std::string>;
+  aligned_storage_for_t<std::string> buf;
+
+  {
+    auto str = ctor0(&buf);
+    EXPECT_EQ("", *(std::string*)str);
+    dtor(str);
+  }
+  {
+    auto str = ctor1(&buf, "blargh");
+    EXPECT_EQ("blargh", *(std::string*)str);
+    dtor(str);
+  }
+  {
+    std::string const src{"blargh"};
+    auto str = ctorC(&buf, (void const*)&src);
+    EXPECT_EQ("blargh", *(std::string*)str);
+    dtor(str);
+    EXPECT_EQ("blargh", src);
+  }
+  {
+    std::string src{"blargh blargh blargh blargh"};
+    auto str = ctorM(&buf, (void*)&src);
+    EXPECT_EQ("blargh blargh blargh blargh", *(std::string*)str);
+    dtor(str);
+    EXPECT_EQ("", src);
+  }
+}
+
+TEST_F(ThunkTest, operator_new_delete) {
+  auto ptr = thunk::operator_new<64, 32>();
+  EXPECT_NE(nullptr, ptr);
+  thunk::operator_delete<64, 32>(ptr);
+  ptr = thunk::operator_new_nx<64, 32>();
+  EXPECT_NE(nullptr, ptr);
+  thunk::operator_delete<64, 32>(ptr);
+}
+
+} // namespace folly::detail