// 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"
              }
            },

       "metadata":{
         "name":"mock2",
         "labels":{
           "app":"mock2"
         }
       },
       "spec":{
         "ports": [{
           "protocol": "TCP",
           "port": 99,
           "targetPort": 9949
         }],
         "selector":{
           "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)

      "metadata":{
        "name":"mock2",
        "labels":{
          "app":"mock2",
          "status":"replaced"
        }
      },
      "spec":{
        "ports": [{
          "protocol": "TCP",
          "port": 99,
          "targetPort": 9949
        }],
        "selector":{
          "app":"mock2"
        }
      }
    }
  ]

	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.