expectedError:   nil,
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			ctrl := newPlugin()
			informerFactory := informers.NewSharedInformerFactory(nil, controller.NoResyncPeriodFunc())
			ctrl.SetExternalKubeInformerFactory(informerFactory)
			for _, c := range testCase.classes {
				informerFactory.Networking().V1().IngressClasses().Informer().GetStore().Add(c)

	BNE	CR6,foundat3	// Match found at R8+48 bytes, jump out

	ADD	$64,R8
	CMPU	R8,R9,CR1
	BNE	CR1,loop64	// R8 != &s[len &^ 63]?

	PCALIGN	$32
	BEQ	notfound	// Is tail length 0? CR0 is set before entering loop64.

	CMP	R4,$32		// Tail length >= 32, use cmp32 path.
	CMP	R4,$16,CR1
	BGE	cmp32

	ADD	R8,R4,R9
	ADD	$-16,R9
	BLE	CR1,cmp64_tail_gt0

cmp64_tail_gt16:	// Tail length 17 - 32
	LXVD2X	(R0)(R8),V2

					api.DeprecatedAppArmorAnnotationKeyPrefix + "ctr": api.DeprecatedAppArmorAnnotationValueUnconfined,
				},
			},
			Spec: api.PodSpec{
				Containers: []api.Container{{Name: "ctr"}},
			},
		},
		validation: func(t *testing.T, pod *api.Pod) {
			assert.Equal(t, map[string]string{
				api.DeprecatedAppArmorAnnotationKeyPrefix + "ctr": api.DeprecatedAppArmorAnnotationValueUnconfined,

				// Bind the volume to resurrected claim (this should never
				// happen)
				claim := newClaim("claim8-7", "uid8-7", "10Gi", "volume8-7", v1.ClaimBound, nil)
				reactor.AddClaimBoundToVolume(claim)
				ctrl.claims.Add(claim)
			}),
		},
		{

	// the value here doesn't really matter).
	MOVD	$0, R3

	RET

TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
	MOVW	sig+8(FP), R3
	MOVD	info+16(FP), R4
	MOVD	ctx+24(FP), R5
	MOVD	fn+0(FP), R12
	MOVD	R12, CTR
	CALL	(CTR)			// Alignment for ELF ABI?
	RET

TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$16
	// Go relies on R0 being $0 and we may have been executing non-Go code.
	XOR	R0, R0

				func(ctrl *PersistentVolumeController, reactor *pvtesting.VolumeReactor) {
					nodesIndexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{})
					node := &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "node1"}}
					nodesIndexer.Add(node)
					ctrl.NodeLister = corelisters.NewNodeLister(nodesIndexer)
				}),
		},
		{

		klog.V(4).Infof("starting test %q", test.name)

		// clone the claim, it's going to be modified
		claim := test.claim.DeepCopy()

		ctrl := newPlugin()
		informerFactory := informers.NewSharedInformerFactory(nil, controller.NoResyncPeriodFunc())
		ctrl.SetExternalKubeInformerFactory(informerFactory)
		for _, c := range test.classes {
			informerFactory.Storage().V1().StorageClasses().Informer().GetStore().Add(c)
		}

	}, {
		name:   "update: reduce externalIPs from front",
		newSvc: makeSvc("2.2.2.2"),
		oldSvc: makeSvc("1.1.1.1", "2.2.2.2"),
	}}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			ctrl := newPlugin()

			var op admission.Operation
			var opt runtime.Object
			if tc.oldSvc == nil {
				op = admission.Create
				opt = &metav1.CreateOptions{}
			} else {
				op = admission.Update

    ${server.callFromBuild('sync')}
    latch.await()
}
"""
    }

    def "logging does not include message to use ctrl-d to exit"() {
        when:
        runBuild {
            succeeds()
            cancel()
        }

        then:
        !result.output.contains("ctrl-d")
        result.output.contains(waitingMessage)
    }

			case ld.lockContext <- lkctx:
				// Send the lock context to anyone asking for it
			}
		}
	}
}

func mergeContext(ctx1, ctx2 context.Context) (context.Context, context.CancelFunc) {
	ctx, cancel := context.WithCancel(context.Background())
	go func() {
		select {
		case <-ctx1.Done():
		case <-ctx2.Done():
		// The lock acquirer decides to cancel, exit this goroutine
		case <-ctx.Done():
		}

		cancel()