return failure();
    }
    std::string filename = filename_attr.getRawStringData()[0].str();

    if (!saved_model_dir_.empty()) {
      filename = tensorflow::io::JoinPath(
          saved_model_dir_.str(),
          tensorflow::io::JoinPath("assets",
                                   tensorflow::io::Basename(filename)));
    }

    // Read the content of the file.
    std::string error_message;

	}
	return join(artifactsBase, "logs", jobName, buildID, name)
}

func join(base string, elem ...string) string {
	res, _ := url.JoinPath(base, elem...)
	return res

// reproducer will not be enabled.
mlir::ReproducerStreamFactory GetReproducerStreamFactory(
    absl::string_view dump_dir) {
  std::string path = tsl::io::JoinPath(dump_dir, "tfl_mlir_crash_repro.mlir");

  return [path = std::move(path)](
             std::string& error) -> std::unique_ptr<mlir::ReproducerStream> {
    std::unique_ptr<tsl::WritableFile> file;

#include "tsl/platform/statusor.h"

namespace tensorflow::saved_model::fingerprinting {

namespace {

TEST(FingerprintingTest, TestChunkedProto) {
  const std::string export_dir =
      io::JoinPath(testing::TensorFlowSrcRoot(), "cc/saved_model/testdata",
                   "chunked_saved_model/chunked_model");
  TF_ASSERT_OK_AND_ASSIGN(FingerprintDef fingerprint_pb,
                          CreateFingerprintDef(export_dir));

	// 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...)
}

  const std::string variables_dir =
      io::JoinPath(export_dir, kSavedModelVariablesDirectory);
  if (!Env::Default()->FileExists(variables_dir).ok()) {
    LOG(INFO)
        << "No checkpoint found, assuming this is a program-only SavedModel";
  } else {
    // Load the variables checkpoint reader.
    const std::string variables_prefix =
        io::JoinPath(variables_dir, kSavedModelVariablesFilename);

  setenv("TF_DUMP_GRAPH_PREFIX", testing::TmpDir().c_str(), 1);
  UseMlirForGraphDump(MlirDumpConfig());
  string ret = DumpGraphToFile("tir", graph);
  ASSERT_EQ(ret, io::JoinPath(testing::TmpDir(), "tir.mlir"));

  string actual;
  TF_ASSERT_OK(ReadFileToString(Env::Default(), ret, &actual));
}

TEST(Dump, TextualIrWithOptions) {
  Graph graph(OpRegistry::Global());
  Node* node;

      builder.setInsertionPointToStart(&func.getBody().front());

      std::string asset_filename = asset.getFilename().str();
      std::string filename =
          tensorflow::io::JoinPath(saved_model_dir, asset_filename);
      ShapedType shaped_type =
          RankedTensorType::get({1}, TF::StringType::get(builder.getContext()));
      auto const_op = builder.create<TF::ConstOp>(
          asset.getLoc(),

using tensorflow::tstring;

constexpr char kTestData[] = "cc/saved_model/testdata";
const char* kServeTag[] = {"serve"};

std::string SavedModelPath(tensorflow::StringPiece saved_model_dir) {
  return tensorflow::io::JoinPath(tensorflow::testing::TensorFlowSrcRoot(),
                                  kTestData, saved_model_dir);
}

// This value parameterized test allows us to test both TFRT
// and non TFRT runtimes.

		}

		preopens = append(preopens, opendir{
			fd:   preopenFd,
			name: string(dirNameBuf[:prestat.dir.prNameLen]),
		})
	}

	if cwd, _ = Getenv("PWD"); cwd != "" {
		cwd = joinPath("/", cwd)
	} else if len(preopens) > 0 {
		cwd = preopens[0].name
	}
}

// Provided by package runtime.
func now() (sec int64, nsec int32)

//go:nosplit