// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/containerd/containerd/api/services/tasks/v1 (interfaces: TasksClient)

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

import (
	context "context"
	reflect "reflect"

	tasks "github.com/containerd/containerd/api/services/tasks/v1"
	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// MockTasksClient is a mock of TasksClient interface.
type MockTasksClient struct {
	ctrl     *gomock.Controller
	recorder *MockTasksClientMockRecorder
}

// MockTasksClientMockRecorder is the mock recorder for MockTasksClient.
type MockTasksClientMockRecorder struct {
	mock *MockTasksClient
}

// NewMockTasksClient creates a new mock instance.
func NewMockTasksClient(ctrl *gomock.Controller) *MockTasksClient {
	mock := &MockTasksClient{ctrl: ctrl}
	mock.recorder = &MockTasksClientMockRecorder{mock}
	return mock
}

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

// Checkpoint mocks base method.
func (m *MockTasksClient) Checkpoint(arg0 context.Context, arg1 *tasks.CheckpointTaskRequest, arg2 ...grpc.CallOption) (*tasks.CheckpointTaskResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Checkpoint", varargs...)
	ret0, _ := ret[0].(*tasks.CheckpointTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Checkpoint indicates an expected call of Checkpoint.
func (mr *MockTasksClientMockRecorder) Checkpoint(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, "Checkpoint", reflect.TypeOf((*MockTasksClient)(nil).Checkpoint), varargs...)
}

// CloseIO mocks base method.
func (m *MockTasksClient) CloseIO(arg0 context.Context, arg1 *tasks.CloseIORequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CloseIO", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CloseIO indicates an expected call of CloseIO.
func (mr *MockTasksClientMockRecorder) CloseIO(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, "CloseIO", reflect.TypeOf((*MockTasksClient)(nil).CloseIO), varargs...)
}

// Create mocks base method.
func (m *MockTasksClient) Create(arg0 context.Context, arg1 *tasks.CreateTaskRequest, arg2 ...grpc.CallOption) (*tasks.CreateTaskResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Create", varargs...)
	ret0, _ := ret[0].(*tasks.CreateTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockTasksClientMockRecorder) Create(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, "Create", reflect.TypeOf((*MockTasksClient)(nil).Create), varargs...)
}

// Delete mocks base method.
func (m *MockTasksClient) Delete(arg0 context.Context, arg1 *tasks.DeleteTaskRequest, arg2 ...grpc.CallOption) (*tasks.DeleteResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Delete", varargs...)
	ret0, _ := ret[0].(*tasks.DeleteResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockTasksClientMockRecorder) Delete(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, "Delete", reflect.TypeOf((*MockTasksClient)(nil).Delete), varargs...)
}

// DeleteProcess mocks base method.
func (m *MockTasksClient) DeleteProcess(arg0 context.Context, arg1 *tasks.DeleteProcessRequest, arg2 ...grpc.CallOption) (*tasks.DeleteResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteProcess", varargs...)
	ret0, _ := ret[0].(*tasks.DeleteResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteProcess indicates an expected call of DeleteProcess.
func (mr *MockTasksClientMockRecorder) DeleteProcess(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, "DeleteProcess", reflect.TypeOf((*MockTasksClient)(nil).DeleteProcess), varargs...)
}

// Exec mocks base method.
func (m *MockTasksClient) Exec(arg0 context.Context, arg1 *tasks.ExecProcessRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, 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].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Exec indicates an expected call of Exec.
func (mr *MockTasksClientMockRecorder) 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((*MockTasksClient)(nil).Exec), varargs...)
}

// Get mocks base method.
func (m *MockTasksClient) Get(arg0 context.Context, arg1 *tasks.GetRequest, arg2 ...grpc.CallOption) (*tasks.GetResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Get", varargs...)
	ret0, _ := ret[0].(*tasks.GetResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockTasksClientMockRecorder) Get(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, "Get", reflect.TypeOf((*MockTasksClient)(nil).Get), varargs...)
}

// Kill mocks base method.
func (m *MockTasksClient) Kill(arg0 context.Context, arg1 *tasks.KillRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Kill", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Kill indicates an expected call of Kill.
func (mr *MockTasksClientMockRecorder) Kill(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, "Kill", reflect.TypeOf((*MockTasksClient)(nil).Kill), varargs...)
}

// List mocks base method.
func (m *MockTasksClient) List(arg0 context.Context, arg1 *tasks.ListTasksRequest, arg2 ...grpc.CallOption) (*tasks.ListTasksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "List", varargs...)
	ret0, _ := ret[0].(*tasks.ListTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockTasksClientMockRecorder) List(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, "List", reflect.TypeOf((*MockTasksClient)(nil).List), varargs...)
}

// ListPids mocks base method.
func (m *MockTasksClient) ListPids(arg0 context.Context, arg1 *tasks.ListPidsRequest, arg2 ...grpc.CallOption) (*tasks.ListPidsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPids", varargs...)
	ret0, _ := ret[0].(*tasks.ListPidsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPids indicates an expected call of ListPids.
func (mr *MockTasksClientMockRecorder) ListPids(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, "ListPids", reflect.TypeOf((*MockTasksClient)(nil).ListPids), varargs...)
}

// Metrics mocks base method.
func (m *MockTasksClient) Metrics(arg0 context.Context, arg1 *tasks.MetricsRequest, arg2 ...grpc.CallOption) (*tasks.MetricsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Metrics", varargs...)
	ret0, _ := ret[0].(*tasks.MetricsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Metrics indicates an expected call of Metrics.
func (mr *MockTasksClientMockRecorder) Metrics(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, "Metrics", reflect.TypeOf((*MockTasksClient)(nil).Metrics), varargs...)
}

// Pause mocks base method.
func (m *MockTasksClient) Pause(arg0 context.Context, arg1 *tasks.PauseTaskRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Pause", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Pause indicates an expected call of Pause.
func (mr *MockTasksClientMockRecorder) Pause(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, "Pause", reflect.TypeOf((*MockTasksClient)(nil).Pause), varargs...)
}

// ResizePty mocks base method.
func (m *MockTasksClient) ResizePty(arg0 context.Context, arg1 *tasks.ResizePtyRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResizePty", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResizePty indicates an expected call of ResizePty.
func (mr *MockTasksClientMockRecorder) ResizePty(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, "ResizePty", reflect.TypeOf((*MockTasksClient)(nil).ResizePty), varargs...)
}

// Resume mocks base method.
func (m *MockTasksClient) Resume(arg0 context.Context, arg1 *tasks.ResumeTaskRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Resume", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Resume indicates an expected call of Resume.
func (mr *MockTasksClientMockRecorder) Resume(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, "Resume", reflect.TypeOf((*MockTasksClient)(nil).Resume), varargs...)
}

// Start mocks base method.
func (m *MockTasksClient) Start(arg0 context.Context, arg1 *tasks.StartRequest, arg2 ...grpc.CallOption) (*tasks.StartResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Start", varargs...)
	ret0, _ := ret[0].(*tasks.StartResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Start indicates an expected call of Start.
func (mr *MockTasksClientMockRecorder) Start(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, "Start", reflect.TypeOf((*MockTasksClient)(nil).Start), varargs...)
}

// Update mocks base method.
func (m *MockTasksClient) Update(arg0 context.Context, arg1 *tasks.UpdateTaskRequest, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Update", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update.
func (mr *MockTasksClientMockRecorder) Update(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, "Update", reflect.TypeOf((*MockTasksClient)(nil).Update), varargs...)
}

// Wait mocks base method.
func (m *MockTasksClient) Wait(arg0 context.Context, arg1 *tasks.WaitRequest, arg2 ...grpc.CallOption) (*tasks.WaitResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Wait", varargs...)
	ret0, _ := ret[0].(*tasks.WaitResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Wait indicates an expected call of Wait.
func (mr *MockTasksClientMockRecorder) Wait(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, "Wait", reflect.TypeOf((*MockTasksClient)(nil).Wait), varargs...)
}