Containers: []api.Container{
						{Name: "ctr1"},
						{Name: "ctr2", Ports: []api.ContainerPort{{ContainerPort: 9376}}},
					},
				},
				Status: api.PodStatus{PodIPs: []api.PodIP{{IP: expectedIP}}},
			},
			query:    "foo",
			location: expectedIP + ":9376",
		},
		{
			pod: api.Pod{
				ObjectMeta: metav1.ObjectMeta{Name: "foo"},
				Spec: api.PodSpec{
					Containers: []api.Container{

	BC 12, 2, target		<=>	beq cr0, target
	BC 12, 5, target		<=>	bgt cr1, target
	BC 12, 30, target		<=>	beq cr7, target
	BC 4, 6, target		<=>	bne cr1, target
	BC 4, 1, target		<=>	ble cr1, target

	The following extended opcodes are available for ease of use and readability:

	BNE CR2, target		<=>	bne cr2, target
	BEQ CR4, target		<=>	beq cr4, target
	BLT target			<=>	blt target (cr0 default)
	BGE CR7, target		<=>	bge cr7, target

#endif

	// Assume len > 0 && len % blockSize == 0.
	CMPW	ENC, $0
	P8_LXVB16X(IVP, R0, IVEC)
	CMPU	ROUNDS, $10, CR1
	CMPU	ROUNDS, $12, CR2 // Only sizes 10/12/14 are supported.

	// Setup key in VSRs, and set loop count in CTR.
	LOAD_KEY(KEYP)
	SRD	$4, LEN
	MOVD	LEN, CTR

	BEQ	Lcbc_dec

	PCALIGN $16
Lcbc_enc:
	P8_LXVB16X(INP, R0, INOUT)
	ADD	$16, INP
	VXOR	INOUT, V6, INOUT

	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMirrorPodByPod", arg0)
	ret0, _ := ret[0].(*v1.Pod)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetMirrorPodByPod indicates an expected call of GetMirrorPodByPod.
func (mr *MockPodManagerMockRecorder) GetMirrorPodByPod(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()

	}

	ctrl.initializeCaches(logger, ctrl.volumeLister, ctrl.claimLister)

	go wait.Until(func() { ctrl.resync(ctx) }, ctrl.resyncPeriod, ctx.Done())
	go wait.UntilWithContext(ctx, ctrl.volumeWorker, time.Second)
	go wait.UntilWithContext(ctx, ctrl.claimWorker, time.Second)

	metrics.Register(ctrl.volumes.store, ctrl.claims, &ctrl.volumePluginMgr)

	<-ctx.Done()
}

type MockManager struct {
	ctrl     *gomock.Controller
	recorder *MockManagerMockRecorder
}

// MockManagerMockRecorder is the mock recorder for MockManager.
type MockManagerMockRecorder struct {
	mock *MockManager
}

// NewMockManager creates a new mock instance.
func NewMockManager(ctrl *gomock.Controller) *MockManager {
	mock := &MockManager{ctrl: ctrl}
	mock.recorder = &MockManagerMockRecorder{mock}

type MockVersion struct {
	ctrl     *gomock.Controller
	recorder *MockVersionMockRecorder
}

// MockVersionMockRecorder is the mock recorder for MockVersion.
type MockVersionMockRecorder struct {
	mock *MockVersion
}

// NewMockVersion creates a new mock instance.
func NewMockVersion(ctrl *gomock.Controller) *MockVersion {
	mock := &MockVersion{ctrl: ctrl}
	mock.recorder = &MockVersionMockRecorder{mock}

	mock.recorder = &MockDevicesProviderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDevicesProvider) EXPECT() *MockDevicesProviderMockRecorder {
	return m.recorder
}

// GetAllocatableDevices mocks base method.
func (m *MockDevicesProvider) GetAllocatableDevices() []*v10.ContainerDevices {
	m.ctrl.T.Helper()

type MockProvider struct {
	ctrl     *gomock.Controller
	recorder *MockProviderMockRecorder
}

// MockProviderMockRecorder is the mock recorder for MockProvider.
type MockProviderMockRecorder struct {
	mock *MockProvider
}

// NewMockProvider creates a new mock instance.
func NewMockProvider(ctrl *gomock.Controller) *MockProvider {
	mock := &MockProvider{ctrl: ctrl}
	mock.recorder = &MockProviderMockRecorder{mock}

		ctrl.DeleteRegistry("earlyAdd", "test")
		ctrl.DeleteRegistry("earlyAddAndRun", "test")
	})
	t.Run("AddRegistry after aggregate Run does not start registry", func(t *testing.T) {
		ctrl.AddRegistry(runnableRegistry("missed"))
		expectRunningOrFail(t, ctrl, false)
		ctrl.DeleteRegistry("missed", "test")
		expectRunningOrFail(t, ctrl, true)
	})
	t.Run("AddRegistryAndRun after aggregate Run starts registry", func(t *testing.T) {