"@local_xla//xla/translate/hlo_to_mhlo:hlo_utils",
        "@local_xla//xla/translate/mhlo_to_hlo:type_to_shape",
    ],
)

cc_library(
    name = "tensorflow_test_passes",
    testonly = True,  # Ensure alwayslink does not leak in the codebase.
    srcs = [
        "init_text_file_to_import_test_pass.cc",
        "initialize_variables_in_session_init_test_pass.cc",
        "lift_variables_test_pass.cc",

	}
	dir := t.TempDir()
	ia := NewAgent(proxyConfig, &AgentOptions{
		XdsUdsPath:            filepath.Join(dir, "XDS"),
		DownstreamGrpcOptions: opts,
	}, secOpts, envoy.ProxyConfig{TestOnly: true})
	t.Cleanup(func() {
		ia.Close()
	})
	proxy, err := initXdsProxy(ia)
	if err != nil {
		t.Fatalf("Failed to initialize xds proxy %v", err)
	}
	ia.xdsProxy = proxy

	return proxy
}

type WalkOptions struct {
	Filter       func(info FileInfo) bool // return WalkFilter returns 'true/false'
	Marker       string                   // set to skip until this object
	LatestOnly   bool                     // returns only latest versions for all matching objects
	AskDisks     string                   // dictates how many disks are being listed

	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	results := make(chan itemOrErr[ObjectInfo], workerSize)
	if err := api.Walk(ctx, r.Bucket, r.Prefix, results, WalkOptions{
		Marker:       lastObject,
		LatestOnly:   false, // we need to visit all versions of the object to implement purge: retainVersions
		VersionsSort: WalkVersionsSortDesc,
	}); err != nil {
		// Do not need to retry if we can't list objects on source.
		return err

        "@llvm-project//mlir:IR",
        "@llvm-project//mlir:Parser",
        "@local_xla//xla:status_macros",
    ],
)

cc_library(
    name = "tf_xla_mlir_translate",
    testonly = True,  # Ensure alwayslink does not leak in the codebase.
    srcs = ["utils/tf_xla_mlir_translate.cc"],
    deps = [
        ":mlir_roundtrip_flags",
        ":serialize_mlir_module_utils",

	// Run through opts again to apply settings
	for _, opt := range opts {
		resp = opt(resp)
	}
	a := NewAgent(resp.ProxyConfig, &resp.AgentConfig, &resp.Security, envoy.ProxyConfig{TestOnly: !resp.envoyEnable})
	t.Cleanup(a.Close)
	ctx, done := context.WithCancel(context.Background())
	wait, err := a.Run(ctx)
	if err != nil {
		t.Fatal(err)
	}

						disks[i], disks[j] = disks[j], disks[i]
					})
					fallbackDisks = disks[askDisks:]
					disks = disks[:askDisks]
				}

				requestedVersions := 0
				if opts.LatestOnly {
					requestedVersions = 1
				}

				// However many we ask, versions must exist on ~50%
				listingQuorum := (askDisks + 1) / 2

				// How to resolve partial results.

	}
	return p.ImportPath
}

// IsTestOnly reports whether p is a test-only package.
//
// A “test-only” package is one that:
//   - is a test-only variant of an ordinary package, or
//   - is a synthesized "main" package for a test binary, or
//   - contains only _test.go files.
func (p *Package) IsTestOnly() bool {
	return p.ForTest != "" ||
		p.Internal.TestmainGo != nil ||

			// meta-files summary file written by writeCoverMetaAct,
			// so add a dependence edge from writeCoverMetaAct to the
			// run action.
			runAction.Deps = append(runAction.Deps, writeCoverMetaAct)
			if !p.IsTestOnly() {
				// Package p is not test only, meaning that the build
				// action for p may generate a static meta-data file.
				// Add a dependence edge from p to writeCoverMetaAct,