timestamp := time.Now()
	metrics.Register()
	total := 60
	queueableNum := 50
	queueable, failme := "queueable", "failme"
	// First 50 Pods are queueable.
	pInfos := makeQueuedPodInfos(queueableNum, "x", queueable, timestamp)
	// The last 10 Pods are not queueable.
	gated := makeQueuedPodInfos(total-queueableNum, "y", failme, timestamp)
	// Manually mark them as gated=true.
	for _, pInfo := range gated {

	// NOTE: we don't immediately check the error, because the failure could be either because
	// the runner failed for some unexpected reason, or because a test case failed, and we
	// cannot easily differentiate these cases. We check if the JSON results file was written,
	// which should only happen if the failure was because of a test failure, and use that
	// to determine the failure mode.

	resultsJSON, jsonErr := os.ReadFile(resultsFile)

    zero = builder.getFloatAttr(elem_type, 0);
  } else {
    return false;
  }
  if (auto ranked_type = dyn_cast<RankedTensorType>(type)) {
    llvm::ArrayRef<int64_t> type_shape = ranked_type.getShape();
    for (int64_t i : type_shape) {
      if (i < 0) return false;
    }
    shape = builder.getI64TensorAttr(type_shape);
  } else {
    return false;
  }
  return true;
}

  auto status = tensorflow::tf2xla::v2::ConvertMlirToGraph(
      module, confs, &graph, flib_def.get(), &control_ret_nodes);
  if (!status.ok()) {
    LOG(ERROR) << "Export to Graph failed: " << status;
    return mlir::failure();
  }

  // Use Host platform, which should always exist, to make sure graphs compile.
  auto platform = stream_executor::PlatformManager::PlatformWithId(

    tensorflow::TPUDevicesAndHosts& devices_and_hosts) {
  std::string topology;
  if (failed(GetTopology(cluster, topology))) {
    return mlir::failure();
  }

  llvm::SmallVector<int64_t, 8> device_coordinates;
  if (failed(GetDeviceAssignmentCoordinates(cluster, device_coordinates))) {
    return mlir::failure();
  }

  // Determine compilation and execution devices.

  if (!module_ref_status.ok()) {
    // If at least one pass is enabled, return failure to the caller
    // immediately.
    if (overall_state == MlirOptimizationPassState::Enabled) {
      return module_ref_status.status();
    }
    // Do not fail, just keep the original TF graph unchanged in fallback mode.
    LOG(WARNING) << "Failed to convert graph to MLIR: "
                 << module_ref_status.status()

type FakeDiscoveryServer struct {
	*core.ConfigGenTest
	t            test.Failer
	Discovery    *xds.DiscoveryServer
	Listener     net.Listener
	BufListener  *bufconn.Listener
	kubeClient   kubelib.Client
	KubeRegistry *kube.FakeController
	XdsUpdater   model.XDSUpdater
	MemRegistry  *memregistry.ServiceDiscovery
}

func NewFakeDiscoveryServer(t test.Failer, opts FakeOptions) *FakeDiscoveryServer {
	m := opts.MeshConfig

	if err != nil {
		t.Fatalf("Failed to read a file - %v", err)
	}

	// Test 1, remove part.1
	err = firstDisk.Delete(context.Background(), bucket, pathJoin(object, fi.DataDir, "part.1"), DeleteOptions{
		Recursive: false,
		Immediate: false,
	})
	if err != nil {
		t.Fatalf("Failed to delete a file - %v", err)
	}

    if (!symbol) return failure();
    auto f = llvm::dyn_cast<mlir::func::FuncOp>(symbol);

    if (call.getOperation()->getNumOperands() !=
        f.getBody().front().getNumArguments()) {
      return failure();  // RemoteCall et al
    }

    rewriter.startOpModification(f);
    bool changed = false;
    for (auto [call_arg, body_arg] :

		precondition:        nil,
		expectNotFoundErr:   false,
		expectInvalidObjErr: false,
		expectNoUpdate:      false,
	}, {
		name:                "existing key",
		key:                 key,
		ignoreNotFound:      false,
		precondition:        nil,
		expectNotFoundErr:   false,
		expectInvalidObjErr: false,
		expectNoUpdate:      false,
	}, {
		name:                "same data",