// MockDiskInfoProviderMockRecorder is the mock recorder for MockDiskInfoProvider.
type MockDiskInfoProviderMockRecorder struct {
	mock *MockDiskInfoProvider
}

// NewMockDiskInfoProvider creates a new mock instance.
func NewMockDiskInfoProvider(ctrl *gomock.Controller) *MockDiskInfoProvider {
	mock := &MockDiskInfoProvider{ctrl: ctrl}
	mock.recorder = &MockDiskInfoProviderMockRecorder{mock}
	return mock
}

type MockImageFsInfoProviderMockRecorder struct {
	mock *MockImageFsInfoProvider
}

// NewMockImageFsInfoProvider creates a new mock instance.
func NewMockImageFsInfoProvider(ctrl *gomock.Controller) *MockImageFsInfoProvider {
	mock := &MockImageFsInfoProvider{ctrl: ctrl}
	mock.recorder = &MockImageFsInfoProviderMockRecorder{mock}
	return mock
}

        "metadata":{
          "name":"mock2",
          "labels":{
            "app":"mock2",
            "status":"replaced"
          }
        },
        "spec":{
          "replicas":1,
          "selector":{
            "app":"mock2"
          },
          "template":{
            "metadata":{
              "labels":{
                "app":"mock2"
              }
            },

}

// MockPodsProviderMockRecorder is the mock recorder for MockPodsProvider.
type MockPodsProviderMockRecorder struct {
	mock *MockPodsProvider
}

// NewMockPodsProvider creates a new mock instance.
func NewMockPodsProvider(ctrl *gomock.Controller) *MockPodsProvider {
	mock := &MockPodsProvider{ctrl: ctrl}
	mock.recorder = &MockPodsProviderMockRecorder{mock}
	return mock
}

        "metadata":{
          "name":"mock2",
          "labels":{
            "app":"mock2",
            "status":"replaced"
          }
        },
        "spec":{
          "replicas":1,
          "selector":{
            "app":"mock2"
          },
          "template":{
            "metadata":{
              "labels":{
                "app":"mock2"
              }
            },

	mock := &MockDirEntry{ctrl: ctrl}
	mock.recorder = &MockDirEntryMockRecorder{mock}
	return mock
}

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

// Info mocks base method.
func (m *MockDirEntry) Info() (fs.FileInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Info")
	ret0, _ := ret[0].(fs.FileInfo)

	mock.CheckCacheEvents(ctl, ctl, TestNamespace, 5, t)
}

func TestControllerCacheFreshness(t *testing.T) {
	store := memory.Make(collections.Mocks)
	ctl := memory.NewController(store)
	mock.CheckCacheFreshness(ctl, TestNamespace, t)
}

func TestControllerClientSync(t *testing.T) {
	store := memory.Make(collections.Mocks)
	ctl := memory.NewController(store)

func NewMockRuntimeCache(ctrl *gomock.Controller) *MockRuntimeCache {
	mock := &MockRuntimeCache{ctrl: ctrl}
	mock.recorder = &MockRuntimeCacheMockRecorder{mock}
	return mock
}

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

// ForceUpdateIfOlder mocks base method.

	mock *MockSummaryProvider
}

// NewMockSummaryProvider creates a new mock instance.
func NewMockSummaryProvider(ctrl *gomock.Controller) *MockSummaryProvider {
	mock := &MockSummaryProvider{ctrl: ctrl}
	mock.recorder = &MockSummaryProviderMockRecorder{mock}
	return mock
}

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

}

func TestEventConsistency(t *testing.T) {
	store := memory.Make(collections.Mocks)
	controller := memory.NewController(store)

	testConfig := mock.Make(TestNamespace, 0)
	var testEvent model.Event

	done := make(chan bool)

	lock := sync.Mutex{}

	controller.RegisterEventHandler(collections.Mock.GroupVersionKind(), func(_, config config.Config, event model.Event) {
		lock.Lock()
		tc := testConfig