oldObj:       st.MakePod().Obj(),
			expectedHint: framework.QueueSkip,
		},
		"skip-queue-on-non-hostport": {
			pod:          podWithHostPort.Obj(),
			oldObj:       st.MakePod().Node("fake-node").Obj(),
			expectedHint: framework.QueueSkip,
		},
		"skip-queue-on-unrelated-hostport": {
			pod:          podWithHostPort.Obj(),
			oldObj:       st.MakePod().Node("fake-node").HostPort(8081).Obj(),

		st.MakeNode().Name("node3").UID("node3").Obj(),
	}
	pods := []*v1.Pod{
		st.MakePod().Name("pod1").UID("pod1").SchedulerName("match-node3").Obj(),
		st.MakePod().Name("pod2").UID("pod2").SchedulerName("match-node2").Obj(),
		st.MakePod().Name("pod3").UID("pod3").SchedulerName("match-node2").Obj(),
		st.MakePod().Name("pod4").UID("pod4").SchedulerName("match-node3").Obj(),
	}
	wantBindings := map[string]string{

	assert.Equal(t, thirtySeconds, delay)
}

func TestInhibitShutdown(t *testing.T) {
	var fakeFd uint32 = 42

	bus := DBusCon{
		SystemBus: &fakeSystemDBus{
			fakeDBusObject: &fakeDBusObject{
				bodyValue: fakeFd,
			},
		},
	}

	fdLock, err := bus.InhibitShutdown()
	assert.Equal(t, InhibitLock(fakeFd), fdLock)
	assert.NoError(t, err)
}

func TestReloadLogindConf(t *testing.T) {

		},
		{
			name: "partial pods matching quotaScopeSelector - w/ multiple scopeNames specified",
			objs: []runtime.Object{
				makePod("p1", "high-priority", cpu1, api.PodRunning),
				makePod("p2", "high-priority", cpu1, api.PodSucceeded),
				makePod("p3", "low-priority", cpu1, api.PodRunning),
				makePod("p4", "high-priority", nil, api.PodFailed),
			},
			quotaScopes: []corev1.ResourceQuotaScope{

		wantStatus *framework.Status
	}{
		{
			pod:  &v1.Pod{},
			node: &v1.Node{},
			name: "no host specified",
		},
		{
			pod:  st.MakePod().Node("foo").Obj(),
			node: st.MakeNode().Name("foo").Obj(),
			name: "host matches",
		},
		{
			pod:        st.MakePod().Node("bar").Obj(),
			node:       st.MakeNode().Name("foo").Obj(),
			name:       "host doesn't match",

		t.Fatalf("can't create temp dir: %v", err)
	}

	if client == nil {
		client = fakeclient.NewSimpleClientset()
	}

	client.Tracker().Add(&v1.Node{
		ObjectMeta: metav1.ObjectMeta{
			Name: "fakeNode",
		},
		Spec: v1.NodeSpec{},
	})

	// Start informer for CSIDrivers.
	factory := informers.NewSharedInformerFactory(client, csi.CsiResyncPeriod)
	csiDriverInformer := factory.Storage().V1().CSIDrivers()

    class FakeOp implements Runnable {
      final int op;

      FakeOp(int op) {
        this.op = op;
      }

      @Override
      public void run() {
        callOrder.add(op);
      }
    }

    e.execute(new FakeOp(0));
    e.execute(new FakeOp(1));
    e.execute(new FakeOp(2));
    fakePool.runAll();

		{Type: watch.Added, Object: makePod(1)},
		{Type: watch.Added, Object: makePod(2)},
		{Type: watch.Added, Object: makePod(5)},
		{Type: watch.Bookmark, Object: &v1.Pod{
			ObjectMeta: metav1.ObjectMeta{
				ResourceVersion: "10",
				Annotations:     map[string]string{metav1.InitialEventsAnnotationKey: "true"},
			},
		}},
		{Type: watch.Added, Object: makePod(15)},
	}, true)

		_, kube, xdsUpdater := setupTest(t)
		makeService(t, kube, service)
		xdsUpdater.WaitOrFail(t, "service")
		makePod(t, kube, pod)
		xdsUpdater.WaitOrFail(t, "proxy")
		newPod := pod.DeepCopy()
		newPod.Labels["newlabel"] = "new"
		makePod(t, kube, newPod)
		xdsUpdater.WaitOrFail(t, "proxy")
	})

	t.Run("Kubernetes only: headless pure HTTP service", func(t *testing.T) {

[short] skip

env TESTGO_VERSION=go1.21pre3

# Compile a fake toolchain to put in the path under various names.
env GOTOOLCHAIN=
mkdir $WORK/bin
go build -o $WORK/bin/go1.50.0$GOEXE ./fakego.go  # adds .exe extension implicitly on Windows

[!GOOS:plan9] env PATH=$WORK/bin
[GOOS:plan9] env path=$WORK/bin

go version
stdout go1.21pre3

# GOTOOLCHAIN=go1.50.0
env GOTOOLCHAIN=go1.50.0
! go version