react-native-windows 0.84.0 → 0.84.1

package/external/folly/folly/detail/test/BUCK

@@ -0,0 +1,118 @@
+load("@fbcode_macros//build_defs:cpp_benchmark.bzl", "cpp_benchmark")
+load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
+
+oncall("fbcode_entropy_wardens_folly")
+
+cpp_unittest(
+    name = "async_trace_test",
+    srcs = ["AsyncTraceTest.cpp"],
+    deps = [
+        "//folly/detail:async_trace",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "static_singleton_manager_test",
+    srcs = ["StaticSingletonManagerTest.cpp"],
+    supports_static_listing = False,
+    deps = [
+        "//folly/detail:static_singleton_manager",
+        "//folly/lang:keep",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "unique_instance_test",
+    srcs = ["UniqueInstanceTest.cpp"],
+    deps = [
+        "//folly:string",
+        "//folly:traits",
+        "//folly/detail:unique_instance",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "file_util_detail_test",
+    srcs = [
+        "FileUtilDetailTest.cpp",
+    ],
+    deps = [
+        "//folly/detail:file_util_detail",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "perf_scoped_test",
+    srcs = [
+        "PerfScopedTest.cpp",
+    ],
+    deps = [
+        "//folly/detail:perf_scoped",
+        "//folly/portability:gmock",
+        "//folly/portability:gtest",
+        "//folly/portability:unistd",
+    ],
+)
+
+cpp_unittest(
+    name = "simple_simd_string_utils_test",
+    srcs = [
+        "SimpleSimdStringUtilsTest.cpp",
+    ],
+    deps = [
+        "//folly/algorithm/simd/detail:simd_platform",
+        "//folly/detail:simple_simd_string_utils",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "split_string_simd_test",
+    srcs = [
+        "SplitStringSimdTest.cpp",
+    ],
+    deps = [
+        "//folly:fbstring",
+        "//folly:fbvector",
+        "//folly:range",
+        "//folly:small_vector",
+        "//folly/detail:split_string_simd",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "thread_local_detail_test",
+    srcs = [
+        "ThreadLocalDetailTest.cpp",
+    ],
+    deps = [
+        "//folly:synchronized",
+        "//folly:thread_local",
+        "//folly/portability:gtest",
+        "//folly/synchronization/test:barrier",
+    ],
+)
+
+cpp_benchmark(
+    name = "thread_local_benchmark",
+    srcs = ["ThreadLocalBenchmark.cpp"],
+    deps = [
+        "//folly:benchmark",
+        "//folly:thread_local",
+        "//folly/synchronization/test:barrier",
+    ],
+)
+
+cpp_unittest(
+    name = "traponavx512_test_negative",
+    srcs = ["TrapOnAvx512TestNegative.cpp"],
+    deps = [
+        "//folly/detail:traponavx512",
+        "//folly/portability:gtest",
+    ],
+)

package/external/folly/folly/detail/test/FileUtilDetailTest.cpp

@@ -0,0 +1,56 @@
+/*
+ * 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/detail/FileUtilDetail.h>
+#include <folly/portability/GTest.h>
+
+namespace folly {
+namespace fileutil_detail {
+
+class FileUtilDetailTest : public ::testing::Test {};
+
+TEST_F(FileUtilDetailTest, TemporaryPathWithoutTemporaryDirectory) {
+  auto path = std::string{"/a/b/c"};
+  auto tempPath = getTemporaryFilePathString(path, std::string{});
+  EXPECT_EQ(tempPath, "/a/b/c.XXXXXX");
+}
+
+TEST_F(FileUtilDetailTest, TemporaryPathWithoutTemporaryDirectoryRelative) {
+  auto path = std::string{"a/b/c"};
+  auto tempPath = getTemporaryFilePathString(path, std::string{});
+  EXPECT_EQ(tempPath, "a/b/c.XXXXXX");
+}
+
+TEST_F(
+    FileUtilDetailTest,
+    TemporaryPathWithoutTemporaryDirectoryWithTempDirectoryAbsolute) {
+  auto path = std::string{"a/b/c"};
+  auto tempDirectory = std::string{"/temp/directory/"};
+  auto tempPath = getTemporaryFilePathString(path, tempDirectory);
+  EXPECT_EQ(tempPath, "/temp/directory/tempForAtomicWrite.XXXXXX");
+}
+
+TEST_F(
+    FileUtilDetailTest,
+    TemporaryPathWithoutTemporaryDirectoryWithTempDirectoryRelative) {
+  auto path = std::string{"a/b/c"};
+  auto tempDirectory = std::string{"temp/directory/"};
+  auto tempPath = getTemporaryFilePathString(path, tempDirectory);
+  EXPECT_EQ(tempPath, "temp/directory/tempForAtomicWrite.XXXXXX");
+}
+
+} // namespace fileutil_detail
+} // namespace folly

package/external/folly/folly/detail/test/PerfScopedTest.cpp

@@ -0,0 +1,107 @@
+/*
+ * 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/detail/PerfScoped.h>
+
+#include <folly/portability/GMock.h>
+#include <folly/portability/GTest.h>
+#include <folly/portability/Unistd.h>
+
+#include <thread>
+
+#if FOLLY_PERF_IS_SUPPORTED
+
+namespace folly {
+namespace detail {
+namespace {
+
+// This is obviously not amazing
+// but if perf didn't start properly,
+// we won't get any results.
+template <typename Test>
+void retryWithTimeOuts(Test test) {
+  for (auto timeOut = std::chrono::seconds(1);
+       timeOut != std::chrono::seconds(10);
+       ++timeOut) {
+    if (test(timeOut)) {
+      return;
+    }
+  }
+}
+
+TEST(PerfScopedTest, Stat) {
+  std::string output;
+
+  retryWithTimeOuts([&](auto timeOut) {
+    {
+      PerfScoped perf{{"stat"}, &output};
+      std::this_thread::sleep_for(timeOut);
+    }
+    return !output.empty();
+  });
+
+  ASSERT_THAT(
+      output, ::testing::HasSubstr("Performance counter stats for process id"));
+}
+
+TEST(PerfScopedTest, Move) {
+  std::string output;
+
+  retryWithTimeOuts([&](auto timeOut) {
+    {
+      PerfScoped assignHere;
+      {
+        PerfScoped fromHere{{"stat"}, &output};
+        assignHere = std::move(fromHere);
+        std::this_thread::sleep_for(timeOut);
+      }
+      // because assign here is still alive, should not do anything.
+      EXPECT_TRUE(output.empty());
+    }
+    std::this_thread::sleep_for(timeOut);
+
+    // Now that all guards are off, should be fine.
+    return !output.empty();
+  });
+
+  ASSERT_FALSE(output.empty());
+}
+
+TEST(PerfScopedTest, Record) {
+  std::string output;
+
+  retryWithTimeOuts([&](auto timeOut) {
+    {
+      PerfScoped perf{{"record"}, &output};
+      std::this_thread::sleep_for(timeOut);
+    }
+    return !output.empty();
+  });
+
+  ASSERT_FALSE(output.empty());
+}
+
+TEST(PerfScopedTest, StatNoOutput) {
+  // Just verifying that this doesn't crash.
+  PerfScoped perf{{"stat"}};
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+}
+
+} // namespace
+} // namespace detail
+} // namespace folly
+
+#endif // defined(__linux__)

package/external/folly/folly/detail/test/SimpleSimdStringUtilsTest.cpp

@@ -0,0 +1,92 @@
+/*
+ * 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/detail/SimpleSimdStringUtils.h>
+
+#include <folly/algorithm/simd/detail/SimdPlatform.h>
+#include <folly/detail/SimpleSimdStringUtilsImpl.h>
+#include <folly/portability/GTest.h>
+
+namespace folly {
+namespace detail {
+namespace {
+
+template <typename Platform>
+bool hasSpaceOrCntrlSymbolsForPlatform(folly::StringPiece s) {
+  return SimpleSimdStringUtilsImpl<Platform>::hasSpaceOrCntrlSymbols(s);
+}
+
+void testHasSpaceOrCntrlSymbols(folly::StringPiece s, bool r) {
+  ASSERT_EQ(r, simdHasSpaceOrCntrlSymbols(s)) << s;
+
+  using namespace simd::detail;
+  ASSERT_EQ(r, hasSpaceOrCntrlSymbolsForPlatform<void>(s)) << s;
+
+#if FOLLY_SSE_PREREQ(4, 2)
+  ASSERT_EQ(
+      r, hasSpaceOrCntrlSymbolsForPlatform<SimdSse42Platform<std::uint8_t>>(s))
+      << s;
+#if defined(__AVX2__)
+  ASSERT_EQ(
+      r, hasSpaceOrCntrlSymbolsForPlatform<SimdAvx2Platform<std::uint8_t>>(s))
+      << s;
+#endif
+#endif
+
+#if FOLLY_AARCH64
+  ASSERT_EQ(
+      r,
+      hasSpaceOrCntrlSymbolsForPlatform<SimdAarch64Platform<std::uint8_t>>(s))
+      << s;
+#endif
+}
+
+// We also substantially rely on fuzzers for our testing
+
+TEST(SpaceOrCntrl, One) {
+  testHasSpaceOrCntrlSymbols("!", false);
+}
+
+TEST(SpaceOrCntrl, EachSymbol) {
+  for (std::uint16_t uChar = 0;
+       uChar <= std::numeric_limits<std::uint8_t>::max();
+       ++uChar) {
+    bool expected = std::isspace(uChar) || std::iscntrl(uChar);
+
+    char c = static_cast<char>(uChar);
+    ASSERT_NO_FATAL_FAILURE(testHasSpaceOrCntrlSymbols({&c, 1u}, expected));
+  }
+}
+
+TEST(SpaceOrCntrl, ExplicitExamples) {
+  using TestCase = std::pair<std::string, bool>;
+
+  std::pair<std::string, bool> testCases[] = {
+      TestCase{" ", true},
+      TestCase{"123\t", true},
+      TestCase{"123", false},
+      TestCase{"abA__11", false},
+      TestCase{std::string("123") + char(1), true},
+  };
+  for (const auto& testCase : testCases) {
+    ASSERT_NO_FATAL_FAILURE(
+        testHasSpaceOrCntrlSymbols(testCase.first, testCase.second));
+  }
+}
+
+} // namespace
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/test/SplitStringSimdTest.cpp

@@ -0,0 +1,242 @@
+/*
+ * 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/detail/SplitStringSimd.h>
+#include <folly/detail/SplitStringSimdImpl.h>
+
+#include <folly/FBString.h>
+#include <folly/FBVector.h>
+#include <folly/Range.h>
+#include <folly/portability/GTest.h>
+#include <folly/small_vector.h>
+
+#include <random>
+
+namespace folly {
+namespace detail {
+
+// making sure that basic scalar works
+TEST(SplitStringSimdTest, ByCharScalarKeepEmpty) {
+  using pieces = std::vector<folly::StringPiece>;
+
+  auto run = [](folly::StringPiece s) {
+    pieces res;
+    splitByCharScalar<false>(',', s, res);
+    return res;
+  };
+
+  ASSERT_EQ(run(""), (pieces{""}));
+  ASSERT_EQ(run("a"), (pieces{"a"}));
+  ASSERT_EQ(run(",a"), (pieces{"", "a"}));
+  ASSERT_EQ(run("a,aa"), (pieces{"a", "aa"}));
+  ASSERT_EQ(run("a,,aa"), (pieces{"a", "", "aa"}));
+  ASSERT_EQ(run("aaaa,aaa,aa,a"), (pieces{"aaaa", "aaa", "aa", "a"}));
+  ASSERT_EQ(run("aaaa,aaa,aa,a,"), (pieces{"aaaa", "aaa", "aa", "a", ""}));
+}
+
+TEST(SplitStringSimdTest, ByCharScalarIgnoreEmpty) {
+  using pieces = std::vector<folly::StringPiece>;
+
+  auto run = [](folly::StringPiece s) {
+    pieces res;
+    splitByCharScalar<true>(',', s, res);
+    return res;
+  };
+
+  ASSERT_EQ(run(""), (pieces{}));
+  ASSERT_EQ(run("a"), (pieces{"a"}));
+  ASSERT_EQ(run(",a"), (pieces{"a"}));
+  ASSERT_EQ(run("a,aa"), (pieces{"a", "aa"}));
+  ASSERT_EQ(run("a,,aa"), (pieces{"a", "aa"}));
+  ASSERT_EQ(run("aaaa,aaa,aa,a,"), (pieces{"aaaa", "aaa", "aa", "a"}));
+  ASSERT_EQ(run(",,,"), (pieces{}));
+}
+
+template <bool ignoreEmpty, typename Container>
+void testContainerSV(
+    folly::StringPiece s, const std::vector<folly::StringPiece>& expected) {
+  Container actual;
+  simdSplitByChar(',', s, actual, ignoreEmpty);
+
+  ASSERT_EQ(expected.size(), actual.size());
+
+  for (std::size_t i = 0; i != expected.size(); ++i) {
+    ASSERT_EQ(expected[i].data(), actual[i].data()) << s << " : " << i;
+    ASSERT_EQ(expected[i].size(), actual[i].size()) << s << " : " << i;
+  }
+}
+
+// shorter name to get 1 line auto format
+template <bool ie>
+void testAllContainersOfSVs(
+    folly::StringPiece s, const std::vector<folly::StringPiece>& expected) {
+  testContainerSV<ie, folly::fbvector<folly::StringPiece>>(s, expected);
+  testContainerSV<ie, folly::fbvector<std::string_view>>(s, expected);
+
+  testContainerSV<ie, folly::small_vector<folly::StringPiece, 1>>(s, expected);
+  testContainerSV<ie, folly::small_vector<folly::StringPiece, 2>>(s, expected);
+  testContainerSV<ie, folly::small_vector<folly::StringPiece, 3>>(s, expected);
+  testContainerSV<ie, folly::small_vector<folly::StringPiece, 4>>(s, expected);
+  testContainerSV<ie, folly::small_vector<folly::StringPiece, 6>>(s, expected);
+  testContainerSV<ie, folly::small_vector<folly::StringPiece, 7>>(s, expected);
+  testContainerSV<ie, folly::small_vector<folly::StringPiece, 8>>(s, expected);
+  static_assert(
+      !SimdSplitByCharIsDefinedFor<
+          folly::small_vector<folly::StringPiece, 9>>::value,
+      "");
+
+  testContainerSV<ie, folly::small_vector<std::string_view, 1>>(s, expected);
+  testContainerSV<ie, folly::small_vector<std::string_view, 2>>(s, expected);
+  testContainerSV<ie, folly::small_vector<std::string_view, 3>>(s, expected);
+  testContainerSV<ie, folly::small_vector<std::string_view, 4>>(s, expected);
+  testContainerSV<ie, folly::small_vector<std::string_view, 6>>(s, expected);
+  testContainerSV<ie, folly::small_vector<std::string_view, 7>>(s, expected);
+  testContainerSV<ie, folly::small_vector<std::string_view, 8>>(s, expected);
+  static_assert(
+      !SimdSplitByCharIsDefinedFor<
+          folly::small_vector<std::string_view, 9>>::value,
+      "");
+}
+
+template <bool ignoreEmpty, typename Container>
+void testContainersOfStrings(
+    folly::StringPiece s, const std::vector<folly::StringPiece>& expected) {
+  Container actual;
+  simdSplitByChar(',', s, actual, ignoreEmpty);
+
+  ASSERT_EQ(expected.size(), actual.size()) << s;
+
+  for (std::size_t i = 0; i != expected.size(); ++i) {
+    ASSERT_EQ(expected[i], actual[i]) << s << " : " << i;
+  }
+}
+
+template <bool ie>
+void testAllContainersOfStrings(
+    folly::StringPiece s, const std::vector<folly::StringPiece>& expected) {
+  testContainersOfStrings<ie, std::vector<std::string>>(s, expected);
+  testContainersOfStrings<ie, folly::fbvector<std::string>>(s, expected);
+
+  testContainersOfStrings<ie, std::vector<folly::fbstring>>(s, expected);
+  testContainersOfStrings<ie, folly::fbvector<folly::fbstring>>(s, expected);
+}
+
+template <bool ignoreEmpty>
+void runTestStringSplitOneType(folly::StringPiece s) {
+  std::vector<folly::StringPiece> expected;
+  splitByCharScalar<ignoreEmpty>(',', s, expected);
+
+  std::vector<std::vector<folly::StringPiece>> actuals;
+
+  actuals.emplace_back();
+  simdSplitByChar(',', s, actuals.back(), ignoreEmpty);
+
+#if FOLLY_SSE_PREREQ(4, 2)
+  actuals.emplace_back();
+  PlatformSimdSplitByChar<
+      simd::detail::SimdSse42Platform<std::uint8_t>,
+      ignoreEmpty>{}(',', s, actuals.back());
+#if defined(__AVX2__)
+  actuals.emplace_back();
+  PlatformSimdSplitByChar<
+      simd::detail::SimdAvx2Platform<std::uint8_t>,
+      ignoreEmpty>{}(',', s, actuals.back());
+#endif
+#endif
+
+#if FOLLY_AARCH64
+  actuals.emplace_back();
+  PlatformSimdSplitByChar<
+      simd::detail::SimdAarch64Platform<std::uint8_t>,
+      ignoreEmpty>{}(',', s, actuals.back());
+#endif
+
+  for (const auto& actual : actuals) {
+    ASSERT_EQ(expected.size(), actual.size()) << s;
+
+    for (std::size_t i = 0; i != expected.size(); ++i) {
+      ASSERT_EQ(expected[i].data(), actual[i].data()) << s << " : " << i;
+      ASSERT_EQ(expected[i].size(), actual[i].size()) << s << " : " << i;
+    }
+  }
+
+  testAllContainersOfSVs<ignoreEmpty>(s, expected);
+  testAllContainersOfStrings<ignoreEmpty>(s, expected);
+}
+
+void runTestStringSplit(folly::StringPiece s) {
+  runTestStringSplitOneType<false>(s);
+  runTestStringSplitOneType<true>(s);
+}
+
+std::string repeat(std::string_view substr, std::size_t n) {
+  std::string res;
+  while (n--) {
+    res.append(substr);
+  }
+  return res;
+}
+
+// We also do fuzzing for covering more cases.
+TEST(SplitStringSimd, ByChar) {
+  runTestStringSplit("");
+  runTestStringSplit(",");
+  runTestStringSplit(",,");
+  runTestStringSplit(",,,");
+  runTestStringSplit(",a,,aa");
+  runTestStringSplit("aa,aaa,aaaa");
+  runTestStringSplit("aa,aaa,,,aaa,,a");
+
+  runTestStringSplit(repeat("a,", 100));
+  runTestStringSplit(repeat("aa,", 100));
+  // every char (the bigger cases come from older version)
+  runTestStringSplit(repeat(",", 255));
+  runTestStringSplit(repeat(",", 512));
+  runTestStringSplit(repeat(",", 512 + 16));
+  runTestStringSplit(repeat(",", 512 + 32));
+  runTestStringSplit(repeat(",", 512 + 64));
+  runTestStringSplit(
+      repeat(",", std::numeric_limits<std::uint16_t>::max() + 512 + 16));
+
+  // special case: triggered shift right by 32 on uint32
+  {
+    constexpr std::string_view kTestData = "ong_history_by_pagetype_convr:0,";
+    static_assert(kTestData.size() == 32);
+
+    alignas(32) std::array<char, 32> buf;
+    std::copy(kTestData.begin(), kTestData.end(), buf.begin());
+    runTestStringSplit({buf.data(), buf.size()});
+  }
+}
+
+TEST(SplitStringSimd, ByCharTestDifferentOffsets) {
+  alignas(32) std::array<char, 100> buf;
+
+  std::mt19937 gen;
+  std::uniform_int_distribution<> dis(0, 1);
+  for (auto& c : buf) {
+    c = dis(gen) ? ',' : 'a';
+  }
+
+  for (auto f = buf.begin(); f != buf.end(); ++f) {
+    for (auto l = f; l != buf.end(); ++l) {
+      runTestStringSplit({f, l});
+    }
+  }
+}
+
+} // namespace detail
+} // namespace folly