TF_Status* s = TF_NewStatus();

    ::tensorflow::string dirpath =
        ::tensorflow::io::JoinPath(tempdir, "somedir");
    TF_CreateDir(dirpath.c_str(), s);
    ASSERT_TF_OK(s) << "TF_CreateDir failed for " << dirpath << ": "
                    << TF_Message(s);

    ::tensorflow::string filepath =
        ::tensorflow::io::JoinPath(dirpath, "somefile.txt");
    TF_WritableFileHandle* handle;

#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {
namespace cpp {

GuardRenderer::GuardRenderer(RendererContext context) : Renderer(context) {
  string self_path = io::JoinPath(context_.path_config.tf_root_dir,
                                  context_.path_config.tf_output_dir,
                                  context_.cpp_config.unit + "_ops.h");
  string with_underscores(self_path);

    OP_REQUIRES_OK(ctx, ctx->GetAttr("node_name", &node_name));
    OP_REQUIRES_OK(ctx, ctx->env()->RecursivelyCreateDir(log_dir_path));

    std::string tensor_data_path = io::JoinPath(log_dir_path, file_name);
    OP_REQUIRES_OK(
        ctx, ctx->env()->NewWritableFile(tensor_data_path, &tensor_data_file_));

    // Turn on Zlib compression.
    io::RecordWriterOptions options =

  inputs.emplace_back("max", 0, DT_FLOAT);
  inputs.emplace_back("histogram", 0, DT_INT64);

  const std::string dir = testing::TmpDir();
  const std::string output_file_path = io::JoinPath(dir, "statistics.pbtxt");

  TF_CHECK_OK(NodeDefBuilder("op", "CalibrationStatisticsSaver")
                  .Input(inputs)
                  .Attr("ids", ids)

	// resolve and capture it here.
	if filePath[0] != '/' {
		wd, err := syscall.Getwd()
		if err != nil {
			return -1, poll.SysFile{}, err
		}
		absPath = joinPath(wd, filePath)
	}
	fd, err := syscall.Open(absPath, flag, perm)
	return fd, poll.SysFile{Path: absPath}, err

using ::tensorflow::protobuf::io::StringOutputStream;

// TODO(b/290063184): remove when USM is GA
uint64_t HashCheckpointIndexFile(absl::string_view model_dir) {
  std::string meta_filename = MetaFilename(io::JoinPath(
      model_dir, kSavedModelVariablesDirectory, kSavedModelVariablesFilename));
  std::string data;
  absl::Status read_status =
      ReadFileToString(Env::Default(), meta_filename, &data);
  if (read_status.ok()) {

  }
  std::string tfr_raw_text;
  for (const auto& file : files) {
    string fullpath = io::JoinPath(composite_mlir_dir, file);
    if (env->MatchPath(fullpath, io::JoinPath(composite_mlir_dir, "*.mlir"))) {
      std::string text;
      TF_RETURN_IF_ERROR(ReadFileToString(env, fullpath, &text));
      tfr_raw_text.append(text);
    }
  }

}

func (p *Importer) isAbsPath(path string) bool {
	if f := p.ctxt.IsAbsPath; f != nil {
		return f(path)
	}
	return filepath.IsAbs(path)
}

func (p *Importer) joinPath(elem ...string) string {
	if f := p.ctxt.JoinPath; f != nil {
		return f(elem...)
	}
	return filepath.Join(elem...)
}

//go:linkname setUsesCgo go/types.srcimporter_setUsesCgo

#include "tensorflow/core/platform/test.h"

namespace tensorflow {
namespace libexport {
namespace {

TEST(SaveTest, TestDirectoryStructure) {
  const string base_dir = tensorflow::io::JoinPath(
      tensorflow::testing::TmpDir(), "test_directory_structure");
  TF_ASSERT_OK(Save(base_dir));
  TF_ASSERT_OK(Env::Default()->IsDirectory(base_dir));
}

}  // namespace
}  // namespace libexport

                     const std::string& saved_model_dir,
                     const std::string& asset_filename,
                     std::unique_ptr<Asset>* output) {
  std::string abs_path =
      io::JoinPath(saved_model_dir, kSavedModelAssetsDirectory, asset_filename);
  AbstractTensorPtr tensor(ctx->CreateStringScalar(abs_path));
  if (tensor.get() == nullptr) {
    return absl::InternalError(absl::StrCat(