react-native-windows 0.84.0 → 0.84.1

package/external/folly/folly/portability/openat2.h

@@ -0,0 +1,39 @@
+/*
+ * 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.
+ */
+
+/**
+ * Provide (glibc's missing) wrapper around the low-level `openat2` syscall.
+ */
+
+#pragma once
+
+#include <folly/folly-config.h>
+
+#if !FOLLY_HAVE_OPENAT2
+#error "FOLLY_HAVE_OPENAT2 is disabled"
+#endif
+
+#include <linux/openat2.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int openat2(int dirfd, const char* pathname, const struct open_how* how);
+
+#ifdef __cplusplus
+}
+#endif

package/external/folly/folly/portability/test/BUCK

@@ -0,0 +1,59 @@
+load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
+
+oncall("fbcode_entropy_wardens_folly")
+
+cpp_unittest(
+    name = "constexpr_test",
+    srcs = ["ConstexprTest.cpp"],
+    deps = [
+        "//folly/portability:constexpr",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "filesystem_test",
+    srcs = ["FilesystemTest.cpp"],
+    deps = [
+        "//folly/portability:filesystem",
+        "//folly/portability:gmock",
+        "//folly/portability:gtest",
+    ],
+)
+
+cpp_unittest(
+    name = "libgen_test",
+    srcs = ["LibgenTest.cpp"],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/portability:libgen",
+    ],
+)
+
+cpp_unittest(
+    name = "openssl_portability_test",
+    srcs = ["OpenSSLPortabilityTest.cpp"],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/ssl:openssl_ptr_types",
+    ],
+)
+
+cpp_unittest(
+    name = "pthread_test",
+    srcs = ["PThreadTest.cpp"],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/portability:pthread",
+    ],
+)
+
+cpp_unittest(
+    name = "time_test",
+    srcs = ["TimeTest.cpp"],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/portability:time",
+        "//folly/test:test_utils",
+    ],
+)

package/external/folly/folly/portability/test/ConstexprTest.cpp

@@ -0,0 +1,102 @@
+/*
+ * 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/portability/Constexpr.h>
+
+#include <folly/portability/GTest.h>
+
+using folly::constexpr_strcmp;
+using folly::constexpr_strlen;
+using folly::detail::constexpr_strcmp_fallback;
+using folly::detail::constexpr_strlen_fallback;
+
+template <typename, typename>
+struct static_assert_same;
+template <typename T>
+struct static_assert_same<T, T> {};
+
+TEST(ConstexprTest, constexprStrlenCstr) {
+  constexpr auto v = "hello";
+  {
+    constexpr auto a = constexpr_strlen(v);
+    void(static_assert_same<const size_t, decltype(a)>{});
+    EXPECT_EQ(5, a);
+  }
+  {
+    constexpr auto a = constexpr_strlen_fallback(v);
+    void(static_assert_same<const size_t, decltype(a)>{});
+    EXPECT_EQ(5, a);
+  }
+}
+
+TEST(ConstexprTest, constexprStrlenInts) {
+  constexpr int v[] = {5, 3, 4, 0, 7};
+  {
+    constexpr auto a = constexpr_strlen(v);
+    void(static_assert_same<const size_t, decltype(a)>{});
+    EXPECT_EQ(3, a);
+  }
+  {
+    constexpr auto a = constexpr_strlen_fallback(v);
+    void(static_assert_same<const size_t, decltype(a)>{});
+    EXPECT_EQ(3, a);
+  }
+}
+
+TEST(ConstexprTest, constexprStrcmpInts) {
+  constexpr int v[] = {5, 3, 4, 0, 7};
+  constexpr int v1[] = {6, 4};
+  static_assert(constexpr_strcmp(v1, v) > 0, "constexpr_strcmp is broken");
+  static_assert(constexpr_strcmp(v, v1) < 0, "constexpr_strcmp is broken");
+  static_assert(constexpr_strcmp(v, v) == 0, "constexpr_strcmp is broken");
+  static_assert(
+      constexpr_strcmp_fallback(v1, v) > 0, "constexpr_strcmp is broken");
+  static_assert(
+      constexpr_strcmp_fallback(v, v1) < 0, "constexpr_strcmp is broken");
+  static_assert(
+      constexpr_strcmp_fallback(v, v) == 0, "constexpr_strcmp is broken");
+}
+
+static_assert(
+    constexpr_strcmp("abc", "abc") == 0, "constexpr_strcmp is broken");
+static_assert(constexpr_strcmp("", "") == 0, "constexpr_strcmp is broken");
+static_assert(constexpr_strcmp("abc", "def") < 0, "constexpr_strcmp is broken");
+static_assert(constexpr_strcmp("xyz", "abc") > 0, "constexpr_strcmp is broken");
+static_assert(constexpr_strcmp("a", "abc") < 0, "constexpr_strcmp is broken");
+static_assert(constexpr_strcmp("abc", "a") > 0, "constexpr_strcmp is broken");
+static_assert(
+    constexpr_strcmp_fallback("abc", "abc") == 0, "constexpr_strcmp is broken");
+static_assert(
+    constexpr_strcmp_fallback("", "") == 0, "constexpr_strcmp is broken");
+static_assert(
+    constexpr_strcmp_fallback("abc", "def") < 0, "constexpr_strcmp is broken");
+static_assert(
+    constexpr_strcmp_fallback("xyz", "abc") > 0, "constexpr_strcmp is broken");
+static_assert(
+    constexpr_strcmp_fallback("a", "abc") < 0, "constexpr_strcmp is broken");
+static_assert(
+    constexpr_strcmp_fallback("abc", "a") > 0, "constexpr_strcmp is broken");
+
+TEST(ConstexprTest, isConstantEvaluatedOr) {
+  static_assert(folly::is_constant_evaluated_or(true));
+  EXPECT_FALSE(folly::is_constant_evaluated_or(false));
+
+#if !defined(__cpp_lib_is_constant_evaluated) && \
+    !FOLLY_HAS_BUILTIN(__builtin_is_constant_evaluated)
+  static_assert(!folly::is_constant_evaluated_or(false));
+  EXPECT_TRUE(folly::is_constant_evaluated_or(true));
+#endif
+}

package/external/folly/folly/portability/test/FilesystemTest.cpp

@@ -0,0 +1,35 @@
+/*
+ * 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/portability/Filesystem.h>
+
+#include <folly/portability/GMock.h>
+#include <folly/portability/GTest.h>
+
+using namespace testing;
+
+class FilesystemTest : public Test {};
+
+TEST_F(FilesystemTest, lexically_normal) {
+  //  from: https://en.cppreference.com/w/cpp/filesystem/path/lexically_normal,
+  //      CC-BY-SA, GFDL
+  EXPECT_THAT(
+      folly::fs::lexically_normal("foo/./bar/..").native(),
+      Eq(folly::fs::path("foo/").make_preferred().native()));
+  EXPECT_THAT(
+      folly::fs::lexically_normal("foo/.///bar/../").native(),
+      Eq(folly::fs::path("foo/").make_preferred().native()));
+}

package/external/folly/folly/portability/test/LibgenTest.cpp

@@ -0,0 +1,35 @@
+/*
+ * 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 <string>
+
+#include <folly/portability/GTest.h>
+#include <folly/portability/Libgen.h>
+
+TEST(Libgen, dirname) {
+  auto doDirname = [](const char* str) -> std::string {
+    auto tmp = strdup(str); // we need a mutable string for dirname.
+    auto ret = std::string(folly::portability::internal_dirname(tmp));
+    free(tmp);
+    return ret;
+  };
+  EXPECT_EQ("/usr", doDirname("/usr/lib"));
+  EXPECT_EQ("/", doDirname("/usr/"));
+  EXPECT_EQ(".", doDirname("usr"));
+  EXPECT_EQ("/", doDirname("/"));
+  EXPECT_EQ(".", doDirname("."));
+  EXPECT_EQ(".", doDirname(".."));
+}

package/external/folly/folly/portability/test/OpenSSLPortabilityTest.cpp

@@ -0,0 +1,108 @@
+/*
+ * 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 <ctime>
+
+#include <folly/portability/GTest.h>
+#include <folly/ssl/OpenSSLPtrTypes.h>
+
+using namespace folly;
+using namespace folly::ssl;
+using namespace testing;
+
+TEST(OpenSSLPortabilityTest, TestRSASetter) {
+  RsaUniquePtr r(RSA_new());
+  BIGNUM* n = BN_new();
+  BIGNUM* e = BN_new();
+  BIGNUM* d = BN_new();
+  BIGNUM* n_actual;
+  BIGNUM* e_actual;
+  BIGNUM* d_actual;
+  EXPECT_TRUE(BN_set_bit(n, 1));
+  EXPECT_TRUE(BN_set_bit(e, 3));
+  EXPECT_TRUE(BN_set_bit(d, 2));
+  RSA_set0_key(r.get(), n, e, d);
+  RSA_get0_key(
+      r.get(),
+      (const BIGNUM**)&n_actual,
+      (const BIGNUM**)&e_actual,
+      (const BIGNUM**)&d_actual);
+  // BN_cmp returns 0 if the two BIGNUMs are equal
+  EXPECT_FALSE(BN_cmp(n, n_actual));
+  EXPECT_FALSE(BN_cmp(e, e_actual));
+  EXPECT_FALSE(BN_cmp(d, d_actual));
+
+  RsaUniquePtr public_key(RSA_new());
+  BIGNUM* n_public = BN_new();
+  BIGNUM* e_public = BN_new();
+  EXPECT_TRUE(BN_set_bit(n_public, 1));
+  EXPECT_TRUE(BN_set_bit(e_public, 3));
+  RSA_set0_key(public_key.get(), n_public, e_public, nullptr);
+  BIGNUM* n_public_actual;
+  BIGNUM* e_public_actual;
+  RSA_get0_key(
+      public_key.get(),
+      (const BIGNUM**)&n_public_actual,
+      (const BIGNUM**)&e_public_actual,
+      nullptr);
+  EXPECT_FALSE(BN_cmp(n_public, n_public_actual));
+  EXPECT_FALSE(BN_cmp(e_public, e_public_actual));
+}
+
+TEST(OpenSSLPortabilityTest, TestEcdsaSigPortability) {
+  EcdsaSigUniquePtr ecdsa(ECDSA_SIG_new());
+  BIGNUM* r = BN_new();
+  BIGNUM* s = BN_new();
+  BIGNUM* r_actual;
+  BIGNUM* s_actual;
+  EXPECT_TRUE(BN_set_bit(r, 1));
+  EXPECT_TRUE(BN_set_bit(s, 2));
+  EXPECT_TRUE(ECDSA_SIG_set0(ecdsa.get(), r, s));
+  ECDSA_SIG_get0(
+      ecdsa.get(), (const BIGNUM**)&r_actual, (const BIGNUM**)&s_actual);
+  // BN_cmp returns 0 if the two BIGNUMs are equal
+  EXPECT_FALSE(BN_cmp(r, r_actual));
+  EXPECT_FALSE(BN_cmp(s, s_actual));
+}
+
+TEST(OpenSSLPortabilityTest, TestX509RevokedApi) {
+  X509_REVOKED* rev = X509_REVOKED_new();
+
+  ASN1_INTEGER* serial = ASN1_INTEGER_new();
+  ASN1_INTEGER_set(serial, 1234L);
+
+  ASN1_TIME* revocation_date = ASN1_TIME_new();
+  time_t t = time(nullptr);
+  ASN1_TIME_set(revocation_date, t);
+
+  X509_REVOKED_set_serialNumber(rev, serial);
+  X509_REVOKED_set_revocationDate(rev, revocation_date);
+
+  const ASN1_INTEGER* retrieved_serial = X509_REVOKED_get0_serialNumber(rev);
+  const ASN1_TIME* retrieved_date = X509_REVOKED_get0_revocationDate(rev);
+
+  EXPECT_EQ(0, ASN1_INTEGER_cmp(serial, retrieved_serial));
+
+  int diff_days;
+  int diff_secs;
+  ASN1_TIME_diff(&diff_days, &diff_secs, revocation_date, retrieved_date);
+  EXPECT_EQ(0, diff_days);
+  EXPECT_EQ(0, diff_secs);
+
+  ASN1_INTEGER_free(serial);
+  ASN1_TIME_free(revocation_date);
+  X509_REVOKED_free(rev);
+}

package/external/folly/folly/portability/test/PThreadTest.cpp

@@ -0,0 +1,80 @@
+/*
+ * 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/portability/PThread.h>
+
+#include <folly/portability/GTest.h>
+
+#include <atomic>
+
+TEST(PThreadTest, pthreadCreateAndJoin) {
+  static std::atomic<bool> hasRun{false};
+  static std::atomic<int32_t> argPassedIn{0};
+  auto mainFunc = [](void* arg) -> void* {
+    hasRun = true;
+    argPassedIn = (int32_t) reinterpret_cast<uintptr_t>(arg);
+    return nullptr;
+  };
+
+  pthread_t thread;
+  EXPECT_EQ(pthread_create(&thread, nullptr, mainFunc, (void*)53), 0);
+  EXPECT_EQ(pthread_join(thread, nullptr), 0);
+  EXPECT_TRUE(hasRun);
+  EXPECT_EQ(argPassedIn, 53);
+}
+
+TEST(PThreadTest, pthreadJoinReturnValue) {
+  static std::atomic<bool> hasRun{false};
+  auto mainFunc = [](void*) -> void* {
+    hasRun = true;
+    return (void*)5;
+  };
+
+  pthread_t thread;
+  EXPECT_EQ(pthread_create(&thread, nullptr, mainFunc, nullptr), 0);
+  void* exitCode = nullptr;
+  EXPECT_EQ(pthread_join(thread, &exitCode), 0);
+  EXPECT_EQ(exitCode, (void*)5);
+  EXPECT_TRUE(hasRun);
+}
+
+TEST(PThreadTest, pthreadEqual) {
+  auto self = pthread_self();
+  EXPECT_NE(pthread_equal(self, self), 0);
+
+  auto mainFunc = [](void*) -> void* { return nullptr; };
+  pthread_t thread;
+  EXPECT_EQ(pthread_create(&thread, nullptr, mainFunc, nullptr), 0);
+  EXPECT_EQ(pthread_equal(thread, self), 0);
+  void* exitCode = nullptr;
+  pthread_join(thread, &exitCode);
+}
+
+TEST(PThreadTest, pthreadSelfOnPthreadThread) {
+  static std::atomic<bool> hasRun{false};
+  static pthread_t otherSelf;
+  auto mainFunc = [](void*) -> void* {
+    hasRun = true;
+    otherSelf = pthread_self();
+    return nullptr;
+  };
+
+  pthread_t thread;
+  EXPECT_EQ(pthread_create(&thread, nullptr, mainFunc, nullptr), 0);
+  EXPECT_EQ(pthread_join(thread, nullptr), 0);
+  EXPECT_NE(pthread_equal(otherSelf, thread), 0);
+  EXPECT_TRUE(hasRun);
+}

package/external/folly/folly/portability/test/TimeTest.cpp

@@ -0,0 +1,90 @@
+/*
+ * 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/portability/Time.h>
+
+#include <folly/portability/GTest.h>
+#include <folly/test/TestUtils.h>
+
+#include <chrono>
+
+static constexpr auto kAcceptableDeltaSecs = std::chrono::seconds(120);
+
+using folly::test::AreWithinSecs;
+
+#ifdef CLOCK_REALTIME
+
+TEST(Time, clockGettimeRealtimeAreWithin120SecsOfStdChronoSystemClock) {
+  struct timespec ts;
+  auto ret = clock_gettime(CLOCK_REALTIME, &ts);
+  ASSERT_EQ(0, ret);
+
+  auto gettimeResult =
+      std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec);
+  auto stdChronoSystemClockNow =
+      std::chrono::system_clock::now().time_since_epoch();
+  ASSERT_TRUE(AreWithinSecs(
+      gettimeResult, stdChronoSystemClockNow, kAcceptableDeltaSecs));
+}
+
+#endif /* CLOCK_REALTIME */
+
+#ifdef CLOCK_MONOTONIC
+
+TEST(Time, clockGettimeMonotonicAreWithin120SecsOfStdChronoSteadyClock) {
+  struct timespec ts;
+  auto ret = clock_gettime(CLOCK_MONOTONIC, &ts);
+  ASSERT_EQ(0, ret);
+
+  auto gettimeResult =
+      std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec);
+  auto stdChronoSteadyClockNow =
+      std::chrono::steady_clock::now().time_since_epoch();
+  ASSERT_TRUE(AreWithinSecs(
+      gettimeResult, stdChronoSteadyClockNow, kAcceptableDeltaSecs));
+}
+
+#endif /* CLOCK_MONOTONIC */
+
+#ifdef CLOCK_PROCESS_CPUTIME_ID
+
+TEST(Time, clockGettimeProcessCputimeIsGreaterThanZero) {
+  struct timespec ts;
+  auto ret = clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts);
+  ASSERT_EQ(0, ret);
+
+  auto gettimeResult =
+      std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec);
+
+  ASSERT_GT(gettimeResult, std::chrono::nanoseconds::zero());
+}
+
+#endif /* CLOCK_PROCESS_CPUTIME_ID */
+
+#ifdef CLOCK_THREAD_CPUTIME_ID
+
+TEST(Time, clockGettimeProcessThreadTimeIsGreaterThanZero) {
+  struct timespec ts;
+  auto ret = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
+  ASSERT_EQ(0, ret);
+
+  auto gettimeResult =
+      std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec);
+
+  ASSERT_GT(gettimeResult, std::chrono::nanoseconds::zero());
+}
+
+#endif /* CLOCK_THREAD_CPUTIME_ID */

package/external/folly/folly/small_vector.h

@@ -0,0 +1,17 @@
+/*
+ * 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/container/small_vector.h>