const absl::string_view dump_file_name) {
  const absl::StatusOr<std::string> dump_dir = GetMlirDumpDir();
  if (!dump_dir.ok()) {
    return dump_dir.status();
  }

  auto* env = tsl::Env::Default();
  TF_RETURN_IF_ERROR(env->RecursivelyCreateDir(*dump_dir));

  const std::string dump_file_path =
      tsl::io::JoinPath(*dump_dir, dump_file_name);
  TF_ASSIGN_OR_RETURN(std::unique_ptr<llvm::raw_ostream> file,

		}
	}
}

func TestDumper_doubleclose(t *testing.T) {
	var out strings.Builder
	dumper := Dumper(&out)

	dumper.Write([]byte(`gopher`))
	dumper.Close()
	dumper.Close()
	dumper.Write([]byte(`gopher`))
	dumper.Close()

	expected := "00000000  67 6f 70 68 65 72                                 |gopher|\n"
	if out.String() != expected {

  pm.addPass(std::make_unique<AlwaysFailPass>());
  ASSERT_TRUE(mlir::failed(pm.run(*module_)));

  std::string dump_dir;
  TF_ASSERT_OK(GetDumpDir(&dump_dir));

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

	if len(data) == 0 {
		return ""
	}

	var buf strings.Builder
	// Dumper will write 79 bytes per complete 16 byte chunk, and at least
	// 64 bytes for whatever remains. Round the allocation up, since only a
	// maximum of 15 bytes will be wasted.
	buf.Grow((1 + ((len(data) - 1) / 16)) * 79)

	dumper := Dumper(&buf)
	dumper.Write(data)
	dumper.Close()
	return buf.String()
}

// WITH_FIR_TEST_COMPILER_PLUGIN
// DUMP_IR

// FILE: data/PodcastWithExtraInfo.kt
package data

class PodcastWithExtraInfo {
    lateinit var url: String
    lateinit var lastEpisodeDate: kotlin.time.TimeSource?
        set(value) {
            field = value
        }
    init {
        lastEpisodeDate = null
        url = ""
    }

    operator fun component1() = url
    operator fun component2() = lastEpisodeDate
}

// WITH_FIR_TEST_COMPILER_PLUGIN
// DUMP_IR

// FILE: data/PodcastWithExtraInfo.kt
package data

class PodcastWithExtraInfo {
    lateinit var url: String
    var lastEpisodeDate: kotlin.time.TimeSource? = null
    operator fun component1() = url
    operator fun component2() = lastEpisodeDate
}

// FILE: main.kt
package home

import data.PodcastWithExtraInfo

fun preview(featuredPodcast: PodcastWithExtraInfo) {

// The full pipeline of converting jax random include 2 steps.
// 1. Rename the jax random functions to tflite wrapped functions with the aid
//    of "jax.named_call". For example, in the dumped hlo, the
//    jax.random.uniform will have name "tfl_wrapped_jax_random_uniform".
// 2. Replace the body of "tfl_wrapped_jax_random_uniform" and
//    "tfl_wrapped_jax_random_normal" with tfl.CustomOp("RandomUniform") and

        <option value="$PROJECT_DIR$/plugins/atomicfu/atomicfu-compiler/testData" />
        <option value="$PROJECT_DIR$/plugins/fir-plugin-prototype/testData" />
        <option value="$PROJECT_DIR$/plugins/imports-dumper/testData" />
        <option value="$PROJECT_DIR$/plugins/jvm-abi-gen/testData" />
        <option value="$PROJECT_DIR$/plugins/kapt3/kapt3-base/testData" />
        <option value="$PROJECT_DIR$/plugins/kapt3/kapt3-cli/testData" />

			res += " (trap " + itoa.Itoa(status.TrapCause()) + ")"
		}
	case status.Continued():
		res = "continued"
	}
	if status.CoreDump() {
		res += " (core dumped)"
	}
	return res
}

// ExitCode returns the exit code of the exited process, or -1
// if the process hasn't exited or was terminated by a signal.
func (p *ProcessState) ExitCode() int {

	kube2.DumpDeployments(n.ctx, d, n.name)
}

var (
	_ Instance          = &kubeNamespace{}
	_ io.Closer         = &kubeNamespace{}
	_ resource.Resource = &kubeNamespace{}
	_ resource.Dumper   = &kubeNamespace{}
)

func (n *kubeNamespace) Name() string {
	return n.name
}

func (n *kubeNamespace) Prefix() string {
	return n.prefix
}