}

  return absl::OkStatus();
}

tensorflow::Status RunSessionTf2xlaClusteringBridge(
    ModuleOp module, bool is_in_fallback_enabled_mode) {
  VLOG(2) << "TPU Sessions Bridge called stack trace is "
          << "(NOTE: this is not an error; rather the stack trace for "
             "debugging) : "
          << tensorflow::CurrentStackTrace();

			}

			prof, err := profile.Parse(bytes.NewReader(out))
			if err != nil {
				t.Fatalf("failed to parse the generated profile data: %v", err)
			}
			t.Logf("Profile: %s", prof)

			hit := make(map[*profile.Mapping]bool)
			miss := make(map[*profile.Mapping]bool)
			for _, loc := range prof.Location {
				if symbolized(loc) {
					hit[loc.Mapping] = true

		}
		return false
	}
	return true
}

func dumpFiles(t *testing.T, files []*LineFile) {
	for i, f := range files {
		name := "<nil>"
		if f != nil {
			name = f.Name
		}
		t.Logf("  %d %s", i, name)
	}
}

func compareLines(t *testing.T, a, b []LineEntry) bool {
	t.Helper()
	if len(a) != len(b) {
		t.Errorf("len(a) == %d, len(b) == %d", len(a), len(b))
		return false
	}

		t.Errorf("want cluster matched %q got %q", want.ClusterMatched, r.ClusterMatched)
	} else {
		want.ClusterMatched = r.ClusterMatched
	}
	if t.Failed() {
		t.Logf("Diff: %+v", diff)
		t.Logf("Full Diff: %+v", cmp.Diff(want, r, cmpopts.IgnoreUnexported(Result{}), cmpopts.EquateErrors()))
	} else if want.Skip != "" {
		t.Skipf("Known bug: %v", r.Skip)
	}
}

type Simulation struct {

				{Address: "1.2.3.5", Locality: "notmatch"},
			}),
		},
	})
	ads := s.Connect(&model.Proxy{Locality: &core.Locality{Region: "region"}}, nil, watchAll)

	assertEndpoints(ads, "1.2.3.4:80", "1.2.3.5:80")
	t.Logf("endpoints: %+v", xdstest.ExtractEndpoints(ads.GetEndpoints()["outbound|80||foo.com"]))

	if _, err := s.Store().Update(makeEndpoint([]*networking.WorkloadEntry{
		{Address: "1.2.3.6", Locality: "region/zone"},

      wrapper.CreateGraphOptimizationPassOptions(&graph);
  opt_options.flib_def = &flib_def;

  BuildXlaOpsPass pass(/*enable_lazy_compilation=*/true);
  TF_RETURN_IF_ERROR(pass.Run(opt_options));
  VLOG(3) << graph->ToGraphDefDebug().DebugString();
  *result = std::move(graph);
  return absl::OkStatus();
}

Status MakeXlaCompiledKernel(Graph* graph, const string& callee_name,

					if method == 0 {
						if ent.Tag != TagCompileUnit {
							t.Fatalf("found unexpected tag %v on top level", ent.Tag)
						}
						r.SkipChildren()
					}
				}
			}
			t.Logf("skipping CUs:     %v", units[0])
			t.Logf("not-skipping CUs: %v", units[1])
			if !reflect.DeepEqual(units[0], units[1]) {
				t.Fatal("set of CUs differ")
			}
		})
	}
}

func TestIssue51758(t *testing.T) {

					d := &testingData{desc: desc, t: t, data: mdata[0:n], maxswap: maxswap(n)}
					sort(d)
					// Uncomment if you are trying to improve the number of compares/swaps.
					//t.Logf("%s: ncmp=%d, nswp=%d", desc, d.ncmp, d.nswap)

					// If we were testing C qsort, we'd have to make a copy
					// of the slice and sort it ourselves and then compare

  while (node->input_size() > 0) {
    auto parent = name_to_node_map.find(node->input(0));
    if (parent == name_to_node_map.end()) break;
    node = parent->second;
    if (node->op() != "Identity") {
      VLOG(2) << "Stopping at non-identity node " << node->op();
      break;
    }
  }
  if (node->op() == "VarHandleOp") {
    return node->name();
  }
  return absl::NotFoundError("No VarHandleOp ancestor found");

		}
		if err == nil {
			t.Errorf("%s: should fail", network)
			continue
		}
		if err := parseDialError(err); err != nil {
			t.Errorf("%s: %v", network, err)
			continue
		}
		t.Logf("%s: error as expected: %v", network, err)
	}
}

func TestDialAddrError(t *testing.T) {
	switch runtime.GOOS {
	case "plan9":
		t.Skipf("not supported on %s", runtime.GOOS)
	}