ctrl     *gomock.Controller
	recorder *MockpodsGetterMockRecorder
}

// MockpodsGetterMockRecorder is the mock recorder for MockpodsGetter.
type MockpodsGetterMockRecorder struct {
	mock *MockpodsGetter
}

// NewMockpodsGetter creates a new mock instance.
func NewMockpodsGetter(ctrl *gomock.Controller) *MockpodsGetter {
	mock := &MockpodsGetter{ctrl: ctrl}
	mock.recorder = &MockpodsGetterMockRecorder{mock}

)

// MockSummaryProvider is a mock of SummaryProvider interface.
type MockSummaryProvider struct {
	ctrl     *gomock.Controller
	recorder *MockSummaryProviderMockRecorder
}

// MockSummaryProviderMockRecorder is the mock recorder for MockSummaryProvider.
type MockSummaryProviderMockRecorder struct {
	mock *MockSummaryProvider
}

// NewMockSummaryProvider creates a new mock instance.

type MockDirEntry struct {
	ctrl     *gomock.Controller
	recorder *MockDirEntryMockRecorder
}

// MockDirEntryMockRecorder is the mock recorder for MockDirEntry.
type MockDirEntryMockRecorder struct {
	mock *MockDirEntry
}

// NewMockDirEntry creates a new mock instance.
func NewMockDirEntry(ctrl *gomock.Controller) *MockDirEntry {
	mock := &MockDirEntry{ctrl: ctrl}
	mock.recorder = &MockDirEntryMockRecorder{mock}
	return mock
}

func NewRecordFlags() *RecordFlags {
	record := false

	return &RecordFlags{
		Record: &record,
	}
}

// Recorder is used to record why a runtime.Object was changed in an annotation.
type Recorder interface {
	// Record records why a runtime.Object was changed in an annotation.
	Record(runtime.Object) error
	MakeRecordMergePatch(runtime.Object) ([]byte, error)
}

	ctx := context.Background()
	recorder := &record.FakeRecorder{}
	logManager, err := logs.NewContainerLogManager(runtimeService, osInterface, "1", 2, 10, metav1.Duration{Duration: 10 * time.Second})
	if err != nil {
		return nil, err
	}
	kubeRuntimeManager := &kubeGenericRuntimeManager{
		recorder:               recorder,
		cpuCFSQuota:            false,

	ctrl     *gomock.Controller
	recorder *MockInterfaceMockRecorder
}

// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
	mock *MockInterface
}

// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
	mock := &MockInterface{ctrl: ctrl}
	mock.recorder = &MockInterfaceMockRecorder{mock}
	return mock
}

				OOMScoreAdj:      ptr.To[int32](0),
			},

			Client:      client,
			Proxier:     &FakeProxier{},
			Broadcaster: broadcaster,
			Recorder:    recorder,
			NodeRef: &v1.ObjectReference{
				Kind:      "Node",
				Name:      nodeName,
				UID:       types.UID(nodeName),
				Namespace: "",
			},
		},
	}
}

func (hp *HollowProxy) Run() error {

}

// NewOperationGenerator is returns instance of operationGenerator
func NewOperationGenerator(recorder record.EventRecorder) OperationGenerator {

	return &operationGenerator{
		recorder: recorder,
	}
}

// OperationGenerator interface that extracts out the functions from operation_executor to make it dependency injectable
type OperationGenerator interface {

		fakeRuntime,
		kb.mounter,
		kb.hostutil,
		kb.getPodsDir(),
		kb.recorder,
		volumetest.NewBlockVolumePathHandler())

	// TODO: Factor out "stats.Provider" from Kubelet so we don't have a cyclic dependency
	volumeStatsAggPeriod := time.Second * 10
	kb.resourceAnalyzer = stats.NewResourceAnalyzer(kb, volumeStatsAggPeriod, kb.recorder)
	nodeRef := &v1.ObjectReference{
		Kind:      "Node",

	http   httpprobe.Prober
	tcp    tcpprobe.Prober
	grpc   grpcprobe.Prober
	runner kubecontainer.CommandRunner

	recorder record.EventRecorder
}

// NewProber creates a Prober, it takes a command runner and
// several container info managers.
func newProber(
	runner kubecontainer.CommandRunner,
	recorder record.EventRecorder) *prober {

	const followNonLocalRedirects = false
	return &prober{
		exec:     execprobe.New(),