DCHECK_EQ(nullptr, session);
    return nullptr;
  }
}

TF_Session* TF_LoadSessionFromSavedModel(
    const TF_SessionOptions* session_options, const TF_Buffer* run_options,
    const char* export_dir, const char* const* tags, int tags_len,
    TF_Graph* graph, TF_Buffer* meta_graph_def, TF_Status* status) {
// TODO(sjr): Remove the IS_MOBILE_PLATFORM guard. This will require ensuring

                          int64_t* undeleted_dir_count, TF_Status* status) {
  ::int64_t f, d;

  TF_SetStatus(status, TF_OK, "");
  ::tensorflow::Set_TF_Status_from_Status(
      status, ::tensorflow::Env::Default()->DeleteRecursively(dirname, &f, &d));
  *undeleted_file_count = f;
  *undeleted_dir_count = d;
}

void TF_FileStat(const char* filename, TF_FileStatistics* stats,

    ASSERT_TF_OK(s) << "TF_DeleteDir failed for " << dirpath << ": "
                    << TF_Message(s);

    TF_DeleteStatus(s);
    break;
  }

  ASSERT_TRUE(found) << "expected at least one temp dir";

  TF_StringStreamDone(tempdirs);
}

TEST(TestEnv, TestTimeFunctions) {
  ASSERT_GE(TF_NowSeconds(), 946684800);  // Midnight Jan 1, 2000
  ASSERT_GE(TF_NowMicros(), 946684800 * 1e6);

  if (tmp_dir == "")
    return nullptr;
  else
    return &tmp_dir;
}

namespace tensorflow {
namespace {

// TODO(vnvo2409): Refactor `gcs_filesystem_test` to remove unnecessary tests
// after porting all tests from
// `//tensorflow/core/platform/cloud:gcs_file_system_test`.
class GCSFilesystemTest : public ::testing::Test {
 public:
  void SetUp() override {
    root_dir_ = io::JoinPath(

        plugin_memory_allocate(num_entries * sizeof((*entries)[0])));
    for (int i = 0; i < num_entries; i++) {
      (*entries)[i] = strdup(dir_entries[i]->d_name);
      plugin_memory_free(dir_entries[i]);
    }
    plugin_memory_free(dir_entries);
  }

  return num_entries;
}

}  // namespace tf_posix_filesystem

static void ProvideFilesystemSupportFor(TF_FilesystemPluginOps* ops,

  if (TF_GetCode(status) != TF_OK) return;

  std::string src_dir = src;
  std::string dst_dir = dst;
  MaybeAppendSlash(&src_dir);
  MaybeAppendSlash(&dst_dir);
  for (const std::string& children : childrens) {
    RenameObject(filesystem, src_dir + children, dst_dir + children, status);
    if (TF_GetCode(status) != TF_OK) return;
  }
  TF_SetStatus(status, TF_OK, "");
}

      // behaves differently on Windows. `tmp_dir` should be something like
      // `path/to/tmp/dir/`. After joining path, we will have
      // /path/to/tmp/dir/tf_fs_rng_name/`
      root_dir_ = tensorflow::strings::StrCat(
          "/", tmp_dir_,
          tensorflow::strings::StrCat("tf_fs_", rng_val_, "_", test_name), "/");
    } else {
      root_dir_ = tensorflow::io::JoinPath(
          tmp_dir_,

  return result;
}

Status ModularFileSystem::GetChildren(const std::string& dir,
                                      TransactionToken* token,
                                      std::vector<std::string>* result) {
  if (ops_->get_children == nullptr)
    return errors::Unimplemented(tensorflow::strings::StrCat(
        "Filesystem for ", dir, " does not support GetChildren()"));

  TF_ColocateWith(desc_, feed1_);
  SetViaProto(desc_, {});
  FinishAndVerify(desc_, {});
}

TEST(CAPI, SavedModel) {
  // Load the saved model.
  const string saved_model_dir = tensorflow::GetDataDependencyFilepath(
      tensorflow::io::JoinPath("tensorflow", "cc", "saved_model", "testdata",
                               "half_plus_two", "00000123"));