text:
package mock

import (
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
	core "github.com/portworx/sched-ops/k8s/core"
	v1 "k8s.io/api/core/v1"
	v10 "k8s.io/api/storage/v1"
	v11 "k8s.io/apimachinery/pkg/apis/meta/v1"
	runtime "k8s.io/apimachinery/pkg/runtime"
	schema "k8s.io/apimachinery/pkg/runtime/schema"
	types "k8s.io/apimachinery/pkg/types"
	version "k8s.io/apimachinery/pkg/version"
	rest "k8s.io/client-go/rest"
)

// MockOps is a mock of Ops interface.
type MockOps struct {
	ctrl     *gomock.Controller
	recorder *MockOpsMockRecorder
}

// MockOpsMockRecorder is the mock recorder for MockOps.
type MockOpsMockRecorder struct {
	mock *MockOps
}

// NewMockOps creates a new mock instance.
func NewMockOps(ctrl *gomock.Controller) *MockOps {
	mock := &MockOps{ctrl: ctrl}
	mock.recorder = &MockOpsMockRecorder{mock}
	return mock
}

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

// AddLabelOnNode mocks base method.
func (m *MockOps) AddLabelOnNode(arg0, arg1, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLabelOnNode", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddLabelOnNode indicates an expected call of AddLabelOnNode.
func (mr *MockOpsMockRecorder) AddLabelOnNode(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLabelOnNode", reflect.TypeOf((*MockOps)(nil).AddLabelOnNode), arg0, arg1, arg2)
}

// CordonNode mocks base method.
func (m *MockOps) CordonNode(arg0 string, arg1, arg2 time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CordonNode", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// CordonNode indicates an expected call of CordonNode.
func (mr *MockOpsMockRecorder) CordonNode(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CordonNode", reflect.TypeOf((*MockOps)(nil).CordonNode), arg0, arg1, arg2)
}

// CreateConfigMap mocks base method.
func (m *MockOps) CreateConfigMap(arg0 *v1.ConfigMap) (*v1.ConfigMap, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateConfigMap", arg0)
	ret0, _ := ret[0].(*v1.ConfigMap)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateConfigMap indicates an expected call of CreateConfigMap.
func (mr *MockOpsMockRecorder) CreateConfigMap(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConfigMap", reflect.TypeOf((*MockOps)(nil).CreateConfigMap), arg0)
}

// CreateEndpoints mocks base method.
func (m *MockOps) CreateEndpoints(arg0 *v1.Endpoints) (*v1.Endpoints, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEndpoints", arg0)
	ret0, _ := ret[0].(*v1.Endpoints)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateEndpoints indicates an expected call of CreateEndpoints.
func (mr *MockOpsMockRecorder) CreateEndpoints(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEndpoints", reflect.TypeOf((*MockOps)(nil).CreateEndpoints), arg0)
}

// CreateEvent mocks base method.
func (m *MockOps) CreateEvent(arg0 *v1.Event) (*v1.Event, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEvent", arg0)
	ret0, _ := ret[0].(*v1.Event)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateEvent indicates an expected call of CreateEvent.
func (mr *MockOpsMockRecorder) CreateEvent(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEvent", reflect.TypeOf((*MockOps)(nil).CreateEvent), arg0)
}

// CreateLimitRange mocks base method.
func (m *MockOps) CreateLimitRange(arg0 *v1.LimitRange) (*v1.LimitRange, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLimitRange", arg0)
	ret0, _ := ret[0].(*v1.LimitRange)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLimitRange indicates an expected call of CreateLimitRange.
func (mr *MockOpsMockRecorder) CreateLimitRange(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLimitRange", reflect.TypeOf((*MockOps)(nil).CreateLimitRange), arg0)
}

// CreateNamespace mocks base method.
func (m *MockOps) CreateNamespace(arg0 *v1.Namespace) (*v1.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNamespace", arg0)
	ret0, _ := ret[0].(*v1.Namespace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNamespace indicates an expected call of CreateNamespace.
func (mr *MockOpsMockRecorder) CreateNamespace(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNamespace", reflect.TypeOf((*MockOps)(nil).CreateNamespace), arg0)
}

// CreateNode mocks base method.
func (m *MockOps) CreateNode(arg0 *v1.Node) (*v1.Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNode", arg0)
	ret0, _ := ret[0].(*v1.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNode indicates an expected call of CreateNode.
func (mr *MockOpsMockRecorder) CreateNode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNode", reflect.TypeOf((*MockOps)(nil).CreateNode), arg0)
}

// CreatePersistentVolume mocks base method.
func (m *MockOps) CreatePersistentVolume(arg0 *v1.PersistentVolume) (*v1.PersistentVolume, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePersistentVolume", arg0)
	ret0, _ := ret[0].(*v1.PersistentVolume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePersistentVolume indicates an expected call of CreatePersistentVolume.
func (mr *MockOpsMockRecorder) CreatePersistentVolume(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePersistentVolume", reflect.TypeOf((*MockOps)(nil).CreatePersistentVolume), arg0)
}

// CreatePersistentVolumeClaim mocks base method.
func (m *MockOps) CreatePersistentVolumeClaim(arg0 *v1.PersistentVolumeClaim) (*v1.PersistentVolumeClaim, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePersistentVolumeClaim", arg0)
	ret0, _ := ret[0].(*v1.PersistentVolumeClaim)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePersistentVolumeClaim indicates an expected call of CreatePersistentVolumeClaim.
func (mr *MockOpsMockRecorder) CreatePersistentVolumeClaim(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePersistentVolumeClaim", reflect.TypeOf((*MockOps)(nil).CreatePersistentVolumeClaim), arg0)
}

// CreatePod mocks base method.
func (m *MockOps) CreatePod(arg0 *v1.Pod) (*v1.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePod", arg0)
	ret0, _ := ret[0].(*v1.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePod indicates an expected call of CreatePod.
func (mr *MockOpsMockRecorder) CreatePod(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePod", reflect.TypeOf((*MockOps)(nil).CreatePod), arg0)
}

// CreateSecret mocks base method.
func (m *MockOps) CreateSecret(arg0 *v1.Secret) (*v1.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSecret", arg0)
	ret0, _ := ret[0].(*v1.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSecret indicates an expected call of CreateSecret.
func (mr *MockOpsMockRecorder) CreateSecret(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecret", reflect.TypeOf((*MockOps)(nil).CreateSecret), arg0)
}

// CreateService mocks base method.
func (m *MockOps) CreateService(arg0 *v1.Service) (*v1.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateService", arg0)
	ret0, _ := ret[0].(*v1.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateService indicates an expected call of CreateService.
func (mr *MockOpsMockRecorder) CreateService(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateService", reflect.TypeOf((*MockOps)(nil).CreateService), arg0)
}

// CreateServiceAccount mocks base method.
func (m *MockOps) CreateServiceAccount(arg0 *v1.ServiceAccount) (*v1.ServiceAccount, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateServiceAccount", arg0)
	ret0, _ := ret[0].(*v1.ServiceAccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateServiceAccount indicates an expected call of CreateServiceAccount.
func (mr *MockOpsMockRecorder) CreateServiceAccount(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceAccount", reflect.TypeOf((*MockOps)(nil).CreateServiceAccount), arg0)
}

// DeleteConfigMap mocks base method.
func (m *MockOps) DeleteConfigMap(arg0, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteConfigMap", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteConfigMap indicates an expected call of DeleteConfigMap.
func (mr *MockOpsMockRecorder) DeleteConfigMap(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigMap", reflect.TypeOf((*MockOps)(nil).DeleteConfigMap), arg0, arg1)
}

// DeleteEndpoints mocks base method.
func (m *MockOps) DeleteEndpoints(arg0, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEndpoints", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteEndpoints indicates an expected call of DeleteEndpoints.
func (mr *MockOpsMockRecorder) DeleteEndpoints(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEndpoints", reflect.TypeOf((*MockOps)(nil).DeleteEndpoints), arg0, arg1)
}

// DeleteLimitRange mocks base method.
func (m *MockOps) DeleteLimitRange(arg0, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLimitRange", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLimitRange indicates an expected call of DeleteLimitRange.
func (mr *MockOpsMockRecorder) DeleteLimitRange(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLimitRange", reflect.TypeOf((*MockOps)(nil).DeleteLimitRange), arg0, arg1)
}

// DeleteNamespace mocks base method.
func (m *MockOps) DeleteNamespace(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNamespace", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNamespace indicates an expected call of DeleteNamespace.
func (mr *MockOpsMockRecorder) DeleteNamespace(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespace", reflect.TypeOf((*MockOps)(nil).DeleteNamespace), arg0)
}

// DeleteNode mocks base method.
func (m *MockOps) DeleteNode(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNode", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNode indicates an expected call of DeleteNode.
func (mr *MockOpsMockRecorder) DeleteNode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNode", reflect.TypeOf((*MockOps)(nil).DeleteNode), arg0)
}

// DeletePersistentVolume mocks base method.
func (m *MockOps) DeletePersistentVolume(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePersistentVolume", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePersistentVolume indicates an expected call of DeletePersistentVolume.
func (mr *MockOpsMockRecorder) DeletePersistentVolume(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePersistentVolume", reflect.TypeOf((*MockOps)(nil).DeletePersistentVolume), arg0)
}

// DeletePersistentVolumeClaim mocks base method.
func (m *MockOps) DeletePersistentVolumeClaim(arg0, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePersistentVolumeClaim", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePersistentVolumeClaim indicates an expected call of DeletePersistentVolumeClaim.
func (mr *MockOpsMockRecorder) DeletePersistentVolumeClaim(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePersistentVolumeClaim", reflect.TypeOf((*MockOps)(nil).DeletePersistentVolumeClaim), arg0, arg1)
}

// DeletePod mocks base method.
func (m *MockOps) DeletePod(arg0, arg1 string, arg2 bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePod", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePod indicates an expected call of DeletePod.
func (mr *MockOpsMockRecorder) DeletePod(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePod", reflect.TypeOf((*MockOps)(nil).DeletePod), arg0, arg1, arg2)
}

// DeletePods mocks base method.
func (m *MockOps) DeletePods(arg0 []v1.Pod, arg1 bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePods", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePods indicates an expected call of DeletePods.
func (mr *MockOpsMockRecorder) DeletePods(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePods", reflect.TypeOf((*MockOps)(nil).DeletePods), arg0, arg1)
}

// DeleteSecret mocks base method.
func (m *MockOps) DeleteSecret(arg0, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSecret", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSecret indicates an expected call of DeleteSecret.
func (mr *MockOpsMockRecorder) DeleteSecret(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecret", reflect.TypeOf((*MockOps)(nil).DeleteSecret), arg0, arg1)
}

// DeleteService mocks base method.
func (m *MockOps) DeleteService(arg0, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteService", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteService indicates an expected call of DeleteService.
func (mr *MockOpsMockRecorder) DeleteService(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteService", reflect.TypeOf((*MockOps)(nil).DeleteService), arg0, arg1)
}

// DeleteServiceAccount mocks base method.
func (m *MockOps) DeleteServiceAccount(arg0, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteServiceAccount", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteServiceAccount indicates an expected call of DeleteServiceAccount.
func (mr *MockOpsMockRecorder) DeleteServiceAccount(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceAccount", reflect.TypeOf((*MockOps)(nil).DeleteServiceAccount), arg0, arg1)
}

// DescribeService mocks base method.
func (m *MockOps) DescribeService(arg0, arg1 string) (*v1.ServiceStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeService", arg0, arg1)
	ret0, _ := ret[0].(*v1.ServiceStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeService indicates an expected call of DescribeService.
func (mr *MockOpsMockRecorder) DescribeService(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeService", reflect.TypeOf((*MockOps)(nil).DescribeService), arg0, arg1)
}

// DrainPodsFromNode mocks base method.
func (m *MockOps) DrainPodsFromNode(arg0 string, arg1 []v1.Pod, arg2, arg3 time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DrainPodsFromNode", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// DrainPodsFromNode indicates an expected call of DrainPodsFromNode.
func (mr *MockOpsMockRecorder) DrainPodsFromNode(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DrainPodsFromNode", reflect.TypeOf((*MockOps)(nil).DrainPodsFromNode), arg0, arg1, arg2, arg3)
}

// FindMyNode mocks base method.
func (m *MockOps) FindMyNode() (*v1.Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindMyNode")
	ret0, _ := ret[0].(*v1.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindMyNode indicates an expected call of FindMyNode.
func (mr *MockOpsMockRecorder) FindMyNode() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindMyNode", reflect.TypeOf((*MockOps)(nil).FindMyNode))
}

// GetConfigMap mocks base method.
func (m *MockOps) GetConfigMap(arg0, arg1 string) (*v1.ConfigMap, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigMap", arg0, arg1)
	ret0, _ := ret[0].(*v1.ConfigMap)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfigMap indicates an expected call of GetConfigMap.
func (mr *MockOpsMockRecorder) GetConfigMap(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigMap", reflect.TypeOf((*MockOps)(nil).GetConfigMap), arg0, arg1)
}

// GetEndpoints mocks base method.
func (m *MockOps) GetEndpoints(arg0, arg1 string) (*v1.Endpoints, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEndpoints", arg0, arg1)
	ret0, _ := ret[0].(*v1.Endpoints)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEndpoints indicates an expected call of GetEndpoints.
func (mr *MockOpsMockRecorder) GetEndpoints(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEndpoints", reflect.TypeOf((*MockOps)(nil).GetEndpoints), arg0, arg1)
}

// GetLabelsOnNode mocks base method.
func (m *MockOps) GetLabelsOnNode(arg0 string) (map[string]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLabelsOnNode", arg0)
	ret0, _ := ret[0].(map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLabelsOnNode indicates an expected call of GetLabelsOnNode.
func (mr *MockOpsMockRecorder) GetLabelsOnNode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLabelsOnNode", reflect.TypeOf((*MockOps)(nil).GetLabelsOnNode), arg0)
}

// GetLimitRange mocks base method.
func (m *MockOps) GetLimitRange(arg0, arg1 string) (*v1.LimitRange, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLimitRange", arg0, arg1)
	ret0, _ := ret[0].(*v1.LimitRange)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLimitRange indicates an expected call of GetLimitRange.
func (mr *MockOpsMockRecorder) GetLimitRange(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLimitRange", reflect.TypeOf((*MockOps)(nil).GetLimitRange), arg0, arg1)
}

// GetNamespace mocks base method.
func (m *MockOps) GetNamespace(arg0 string) (*v1.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespace", arg0)
	ret0, _ := ret[0].(*v1.Namespace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNamespace indicates an expected call of GetNamespace.
func (mr *MockOpsMockRecorder) GetNamespace(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockOps)(nil).GetNamespace), arg0)
}

// GetNodeByName mocks base method.
func (m *MockOps) GetNodeByName(arg0 string) (*v1.Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodeByName", arg0)
	ret0, _ := ret[0].(*v1.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeByName indicates an expected call of GetNodeByName.
func (mr *MockOpsMockRecorder) GetNodeByName(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeByName", reflect.TypeOf((*MockOps)(nil).GetNodeByName), arg0)
}

// GetNodes mocks base method.
func (m *MockOps) GetNodes() (*v1.NodeList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodes")
	ret0, _ := ret[0].(*v1.NodeList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodes indicates an expected call of GetNodes.
func (mr *MockOpsMockRecorder) GetNodes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodes", reflect.TypeOf((*MockOps)(nil).GetNodes))
}

// GetPVCsUsingStorageClass mocks base method.
func (m *MockOps) GetPVCsUsingStorageClass(arg0 string) ([]v1.PersistentVolumeClaim, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPVCsUsingStorageClass", arg0)
	ret0, _ := ret[0].([]v1.PersistentVolumeClaim)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPVCsUsingStorageClass indicates an expected call of GetPVCsUsingStorageClass.
func (mr *MockOpsMockRecorder) GetPVCsUsingStorageClass(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPVCsUsingStorageClass", reflect.TypeOf((*MockOps)(nil).GetPVCsUsingStorageClass), arg0)
}

// GetPersistentVolume mocks base method.
func (m *MockOps) GetPersistentVolume(arg0 string) (*v1.PersistentVolume, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPersistentVolume", arg0)
	ret0, _ := ret[0].(*v1.PersistentVolume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPersistentVolume indicates an expected call of GetPersistentVolume.
func (mr *MockOpsMockRecorder) GetPersistentVolume(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersistentVolume", reflect.TypeOf((*MockOps)(nil).GetPersistentVolume), arg0)
}

// GetPersistentVolumeClaim mocks base method.
func (m *MockOps) GetPersistentVolumeClaim(arg0, arg1 string) (*v1.PersistentVolumeClaim, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPersistentVolumeClaim", arg0, arg1)
	ret0, _ := ret[0].(*v1.PersistentVolumeClaim)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPersistentVolumeClaim indicates an expected call of GetPersistentVolumeClaim.
func (mr *MockOpsMockRecorder) GetPersistentVolumeClaim(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersistentVolumeClaim", reflect.TypeOf((*MockOps)(nil).GetPersistentVolumeClaim), arg0, arg1)
}

// GetPersistentVolumeClaimParams mocks base method.
func (m *MockOps) GetPersistentVolumeClaimParams(arg0 *v1.PersistentVolumeClaim) (map[string]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPersistentVolumeClaimParams", arg0)
	ret0, _ := ret[0].(map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPersistentVolumeClaimParams indicates an expected call of GetPersistentVolumeClaimParams.
func (mr *MockOpsMockRecorder) GetPersistentVolumeClaimParams(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersistentVolumeClaimParams", reflect.TypeOf((*MockOps)(nil).GetPersistentVolumeClaimParams), arg0)
}

// GetPersistentVolumeClaimStatus mocks base method.
func (m *MockOps) GetPersistentVolumeClaimStatus(arg0 *v1.PersistentVolumeClaim) (*v1.PersistentVolumeClaimStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPersistentVolumeClaimStatus", arg0)
	ret0, _ := ret[0].(*v1.PersistentVolumeClaimStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPersistentVolumeClaimStatus indicates an expected call of GetPersistentVolumeClaimStatus.
func (mr *MockOpsMockRecorder) GetPersistentVolumeClaimStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersistentVolumeClaimStatus", reflect.TypeOf((*MockOps)(nil).GetPersistentVolumeClaimStatus), arg0)
}

// GetPersistentVolumeClaims mocks base method.
func (m *MockOps) GetPersistentVolumeClaims(arg0 string, arg1 map[string]string) (*v1.PersistentVolumeClaimList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPersistentVolumeClaims", arg0, arg1)
	ret0, _ := ret[0].(*v1.PersistentVolumeClaimList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPersistentVolumeClaims indicates an expected call of GetPersistentVolumeClaims.
func (mr *MockOpsMockRecorder) GetPersistentVolumeClaims(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersistentVolumeClaims", reflect.TypeOf((*MockOps)(nil).GetPersistentVolumeClaims), arg0, arg1)
}

// GetPersistentVolumes mocks base method.
func (m *MockOps) GetPersistentVolumes() (*v1.PersistentVolumeList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPersistentVolumes")
	ret0, _ := ret[0].(*v1.PersistentVolumeList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPersistentVolumes indicates an expected call of GetPersistentVolumes.
func (mr *MockOpsMockRecorder) GetPersistentVolumes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersistentVolumes", reflect.TypeOf((*MockOps)(nil).GetPersistentVolumes))
}

// GetPodByName mocks base method.
func (m *MockOps) GetPodByName(arg0, arg1 string) (*v1.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodByName", arg0, arg1)
	ret0, _ := ret[0].(*v1.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodByName indicates an expected call of GetPodByName.
func (mr *MockOpsMockRecorder) GetPodByName(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByName", reflect.TypeOf((*MockOps)(nil).GetPodByName), arg0, arg1)
}

// GetPodByUID mocks base method.
func (m *MockOps) GetPodByUID(arg0 types.UID, arg1 string) (*v1.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodByUID", arg0, arg1)
	ret0, _ := ret[0].(*v1.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodByUID indicates an expected call of GetPodByUID.
func (mr *MockOpsMockRecorder) GetPodByUID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodByUID", reflect.TypeOf((*MockOps)(nil).GetPodByUID), arg0, arg1)
}

// GetPods mocks base method.
func (m *MockOps) GetPods(arg0 string, arg1 map[string]string) (*v1.PodList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPods", arg0, arg1)
	ret0, _ := ret[0].(*v1.PodList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPods indicates an expected call of GetPods.
func (mr *MockOpsMockRecorder) GetPods(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockOps)(nil).GetPods), arg0, arg1)
}

// GetPodsByNode mocks base method.
func (m *MockOps) GetPodsByNode(arg0, arg1 string) (*v1.PodList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodsByNode", arg0, arg1)
	ret0, _ := ret[0].(*v1.PodList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodsByNode indicates an expected call of GetPodsByNode.
func (mr *MockOpsMockRecorder) GetPodsByNode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodsByNode", reflect.TypeOf((*MockOps)(nil).GetPodsByNode), arg0, arg1)
}

// GetPodsByNodeAndLabels mocks base method.
func (m *MockOps) GetPodsByNodeAndLabels(arg0, arg1 string, arg2 map[string]string) (*v1.PodList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodsByNodeAndLabels", arg0, arg1, arg2)
	ret0, _ := ret[0].(*v1.PodList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodsByNodeAndLabels indicates an expected call of GetPodsByNodeAndLabels.
func (mr *MockOpsMockRecorder) GetPodsByNodeAndLabels(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodsByNodeAndLabels", reflect.TypeOf((*MockOps)(nil).GetPodsByNodeAndLabels), arg0, arg1, arg2)
}

// GetPodsByOwner mocks base method.
func (m *MockOps) GetPodsByOwner(arg0 types.UID, arg1 string) ([]v1.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodsByOwner", arg0, arg1)
	ret0, _ := ret[0].([]v1.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodsByOwner indicates an expected call of GetPodsByOwner.
func (mr *MockOpsMockRecorder) GetPodsByOwner(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodsByOwner", reflect.TypeOf((*MockOps)(nil).GetPodsByOwner), arg0, arg1)
}

// GetPodsUsingPV mocks base method.
func (m *MockOps) GetPodsUsingPV(arg0 string) ([]v1.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodsUsingPV", arg0)
	ret0, _ := ret[0].([]v1.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodsUsingPV indicates an expected call of GetPodsUsingPV.
func (mr *MockOpsMockRecorder) GetPodsUsingPV(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodsUsingPV", reflect.TypeOf((*MockOps)(nil).GetPodsUsingPV), arg0)
}

// GetPodsUsingPVByNodeName mocks base method.
func (m *MockOps) GetPodsUsingPVByNodeName(arg0, arg1 string) ([]v1.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodsUsingPVByNodeName", arg0, arg1)
	ret0, _ := ret[0].([]v1.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodsUsingPVByNodeName indicates an expected call of GetPodsUsingPVByNodeName.
func (mr *MockOpsMockRecorder) GetPodsUsingPVByNodeName(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodsUsingPVByNodeName", reflect.TypeOf((*MockOps)(nil).GetPodsUsingPVByNodeName), arg0, arg1)
}

// GetPodsUsingPVC mocks base method.
func (m *MockOps) GetPodsUsingPVC(arg0, arg1 string) ([]v1.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodsUsingPVC", arg0, arg1)
	ret0, _ := ret[0].([]v1.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodsUsingPVC indicates an expected call of GetPodsUsingPVC.
func (mr *MockOpsMockRecorder) GetPodsUsingPVC(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodsUsingPVC", reflect.TypeOf((*MockOps)(nil).GetPodsUsingPVC), arg0, arg1)
}

// GetPodsUsingPVCByNodeName mocks base method.
func (m *MockOps) GetPodsUsingPVCByNodeName(arg0, arg1, arg2 string) ([]v1.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodsUsingPVCByNodeName", arg0, arg1, arg2)
	ret0, _ := ret[0].([]v1.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodsUsingPVCByNodeName indicates an expected call of GetPodsUsingPVCByNodeName.
func (mr *MockOpsMockRecorder) GetPodsUsingPVCByNodeName(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodsUsingPVCByNodeName", reflect.TypeOf((*MockOps)(nil).GetPodsUsingPVCByNodeName), arg0, arg1, arg2)
}

// GetPodsUsingVolumePlugin mocks base method.
func (m *MockOps) GetPodsUsingVolumePlugin(arg0 string) ([]v1.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodsUsingVolumePlugin", arg0)
	ret0, _ := ret[0].([]v1.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodsUsingVolumePlugin indicates an expected call of GetPodsUsingVolumePlugin.
func (mr *MockOpsMockRecorder) GetPodsUsingVolumePlugin(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodsUsingVolumePlugin", reflect.TypeOf((*MockOps)(nil).GetPodsUsingVolumePlugin), arg0)
}

// GetPodsUsingVolumePluginByNodeName mocks base method.
func (m *MockOps) GetPodsUsingVolumePluginByNodeName(arg0, arg1 string) ([]v1.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodsUsingVolumePluginByNodeName", arg0, arg1)
	ret0, _ := ret[0].([]v1.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodsUsingVolumePluginByNodeName indicates an expected call of GetPodsUsingVolumePluginByNodeName.
func (mr *MockOpsMockRecorder) GetPodsUsingVolumePluginByNodeName(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodsUsingVolumePluginByNodeName", reflect.TypeOf((*MockOps)(nil).GetPodsUsingVolumePluginByNodeName), arg0, arg1)
}

// GetSecret mocks base method.
func (m *MockOps) GetSecret(arg0, arg1 string) (*v1.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSecret", arg0, arg1)
	ret0, _ := ret[0].(*v1.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSecret indicates an expected call of GetSecret.
func (mr *MockOpsMockRecorder) GetSecret(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecret", reflect.TypeOf((*MockOps)(nil).GetSecret), arg0, arg1)
}

// GetService mocks base method.
func (m *MockOps) GetService(arg0, arg1 string) (*v1.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetService", arg0, arg1)
	ret0, _ := ret[0].(*v1.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetService indicates an expected call of GetService.
func (mr *MockOpsMockRecorder) GetService(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetService", reflect.TypeOf((*MockOps)(nil).GetService), arg0, arg1)
}

// GetServiceAccount mocks base method.
func (m *MockOps) GetServiceAccount(arg0, arg1 string) (*v1.ServiceAccount, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceAccount", arg0, arg1)
	ret0, _ := ret[0].(*v1.ServiceAccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServiceAccount indicates an expected call of GetServiceAccount.
func (mr *MockOpsMockRecorder) GetServiceAccount(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceAccount", reflect.TypeOf((*MockOps)(nil).GetServiceAccount), arg0, arg1)
}

// GetServiceEndpoint mocks base method.
func (m *MockOps) GetServiceEndpoint(arg0, arg1 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceEndpoint", arg0, arg1)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServiceEndpoint indicates an expected call of GetServiceEndpoint.
func (mr *MockOpsMockRecorder) GetServiceEndpoint(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceEndpoint", reflect.TypeOf((*MockOps)(nil).GetServiceEndpoint), arg0, arg1)
}

// GetStorageClassForPVC mocks base method.
func (m *MockOps) GetStorageClassForPVC(arg0 *v1.PersistentVolumeClaim) (*v10.StorageClass, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStorageClassForPVC", arg0)
	ret0, _ := ret[0].(*v10.StorageClass)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStorageClassForPVC indicates an expected call of GetStorageClassForPVC.
func (mr *MockOpsMockRecorder) GetStorageClassForPVC(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageClassForPVC", reflect.TypeOf((*MockOps)(nil).GetStorageClassForPVC), arg0)
}

// GetStorageProvisionerForPVC mocks base method.
func (m *MockOps) GetStorageProvisionerForPVC(arg0 *v1.PersistentVolumeClaim) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStorageProvisionerForPVC", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStorageProvisionerForPVC indicates an expected call of GetStorageProvisionerForPVC.
func (mr *MockOpsMockRecorder) GetStorageProvisionerForPVC(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageProvisionerForPVC", reflect.TypeOf((*MockOps)(nil).GetStorageProvisionerForPVC), arg0)
}

// GetVersion mocks base method.
func (m *MockOps) GetVersion() (*version.Info, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVersion")
	ret0, _ := ret[0].(*version.Info)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVersion indicates an expected call of GetVersion.
func (mr *MockOpsMockRecorder) GetVersion() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersion", reflect.TypeOf((*MockOps)(nil).GetVersion))
}

// GetVolumeForPersistentVolumeClaim mocks base method.
func (m *MockOps) GetVolumeForPersistentVolumeClaim(arg0 *v1.PersistentVolumeClaim) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVolumeForPersistentVolumeClaim", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVolumeForPersistentVolumeClaim indicates an expected call of GetVolumeForPersistentVolumeClaim.
func (mr *MockOpsMockRecorder) GetVolumeForPersistentVolumeClaim(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeForPersistentVolumeClaim", reflect.TypeOf((*MockOps)(nil).GetVolumeForPersistentVolumeClaim), arg0)
}

// IsNodeMaster mocks base method.
func (m *MockOps) IsNodeMaster(arg0 v1.Node) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsNodeMaster", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsNodeMaster indicates an expected call of IsNodeMaster.
func (mr *MockOpsMockRecorder) IsNodeMaster(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNodeMaster", reflect.TypeOf((*MockOps)(nil).IsNodeMaster), arg0)
}

// IsNodeReady mocks base method.
func (m *MockOps) IsNodeReady(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsNodeReady", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// IsNodeReady indicates an expected call of IsNodeReady.
func (mr *MockOpsMockRecorder) IsNodeReady(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNodeReady", reflect.TypeOf((*MockOps)(nil).IsNodeReady), arg0)
}

// IsPodBeingManaged mocks base method.
func (m *MockOps) IsPodBeingManaged(arg0 v1.Pod) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsPodBeingManaged", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsPodBeingManaged indicates an expected call of IsPodBeingManaged.
func (mr *MockOpsMockRecorder) IsPodBeingManaged(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPodBeingManaged", reflect.TypeOf((*MockOps)(nil).IsPodBeingManaged), arg0)
}

// IsPodReady mocks base method.
func (m *MockOps) IsPodReady(arg0 v1.Pod) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsPodReady", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsPodReady indicates an expected call of IsPodReady.
func (mr *MockOpsMockRecorder) IsPodReady(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPodReady", reflect.TypeOf((*MockOps)(nil).IsPodReady), arg0)
}

// IsPodRunning mocks base method.
func (m *MockOps) IsPodRunning(arg0 v1.Pod) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsPodRunning", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsPodRunning indicates an expected call of IsPodRunning.
func (mr *MockOpsMockRecorder) IsPodRunning(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPodRunning", reflect.TypeOf((*MockOps)(nil).IsPodRunning), arg0)
}

// ListEvents mocks base method.
func (m *MockOps) ListEvents(arg0 string, arg1 v11.ListOptions) (*v1.EventList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEvents", arg0, arg1)
	ret0, _ := ret[0].(*v1.EventList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListEvents indicates an expected call of ListEvents.
func (mr *MockOpsMockRecorder) ListEvents(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEvents", reflect.TypeOf((*MockOps)(nil).ListEvents), arg0, arg1)
}

// ListLimitRange mocks base method.
func (m *MockOps) ListLimitRange(arg0 string, arg1 v11.ListOptions) (*v1.LimitRangeList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLimitRange", arg0, arg1)
	ret0, _ := ret[0].(*v1.LimitRangeList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLimitRange indicates an expected call of ListLimitRange.
func (mr *MockOpsMockRecorder) ListLimitRange(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLimitRange", reflect.TypeOf((*MockOps)(nil).ListLimitRange), arg0, arg1)
}

// ListNamespaces mocks base method.
func (m *MockOps) ListNamespaces(arg0 map[string]string) (*v1.NamespaceList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNamespaces", arg0)
	ret0, _ := ret[0].(*v1.NamespaceList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNamespaces indicates an expected call of ListNamespaces.
func (mr *MockOpsMockRecorder) ListNamespaces(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamespaces", reflect.TypeOf((*MockOps)(nil).ListNamespaces), arg0)
}

// ListServices mocks base method.
func (m *MockOps) ListServices(arg0 string, arg1 v11.ListOptions) (*v1.ServiceList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListServices", arg0, arg1)
	ret0, _ := ret[0].(*v1.ServiceList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListServices indicates an expected call of ListServices.
func (mr *MockOpsMockRecorder) ListServices(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServices", reflect.TypeOf((*MockOps)(nil).ListServices), arg0, arg1)
}

// PatchEndpoints mocks base method.
func (m *MockOps) PatchEndpoints(arg0, arg1 string, arg2 types.PatchType, arg3 []byte, arg4 ...string) (*v1.Endpoints, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchEndpoints", varargs...)
	ret0, _ := ret[0].(*v1.Endpoints)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchEndpoints indicates an expected call of PatchEndpoints.
func (mr *MockOpsMockRecorder) PatchEndpoints(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchEndpoints", reflect.TypeOf((*MockOps)(nil).PatchEndpoints), varargs...)
}

// PatchService mocks base method.
func (m *MockOps) PatchService(arg0, arg1 string, arg2 []byte, arg3 ...string) (*v1.Service, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchService", varargs...)
	ret0, _ := ret[0].(*v1.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchService indicates an expected call of PatchService.
func (mr *MockOpsMockRecorder) PatchService(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchService", reflect.TypeOf((*MockOps)(nil).PatchService), varargs...)
}

// RecordEvent mocks base method.
func (m *MockOps) RecordEvent(arg0 v1.EventSource, arg1 runtime.Object, arg2, arg3, arg4 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RecordEvent", arg0, arg1, arg2, arg3, arg4)
}

// RecordEvent indicates an expected call of RecordEvent.
func (mr *MockOpsMockRecorder) RecordEvent(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordEvent", reflect.TypeOf((*MockOps)(nil).RecordEvent), arg0, arg1, arg2, arg3, arg4)
}

// RemoveLabelOnNode mocks base method.
func (m *MockOps) RemoveLabelOnNode(arg0, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveLabelOnNode", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveLabelOnNode indicates an expected call of RemoveLabelOnNode.
func (mr *MockOpsMockRecorder) RemoveLabelOnNode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveLabelOnNode", reflect.TypeOf((*MockOps)(nil).RemoveLabelOnNode), arg0, arg1)
}

// ResourceExists mocks base method.
func (m *MockOps) ResourceExists(arg0 schema.GroupVersionKind) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResourceExists", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResourceExists indicates an expected call of ResourceExists.
func (mr *MockOpsMockRecorder) ResourceExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourceExists", reflect.TypeOf((*MockOps)(nil).ResourceExists), arg0)
}

// RunCommandInPod mocks base method.
func (m *MockOps) RunCommandInPod(arg0 []string, arg1, arg2, arg3 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunCommandInPod", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RunCommandInPod indicates an expected call of RunCommandInPod.
func (mr *MockOpsMockRecorder) RunCommandInPod(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunCommandInPod", reflect.TypeOf((*MockOps)(nil).RunCommandInPod), arg0, arg1, arg2, arg3)
}

// SearchNodeByAddresses mocks base method.
func (m *MockOps) SearchNodeByAddresses(arg0 []string) (*v1.Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchNodeByAddresses", arg0)
	ret0, _ := ret[0].(*v1.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchNodeByAddresses indicates an expected call of SearchNodeByAddresses.
func (mr *MockOpsMockRecorder) SearchNodeByAddresses(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchNodeByAddresses", reflect.TypeOf((*MockOps)(nil).SearchNodeByAddresses), arg0)
}

// SetConfig mocks base method.
func (m *MockOps) SetConfig(arg0 *rest.Config) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetConfig", arg0)
}

// SetConfig indicates an expected call of SetConfig.
func (mr *MockOpsMockRecorder) SetConfig(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConfig", reflect.TypeOf((*MockOps)(nil).SetConfig), arg0)
}

// UnCordonNode mocks base method.
func (m *MockOps) UnCordonNode(arg0 string, arg1, arg2 time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnCordonNode", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnCordonNode indicates an expected call of UnCordonNode.
func (mr *MockOpsMockRecorder) UnCordonNode(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnCordonNode", reflect.TypeOf((*MockOps)(nil).UnCordonNode), arg0, arg1, arg2)
}

// UpdateConfigMap mocks base method.
func (m *MockOps) UpdateConfigMap(arg0 *v1.ConfigMap) (*v1.ConfigMap, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateConfigMap", arg0)
	ret0, _ := ret[0].(*v1.ConfigMap)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateConfigMap indicates an expected call of UpdateConfigMap.
func (mr *MockOpsMockRecorder) UpdateConfigMap(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateConfigMap", reflect.TypeOf((*MockOps)(nil).UpdateConfigMap), arg0)
}

// UpdateEndpoints mocks base method.
func (m *MockOps) UpdateEndpoints(arg0 *v1.Endpoints) (*v1.Endpoints, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEndpoints", arg0)
	ret0, _ := ret[0].(*v1.Endpoints)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateEndpoints indicates an expected call of UpdateEndpoints.
func (mr *MockOpsMockRecorder) UpdateEndpoints(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEndpoints", reflect.TypeOf((*MockOps)(nil).UpdateEndpoints), arg0)
}

// UpdateLimitRange mocks base method.
func (m *MockOps) UpdateLimitRange(arg0 *v1.LimitRange) (*v1.LimitRange, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLimitRange", arg0)
	ret0, _ := ret[0].(*v1.LimitRange)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateLimitRange indicates an expected call of UpdateLimitRange.
func (mr *MockOpsMockRecorder) UpdateLimitRange(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLimitRange", reflect.TypeOf((*MockOps)(nil).UpdateLimitRange), arg0)
}

// UpdateNamespace mocks base method.
func (m *MockOps) UpdateNamespace(arg0 *v1.Namespace) (*v1.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNamespace", arg0)
	ret0, _ := ret[0].(*v1.Namespace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNamespace indicates an expected call of UpdateNamespace.
func (mr *MockOpsMockRecorder) UpdateNamespace(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNamespace", reflect.TypeOf((*MockOps)(nil).UpdateNamespace), arg0)
}

// UpdateNode mocks base method.
func (m *MockOps) UpdateNode(arg0 *v1.Node) (*v1.Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNode", arg0)
	ret0, _ := ret[0].(*v1.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNode indicates an expected call of UpdateNode.
func (mr *MockOpsMockRecorder) UpdateNode(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNode", reflect.TypeOf((*MockOps)(nil).UpdateNode), arg0)
}

// UpdatePersistentVolumeClaim mocks base method.
func (m *MockOps) UpdatePersistentVolumeClaim(arg0 *v1.PersistentVolumeClaim) (*v1.PersistentVolumeClaim, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePersistentVolumeClaim", arg0)
	ret0, _ := ret[0].(*v1.PersistentVolumeClaim)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePersistentVolumeClaim indicates an expected call of UpdatePersistentVolumeClaim.
func (mr *MockOpsMockRecorder) UpdatePersistentVolumeClaim(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePersistentVolumeClaim", reflect.TypeOf((*MockOps)(nil).UpdatePersistentVolumeClaim), arg0)
}

// UpdatePod mocks base method.
func (m *MockOps) UpdatePod(arg0 *v1.Pod) (*v1.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePod", arg0)
	ret0, _ := ret[0].(*v1.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePod indicates an expected call of UpdatePod.
func (mr *MockOpsMockRecorder) UpdatePod(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePod", reflect.TypeOf((*MockOps)(nil).UpdatePod), arg0)
}

// UpdateSecret mocks base method.
func (m *MockOps) UpdateSecret(arg0 *v1.Secret) (*v1.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSecret", arg0)
	ret0, _ := ret[0].(*v1.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSecret indicates an expected call of UpdateSecret.
func (mr *MockOpsMockRecorder) UpdateSecret(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecret", reflect.TypeOf((*MockOps)(nil).UpdateSecret), arg0)
}

// UpdateSecretData mocks base method.
func (m *MockOps) UpdateSecretData(arg0, arg1 string, arg2 map[string][]byte) (*v1.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSecretData", arg0, arg1, arg2)
	ret0, _ := ret[0].(*v1.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSecretData indicates an expected call of UpdateSecretData.
func (mr *MockOpsMockRecorder) UpdateSecretData(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecretData", reflect.TypeOf((*MockOps)(nil).UpdateSecretData), arg0, arg1, arg2)
}

// UpdateService mocks base method.
func (m *MockOps) UpdateService(arg0 *v1.Service) (*v1.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateService", arg0)
	ret0, _ := ret[0].(*v1.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateService indicates an expected call of UpdateService.
func (mr *MockOpsMockRecorder) UpdateService(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateService", reflect.TypeOf((*MockOps)(nil).UpdateService), arg0)
}

// UpdateServiceAccount mocks base method.
func (m *MockOps) UpdateServiceAccount(arg0 *v1.ServiceAccount) (*v1.ServiceAccount, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateServiceAccount", arg0)
	ret0, _ := ret[0].(*v1.ServiceAccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateServiceAccount indicates an expected call of UpdateServiceAccount.
func (mr *MockOpsMockRecorder) UpdateServiceAccount(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceAccount", reflect.TypeOf((*MockOps)(nil).UpdateServiceAccount), arg0)
}

// ValidateDeletedService mocks base method.
func (m *MockOps) ValidateDeletedService(arg0, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateDeletedService", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateDeletedService indicates an expected call of ValidateDeletedService.
func (mr *MockOpsMockRecorder) ValidateDeletedService(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateDeletedService", reflect.TypeOf((*MockOps)(nil).ValidateDeletedService), arg0, arg1)
}

// ValidatePersistentVolumeClaim mocks base method.
func (m *MockOps) ValidatePersistentVolumeClaim(arg0 *v1.PersistentVolumeClaim, arg1, arg2 time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatePersistentVolumeClaim", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidatePersistentVolumeClaim indicates an expected call of ValidatePersistentVolumeClaim.
func (mr *MockOpsMockRecorder) ValidatePersistentVolumeClaim(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatePersistentVolumeClaim", reflect.TypeOf((*MockOps)(nil).ValidatePersistentVolumeClaim), arg0, arg1, arg2)
}

// ValidatePersistentVolumeClaimSize mocks base method.
func (m *MockOps) ValidatePersistentVolumeClaimSize(arg0 *v1.PersistentVolumeClaim, arg1 int64, arg2, arg3 time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatePersistentVolumeClaimSize", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidatePersistentVolumeClaimSize indicates an expected call of ValidatePersistentVolumeClaimSize.
func (mr *MockOpsMockRecorder) ValidatePersistentVolumeClaimSize(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatePersistentVolumeClaimSize", reflect.TypeOf((*MockOps)(nil).ValidatePersistentVolumeClaimSize), arg0, arg1, arg2, arg3)
}

// ValidatePod mocks base method.
func (m *MockOps) ValidatePod(arg0 *v1.Pod, arg1, arg2 time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatePod", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidatePod indicates an expected call of ValidatePod.
func (mr *MockOpsMockRecorder) ValidatePod(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatePod", reflect.TypeOf((*MockOps)(nil).ValidatePod), arg0, arg1, arg2)
}

// WaitForPodDeletion mocks base method.
func (m *MockOps) WaitForPodDeletion(arg0 types.UID, arg1 string, arg2 time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitForPodDeletion", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitForPodDeletion indicates an expected call of WaitForPodDeletion.
func (mr *MockOpsMockRecorder) WaitForPodDeletion(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForPodDeletion", reflect.TypeOf((*MockOps)(nil).WaitForPodDeletion), arg0, arg1, arg2)
}

// WatchConfigMap mocks base method.
func (m *MockOps) WatchConfigMap(arg0 *v1.ConfigMap, arg1 core.WatchFunc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchConfigMap", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchConfigMap indicates an expected call of WatchConfigMap.
func (mr *MockOpsMockRecorder) WatchConfigMap(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchConfigMap", reflect.TypeOf((*MockOps)(nil).WatchConfigMap), arg0, arg1)
}

// WatchLimitRange mocks base method.
func (m *MockOps) WatchLimitRange(arg0 *v1.LimitRange, arg1 core.WatchFunc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchLimitRange", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchLimitRange indicates an expected call of WatchLimitRange.
func (mr *MockOpsMockRecorder) WatchLimitRange(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchLimitRange", reflect.TypeOf((*MockOps)(nil).WatchLimitRange), arg0, arg1)
}

// WatchNode mocks base method.
func (m *MockOps) WatchNode(arg0 *v1.Node, arg1 core.WatchFunc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchNode", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchNode indicates an expected call of WatchNode.
func (mr *MockOpsMockRecorder) WatchNode(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchNode", reflect.TypeOf((*MockOps)(nil).WatchNode), arg0, arg1)
}

// WatchPods mocks base method.
func (m *MockOps) WatchPods(arg0 string, arg1 core.WatchFunc, arg2 v11.ListOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchPods", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchPods indicates an expected call of WatchPods.
func (mr *MockOpsMockRecorder) WatchPods(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchPods", reflect.TypeOf((*MockOps)(nil).WatchPods), arg0, arg1, arg2)
}

// WatchSecret mocks base method.
func (m *MockOps) WatchSecret(arg0 *v1.Secret, arg1 core.WatchFunc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchSecret", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// WatchSecret indicates an expected call of WatchSecret.
func (mr *MockOpsMockRecorder) WatchSecret(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchSecret", reflect.TypeOf((*MockOps)(nil).WatchSecret), arg0, arg1)
}


text:
/*
 * vim:ts=4:sw=4:expandtab
 *
 * i3 - an improved dynamic tiling window manager
 * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
 *
 * string.c: Define an i3String type to automagically handle UTF-8/UCS-2
 *           conversions. Some font backends need UCS-2 (X core fonts),
 *           others want UTF-8 (Pango).
 *
 */

#include <stdlib.h>
#include <string.h>

#include <glib.h>

#include "libi3.h"

struct _i3String {
    char *utf8;
    xcb_char2b_t *ucs2;
    size_t num_glyphs;
    size_t num_bytes;
    bool pango_markup;
};

/*
 * Build an i3String from an UTF-8 encoded string.
 * Returns the newly-allocated i3String.
 *
 */
i3String *i3string_from_utf8(const char *from_utf8) {
    i3String *str = scalloc(1, sizeof(i3String));

    /* Get the text */
    str->utf8 = sstrdup(from_utf8);

    /* Compute and store the length */
    str->num_bytes = strlen(str->utf8);

    return str;
}

/*
 * Build an i3String from an UTF-8 encoded string in Pango markup.
 *
 */
i3String *i3string_from_markup(const char *from_markup) {
    i3String *str = i3string_from_utf8(from_markup);

    /* Set the markup flag */
    str->pango_markup = true;

    return str;
}

/*
 * Build an i3String from an UTF-8 encoded string with fixed length.
 * To be used when no proper NUL-terminaison is available.
 * Returns the newly-allocated i3String.
 *
 */
i3String *i3string_from_utf8_with_length(const char *from_utf8, size_t num_bytes) {
    i3String *str = scalloc(1, sizeof(i3String));

    /* Copy the actual text to our i3String */
    str->utf8 = scalloc(num_bytes + 1, 1);
    strncpy(str->utf8, from_utf8, num_bytes);
    str->utf8[num_bytes] = '\0';

    /* Store the length */
    str->num_bytes = num_bytes;

    return str;
}

/*
 * Build an i3String from an UTF-8 encoded string in Pango markup with fixed
 * length.
 *
 */
i3String *i3string_from_markup_with_length(const char *from_markup, size_t num_bytes) {
    i3String *str = i3string_from_utf8_with_length(from_markup, num_bytes);

    /* set the markup flag */
    str->pango_markup = true;

    return str;
}

/*
 * Build an i3String from an UCS-2 encoded string.
 * Returns the newly-allocated i3String.
 *
 */
i3String *i3string_from_ucs2(const xcb_char2b_t *from_ucs2, size_t num_glyphs) {
    i3String *str = scalloc(1, sizeof(i3String));

    /* Copy the actual text to our i3String */
    str->ucs2 = scalloc(num_glyphs, sizeof(xcb_char2b_t));
    memcpy(str->ucs2, from_ucs2, num_glyphs * sizeof(xcb_char2b_t));

    /* Store the length */
    str->num_glyphs = num_glyphs;

    str->utf8 = NULL;
    str->num_bytes = 0;

    return str;
}

/**
 * Copies the given i3string.
 * Note that this will not free the source string.
 */
i3String *i3string_copy(i3String *str) {
    i3String *copy = i3string_from_utf8(i3string_as_utf8(str));
    copy->pango_markup = str->pango_markup;
    return copy;
}

/*
 * Free an i3String.
 *
 */
void i3string_free(i3String *str) {
    if (str == NULL)
        return;
    free(str->utf8);
    free(str->ucs2);
    free(str);
}

static void i3string_ensure_utf8(i3String *str) {
    if (str->utf8 != NULL)
        return;
    if ((str->utf8 = convert_ucs2_to_utf8(str->ucs2, str->num_glyphs)) != NULL)
        str->num_bytes = strlen(str->utf8);
}

static void i3string_ensure_ucs2(i3String *str) {
    if (str->ucs2 != NULL)
        return;
    str->ucs2 = convert_utf8_to_ucs2(str->utf8, &str->num_glyphs);
}

/*
 * Returns the UTF-8 encoded version of the i3String.
 *
 */
const char *i3string_as_utf8(i3String *str) {
    i3string_ensure_utf8(str);
    return str->utf8;
}

/*
 * Returns the UCS-2 encoded version of the i3String.
 *
 */
const xcb_char2b_t *i3string_as_ucs2(i3String *str) {
    i3string_ensure_ucs2(str);
    return str->ucs2;
}

/*
 * Returns the number of bytes (UTF-8 encoded) in an i3String.
 *
 */
size_t i3string_get_num_bytes(i3String *str) {
    i3string_ensure_utf8(str);
    return str->num_bytes;
}

/*
 * Whether the given i3String is in Pango markup.
 */
bool i3string_is_markup(i3String *str) {
    return str->pango_markup;
}

/*
 * Set whether the i3String should use Pango markup.
 */
void i3string_set_markup(i3String *str, bool pango_markup) {
    str->pango_markup = pango_markup;
}

/*
 * Escape pango markup characters in the given string.
 */
i3String *i3string_escape_markup(i3String *str) {
    const char *text = i3string_as_utf8(str);
    char *escaped = g_markup_escape_text(text, -1);
    i3String *result = i3string_from_utf8(escaped);
    free(escaped);
    return result;
}

/*
 * Returns the number of glyphs in an i3String.
 *
 */
size_t i3string_get_num_glyphs(i3String *str) {
    i3string_ensure_ucs2(str);
    return str->num_glyphs;
}

redpajama_set_name: RedPajamaGithub


text:
/*
 * This is not the original file distributed by the Apache Software Foundation
 * It has been modified by the Hipparchus project
 */
package org.hipparchus.stat.fitting;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.hipparchus.distribution.multivariate.MixtureMultivariateNormalDistribution;
import org.hipparchus.distribution.multivariate.MultivariateNormalDistribution;
import org.hipparchus.exception.LocalizedCoreFormats;
import org.hipparchus.exception.MathIllegalArgumentException;
import org.hipparchus.exception.MathIllegalStateException;
import org.hipparchus.linear.Array2DRowRealMatrix;
import org.hipparchus.linear.RealMatrix;
import org.hipparchus.stat.correlation.Covariance;
import org.hipparchus.util.FastMath;
import org.hipparchus.util.MathArrays;
import org.hipparchus.util.Pair;

/**
 * Expectation-Maximization algorithm for fitting the parameters of
 * multivariate normal mixture model distributions.
 *
 * This implementation is pure original code based on
 * EM Demystified: An Expectation-Maximization Tutorial by Yihua Chen and Maya R. Gupta,
 * Department of Electrical Engineering, University of Washington, Seattle, WA 98195.
 * It was verified using external tools like CRAN Mixtools
 * (see the JUnit test cases) but it is not based on Mixtools code at all.
 * The discussion of the origin of this class can be seen in the comments of the MATH-817 JIRA issue.
 */
public class MultivariateNormalMixtureExpectationMaximization {
    /** Default maximum number of iterations allowed per fitting process. */
    private static final int DEFAULT_MAX_ITERATIONS = 1000;
    /** Default convergence threshold for fitting. */
    private static final double DEFAULT_THRESHOLD = 1E-5;
    /** The data to fit. */
    private final double[][] data;
    /** The model fit against the data. */
    private MixtureMultivariateNormalDistribution fittedModel;
    /** The log likelihood of the data given the fitted model. */
    private double logLikelihood;

    /**
     * Creates an object to fit a multivariate normal mixture model to data.
     *
     * @param data Data to use in fitting procedure
     * @throws MathIllegalArgumentException if data has no rows
     * @throws MathIllegalArgumentException if rows of data have different numbers
     * of columns
     * @throws MathIllegalArgumentException if the number of columns in the data is
     * less than 2
     */
    public MultivariateNormalMixtureExpectationMaximization(double[][] data)
        throws MathIllegalArgumentException {
        if (data.length < 1) {
            throw new MathIllegalArgumentException(LocalizedCoreFormats.NUMBER_TOO_SMALL,
                                                   data.length, 1);
        }

        this.data = new double[data.length][data[0].length];

        for (int i = 0; i < data.length; i++) {
            if (data[i].length != data[0].length) {
                // Jagged arrays not allowed
                throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
                                                       data[i].length, data[0].length);
            }
            if (data[i].length < 2) {
                throw new MathIllegalArgumentException(LocalizedCoreFormats.NUMBER_TOO_SMALL,
                                                    data[i].length, 2, true);
            }
            this.data[i] = data[i].clone();
        }
    }

    /**
     * Fit a mixture model to the data supplied to the constructor.
     *
     * The quality of the fit depends on the concavity of the data provided to
     * the constructor and the initial mixture provided to this function. If the
     * data has many local optima, multiple runs of the fitting function with
     * different initial mixtures may be required to find the optimal solution.
     * If a MathIllegalArgumentException is encountered, it is possible that another
     * initialization would work.
     *
     * @param initialMixture Model containing initial values of weights and
     * multivariate normals
     * @param maxIterations Maximum iterations allowed for fit
     * @param threshold Convergence threshold computed as difference in
     * logLikelihoods between successive iterations
     * @throws MathIllegalArgumentException if any component's covariance matrix is
     * singular during fitting
     * @throws MathIllegalArgumentException if numComponents is less than one
     * or threshold is less than Double.MIN_VALUE
     * @throws MathIllegalArgumentException if initialMixture mean vector and data
     * number of columns are not equal
     */
    public void fit(final MixtureMultivariateNormalDistribution initialMixture,
                    final int maxIterations,
                    final double threshold)
        throws MathIllegalArgumentException {
        if (maxIterations < 1) {
            throw new MathIllegalArgumentException(LocalizedCoreFormats.NUMBER_TOO_SMALL,
                                                   maxIterations, 1);
        }

        if (threshold < Double.MIN_VALUE) {
            throw new MathIllegalArgumentException(LocalizedCoreFormats.NUMBER_TOO_SMALL,
                                                   threshold, Double.MIN_VALUE);
        }

        final int n = data.length;

        // Number of data columns. Jagged data already rejected in constructor,
        // so we can assume the lengths of each row are equal.
        final int numCols = data[0].length;
        final int k = initialMixture.getComponents().size();

        final int numMeanColumns
            = initialMixture.getComponents().get(0).getSecond().getMeans().length;

        if (numMeanColumns != numCols) {
            throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
                                                   numMeanColumns, numCols);
        }

        double previousLogLikelihood = 0d;

        logLikelihood = Double.NEGATIVE_INFINITY;

        // Initialize model to fit to initial mixture.
        fittedModel = new MixtureMultivariateNormalDistribution(initialMixture.getComponents());

        for (int numIterations = 0;
             numIterations < maxIterations && FastMath.abs(previousLogLikelihood - logLikelihood) > threshold;
             ++numIterations) {
            previousLogLikelihood = logLikelihood;
            double sumLogLikelihood = 0d;

            // Mixture components
            final List<Pair<Double, MultivariateNormalDistribution>> components
                = fittedModel.getComponents();

            // Weight and distribution of each component
            final double[] weights = new double[k];

            final MultivariateNormalDistribution[] mvns = new MultivariateNormalDistribution[k];

            for (int j = 0; j < k; j++) {
                weights[j] = components.get(j).getFirst();
                mvns[j] = components.get(j).getSecond();
            }

            // E-step: compute the data dependent parameters of the expectation
            // function.
            // The percentage of row's total density between a row and a
            // component
            final double[][] gamma = new double[n][k];

            // Sum of gamma for each component
            final double[] gammaSums = new double[k];

            // Sum of gamma times its row for each each component
            final double[][] gammaDataProdSums = new double[k][numCols];

            for (int i = 0; i < n; i++) {
                final double rowDensity = fittedModel.density(data[i]);
                sumLogLikelihood += FastMath.log(rowDensity);

                for (int j = 0; j < k; j++) {
                    gamma[i][j] = weights[j] * mvns[j].density(data[i]) / rowDensity;
                    gammaSums[j] += gamma[i][j];

                    for (int col = 0; col < numCols; col++) {
                        gammaDataProdSums[j][col] += gamma[i][j] * data[i][col];
                    }
                }
            }

            logLikelihood = sumLogLikelihood / n;

            // M-step: compute the new parameters based on the expectation
            // function.
            final double[] newWeights = new double[k];
            final double[][] newMeans = new double[k][numCols];

            for (int j = 0; j < k; j++) {
                newWeights[j] = gammaSums[j] / n;
                for (int col = 0; col < numCols; col++) {
                    newMeans[j][col] = gammaDataProdSums[j][col] / gammaSums[j];
                }
            }

            // Compute new covariance matrices
            final RealMatrix[] newCovMats = new RealMatrix[k];
            for (int j = 0; j < k; j++) {
                newCovMats[j] = new Array2DRowRealMatrix(numCols, numCols);
            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < k; j++) {
                    final RealMatrix vec
                        = new Array2DRowRealMatrix(MathArrays.ebeSubtract(data[i], newMeans[j]));
                    final RealMatrix dataCov
                        = vec.multiplyTransposed(vec).scalarMultiply(gamma[i][j]);
                    newCovMats[j] = newCovMats[j].add(dataCov);
                }
            }

            // Converting to arrays for use by fitted model
            final double[][][] newCovMatArrays = new double[k][numCols][numCols];
            for (int j = 0; j < k; j++) {
                newCovMats[j] = newCovMats[j].scalarMultiply(1d / gammaSums[j]);
                newCovMatArrays[j] = newCovMats[j].getData();
            }

            // Update current model
            fittedModel = new MixtureMultivariateNormalDistribution(newWeights,
                                                                    newMeans,
                                                                    newCovMatArrays);
        }

        if (FastMath.abs(previousLogLikelihood - logLikelihood) > threshold) {
            // Did not converge before the maximum number of iterations
            throw new MathIllegalStateException(LocalizedCoreFormats.CONVERGENCE_FAILED);
        }
    }

    /**
     * Fit a mixture model to the data supplied to the constructor.
     *
     * The quality of the fit depends on the concavity of the data provided to
     * the constructor and the initial mixture provided to this function. If the
     * data has many local optima, multiple runs of the fitting function with
     * different initial mixtures may be required to find the optimal solution.
     * If a MathIllegalArgumentException is encountered, it is possible that another
     * initialization would work.
     *
     * @param initialMixture Model containing initial values of weights and
     * multivariate normals
     * @throws MathIllegalArgumentException if any component's covariance matrix is
     * singular during fitting
     * @throws MathIllegalArgumentException if numComponents is less than one or
     * threshold is less than Double.MIN_VALUE
     */
    public void fit(MixtureMultivariateNormalDistribution initialMixture)
        throws MathIllegalArgumentException {
        fit(initialMixture, DEFAULT_MAX_ITERATIONS, DEFAULT_THRESHOLD);
    }

    /**
     * Helper method to create a multivariate normal mixture model which can be
     * used to initialize {@link #fit(MixtureMultivariateNormalDistribution)}.
     *
     * This method uses the data supplied to the constructor to try to determine
     * a good mixture model at which to start the fit, but it is not guaranteed
     * to supply a model which will find the optimal solution or even converge.
     *
     * @param data Data to estimate distribution
     * @param numComponents Number of components for estimated mixture
     * @return Multivariate normal mixture model estimated from the data
     * @throws MathIllegalArgumentException if {@code numComponents} is greater
     * than the number of data rows.
     * @throws MathIllegalArgumentException if {@code numComponents < 2}.
     * @throws MathIllegalArgumentException if data has less than 2 rows
     * @throws MathIllegalArgumentException if rows of data have different numbers
     * of columns
     */
    public static MixtureMultivariateNormalDistribution estimate(final double[][] data,
                                                                 final int numComponents)
        throws MathIllegalArgumentException {
        if (data.length < 2) {
            throw new MathIllegalArgumentException(LocalizedCoreFormats.NUMBER_TOO_SMALL,
                                                   data.length, 2);
        }
        if (numComponents < 2) {
            throw new MathIllegalArgumentException(LocalizedCoreFormats.NUMBER_TOO_SMALL,
                                                   numComponents, 2);
        }
        if (numComponents > data.length) {
            throw new MathIllegalArgumentException(LocalizedCoreFormats.NUMBER_TOO_LARGE,
                                                   numComponents, data.length);
        }

        final int numRows = data.length;
        final int numCols = data[0].length;

        // sort the data
        final DataRow[] sortedData = new DataRow[numRows];
        for (int i = 0; i < numRows; i++) {
            sortedData[i] = new DataRow(data[i]);
        }
        Arrays.sort(sortedData);

        // uniform weight for each bin
        final double weight = 1d / numComponents;

        // components of mixture model to be created
        final List<Pair<Double, MultivariateNormalDistribution>> components = new ArrayList<>(numComponents);

        // create a component based on data in each bin
        for (int binIndex = 0; binIndex < numComponents; binIndex++) {
            // minimum index (inclusive) from sorted data for this bin
            final int minIndex = (binIndex * numRows) / numComponents;

            // maximum index (exclusive) from sorted data for this bin
            final int maxIndex = ((binIndex + 1) * numRows) / numComponents;

            // number of data records that will be in this bin
            final int numBinRows = maxIndex - minIndex;

            // data for this bin
            final double[][] binData = new double[numBinRows][numCols];

            // mean of each column for the data in the this bin
            final double[] columnMeans = new double[numCols];

            // populate bin and create component
            for (int i = minIndex; i < maxIndex; i++) {
                final int iBin = i - minIndex;
                for (int j = 0; j < numCols; j++) {
                    final double val = sortedData[i].getRow()[j];
                    columnMeans[j] += val;
                    binData[iBin][j] = val;
                }
            }

            MathArrays.scaleInPlace(1d / numBinRows, columnMeans);

            // covariance matrix for this bin
            final double[][] covMat
                = new Covariance(binData).getCovarianceMatrix().getData();
            final MultivariateNormalDistribution mvn
                = new MultivariateNormalDistribution(columnMeans, covMat);

            components.add(new Pair<Double, MultivariateNormalDistribution>(weight, mvn));
        }

        return new MixtureMultivariateNormalDistribution(components);
    }

    /**
     * Gets the log likelihood of the data under the fitted model.
     *
     * @return Log likelihood of data or zero of no data has been fit
     */
    public double getLogLikelihood() {
        return logLikelihood;
    }

    /**
     * Gets the fitted model.
     *
     * @return fitted model or {@code null} if no fit has been performed yet.
     */
    public MixtureMultivariateNormalDistribution getFittedModel() {
        return new MixtureMultivariateNormalDistribution(fittedModel.getComponents());
    }

    /**
     * Class used for sorting user-supplied data.
     */
    private static class DataRow implements Comparable<DataRow> {
        /** One data row. */
        private final double[] row;
        /** Mean of the data row. */
        private Double mean;

        /**
         * Create a data row.
         * @param data Data to use for the row, a reference to the data is stored
         */
        DataRow(final double[] data) { // NOPMD - storing a reference to the array is intentional and documented here
            // Store reference.
            row = data;
            // Compute mean.
            mean = 0d;
            for (int i = 0; i < data.length; i++) {
                mean += data[i];
            }
            mean /= data.length;
        }

        /**
         * Compare two data rows.
         * @param other The other row
         * @return int for sorting
         */
        @Override
        public int compareTo(final DataRow other) {
            return mean.compareTo(other.mean);
        }

        /** {@inheritDoc} */
        @Override
        public boolean equals(Object other) {

            if (this == other) {
                return true;
            }

            if (other instanceof DataRow) {
                return MathArrays.equals(row, ((DataRow) other).row);
            }

            return false;

        }

        /** {@inheritDoc} */
        @Override
        public int hashCode() {
            return Arrays.hashCode(row);
        }
        /**
         * Get a data row.
         * @return data row array (a reference to the stored array is returned)
         */
        public double[] getRow() {
            return row; // NOPMD - returning a reference to an internal array is documented here
        }
    }
}


text:
package net.flipback.xpca.core;

import org.hibernate.SessionFactory;
import org.hibernate.Session;

public class Engine {
	private SessionFactory sessionFactory;
	private XGroup root = new XGroup("/");
	public XGroup getRoot() {
		return root;
	}

	public void addObject(String path, XObject xobj) {
		XGroup group = (XGroup)getObject(path);

		if (group != null) {
			xobj.setGroup(group);
			group.getChildren().add(xobj);
		}
	}

	public void deleteObject(String path) {
		XObject xobj = (XObject)getObject(path);

		if (xobj != null) {
			xobj.getGroup().getChildren().remove(xobj);
		}
	}

	public void updateObject(String path, XObject xobj) {
		XObject old_obj = (XObject)getObject(path);

		if (old_obj != null) {
			xobj.setId(old_obj.getId());
			xobj.setGroup(old_obj.getGroup());

			deleteObject(path);
			addObject(old_obj.getGroup().getFullName(), xobj);
		}
	}

	public XObject getObject(String path) {
		return getObject(path, root);
	}

	public Engine(SessionFactory sessionFactory, String root_name) {
		this.sessionFactory = sessionFactory;

		getRoot(root_name);
	}

	public Engine(SessionFactory sessionFactory)
	{
		this.sessionFactory = sessionFactory;

		getRoot("/");
	}

	public void commit() {
		Session session = sessionFactory.openSession();
		session.beginTransaction();

		commitObject(root, session);

		session.getTransaction().commit();
		session.close();
	}

	public void revert() {
		Session session = sessionFactory.openSession();
		session.beginTransaction();

		root = (XGroup) session.createQuery("from XObject where fullName = ?").setParameter(0, root.getFullName()).uniqueResult();

		session.getTransaction().commit();
		session.close();
	}

	private void commitObject(XObject xobj, Session session) {
		if (xobj instanceof XGroup) {
			XGroup group = (XGroup) xobj;
			for( XObject child : group.getChildren()) {
				commitObject(child, session);
			}
		}
		session.saveOrUpdate(xobj);
	}

	private void getRoot(String root_name) {
		Session session = sessionFactory.openSession();
		session.beginTransaction();

		root = (XGroup) session.createQuery("from XObject where fullName = ?").setParameter(0, root_name).uniqueResult();

		session.getTransaction().commit();
		session.close();

		if (root == null) {
			root = new XGroup(root_name);
			commit();
		}
	}

	private XObject getObject(String path, XObject xobj) {
		if (xobj.getName().equals(path)) {
			return xobj;
		}

		XObject result = null;

		path = path.replaceFirst(xobj.getName(), "");
		if (!xobj.getName().equals("/")) {
			path = path.replaceFirst("/", "");
		}

		if (xobj instanceof XGroup) {
			XGroup group = (XGroup)xobj;

			for (XObject child : group.getChildren()) {
				result = getObject(path, child);
				if (result != null) {
					break;
				}
			}
		}

		return result;
	}

}


text:
perform_on :staging do
  pre :remove_output do
    run 'rm -rf output'
  end

  post :render_output do
    run 'rake render:output'
  end

  post :restart_nginx_and_passenger do
    run '/etc/init.d/nginx stop'
    run 'sleep 1'
    run '/etc/init.d/nginx start'
    run 'mkdir tmp'
    run 'touch tmp/restart.txt'
  end

  post :ensure_correct_branch do
    run 'git commit -am "Commit and Ensuring"'
    run 'git checkout master'
  end
end

perform_on :production do
  pre :maintenance_on do
    run 'mv public/maintenance_off.html public/maintenance.html'
  end

  pre :clean_up_local do
    run 'rake remove:trash'
  end

  post :update_vhost do
    run 'webserver update vhost'
    run 'webserver restart'
  end
end


text:
package java.security;

import java.security.spec.AlgorithmParameterSpec;

/**
 * {@code AlgorithmParameterGeneratorSpi} is the Service Provider Interface
 * (SPI) definition for {@code AlgorithmParameterGenerator}.
 *
 * @see AlgorithmParameterGenerator
 */
public abstract class AlgorithmParameterGeneratorSpi {

	/**
	 * Constructs a new instance of {@code AlgorithmParameterGeneratorSpi} .
	 */
	public AlgorithmParameterGeneratorSpi() {
	}

	/**
	 * Initializes this {@code AlgorithmParameterGeneratorSpi} with the given
	 * size and the given {@code SecureRandom}. The default parameter set will
	 * be used.
	 *
	 * @param size
	 *            the size (in number of bits).
	 * @param random
	 *            the source of randomness.
	 */
	protected abstract void engineInit(int size, SecureRandom random);

	/**
	 * Initializes this {@code AlgorithmParameterGeneratorSpi} with the given
	 * {@code AlgorithmParameterSpec} and the given {@code SecureRandom}.
	 *
	 * @param genParamSpec
	 *            the parameters to use.
	 * @param random
	 *            the source of randomness.
	 * @throws InvalidAlgorithmParameterException
	 *             if the specified parameters are not supported.
	 */
	protected abstract void engineInit(AlgorithmParameterSpec genParamSpec,
			SecureRandom random) throws InvalidAlgorithmParameterException;

	/**
	 * Computes and returns {@code AlgorithmParameters} for this generator's
	 * algorithm.
	 *
	 * @return {@code AlgorithmParameters} for this generator's algorithm.
	 */
	protected abstract AlgorithmParameters engineGenerateParameters();
}


text:
After installation, registration and plugged the component you can use `<yandex-map>` and work with a map. All parameters of the map are set via attributes. You can use `map-was-initialized` event to get an access to [map instance](https://tech.yandex.ru/maps/doc/jsapi/2.1/ref/reference/Map-docpage/) for work directly with [YandexMap API](https://tech.yandex.ru/maps/doc/jsapi/2.1/quick-start/index-docpage/). Link to the map instance will be transmitted as payload of event.

You can assign a class to parent element of map via attribute `ymap-class`. If this attribute is not specified the element will be assign an attribute `style="width: 100%; height: 100%;"`.

All markers are added to the map via `GeoObjectCollection` by default, but if there is a huge count of markers, the map rendering will take a lof of time even when markers grouping to clusters. In this case, it is recommended to use `ObjectManager` and assign the attribute of map `useObjectManager`, but then you lose the opportunity to listen events by each marker.

The attributes `coords`, `bounds` and `zoom` are observable. The map is react if these attributes are changing.

## Events

      Event name
      Payload

      map-was-initialized
      Link to map instance

      actionend

        map event

      balloonclose

      balloonopen

      boundschange

      click

      contextmenu

      dblclick

      destroy

      hintclose

      hintopen

      optionschange

      sizechange

      typechange

## Attributes

| Attribute | Type | Description |
| ----- | ----- | ----- |
| settings | Object | Settings of map. API Key, language and version. |
| coords | Array | Map center coordinates. [ lat, lng ]. May use with `.sync`. *Required* |
| map-events | Array | Native events, which map emits. If not provided, map will be emit all events, from section [Events](#events) | All |
| zoom | Number | Zoom map value (from 0 to 19). May use with `.sync`. *Default: 18*. |
| bounds | Array | Coordinates of the left bottom and right top corners of the map. If defined, `coords` and `center` are ignored. May use with `.sync`. |
| [cluster-options](https://tech.yandex.ru/maps/doc/jsapi/2.1/ref/reference/ClusterPlacemark-docpage/#param-options) | Object | An object where the keys are the names of the clusters, and the values are the objects of options these clusters. In options you can point field `layout` (type `String`) for HTML template for `balloonItemContentLayout`, field `clusterIconContentLayout` (type `String`) for cluster icon customization and field `clusterBalloonLayout` (type `String`) for cluster balloon customization: [Custom Balloon example](https://tech.yandex.ru/maps/jsbox/2.1/cluster_custom_balloon_content_layout). There is also `createCluster` field for overriding default creating cluster function (field `use-object-manager` have to be turned off).|
| cluster-callbacks | Object | An object where the keys are the names of the clusters, and the values are the objects of events these clusters, e.g. `{ clusterName: { click: function() {...}, contextmenu: anotherFunction } }` |
| [behaviors](https://tech.yandex.ru/maps/doc/jsapi/2.1/ref/reference/map.behavior.Manager-docpage/#param-behaviors) | Array | Array of connected map behaviors. All other values are considered off.|
| [controls](https://tech.yandex.ru/maps/doc/jsapi/2.1/ref/reference/control.Manager-docpage/#add-param-control) | Array | Array of connected map controls. All other values are considered offth.|
| detailed-controls | Object | An object where the keys are the elements of map control, and the values are the objects of element settings. Designed for fine setting of control elements. |
| map-type | String | Map type. Valid values: `map, satellite, hybrid`. *Default: map*. |
| scroll-zoom | Boolean | Set `false` to disable map zoom on the page when you are scrolling. *Default: true* |
| placemarks  | Array of Objects | **Deprecated**. Use marker component |
| use-object-manager  | Boolean | Set `true` for use Object Manager. Used if there is huge count of markers on the map. *Default: false* |
| object-manager-clusterize  | Boolean | Clustering with Object Manager. *Default: true* |
| ymap-class  | String | Defines class for element, where rendering the map instance. If the attribute is not defined, the element uses style: `width: 100%; height: 100%;` |
| init-without-markers  | Boolean | Set to `false` for prevent init and render map if there are no markers on the map. Default: `true` |
| show-all-markers  | Boolean | Set to `true` to initialize map with all markers inside map bounds. Default: `false` |
| use-html-in-layout  | Boolean | Set to `true` to define balloon properties as html. Default: `false` |
| [options](https://tech.yandex.ru/maps/doc/jsapi/2.1/ref/reference/Map-docpage/#Map__param-options) | Object | Map options. |
| balloon-component | Vue Component | Allow to use Vue Component as balloon. Need to activate [runtimeCompiler](https://cli.vuejs.org/config/#runtimecompiler). **Vue 2 only**|


text:
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SunokoLibrary.Web.GooglePlus
{
    using SunokoLibrary.Web.GooglePlus.Primitive;

    public class NotificationInfo : AccessorBase
    {
        public NotificationInfo(NotificationData data, NotificationInfoContainer container, PlatformClient client)
            : base(client)
        {
            _data = data;
            _container = container;
        }
        NotificationData _data;
        NotificationInfoContainer _container;

        public string Id { get { return _data.Id; } }
        public string Title { get { return _data.Title; } }
        public string Summary { get { return _data.Summary; } }
        public NotificationFlag Type { get { return _data.Type; } }
        public DateTime NoticedDate { get { return _data.NoticedDate; } }
        public async Task MarkAsReadAsync()
        {
            try { await Client.ServiceApi.MarkAsReadAsync(_data, Client); }
            catch (ApiErrorException e)
            { throw new FailToOperationException("既読化の通信に失敗しました。", e); }
        }
        internal virtual void Update(NotificationData data)
        {
            _data = data;
            OnUpdated(new EventArgs());
        }

        public event EventHandler Updated;
        protected virtual void OnUpdated(EventArgs e)
        {
            if (Updated != null)
                Updated(this, e);
        }
    }
    [Flags]
    public enum NotificationFlag : uint
    {
        Unknown = 0x00000000,
        CameraSyncUploaded = 0x00000001,
        CircleAddBack = 0x00000002,
        CircleIn = 0x00000004,
        DirectMessage = 0x00000008,
        Followup = 0x00000010,
        InviteEvent = 0x00000020,
        InviteHangout = 0x00000040,
        InviteCommunitiy = 0x00000080,
        Mension = 0x00000100,
        NewPhotosAdded = 0x00000200,
        SubscriptionCommunitiy = 0x00000400,
        PlusOne = 0x00000800,
        Reshare = 0x00001000,
        Response = 0x00002000,
        TaggedImage = 0x00004000,
    }
}


text:
class Api::V1::Versions::DownloadsController < Api::BaseController
  def index
    render text: "This endpoint is not supported anymore", status: :gone
  end

  def search
    render text: "This endpoint is not supported anymore", status: :gone
  end
end


text:
xmlplus("xp", function (xp, $_, t) {
    $_().imports({
        Index: {
            css: "#index { width: 640px; height: 480px; box-sizing: border-box; border: 1px solid #AAA; }",
            xml: "<VDividedBox id='index'>\
                     <Editor id='top'/>\
                     <Editor id='bottom'/>\
                  </VDividedBox>"
        },
        VDividedBox: {
            css: "#vbox { position:relative; width:100%; height:100%; box-sizing: border-box; }\
                  #top { top: 0; height: 30%; } #bottom { bottom: 0; height: calc(70% - 5px); }\
                  #top,#bottom { left: 0; right: 0; position: absolute; }\
                  #handle { height: 5px; width: 100%; position:absolute; left:0; top: 30%; z-index:11; cursor:row-resize; }\
                  #mask { width: 100%; height: 100%; position: absolute; display: none; z-index: 10; }",
            xml: "
\

\

\

\

\

",
            map: { format: {"int": "percent"}, appendTo: "top" },
            fun: function (sys, items, opts) {
                var percent = 50;
                sys.handle.on("dragstart", function (e) {
                    sys.mask.show();
                    sys.vbox.on("dragover", dragover);
                });
                sys.vbox.on("dragend", function (e) {
                    sys.mask.hide();
                    e.stopPropagation();
                    sys.vbox.off("dragover", dragover);
                });
                function dragover(e) {
                    e.preventDefault();
                    setPercent((e.pageY - sys.vbox.offset().top) / sys.vbox.height() * 100);
                }
                function setPercent(value) {
                    sys.handle.css("top", value + "%");
                    sys.top.css("height", value + "%");
                    sys.bottom.css("height", "calc(" + (100 - value) + "% - 5px)");
                }
                setPercent(opts.percent || percent);
                sys.bottom.elem().appendChild(this.last().elem());
                return Object.defineProperty({}, "percent", {get: () => {return percent}, set: setPercent});
            }
        },
        Editor: {
            css: ".CodeMirror { height:100%; height: 100%; font-size: 14px; }\
                  .CodeMirror-gutters { border-right: 1px solid %border-color; background: linear-gradient(to right,%header-gradient-from 0,%header-gradient-to 100%); }\
                  #editor { position: relative; width: 100%; height: 100%; box-sizing: border-box; border: 1px solid #AAA; }",
            map: { nofragment: true },
            opt: { lineNumbers: true, indentUnit: 4, mode: "text/html" },
            xml: "
",
            fun: function (sys, items, opts) {
                return CodeMirror(sys.editor.elem(), opts);
            }
        }
    });
});


text:
Node* createNode(int _value) {
	Node *pnode = (Node *) malloc(sizeof(Node));
	if (NULL == pnode) {
		perror("malloc fail");
		return NULL;
	}

	pnode->value = _value;
	pnode->lchild = NULL;
	pnode->rchild = NULL;

	return pnode;
}

Node* buildTree(int *_array, int _arrayLength, int _curIndex) {
	if (_curIndex >= _arrayLength || NULL == _array)
		return NULL;

	if (0 == _array[_curIndex])
		return NULL;

	Node *pnode = createNode(_array[_curIndex]);
	if (NULL == pnode)
		return NULL;
	pnode->lchild = buildTree(_array, _arrayLength
			, _curIndex * 2 + 1);
	pnode->rchild = buildTree(_array, _arrayLength
			, _curIndex * 2 + 2);

	return pnode;
}

void releaseTree(Node *_node) {
	if(NULL != _node->lchild)
		releaseTree(_node->lchild);
	if(NULL != _node->rchild)
		releaseTree(_node->rchild);
	free(_node);
}