const string& tmpdir = testing::TmpDir();

  const auto h_file_path = io::JoinPath(tmpdir, "test.h");
  const auto cc_file_path = io::JoinPath(tmpdir, "test.cc");
  const auto internal_h_file_path = io::JoinPath(tmpdir, "test_internal.h");
  const auto internal_cc_file_path = io::JoinPath(tmpdir, "test_internal.cc");

  cc_op::WriteCCOps(ops, api_def_map, h_file_path, cc_file_path);

	if dir == "" {
		dir = TempDir()
	}

	prefix, suffix, err := prefixAndSuffix(pattern)
	if err != nil {
		return nil, &PathError{Op: "createtemp", Path: pattern, Err: err}
	}
	prefix = joinPath(dir, prefix)

	try := 0
	for {
		name := prefix + nextRandom() + suffix
		f, err := OpenFile(name, O_RDWR|O_CREATE|O_EXCL, 0600)
		if IsExist(err) {
			if try++; try < 10000 {
				continue
			}

  BlankLine();
}

string IncludeRenderer::SelfHeaderPath() const {
  return io::JoinPath(context_.path_config.tf_root_dir,
                      context_.path_config.tf_output_dir,
                      context_.cpp_config.unit + "_ops.h");
}

void IncludeRenderer::Include(const string &tf_file_path) {
  CodeLine("#include \"$0\"",
           io::JoinPath(context_.path_config.tf_prefix_dir, tf_file_path));
}

  return GenerateOneFile(cpp::RendererContext::kSource);
}

string CppGenerator::HeaderFileName() const {
  return io::JoinPath(path_config_.output_path, cpp_config_.unit + "_ops.h");
}

string CppGenerator::SourceFileName() const {
  return io::JoinPath(path_config_.output_path, cpp_config_.unit + "_ops.cc");
}

void CppGenerator::WriteHeaderFile() const {

		t.Run("", func(t *testing.T) {
			path := syscall.JoinPath(test.dir, test.file)
			if path != test.path {
				t.Errorf("join(%q,%q): want=%q got=%q", test.dir, test.file, test.path, path)
			}
		})
	}
}

func BenchmarkJoinPath(b *testing.B) {
	for _, test := range joinPathTests {
		b.Run("", func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				syscall.JoinPath(test.dir, test.file)
			}
		})
	}

      TF_ASSERT_OK(
          bundle->variable_reader()->Lookup(std::get<2>(restored_var), &value));
    }
  }
};

TEST_F(BundleV2Test, LoadsVarsAndArithmeticObjectGraph) {
  const std::string export_dir = io::JoinPath(
      testing::TensorFlowSrcRoot(), kTestData, "VarsAndArithmeticObjectGraph");

  SavedModelV2Bundle bundle;
  TF_ASSERT_OK(SavedModelV2Bundle::Load(export_dir, &bundle));

                      SavedModel* saved_model_proto) {
  LOG(INFO) << "Reading SavedModel from: " << export_dir;

  if (IS_OSS) {
    const std::string saved_model_pb_path =
        io::JoinPath(export_dir, kSavedModelFilenamePb);
    TF_ASSIGN_OR_RETURN(
        bool saved_model_pb_exists,
        internal::FileExists(Env::Default(), saved_model_pb_path));
    if (saved_model_pb_exists) {

}

bool MaybeSavedModelDirectory(const string& export_dir) {
  const string saved_model_pb_path =
      io::JoinPath(export_dir, kSavedModelFilenamePb);
  const string saved_model_cpb_path =
      io::JoinPath(export_dir, kSavedModelFilenameCpb);
  const string saved_model_pbtxt_path =
      io::JoinPath(export_dir, kSavedModelFilenamePbTxt);
  return Env::Default()->FileExists(saved_model_pb_path).ok() ||

	// If OpenFile is nil, Import uses os.Open.
	OpenFile func(path string) (io.ReadCloser, error)
}

// joinPath calls ctxt.JoinPath (if not nil) or else filepath.Join.
func (ctxt *Context) joinPath(elem ...string) string {
	if f := ctxt.JoinPath; f != nil {
		return f(elem...)
	}
	return filepath.Join(elem...)
}

  EXPECT_TF_OK(status_);

  const std::string file = io::JoinPath(base, "TestFile.csv");
  WriteString(file, "test");
  EXPECT_TF_OK(status_);

  const std::string subdir = io::JoinPath(base, "SubDir");
  tf_gcs_filesystem::CreateDir(filesystem_, subdir.c_str(), status_);
  EXPECT_TF_OK(status_);
  const std::string subfile = io::JoinPath(subdir, "TestSubFile.csv");
  WriteString(subfile, "test");