// Code generated by MockGen. DO NOT EDIT. // Source: k8s.io/cri-api/pkg/apis/runtime/v1 (interfaces: RuntimeServiceClient) // Package mocks is a generated GoMock package. package mocks import ( context "context" reflect "reflect" gomock "github.com/golang/mock/gomock" grpc "google.golang.org/grpc" v1 "k8s.io/cri-api/pkg/apis/runtime/v1" ) // MockRuntimeServiceClient is a mock of RuntimeServiceClient interface. type MockRuntimeServiceClient struct { ctrl *gomock.Controller recorder *MockRuntimeServiceClientMockRecorder } // MockRuntimeServiceClientMockRecorder is the mock recorder for MockRuntimeServiceClient. type MockRuntimeServiceClientMockRecorder struct { mock *MockRuntimeServiceClient } // NewMockRuntimeServiceClient creates a new mock instance. 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. func (m *MockRuntimeServiceClient) EXPECT() *MockRuntimeServiceClientMockRecorder { return m.recorder } // Attach mocks base method. func (m *MockRuntimeServiceClient) Attach(arg0 context.Context, arg1 *v1.AttachRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.AttachResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // Attach indicates an expected call of Attach. 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...) } // CheckpointContainer mocks base method. func (m *MockRuntimeServiceClient) CheckpointContainer(arg0 context.Context, arg1 *v1.CheckpointContainerRequest, arg2 ...grpc.CallOption) (*v1.CheckpointContainerResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CheckpointContainer", varargs...) ret0, _ := ret[0].(*v1.CheckpointContainerResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // CheckpointContainer indicates an expected call of CheckpointContainer. func (mr *MockRuntimeServiceClientMockRecorder) CheckpointContainer(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, "CheckpointContainer", reflect.TypeOf((*MockRuntimeServiceClient)(nil).CheckpointContainer), varargs...) } // ContainerStats mocks base method. func (m *MockRuntimeServiceClient) ContainerStats(arg0 context.Context, arg1 *v1.ContainerStatsRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.ContainerStatsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ContainerStats indicates an expected call of ContainerStats. 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. func (m *MockRuntimeServiceClient) ContainerStatus(arg0 context.Context, arg1 *v1.ContainerStatusRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.ContainerStatusResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ContainerStatus indicates an expected call of ContainerStatus. 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. func (m *MockRuntimeServiceClient) CreateContainer(arg0 context.Context, arg1 *v1.CreateContainerRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.CreateContainerResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateContainer indicates an expected call of CreateContainer. 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. func (m *MockRuntimeServiceClient) Exec(arg0 context.Context, arg1 *v1.ExecRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.ExecResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // Exec indicates an expected call of Exec. 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. func (m *MockRuntimeServiceClient) ExecSync(arg0 context.Context, arg1 *v1.ExecSyncRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.ExecSyncResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ExecSync indicates an expected call of ExecSync. 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...) } // GetContainerEvents mocks base method. func (m *MockRuntimeServiceClient) GetContainerEvents(arg0 context.Context, arg1 *v1.GetEventsRequest, arg2 ...grpc.CallOption) (v1.RuntimeService_GetContainerEventsClient, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetContainerEvents", varargs...) ret0, _ := ret[0].(v1.RuntimeService_GetContainerEventsClient) ret1, _ := ret[1].(error) return ret0, ret1 } // GetContainerEvents indicates an expected call of GetContainerEvents. func (mr *MockRuntimeServiceClientMockRecorder) GetContainerEvents(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, "GetContainerEvents", reflect.TypeOf((*MockRuntimeServiceClient)(nil).GetContainerEvents), varargs...) } // ListContainerStats mocks base method. func (m *MockRuntimeServiceClient) ListContainerStats(arg0 context.Context, arg1 *v1.ListContainerStatsRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.ListContainerStatsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ListContainerStats indicates an expected call of ListContainerStats. 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. func (m *MockRuntimeServiceClient) ListContainers(arg0 context.Context, arg1 *v1.ListContainersRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.ListContainersResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ListContainers indicates an expected call of ListContainers. 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...) } // ListMetricDescriptors mocks base method. func (m *MockRuntimeServiceClient) ListMetricDescriptors(arg0 context.Context, arg1 *v1.ListMetricDescriptorsRequest, arg2 ...grpc.CallOption) (*v1.ListMetricDescriptorsResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListMetricDescriptors", varargs...) ret0, _ := ret[0].(*v1.ListMetricDescriptorsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ListMetricDescriptors indicates an expected call of ListMetricDescriptors. func (mr *MockRuntimeServiceClientMockRecorder) ListMetricDescriptors(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, "ListMetricDescriptors", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ListMetricDescriptors), varargs...) } // ListPodSandbox mocks base method. func (m *MockRuntimeServiceClient) ListPodSandbox(arg0 context.Context, arg1 *v1.ListPodSandboxRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.ListPodSandboxResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ListPodSandbox indicates an expected call of ListPodSandbox. 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...) } // ListPodSandboxMetrics mocks base method. func (m *MockRuntimeServiceClient) ListPodSandboxMetrics(arg0 context.Context, arg1 *v1.ListPodSandboxMetricsRequest, arg2 ...grpc.CallOption) (*v1.ListPodSandboxMetricsResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListPodSandboxMetrics", varargs...) ret0, _ := ret[0].(*v1.ListPodSandboxMetricsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ListPodSandboxMetrics indicates an expected call of ListPodSandboxMetrics. func (mr *MockRuntimeServiceClientMockRecorder) ListPodSandboxMetrics(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, "ListPodSandboxMetrics", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ListPodSandboxMetrics), varargs...) } // ListPodSandboxStats mocks base method. func (m *MockRuntimeServiceClient) ListPodSandboxStats(arg0 context.Context, arg1 *v1.ListPodSandboxStatsRequest, arg2 ...grpc.CallOption) (*v1.ListPodSandboxStatsResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListPodSandboxStats", varargs...) ret0, _ := ret[0].(*v1.ListPodSandboxStatsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ListPodSandboxStats indicates an expected call of ListPodSandboxStats. func (mr *MockRuntimeServiceClientMockRecorder) ListPodSandboxStats(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, "ListPodSandboxStats", reflect.TypeOf((*MockRuntimeServiceClient)(nil).ListPodSandboxStats), varargs...) } // PodSandboxStats mocks base method. func (m *MockRuntimeServiceClient) PodSandboxStats(arg0 context.Context, arg1 *v1.PodSandboxStatsRequest, arg2 ...grpc.CallOption) (*v1.PodSandboxStatsResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "PodSandboxStats", varargs...) ret0, _ := ret[0].(*v1.PodSandboxStatsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // PodSandboxStats indicates an expected call of PodSandboxStats. func (mr *MockRuntimeServiceClientMockRecorder) PodSandboxStats(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, "PodSandboxStats", reflect.TypeOf((*MockRuntimeServiceClient)(nil).PodSandboxStats), varargs...) } // PodSandboxStatus mocks base method. func (m *MockRuntimeServiceClient) PodSandboxStatus(arg0 context.Context, arg1 *v1.PodSandboxStatusRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.PodSandboxStatusResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // PodSandboxStatus indicates an expected call of PodSandboxStatus. 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. func (m *MockRuntimeServiceClient) PortForward(arg0 context.Context, arg1 *v1.PortForwardRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.PortForwardResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // PortForward indicates an expected call of PortForward. 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. func (m *MockRuntimeServiceClient) RemoveContainer(arg0 context.Context, arg1 *v1.RemoveContainerRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.RemoveContainerResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // RemoveContainer indicates an expected call of RemoveContainer. 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. func (m *MockRuntimeServiceClient) RemovePodSandbox(arg0 context.Context, arg1 *v1.RemovePodSandboxRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.RemovePodSandboxResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // RemovePodSandbox indicates an expected call of RemovePodSandbox. 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. func (m *MockRuntimeServiceClient) ReopenContainerLog(arg0 context.Context, arg1 *v1.ReopenContainerLogRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.ReopenContainerLogResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ReopenContainerLog indicates an expected call of ReopenContainerLog. 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. func (m *MockRuntimeServiceClient) RunPodSandbox(arg0 context.Context, arg1 *v1.RunPodSandboxRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.RunPodSandboxResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // RunPodSandbox indicates an expected call of RunPodSandbox. 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...) } // RuntimeConfig mocks base method. func (m *MockRuntimeServiceClient) RuntimeConfig(arg0 context.Context, arg1 *v1.RuntimeConfigRequest, arg2 ...grpc.CallOption) (*v1.RuntimeConfigResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RuntimeConfig", varargs...) ret0, _ := ret[0].(*v1.RuntimeConfigResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // RuntimeConfig indicates an expected call of RuntimeConfig. func (mr *MockRuntimeServiceClientMockRecorder) RuntimeConfig(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, "RuntimeConfig", reflect.TypeOf((*MockRuntimeServiceClient)(nil).RuntimeConfig), varargs...) } // StartContainer mocks base method. func (m *MockRuntimeServiceClient) StartContainer(arg0 context.Context, arg1 *v1.StartContainerRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.StartContainerResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // StartContainer indicates an expected call of StartContainer. 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. func (m *MockRuntimeServiceClient) Status(arg0 context.Context, arg1 *v1.StatusRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.StatusResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // Status indicates an expected call of Status. 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. func (m *MockRuntimeServiceClient) StopContainer(arg0 context.Context, arg1 *v1.StopContainerRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.StopContainerResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // StopContainer indicates an expected call of StopContainer. 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. func (m *MockRuntimeServiceClient) StopPodSandbox(arg0 context.Context, arg1 *v1.StopPodSandboxRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.StopPodSandboxResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // StopPodSandbox indicates an expected call of StopPodSandbox. 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. func (m *MockRuntimeServiceClient) UpdateContainerResources(arg0 context.Context, arg1 *v1.UpdateContainerResourcesRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.UpdateContainerResourcesResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateContainerResources indicates an expected call of UpdateContainerResources. 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. func (m *MockRuntimeServiceClient) UpdateRuntimeConfig(arg0 context.Context, arg1 *v1.UpdateRuntimeConfigRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.UpdateRuntimeConfigResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateRuntimeConfig indicates an expected call of UpdateRuntimeConfig. 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. func (m *MockRuntimeServiceClient) Version(arg0 context.Context, arg1 *v1.VersionRequest, arg2 ...grpc.CallOption) (*v1.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].(*v1.VersionResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // Version indicates an expected call of Version. 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...) }