react-native-windows 0.84.0 → 0.84.2

package/external/folly/folly/system/test/AuxVectorTest.cpp

@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+#if defined(__linux__)
+#include <sys/auxv.h> // @manual
+#endif
+
+#include <folly/system/AuxVector.h>
+
+#include <folly/portability/GTest.h>
+
+using namespace folly;
+
+TEST(ElfHwCaps, Simple) {
+  ElfHwCaps caps;
+#if defined(__linux__)
+  // All aarch64 CPUs should support floating point
+  EXPECT_EQ(kIsArchAArch64, caps.aarch64_fp());
+#else
+  GTEST_SKIP();
+#endif
+}
+
+TEST(ElfHwCaps, SimpleStatic) {
+  static ElfHwCaps caps;
+#if defined(__linux__)
+  // All aarch64 CPUs should support floating point
+  EXPECT_EQ(kIsArchAArch64, caps.aarch64_fp());
+#else
+  GTEST_SKIP();
+#endif
+}
+
+TEST(ElfHwCaps, SimpleStaticWithArgs) {
+#if defined(__linux__)
+  static ElfHwCaps caps{getauxval(AT_HWCAP), getauxval(AT_HWCAP2)};
+  // All aarch64 CPUs should support floating point
+  EXPECT_EQ(kIsArchAArch64, caps.aarch64_fp());
+#else
+  GTEST_SKIP();
+#endif
+}

package/external/folly/folly/system/test/BUCK

@@ -0,0 +1,120 @@
+load("@fbcode_macros//build_defs:cpp_binary.bzl", "cpp_binary")
+load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
+
+oncall("fbcode_entropy_wardens_folly")
+
+cpp_unittest(
+    name = "at_fork_test",
+    srcs = ["AtForkTest.cpp"],
+    deps = [
+        "//folly/portability:gmock",
+        "//folly/portability:gtest",
+        "//folly/system:at_fork",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)
+
+cpp_unittest(
+    name = "aux_vector_test",
+    srcs = ["AuxVectorTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/system:aux_vector",
+    ],
+)
+
+cpp_binary(
+    name = "env_util_subprocess",
+    srcs = ["EnvUtilSubprocess.cpp"],
+)
+
+cpp_unittest(
+    name = "env_util_test",
+    srcs = ["EnvUtilTest.cpp"],
+    headers = [],
+    args = [
+        "--env_util_subprocess_binary=$(location :env_util_subprocess)",
+    ],
+    deps = [
+        "//folly:memory",
+        "//folly:subprocess",
+        "//folly/container:array",
+        "//folly/portability:fcntl",
+        "//folly/portability:gflags",
+        "//folly/portability:gtest",
+        "//folly/portability:stdlib",
+        "//folly/system:env_util",
+    ],
+    external_deps = [
+        "glog",
+        ("boost", None, "boost_algorithm"),
+    ],
+)
+
+cpp_unittest(
+    name = "pid_test",
+    srcs = ["PidTest.cpp"],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/system:pid",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)
+
+cpp_unittest(
+    name = "memory_mapping_test",
+    srcs = ["MemoryMappingTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:file_util",
+        "//folly:random",
+        "//folly/portability:gtest",
+        "//folly/portability:sys_mman",
+        "//folly/system:memory_mapping",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)
+
+cpp_unittest(
+    name = "shell_test",
+    srcs = ["ShellTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly/portability:gtest",
+        "//folly/system:shell",
+    ],
+    external_deps = [
+        "glog",
+    ],
+)
+
+cpp_unittest(
+    name = "thread_id_test",
+    srcs = ["ThreadIdTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:benchmark",
+        "//folly/portability:gtest",
+        "//folly/portability:unistd",
+        "//folly/system:thread_id",
+    ],
+)
+
+cpp_unittest(
+    name = "thread_name_test",
+    srcs = ["ThreadNameTest.cpp"],
+    headers = [],
+    deps = [
+        "//folly:scope_guard",
+        "//folly/portability:gtest",
+        "//folly/synchronization:baton",
+        "//folly/system:thread_name",
+    ],
+)

package/external/folly/folly/system/test/EnvUtilSubprocess.cpp

@@ -0,0 +1,26 @@
+/*
+ * 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 <stdlib.h>
+#include <string.h>
+
+int main() {
+  char* spork = getenv("spork");
+  if (!spork) {
+    return 1;
+  }
+  return strcmp("foon", spork);
+}

package/external/folly/folly/system/test/EnvUtilTest.cpp

@@ -0,0 +1,197 @@
+/*
+ * 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/system/EnvUtil.h>
+
+#include <spawn.h>
+
+#include <system_error>
+
+#include <boost/algorithm/string.hpp>
+
+#include <folly/Memory.h>
+#include <folly/Subprocess.h>
+#include <folly/container/Array.h>
+#include <folly/portability/Fcntl.h>
+#include <folly/portability/GFlags.h>
+#include <folly/portability/GTest.h>
+#include <folly/portability/Stdlib.h>
+
+#include <glog/logging.h>
+
+using namespace folly;
+using folly::experimental::EnvironmentState;
+using folly::experimental::MalformedEnvironment;
+using folly::test::EnvVarSaver;
+
+DEFINE_string(
+    env_util_subprocess_binary,
+    "./env_util_subprocess",
+    "Location of the `env_util_subprocess` test helper program");
+
+TEST(EnvVarSaverTest, ExampleNew) {
+  auto key = "hahahahaha";
+  EXPECT_EQ(nullptr, getenv(key));
+
+  PCHECK(0 == setenv(key, "", true));
+  EXPECT_STREQ("", getenv(key));
+  PCHECK(0 == unsetenv(key));
+  EXPECT_EQ(nullptr, getenv(key));
+
+  auto saver = std::make_unique<EnvVarSaver>();
+  PCHECK(0 == setenv(key, "blah", true));
+  EXPECT_STREQ("blah", getenv(key));
+  saver = nullptr;
+  EXPECT_EQ(nullptr, getenv(key));
+}
+
+TEST(EnvVarSaverTest, ExampleExisting) {
+  auto key = "PATH";
+  EXPECT_NE(nullptr, getenv(key));
+  auto value = std::string{getenv(key)};
+
+  auto saver = std::make_unique<EnvVarSaver>();
+  PCHECK(0 == setenv(key, "blah", true));
+  EXPECT_STREQ("blah", getenv(key));
+  saver = nullptr;
+  EXPECT_EQ(value, getenv(key));
+}
+
+TEST(EnvVarSaverTest, Movable) {
+  Optional<EnvVarSaver> pSaver1;
+  pSaver1.emplace();
+  auto key = "PATH";
+  EXPECT_NE(nullptr, getenv(key));
+  auto value = std::string{getenv(key)};
+  Optional<EnvVarSaver> pSaver2;
+  pSaver2.emplace(std::move(*pSaver1));
+  pSaver1.reset();
+  PCHECK(0 == setenv(key, "blah", true));
+  EXPECT_STREQ("blah", getenv(key));
+  pSaver2.reset();
+  EXPECT_EQ(value, getenv(key));
+}
+
+TEST(EnvironmentStateTest, FailOnEmptyString) {
+  EnvVarSaver saver{};
+  char test[4] = "A=B";
+  PCHECK(0 == putenv(test));
+  auto okState = EnvironmentState::fromCurrentEnvironment();
+  test[0] = 0;
+  EXPECT_THROW(
+      EnvironmentState::fromCurrentEnvironment(), MalformedEnvironment);
+}
+
+TEST(EnvironmentStateTest, MovableAndCopyable) {
+  auto initialState = EnvironmentState::fromCurrentEnvironment();
+  auto copiedState1 = EnvironmentState::empty();
+  copiedState1.operator=(initialState);
+  EnvironmentState copiedState2{initialState};
+  EXPECT_EQ(*initialState, *copiedState1);
+  EXPECT_EQ(*initialState, *copiedState2);
+  (*initialState)["foo"] = "bar";
+  EXPECT_EQ(0, copiedState1->count("foo"));
+  EXPECT_EQ(0, copiedState2->count("foo"));
+  auto movedState1 = EnvironmentState::empty();
+  movedState1.operator=(std::move(copiedState1));
+  EnvironmentState movedState2{std::move(copiedState2)};
+  EXPECT_EQ(0, movedState1->count("foo"));
+  EXPECT_EQ(0, movedState2->count("foo"));
+  initialState->erase("foo");
+  EXPECT_EQ(*initialState, *movedState1);
+  EXPECT_EQ(*initialState, *movedState2);
+}
+
+TEST(EnvironmentStateTest, FailOnDuplicate) {
+  EnvVarSaver saver{};
+  char test[7] = "PATG=B";
+  PCHECK(0 == putenv(test));
+  auto okState = EnvironmentState::fromCurrentEnvironment();
+  test[3] = 'H';
+  EXPECT_THROW(
+      EnvironmentState::fromCurrentEnvironment(), MalformedEnvironment);
+}
+
+TEST(EnvironmentStateTest, Separation) {
+  EnvVarSaver saver{};
+  auto initialState = EnvironmentState::fromCurrentEnvironment();
+  PCHECK(0 == setenv("spork", "foon", true));
+  auto updatedState = EnvironmentState::fromCurrentEnvironment();
+  EXPECT_EQ(0, initialState->count("spork"));
+  EXPECT_EQ(1, updatedState->count("spork"));
+  EXPECT_EQ("foon", (*updatedState)["spork"]);
+  updatedState->erase("spork");
+  EXPECT_EQ(0, updatedState->count("spork"));
+  EXPECT_STREQ("foon", getenv("spork"));
+}
+
+TEST(EnvironmentStateTest, Update) {
+  EnvVarSaver saver{};
+  auto env = EnvironmentState::fromCurrentEnvironment();
+  EXPECT_EQ(nullptr, getenv("spork"));
+  (*env)["spork"] = "foon";
+  EXPECT_EQ(nullptr, getenv("spork"));
+  env.setAsCurrentEnvironment();
+  EXPECT_STREQ("foon", getenv("spork"));
+}
+
+TEST(EnvironmentStateTest, forSubprocess) {
+  auto env = EnvironmentState::empty();
+  (*env)["spork"] = "foon";
+  std::vector<std::string> expected = {"spork=foon"};
+  auto vec = env.toVector();
+  EXPECT_EQ(expected, vec);
+  Subprocess subProcess{
+      {fLS::FLAGS_env_util_subprocess_binary},
+      {},
+      fLS::FLAGS_env_util_subprocess_binary.c_str(),
+      &vec};
+  EXPECT_EQ(0, subProcess.wait().exitStatus());
+}
+
+TEST(EnvironmentStateTest, forC) {
+  auto env = EnvironmentState::empty();
+  (*env)["spork"] = "foon";
+  EXPECT_STREQ("spork=foon", env.toPointerArray().get()[0]);
+  EXPECT_EQ(nullptr, env.toPointerArray().get()[1]);
+  char* program = &fLS::FLAGS_env_util_subprocess_binary[0];
+  pid_t pid;
+  auto argV = folly::make_array(program, nullptr);
+  PCHECK(
+      0 ==
+      posix_spawn(
+          &pid,
+          program,
+          nullptr,
+          nullptr,
+          argV.data(),
+          env.toPointerArray().get()));
+  int result;
+  PCHECK(pid == waitpid(pid, &result, 0));
+  EXPECT_EQ(0, result);
+}
+
+TEST(EnvVarSaverTest, ExampleDeleting) {
+  auto key = "PATH";
+  EXPECT_NE(nullptr, getenv(key));
+  auto value = std::string{getenv(key)};
+
+  auto saver = std::make_unique<EnvVarSaver>();
+  PCHECK(0 == unsetenv(key));
+  EXPECT_EQ(nullptr, getenv(key));
+  saver = nullptr;
+  EXPECT_TRUE(value == getenv(key));
+}

package/external/folly/folly/system/test/MemoryMappingTest.cpp

@@ -0,0 +1,179 @@
+/*
+ * 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/system/MemoryMapping.h>
+
+#include <cstdlib>
+
+#include <glog/logging.h>
+
+#include <folly/FileUtil.h>
+#include <folly/Random.h>
+#include <folly/portability/GTest.h>
+#include <folly/portability/SysMman.h>
+
+static constexpr double kSomeDouble = 3.14;
+
+namespace folly {
+
+TEST(MemoryMapping, Basic) {
+  File f = File::temporary();
+  {
+    MemoryMapping m(File(f.fd()), 0, sizeof(double), MemoryMapping::writable());
+    double* d = m.asWritableRange<double>().data();
+    *d = 37 * kSomeDouble;
+  }
+  {
+    MemoryMapping m(File(f.fd()), 0, 3);
+    EXPECT_EQ(0, m.asRange<int>().size()); // not big enough
+  }
+  {
+    MemoryMapping m(File(f.fd()), 0, sizeof(double));
+    const double* d = m.asRange<double>().data();
+    EXPECT_EQ(*d, 37 * kSomeDouble);
+  }
+}
+
+TEST(MemoryMapping, Move) {
+  File f = File::temporary();
+  {
+    MemoryMapping m(
+        File(f.fd()), 0, sizeof(double) * 2, MemoryMapping::writable());
+    double* d = m.asWritableRange<double>().data();
+    d[0] = 37 * kSomeDouble;
+    MemoryMapping m2(std::move(m));
+    double* d2 = m2.asWritableRange<double>().data();
+    d2[1] = 39 * kSomeDouble;
+  }
+  {
+    MemoryMapping m(File(f.fd()), 0, sizeof(double));
+    const double* d = m.asRange<double>().data();
+    EXPECT_EQ(d[0], 37 * kSomeDouble);
+    MemoryMapping m2(std::move(m));
+    const double* d2 = m2.asRange<double>().data();
+    EXPECT_EQ(d2[1], 39 * kSomeDouble);
+  }
+}
+
+TEST(MemoryMapping, DoublyMapped) {
+  File f = File::temporary();
+  // two mappings of the same memory, different addresses.
+  MemoryMapping mw(File(f.fd()), 0, sizeof(double), MemoryMapping::writable());
+  MemoryMapping mr(File(f.fd()), 0, sizeof(double));
+
+  double* dw = mw.asWritableRange<double>().data();
+  const double* dr = mr.asRange<double>().data();
+
+  // Show that it's truly the same value, even though the pointers differ
+  EXPECT_NE(dw, dr);
+  *dw = 42 * kSomeDouble;
+  EXPECT_EQ(*dr, 42 * kSomeDouble);
+  *dw = 43 * kSomeDouble;
+  EXPECT_EQ(*dr, 43 * kSomeDouble);
+}
+
+namespace {
+
+void writeStringToFileOrDie(const std::string& str, int fd) {
+  const char* b = str.c_str();
+  size_t count = str.size();
+  ssize_t r;
+  do {
+    r = write(fd, b, count);
+    if (r == -1) {
+      if (errno == EINTR) {
+        continue;
+      }
+      PCHECK(r) << "write";
+    }
+    b += r;
+    count -= r;
+  } while (r != 0 && count);
+}
+
+} // namespace
+
+TEST(MemoryMapping, Simple) {
+  File f = File::temporary();
+  writeStringToFileOrDie("hello", f.fd());
+
+  {
+    MemoryMapping m(File(f.fd()));
+    EXPECT_EQ("hello", m.data());
+  }
+  {
+    MemoryMapping m(File(f.fd()), 1, 2);
+    EXPECT_EQ("el", m.data());
+  }
+}
+
+TEST(MemoryMapping, LargeFile) {
+  std::string fileData;
+  size_t fileSize = sysconf(_SC_PAGESIZE) * 3 + 10;
+  fileData.reserve(fileSize);
+  for (size_t i = 0; i < fileSize; i++) {
+    fileData.push_back(0xff & Random::rand32());
+  }
+
+  File f = File::temporary();
+  writeStringToFileOrDie(fileData, f.fd());
+
+  {
+    MemoryMapping m(File(f.fd()));
+    EXPECT_EQ(fileData, m.data());
+  }
+  {
+    size_t size = sysconf(_SC_PAGESIZE) * 2;
+    StringPiece s(fileData.data() + 9, size - 9);
+    MemoryMapping m(File(f.fd()), 9, size - 9);
+    EXPECT_EQ(s.toString(), m.data());
+  }
+}
+
+TEST(MemoryMapping, ZeroLength) {
+  File f = File::temporary();
+  MemoryMapping m(File(f.fd()));
+  EXPECT_TRUE(m.mlock(MemoryMapping::LockMode::MUST_LOCK));
+  EXPECT_TRUE(m.mlocked());
+  EXPECT_EQ(0, m.data().size());
+}
+
+TEST(MemoryMapping, Advise) {
+  File f = File::temporary();
+  size_t kPageSize = 4096;
+  size_t size = kPageSize + 10; // unaligned file size
+  PCHECK(ftruncateNoInt(f.fd(), size) == 0) << size;
+
+  MemoryMapping m(File(f.fd()));
+
+  // NOTE: advise crashes on bad input.
+
+  m.advise(MADV_NORMAL, 0, kPageSize);
+  m.advise(MADV_NORMAL, 1, kPageSize);
+  m.advise(MADV_NORMAL, 0, 2);
+  m.advise(MADV_NORMAL, 1, 2);
+
+  m.advise(MADV_NORMAL, kPageSize, 0);
+  m.advise(MADV_NORMAL, kPageSize, 1);
+  m.advise(MADV_NORMAL, kPageSize, size - kPageSize);
+
+  auto off = kPageSize + 1;
+  m.advise(MADV_NORMAL, off, size - off);
+
+  EXPECT_DEATH(m.advise(MADV_NORMAL, off, size - off + 1), "");
+}
+
+} // namespace folly

package/external/folly/folly/system/test/PidTest.cpp

@@ -0,0 +1,46 @@
+/*
+ * 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/system/Pid.h>
+
+#include <glog/logging.h>
+
+#include <folly/portability/GTest.h>
+
+TEST(PidTest, basic) {
+  pid_t mypid = getpid();
+  EXPECT_EQ(mypid, folly::get_cached_pid());
+  EXPECT_EQ(getpid(), folly::get_cached_pid());
+}
+
+TEST(PidTest, fork) {
+  pid_t mypid = getpid();
+  EXPECT_EQ(mypid, folly::get_cached_pid());
+  auto pid = fork();
+  if (pid > 0) {
+    // parent
+    EXPECT_EQ(mypid, folly::get_cached_pid());
+    EXPECT_NE(pid, mypid);
+  } else if (pid == 0) {
+    // child
+    EXPECT_NE(mypid, folly::get_cached_pid()); // mypid still has parent's pid
+    mypid = getpid(); // get child's pid
+    EXPECT_EQ(mypid, folly::get_cached_pid());
+    std::exit(0); // Do not print gtest results
+  } else {
+    PLOG(FATAL) << "Failed to fork()";
+  }
+}

package/external/folly/folly/system/test/ShellTest.cpp

@@ -0,0 +1,66 @@
+/*
+ * 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/system/Shell.h>
+
+#include <glog/logging.h>
+
+#include <folly/portability/GTest.h>
+
+using namespace folly;
+
+TEST(Shell, ShellQuote) {
+  EXPECT_EQ(shellQuote("a"), "'a'");
+  EXPECT_EQ(shellQuote("a'b"), "'a'\\''b'");
+  EXPECT_EQ(shellQuote("a\"b"), "'a\"b'");
+}
+
+TEST(Shell, Shellify) {
+  auto command = "rm -rf /"_shellify();
+  EXPECT_EQ(command[0], "/bin/sh");
+  EXPECT_EQ(command[1], "-c");
+  EXPECT_EQ(command[2], "rm -rf /");
+
+  command = "rm -rf {}"_shellify("someFile.txt");
+  EXPECT_EQ(command[2], "rm -rf 'someFile.txt'");
+
+  command = "rm -rf {}"_shellify(5);
+  EXPECT_EQ(command[2], "rm -rf '5'");
+
+  command = "ls {}"_shellify("blah'; rm -rf /");
+  EXPECT_EQ(command[2], "ls 'blah'\\''; rm -rf /'");
+}
+
+// Tests for the deprecated shellify() function.
+// Don't warn about using this deprecated function in the test for it.
+FOLLY_PUSH_WARNING
+FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations")
+TEST(Shell, ShellifyDeprecated) {
+  auto command = shellify("rm -rf /");
+  EXPECT_EQ(command[0], "/bin/sh");
+  EXPECT_EQ(command[1], "-c");
+  EXPECT_EQ(command[2], "rm -rf /");
+
+  command = shellify("rm -rf {}", "someFile.txt");
+  EXPECT_EQ(command[2], "rm -rf 'someFile.txt'");
+
+  command = shellify("rm -rf {}", 5);
+  EXPECT_EQ(command[2], "rm -rf '5'");
+
+  command = shellify("ls {}", "blah'; rm -rf /");
+  EXPECT_EQ(command[2], "ls 'blah'\\''; rm -rf /'");
+}
+FOLLY_POP_WARNING