TF_RETURN_IF_ERROR(WriteStringToFile(env, flags.out_metadata_object,
                                       metadata_result.object_file_data));
  string header;
  TF_RETURN_IF_ERROR(GenerateHeader(codegen_opts, config, compile_result,
                                    metadata_result, &header));
  TF_RETURN_IF_ERROR(WriteStringToFile(env, flags.out_header, header));
  return absl::OkStatus();
}

                                HasSubstr("Failed to create tmp dir")));
}

TEST(IoTest, WriteStringToFile) {
  const std::string dst_file_path =
      absl::StrCat(testing::TempDir(), "/tmp_file");

  const absl::Status write_status =
      WriteStringToFile(dst_file_path, "test_string");
  ASSERT_THAT(write_status, IsOk());

  auto* const env = tsl::Env::Default();

  // The overloaded function uses the default env.
  return CreateTmpDir(tsl::Env::Default());
}

absl::Status WriteStringToFile(const absl::string_view file_path,
                               const absl::string_view data) {
  auto* env = tsl::Env::Default();
  return WriteStringToFile(env, std::string(file_path), data);
}

absl::StatusOr<std::string> ReadFileToString(
    const absl::string_view file_path) {

namespace {

using ::stablehlo::quantization::Method;
using ::stablehlo::quantization::QuantizationResult;
using ::stablehlo::quantization::QuantizationResults;
using ::stablehlo::quantization::io::WriteStringToFile;
using ::tsl::protobuf::TextFormat;

// Given a `quantized_func_name` that starts with `kQuantizedFuncPrefix`,
// converts `kQuantizedFuncPrefix` to `kCompositeFuncPrefix`.

absl::StatusOr<std::string> CreateTmpDir();

// Convenience function for writing string `data` to file without the need to
// pass `tsl::Env` instance. Internally it uses the default `tsl::Env::Default`.
absl::Status WriteStringToFile(absl::string_view file_path,
                               absl::string_view data);

// Convenience function for reading string data from file at `file_path` without

  BuildModel();
}
Controller::~Controller() { delete api_def_map_; }

const void Controller::WriteFile(const string& file_path,
                                 const SourceCode& code) const {
  TF_CHECK_OK(WriteStringToFile(env_, file_path, code.Render())) << file_path;
}

const std::vector<OpSpec>& Controller::GetModelOps() const {
  return operators_;
}

void Controller::InitializeOpApi() {

  //
  // bazel test --test_strategy=local \
  //   tensorflow/compiler/jit/tests:auto_clustering_test
  bool update_golden = false;
  if (update_golden) {
    TF_RETURN_IF_ERROR(WriteStringToFile(
        Env::Default(), string(golden_summary_file_path), clustering_summary));
  }

  string golden_file_contents;
  TF_RETURN_IF_ERROR(ReadFileToString(

  const bool update_golden = false;
  string golden_file_name =
      GetDataDependencyFilepath(tensorflow_relative_golden_file_name);

  if (update_golden) {
    TF_EXPECT_OK(
        WriteStringToFile(Env::Default(), golden_file_name, expected_contents));
  }

  string golden_file_contents;
  TF_ASSERT_OK(ReadFileToString(Env::Default(), golden_file_name,
                                &golden_file_contents));

        writeFile(content, destination, Charset.defaultCharset().name());
    }

    public static void writeFile(String content, File destination, String encoding) {
        try {
            FileUtils.writeStringToFile(destination, content, encoding);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    }

    public static void writeFile(String content, File destination, String encoding) {
        logDeprecation();
        try {
            FileUtils.writeStringToFile(destination, content, encoding);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }