github.com/aporeto-inc/trireme-lib@v10.358.0+incompatible/utils/cri/mockcri/mock_runtime_service.go

// Code generated by MockGen. DO NOT EDIT.
// Source: k8s.io/cri-api/pkg/apis/runtime/v1alpha2 (interfaces: RuntimeServiceClient)

// Package mockcri is a generated GoMock package.
package mockcri

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
	v1alpha2 "k8s.io/cri-api/pkg/apis/runtime/v1alpha2"
)

// MockRuntimeServiceClient is a mock of RuntimeServiceClient interface
// nolint
type MockRuntimeServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockRuntimeServiceClientMockRecorder
}

// MockRuntimeServiceClientMockRecorder is the mock recorder for MockRuntimeServiceClient
// nolint
type MockRuntimeServiceClientMockRecorder struct {
	mock *MockRuntimeServiceClient
}

// NewMockRuntimeServiceClient creates a new mock instance
// nolint
func NewMockRuntimeServiceClient(ctrl *gomock.Controller) *MockRuntimeServiceClient {
	mock := &MockRuntimeServiceClient{ctrl: ctrl}
	mock.recorder = &MockRuntimeServiceClientMockRecorder{mock}
	return mock
}

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

// Attach mocks base method
// nolint
func (m *MockRuntimeServiceClient) Attach(arg0 context.Context, arg1 *v1alpha2.AttachRequest, arg2 ...grpc.CallOption) (*v1alpha2.AttachResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Attach", varargs...)
	ret0, _ := ret[0].(*v1alpha2.AttachResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ContainerStats mocks base method
// nolint
func (m *MockRuntimeServiceClient) ContainerStats(arg0 context.Context, arg1 *v1alpha2.ContainerStatsRequest, arg2 ...grpc.CallOption) (*v1alpha2.ContainerStatsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ContainerStats", varargs...)
	ret0, _ := ret[0].(*v1alpha2.ContainerStatsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ContainerStatus mocks base method
// nolint
func (m *MockRuntimeServiceClient) ContainerStatus(arg0 context.Context, arg1 *v1alpha2.ContainerStatusRequest, arg2 ...grpc.CallOption) (*v1alpha2.ContainerStatusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ContainerStatus", varargs...)
	ret0, _ := ret[0].(*v1alpha2.ContainerStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateContainer mocks base method
// nolint
func (m *MockRuntimeServiceClient) CreateContainer(arg0 context.Context, arg1 *v1alpha2.CreateContainerRequest, arg2 ...grpc.CallOption) (*v1alpha2.CreateContainerResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateContainer", varargs...)
	ret0, _ := ret[0].(*v1alpha2.CreateContainerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Exec mocks base method
// nolint
func (m *MockRuntimeServiceClient) Exec(arg0 context.Context, arg1 *v1alpha2.ExecRequest, arg2 ...grpc.CallOption) (*v1alpha2.ExecResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Exec", varargs...)
	ret0, _ := ret[0].(*v1alpha2.ExecResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExecSync mocks base method
// nolint
func (m *MockRuntimeServiceClient) ExecSync(arg0 context.Context, arg1 *v1alpha2.ExecSyncRequest, arg2 ...grpc.CallOption) (*v1alpha2.ExecSyncResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExecSync", varargs...)
	ret0, _ := ret[0].(*v1alpha2.ExecSyncResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListContainerStats mocks base method
// nolint
func (m *MockRuntimeServiceClient) ListContainerStats(arg0 context.Context, arg1 *v1alpha2.ListContainerStatsRequest, arg2 ...grpc.CallOption) (*v1alpha2.ListContainerStatsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListContainerStats", varargs...)
	ret0, _ := ret[0].(*v1alpha2.ListContainerStatsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListContainers mocks base method
// nolint
func (m *MockRuntimeServiceClient) ListContainers(arg0 context.Context, arg1 *v1alpha2.ListContainersRequest, arg2 ...grpc.CallOption) (*v1alpha2.ListContainersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListContainers", varargs...)
	ret0, _ := ret[0].(*v1alpha2.ListContainersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPodSandbox mocks base method
// nolint
func (m *MockRuntimeServiceClient) ListPodSandbox(arg0 context.Context, arg1 *v1alpha2.ListPodSandboxRequest, arg2 ...grpc.CallOption) (*v1alpha2.ListPodSandboxResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPodSandbox", varargs...)
	ret0, _ := ret[0].(*v1alpha2.ListPodSandboxResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PodSandboxStatus mocks base method
// nolint
func (m *MockRuntimeServiceClient) PodSandboxStatus(arg0 context.Context, arg1 *v1alpha2.PodSandboxStatusRequest, arg2 ...grpc.CallOption) (*v1alpha2.PodSandboxStatusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PodSandboxStatus", varargs...)
	ret0, _ := ret[0].(*v1alpha2.PodSandboxStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PortForward mocks base method
// nolint
func (m *MockRuntimeServiceClient) PortForward(arg0 context.Context, arg1 *v1alpha2.PortForwardRequest, arg2 ...grpc.CallOption) (*v1alpha2.PortForwardResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PortForward", varargs...)
	ret0, _ := ret[0].(*v1alpha2.PortForwardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveContainer mocks base method
// nolint
func (m *MockRuntimeServiceClient) RemoveContainer(arg0 context.Context, arg1 *v1alpha2.RemoveContainerRequest, arg2 ...grpc.CallOption) (*v1alpha2.RemoveContainerResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveContainer", varargs...)
	ret0, _ := ret[0].(*v1alpha2.RemoveContainerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemovePodSandbox mocks base method
// nolint
func (m *MockRuntimeServiceClient) RemovePodSandbox(arg0 context.Context, arg1 *v1alpha2.RemovePodSandboxRequest, arg2 ...grpc.CallOption) (*v1alpha2.RemovePodSandboxResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemovePodSandbox", varargs...)
	ret0, _ := ret[0].(*v1alpha2.RemovePodSandboxResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReopenContainerLog mocks base method
// nolint
func (m *MockRuntimeServiceClient) ReopenContainerLog(arg0 context.Context, arg1 *v1alpha2.ReopenContainerLogRequest, arg2 ...grpc.CallOption) (*v1alpha2.ReopenContainerLogResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReopenContainerLog", varargs...)
	ret0, _ := ret[0].(*v1alpha2.ReopenContainerLogResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RunPodSandbox mocks base method
// nolint
func (m *MockRuntimeServiceClient) RunPodSandbox(arg0 context.Context, arg1 *v1alpha2.RunPodSandboxRequest, arg2 ...grpc.CallOption) (*v1alpha2.RunPodSandboxResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunPodSandbox", varargs...)
	ret0, _ := ret[0].(*v1alpha2.RunPodSandboxResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartContainer mocks base method
// nolint
func (m *MockRuntimeServiceClient) StartContainer(arg0 context.Context, arg1 *v1alpha2.StartContainerRequest, arg2 ...grpc.CallOption) (*v1alpha2.StartContainerResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartContainer", varargs...)
	ret0, _ := ret[0].(*v1alpha2.StartContainerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Status mocks base method
// nolint
func (m *MockRuntimeServiceClient) Status(arg0 context.Context, arg1 *v1alpha2.StatusRequest, arg2 ...grpc.CallOption) (*v1alpha2.StatusResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Status", varargs...)
	ret0, _ := ret[0].(*v1alpha2.StatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopContainer mocks base method
// nolint
func (m *MockRuntimeServiceClient) StopContainer(arg0 context.Context, arg1 *v1alpha2.StopContainerRequest, arg2 ...grpc.CallOption) (*v1alpha2.StopContainerResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopContainer", varargs...)
	ret0, _ := ret[0].(*v1alpha2.StopContainerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopPodSandbox mocks base method
// nolint
func (m *MockRuntimeServiceClient) StopPodSandbox(arg0 context.Context, arg1 *v1alpha2.StopPodSandboxRequest, arg2 ...grpc.CallOption) (*v1alpha2.StopPodSandboxResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopPodSandbox", varargs...)
	ret0, _ := ret[0].(*v1alpha2.StopPodSandboxResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateContainerResources mocks base method
// nolint
func (m *MockRuntimeServiceClient) UpdateContainerResources(arg0 context.Context, arg1 *v1alpha2.UpdateContainerResourcesRequest, arg2 ...grpc.CallOption) (*v1alpha2.UpdateContainerResourcesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateContainerResources", varargs...)
	ret0, _ := ret[0].(*v1alpha2.UpdateContainerResourcesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateRuntimeConfig mocks base method
// nolint
func (m *MockRuntimeServiceClient) UpdateRuntimeConfig(arg0 context.Context, arg1 *v1alpha2.UpdateRuntimeConfigRequest, arg2 ...grpc.CallOption) (*v1alpha2.UpdateRuntimeConfigResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateRuntimeConfig", varargs...)
	ret0, _ := ret[0].(*v1alpha2.UpdateRuntimeConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Version mocks base method
// nolint
func (m *MockRuntimeServiceClient) Version(arg0 context.Context, arg1 *v1alpha2.VersionRequest, arg2 ...grpc.CallOption) (*v1alpha2.VersionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Version", varargs...)
	ret0, _ := ret[0].(*v1alpha2.VersionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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