}
			}
			n--
			buf[n] = 'x'
			n--
			buf[n] = '0'
			n--
			buf[n] = '('
			dumpslice(buf[n:])
			dumpstr("?")
			dumpint(0)
		} else {
			dumpstr(funcname(f))
			if i > 0 && pc > f.entry() {
				pc--
			}
			file, line := funcline(f, pc)
			dumpstr(file)
			dumpint(uint64(line))
		}
	}
	dumpint(uint64(allocs))
	dumpint(uint64(frees))
}

func dumpmemprof() {

// limitations under the License.

package resource

// Dumper is an interface that is implemented by all components that can dump their state. In CI, it is
// useful to get as much context as possible when a test fails. Dumper allows dumping of state from a test.
type Dumper interface {
	Dump(ctx Context)

	p.dump(reflect.ValueOf(n), n)
	p.printf("\n")

	return
}

type dumper struct {
	output io.Writer
	ptrmap map[Node]int // node -> dump line number
	indent int          // current indentation level
	last   byte         // last byte processed by Write
	line   int          // current line number
}

var indentBytes = []byte(".  ")

func (p *dumper) Write(data []byte) (n int, err error) {
	var m int
	for i, b := range data {

//  limitations under the License.

package framework

import (
	"testing"

	"istio.io/istio/pkg/test/framework/label"
	"istio.io/istio/pkg/test/framework/resource"
)

var _ resource.Dumper = &runtime{}

// runtime for the test environment.
type runtime struct {
	context *suiteContext
}

// newRuntime returns a new runtime instance.

Mengjiao Liu <******@****.***> 1679485684 +0800

    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,

  }

  if (dump_to_dir) {
    dump_dir = tsl::io::JoinPath(
        dump_dir, absl::FormatTime("%E4Y%m%d_%H%M%E6S", absl::Now(),
                                   absl::LocalTimeZone()));

    // Get a valid file path to dump with.
    tsl::Env* env = tsl::Env::Default();
    if (auto status = env->RecursivelyCreateDir(dump_dir); !status.ok()) {
      LOG(WARNING) << "Failed to create '" << dump_dir

		}
	}
}

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

  // Regular expression that matches the names of passes in pascal case (e.g.,
  // FooPass) before/after which MLIR will be dumped. Effective only if
  // ir_dump_dir is not empty.
  optional string ir_dump_pass_regex = 2 [default = ".*"];

  // Regular expression that matches the names of functions to be dumped. MLIR
  // modules are dumped only if there's at least one public function in the