using tensorflow::experimental::cc::Status;

constexpr char kTestData[] = "cc/saved_model/testdata";

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.

  for (const auto& op : op_list_.op()) {
    for (const auto& dir : path_config_.api_dirs) {
      const string file_name = absl::Substitute("api_def_$0.pbtxt", op.name());
      const string file_path = io::JoinPath(dir, file_name);
      if (env_->FileExists(file_path).ok()) {
        TF_CHECK_OK(api_def_map_->LoadFile(env_, file_path)) << file_path;
      } else {
        // API defs are currently used for only optional pieces.

#if !defined(PLATFORM_WINDOWS)
#if !defined(TENSORFLOW_NO_SHARED_OBJECTS)
  // Load the library.
  TF_Status* status = TF_NewStatus();
  string lib_path =
      tensorflow::GetDataDependencyFilepath(tensorflow::io::JoinPath(
          "tensorflow", "c", "experimental", "stream_executor", "test",
          "test_pluggable_device.so"));
  TF_Library* lib = TF_LoadPluggableDeviceLibrary(lib_path.c_str(), status);

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

namespace tensorflow {
namespace {

std::string CheckpointPrefix(StringPiece saved_model_dir) {
  return io::JoinPath(testing::TensorFlowSrcRoot(), "cc/saved_model/testdata",
                      saved_model_dir, kSavedModelVariablesDirectory,
                      kSavedModelVariablesFilename);
}

  for (const std::string& statistics_file : statistics_files) {
    TF_ASSIGN_OR_RETURN(
        const auto single_map,
        io::ReadBinaryProto<CalibrationStatisticsMap>(
            tsl::io::JoinPath(calibration_data_dir, statistics_file)));
    statistics_map.insert(single_map.statistics().begin(),
                          single_map.statistics().end());
  }
  return statistics_map;
}

  for (const auto& file_name : file_names) {
    if (absl::EndsWith(file_name, ".pb") &&
        absl::StartsWith(file_name, file_prefix)) {
      XlaSerializedCacheEntry entry;
      auto file_path = io::JoinPath(persistent_cache_dir_path, file_name);
      TF_RETURN_IF_ERROR(ReadTextOrBinaryProto(env, file_path, &entry));
      entry.mutable_hlo_module()->set_name(
          absl::StrCat(entry.hlo_module().name(), "_altered"));

		}
	}
	return false
}

// JoinPath returns a [URL] string with the provided path elements joined to
// the existing path of base and the resulting path cleaned of any ./ or ../ elements.
func JoinPath(base string, elem ...string) (result string, err error) {
	url, err := Parse(base)
	if err != nil {
		return
	}
	result = url.JoinPath(elem...).String()
	return

}

std::unique_ptr<FlatBufferModel> ReadTestModel() {
  auto model_path = tensorflow::io::JoinPath(
      *g_test_model_dir, internal::kConvModelWith0Plus10Weights);
  return FlatBufferModel::BuildFromFile(model_path.c_str());
}

std::unique_ptr<FlatBufferModel> ReadSharedWeightsTestModel() {
  auto model_path = tensorflow::io::JoinPath(*g_test_model_dir,
                                             internal::kModelWithSharedWeights);

namespace {

std::string GetOutputFilePath(absl::string_view calibration_data_dir,
                              absl::string_view func_name,
                              int32_t output_file_idx) {
  return tsl::io::JoinPath(calibration_data_dir,
                           llvm::Twine(func_name)
                               .concat("_")
                               .concat(std::to_string(output_file_idx))

				pkga = pkgtargetroot + "/" + p.ImportPath + ".a"
			}
			p.SrcRoot = ctxt.joinPath(p.Root, "src")
			p.PkgRoot = ctxt.joinPath(p.Root, "pkg")
			p.BinDir = ctxt.joinPath(p.Root, "bin")
			if pkga != "" {
				// Always set PkgTargetRoot. It might be used when building in shared
				// mode.
				p.PkgTargetRoot = ctxt.joinPath(p.Root, pkgtargetroot)

				// Set the install target if applicable.