Method TestCopyFiles

cpp/src/arrow/filesystem/test_util.cc:591–650

}

void GenericFileSystemTest::TestCopyFiles(FileSystem* fs) {
#if defined(ADDRESS_SANITIZER) || defined(ARROW_VALGRIND)
  if (have_false_positive_memory_leak_with_async_close()) {
    GTEST_SKIP() << "Filesystem have false positive memory leak with generator";
  }
#endif
  auto io_thread_pool =
      static_cast<arrow::internal::ThreadPool*>(fs->io_context().executor());
  auto original_threads = io_thread_pool->GetCapacity();
  // Needs to be smaller than the number of files we test with to catch GH-15233
  ASSERT_OK(io_thread_pool->SetCapacity(2));
  // Ensure the thread pool capacity is set back to the original value after the test
  auto reset_thread_pool = [io_thread_pool, original_threads](void*) {
    ASSERT_OK(io_thread_pool->SetCapacity(original_threads));
  };
  std::unique_ptr<void, decltype(reset_thread_pool)> reset_thread_pool_guard(
      nullptr, reset_thread_pool);

  auto mock_fs = std::make_shared<arrow::fs::internal::MockFileSystem>(
      std::chrono::system_clock::now());
  std::vector<std::string> dirs0{"0", "0/AB", "0/AB/CD"};
  std::map<std::string, std::string> files0{
      {"0/123", "123 data"}, {"0/AB/abc", "abc data"}, {"0/AB/CD/def", "def data"}};

  std::vector<std::string> dirs0and1{"0", "0/AB", "0/AB/CD", "1", "1/AB", "1/AB/CD"};
  std::map<std::string, std::string> files0and1{
      {"0/123", "123 data"}, {"0/AB/abc", "abc data"}, {"0/AB/CD/def", "def data"},
      {"1/123", "123 data"}, {"1/AB/abc", "abc data"}, {"1/AB/CD/def", "def data"}};

  ASSERT_OK(mock_fs->CreateDir("0/AB/CD"));
  for (const auto& kv : files0) {
    CreateFile(mock_fs.get(), kv.first, kv.second);
  }

  auto selector0 = arrow::fs::FileSelector{};
  selector0.base_dir = "0";
  selector0.recursive = true;

  ASSERT_OK(CopyFiles(mock_fs, selector0, fs->shared_from_this(), "0"));
  AssertAllDirs(fs, dirs0);
  for (const auto& kv : files0) {
    AssertFileContents(fs, kv.first, kv.second);
  }

  ASSERT_OK(CopyFiles(fs->shared_from_this(), selector0, fs->shared_from_this(), "1"));
  AssertAllDirs(fs, dirs0and1);
  for (const auto& kv : files0and1) {
    AssertFileContents(fs, kv.first, kv.second);
  }

  auto selector1 = arrow::fs::FileSelector{};
  selector1.base_dir = "1";
  selector1.recursive = true;

  ASSERT_OK(CopyFiles(fs->shared_from_this(), selector1, mock_fs, "1"));
  AssertAllDirs(mock_fs.get(), dirs0and1);
  for (const auto& kv : files0and1) {
    AssertFileContents(mock_fs.get(), kv.first, kv.second);