ASSERT_NE(filepath, "(TF_DUMP_GRAPH_PREFIX not specified)");
  ASSERT_NE(filepath, "LOG(INFO)");
  ASSERT_NE(filepath, "(unavailable)");

  Env* env = Env::Default();
  std::string file_txt_module;
  TF_ASSERT_OK(ReadFileToString(env, filepath, &file_txt_module));
  EXPECT_EQ(file_txt_module, expected_txt_module);
}

TEST(DumpCrashReproducerTest, RoundtripDumpAndReadValid) {
  mlir::registerPassManagerCLOptions();
  mlir::MLIRContext context;

  string expected_header;
  string header_file_name = io::JoinPath(golden_dir, "testing_ops.h.golden");
  TF_CHECK_OK(ReadFileToString(env, header_file_name, &expected_header));

  string expected_source;
  string source_file_name = io::JoinPath(golden_dir, "testing_ops.cc.golden");
  TF_CHECK_OK(ReadFileToString(env, source_file_name, &expected_source));

  // Remove carriage returns (for Windows)
  expected_header.erase(

  auto* env = tsl::Env::Default();
  return WriteStringToFile(env, std::string(file_path), data);
}

absl::StatusOr<std::string> ReadFileToString(
    const absl::string_view file_path) {
  auto* env = tsl::Env::Default();
  std::string data{};
  absl::Status read_status =
      ReadFileToString(env, std::string(file_path), &data);

  if (read_status.ok()) {
    return data;
  } else {
    return read_status;
  }
}

#include "tsl/platform/status_matchers.h"

namespace mlir::quant::stablehlo {
namespace {

using ::stablehlo::quantization::QuantizationResults;
using ::stablehlo::quantization::io::ReadFileToString;
using ::testing::SizeIs;
using ::testing::StrEq;
using ::tsl::protobuf::TextFormat;
using ::tsl::testing::IsOk;
using ::tsl::testing::StatusIs;

  {
    std::string mlir_dump;
    TF_ASSERT_OK(tsl::ReadFileToString(
        tsl::Env::Default(),
        tsl::io::JoinPath(
            dump_dir, "00000000.main.tensorflow_debug_test_NopPass_after.mlir"),
        &mlir_dump));
    EXPECT_THAT(mlir_dump, Not(IsEmpty()));
  }
  {
    std::string mlir_dump;
    TF_ASSERT_OK(tsl::ReadFileToString(
        tsl::Env::Default(),
        tsl::io::JoinPath(

  auto* const env = tsl::Env::Default();
  ASSERT_THAT(env->FileExists(dst_file_path), IsOk());

  std::string data{};
  ASSERT_THAT(tsl::ReadFileToString(env, dst_file_path, &data), IsOk());

  EXPECT_THAT(data, Eq("test_string"));
}

TEST(IoTest, ReadFileToString) {
  // Prepare a temp file and write some string to it.
  const std::string src_file_path =
      absl::StrCat(testing::TempDir(), "/tmp_file");

  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);

  TF_ASSERT_OK(ReadFileToString(env, h_file_path, h_file_text));
  TF_ASSERT_OK(
      ReadFileToString(env, internal_h_file_path, internal_h_file_text));
}

TEST(CcOpGenTest, TestVisibilityChangedToHidden) {
  const string api_def = R"(
op {
  graph_op_name: "Foo"

// `tsl::Env::Default`. Returns an OK status with string data containing file
// contents. Returns non-ok status upon error, e.g. file doesn't exist.
absl::StatusOr<std::string> ReadFileToString(absl::string_view file_path);

// Lists all files and directories under the given directory.
absl::StatusOr<std::vector<std::string>> ListDirectory(
    absl::string_view directory);

template <class MessageT>

            return null;
        }
        try {
            String versionString = FileUtils.readFileToString(msvcVersionFile, StandardCharsets.UTF_8).trim();
            File visualCppDir = new File(installDir, VS2017_COMPILER_PATH_PREFIX + "/" + versionString);

namespace {

absl::StatusOr<SavedModel> ReadSavedModel(absl::string_view file_dir) {
  std::string file_path = io::JoinPath(file_dir, "saved_model.pb");
  std::string serialized_saved_model;
  auto status =
      ReadFileToString(Env::Default(), file_path, &serialized_saved_model);
  if (!status.ok()) {
    return status;
  }
  SavedModel saved_model_pb;
  saved_model_pb.ParseFromString(serialized_saved_model);
  return saved_model_pb;
}