github.com/chenbh/concourse/v6@v6.4.2/worker/runtime/libcontainerd/libcontainerdfakes/fake_process.go

// Code generated by counterfeiter. DO NOT EDIT.
package libcontainerdfakes

import (
	"context"
	"sync"
	"syscall"

	"github.com/containerd/containerd"
	"github.com/containerd/containerd/cio"
)

type FakeProcess struct {
	CloseIOStub        func(context.Context, ...containerd.IOCloserOpts) error
	closeIOMutex       sync.RWMutex
	closeIOArgsForCall []struct {
		arg1 context.Context
		arg2 []containerd.IOCloserOpts
	}
	closeIOReturns struct {
		result1 error
	}
	closeIOReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteStub        func(context.Context, ...containerd.ProcessDeleteOpts) (*containerd.ExitStatus, error)
	deleteMutex       sync.RWMutex
	deleteArgsForCall []struct {
		arg1 context.Context
		arg2 []containerd.ProcessDeleteOpts
	}
	deleteReturns struct {
		result1 *containerd.ExitStatus
		result2 error
	}
	deleteReturnsOnCall map[int]struct {
		result1 *containerd.ExitStatus
		result2 error
	}
	IDStub        func() string
	iDMutex       sync.RWMutex
	iDArgsForCall []struct {
	}
	iDReturns struct {
		result1 string
	}
	iDReturnsOnCall map[int]struct {
		result1 string
	}
	IOStub        func() cio.IO
	iOMutex       sync.RWMutex
	iOArgsForCall []struct {
	}
	iOReturns struct {
		result1 cio.IO
	}
	iOReturnsOnCall map[int]struct {
		result1 cio.IO
	}
	KillStub        func(context.Context, syscall.Signal, ...containerd.KillOpts) error
	killMutex       sync.RWMutex
	killArgsForCall []struct {
		arg1 context.Context
		arg2 syscall.Signal
		arg3 []containerd.KillOpts
	}
	killReturns struct {
		result1 error
	}
	killReturnsOnCall map[int]struct {
		result1 error
	}
	PidStub        func() uint32
	pidMutex       sync.RWMutex
	pidArgsForCall []struct {
	}
	pidReturns struct {
		result1 uint32
	}
	pidReturnsOnCall map[int]struct {
		result1 uint32
	}
	ResizeStub        func(context.Context, uint32, uint32) error
	resizeMutex       sync.RWMutex
	resizeArgsForCall []struct {
		arg1 context.Context
		arg2 uint32
		arg3 uint32
	}
	resizeReturns struct {
		result1 error
	}
	resizeReturnsOnCall map[int]struct {
		result1 error
	}
	StartStub        func(context.Context) error
	startMutex       sync.RWMutex
	startArgsForCall []struct {
		arg1 context.Context
	}
	startReturns struct {
		result1 error
	}
	startReturnsOnCall map[int]struct {
		result1 error
	}
	StatusStub        func(context.Context) (containerd.Status, error)
	statusMutex       sync.RWMutex
	statusArgsForCall []struct {
		arg1 context.Context
	}
	statusReturns struct {
		result1 containerd.Status
		result2 error
	}
	statusReturnsOnCall map[int]struct {
		result1 containerd.Status
		result2 error
	}
	WaitStub        func(context.Context) (<-chan containerd.ExitStatus, error)
	waitMutex       sync.RWMutex
	waitArgsForCall []struct {
		arg1 context.Context
	}
	waitReturns struct {
		result1 <-chan containerd.ExitStatus
		result2 error
	}
	waitReturnsOnCall map[int]struct {
		result1 <-chan containerd.ExitStatus
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeProcess) CloseIO(arg1 context.Context, arg2 ...containerd.IOCloserOpts) error {
	fake.closeIOMutex.Lock()
	ret, specificReturn := fake.closeIOReturnsOnCall[len(fake.closeIOArgsForCall)]
	fake.closeIOArgsForCall = append(fake.closeIOArgsForCall, struct {
		arg1 context.Context
		arg2 []containerd.IOCloserOpts
	}{arg1, arg2})
	fake.recordInvocation("CloseIO", []interface{}{arg1, arg2})
	fake.closeIOMutex.Unlock()
	if fake.CloseIOStub != nil {
		return fake.CloseIOStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.closeIOReturns
	return fakeReturns.result1
}

func (fake *FakeProcess) CloseIOCallCount() int {
	fake.closeIOMutex.RLock()
	defer fake.closeIOMutex.RUnlock()
	return len(fake.closeIOArgsForCall)
}

func (fake *FakeProcess) CloseIOCalls(stub func(context.Context, ...containerd.IOCloserOpts) error) {
	fake.closeIOMutex.Lock()
	defer fake.closeIOMutex.Unlock()
	fake.CloseIOStub = stub
}

func (fake *FakeProcess) CloseIOArgsForCall(i int) (context.Context, []containerd.IOCloserOpts) {
	fake.closeIOMutex.RLock()
	defer fake.closeIOMutex.RUnlock()
	argsForCall := fake.closeIOArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeProcess) CloseIOReturns(result1 error) {
	fake.closeIOMutex.Lock()
	defer fake.closeIOMutex.Unlock()
	fake.CloseIOStub = nil
	fake.closeIOReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeProcess) CloseIOReturnsOnCall(i int, result1 error) {
	fake.closeIOMutex.Lock()
	defer fake.closeIOMutex.Unlock()
	fake.CloseIOStub = nil
	if fake.closeIOReturnsOnCall == nil {
		fake.closeIOReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.closeIOReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeProcess) Delete(arg1 context.Context, arg2 ...containerd.ProcessDeleteOpts) (*containerd.ExitStatus, error) {
	fake.deleteMutex.Lock()
	ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)]
	fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct {
		arg1 context.Context
		arg2 []containerd.ProcessDeleteOpts
	}{arg1, arg2})
	fake.recordInvocation("Delete", []interface{}{arg1, arg2})
	fake.deleteMutex.Unlock()
	if fake.DeleteStub != nil {
		return fake.DeleteStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeProcess) DeleteCallCount() int {
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	return len(fake.deleteArgsForCall)
}

func (fake *FakeProcess) DeleteCalls(stub func(context.Context, ...containerd.ProcessDeleteOpts) (*containerd.ExitStatus, error)) {
	fake.deleteMutex.Lock()
	defer fake.deleteMutex.Unlock()
	fake.DeleteStub = stub
}

func (fake *FakeProcess) DeleteArgsForCall(i int) (context.Context, []containerd.ProcessDeleteOpts) {
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	argsForCall := fake.deleteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeProcess) DeleteReturns(result1 *containerd.ExitStatus, result2 error) {
	fake.deleteMutex.Lock()
	defer fake.deleteMutex.Unlock()
	fake.DeleteStub = nil
	fake.deleteReturns = struct {
		result1 *containerd.ExitStatus
		result2 error
	}{result1, result2}
}

func (fake *FakeProcess) DeleteReturnsOnCall(i int, result1 *containerd.ExitStatus, result2 error) {
	fake.deleteMutex.Lock()
	defer fake.deleteMutex.Unlock()
	fake.DeleteStub = nil
	if fake.deleteReturnsOnCall == nil {
		fake.deleteReturnsOnCall = make(map[int]struct {
			result1 *containerd.ExitStatus
			result2 error
		})
	}
	fake.deleteReturnsOnCall[i] = struct {
		result1 *containerd.ExitStatus
		result2 error
	}{result1, result2}
}

func (fake *FakeProcess) ID() string {
	fake.iDMutex.Lock()
	ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)]
	fake.iDArgsForCall = append(fake.iDArgsForCall, struct {
	}{})
	fake.recordInvocation("ID", []interface{}{})
	fake.iDMutex.Unlock()
	if fake.IDStub != nil {
		return fake.IDStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.iDReturns
	return fakeReturns.result1
}

func (fake *FakeProcess) IDCallCount() int {
	fake.iDMutex.RLock()
	defer fake.iDMutex.RUnlock()
	return len(fake.iDArgsForCall)
}

func (fake *FakeProcess) IDCalls(stub func() string) {
	fake.iDMutex.Lock()
	defer fake.iDMutex.Unlock()
	fake.IDStub = stub
}

func (fake *FakeProcess) IDReturns(result1 string) {
	fake.iDMutex.Lock()
	defer fake.iDMutex.Unlock()
	fake.IDStub = nil
	fake.iDReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeProcess) IDReturnsOnCall(i int, result1 string) {
	fake.iDMutex.Lock()
	defer fake.iDMutex.Unlock()
	fake.IDStub = nil
	if fake.iDReturnsOnCall == nil {
		fake.iDReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.iDReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeProcess) IO() cio.IO {
	fake.iOMutex.Lock()
	ret, specificReturn := fake.iOReturnsOnCall[len(fake.iOArgsForCall)]
	fake.iOArgsForCall = append(fake.iOArgsForCall, struct {
	}{})
	fake.recordInvocation("IO", []interface{}{})
	fake.iOMutex.Unlock()
	if fake.IOStub != nil {
		return fake.IOStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.iOReturns
	return fakeReturns.result1
}

func (fake *FakeProcess) IOCallCount() int {
	fake.iOMutex.RLock()
	defer fake.iOMutex.RUnlock()
	return len(fake.iOArgsForCall)
}

func (fake *FakeProcess) IOCalls(stub func() cio.IO) {
	fake.iOMutex.Lock()
	defer fake.iOMutex.Unlock()
	fake.IOStub = stub
}

func (fake *FakeProcess) IOReturns(result1 cio.IO) {
	fake.iOMutex.Lock()
	defer fake.iOMutex.Unlock()
	fake.IOStub = nil
	fake.iOReturns = struct {
		result1 cio.IO
	}{result1}
}

func (fake *FakeProcess) IOReturnsOnCall(i int, result1 cio.IO) {
	fake.iOMutex.Lock()
	defer fake.iOMutex.Unlock()
	fake.IOStub = nil
	if fake.iOReturnsOnCall == nil {
		fake.iOReturnsOnCall = make(map[int]struct {
			result1 cio.IO
		})
	}
	fake.iOReturnsOnCall[i] = struct {
		result1 cio.IO
	}{result1}
}

func (fake *FakeProcess) Kill(arg1 context.Context, arg2 syscall.Signal, arg3 ...containerd.KillOpts) error {
	fake.killMutex.Lock()
	ret, specificReturn := fake.killReturnsOnCall[len(fake.killArgsForCall)]
	fake.killArgsForCall = append(fake.killArgsForCall, struct {
		arg1 context.Context
		arg2 syscall.Signal
		arg3 []containerd.KillOpts
	}{arg1, arg2, arg3})
	fake.recordInvocation("Kill", []interface{}{arg1, arg2, arg3})
	fake.killMutex.Unlock()
	if fake.KillStub != nil {
		return fake.KillStub(arg1, arg2, arg3...)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.killReturns
	return fakeReturns.result1
}

func (fake *FakeProcess) KillCallCount() int {
	fake.killMutex.RLock()
	defer fake.killMutex.RUnlock()
	return len(fake.killArgsForCall)
}

func (fake *FakeProcess) KillCalls(stub func(context.Context, syscall.Signal, ...containerd.KillOpts) error) {
	fake.killMutex.Lock()
	defer fake.killMutex.Unlock()
	fake.KillStub = stub
}

func (fake *FakeProcess) KillArgsForCall(i int) (context.Context, syscall.Signal, []containerd.KillOpts) {
	fake.killMutex.RLock()
	defer fake.killMutex.RUnlock()
	argsForCall := fake.killArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeProcess) KillReturns(result1 error) {
	fake.killMutex.Lock()
	defer fake.killMutex.Unlock()
	fake.KillStub = nil
	fake.killReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeProcess) KillReturnsOnCall(i int, result1 error) {
	fake.killMutex.Lock()
	defer fake.killMutex.Unlock()
	fake.KillStub = nil
	if fake.killReturnsOnCall == nil {
		fake.killReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.killReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeProcess) Pid() uint32 {
	fake.pidMutex.Lock()
	ret, specificReturn := fake.pidReturnsOnCall[len(fake.pidArgsForCall)]
	fake.pidArgsForCall = append(fake.pidArgsForCall, struct {
	}{})
	fake.recordInvocation("Pid", []interface{}{})
	fake.pidMutex.Unlock()
	if fake.PidStub != nil {
		return fake.PidStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.pidReturns
	return fakeReturns.result1
}

func (fake *FakeProcess) PidCallCount() int {
	fake.pidMutex.RLock()
	defer fake.pidMutex.RUnlock()
	return len(fake.pidArgsForCall)
}

func (fake *FakeProcess) PidCalls(stub func() uint32) {
	fake.pidMutex.Lock()
	defer fake.pidMutex.Unlock()
	fake.PidStub = stub
}

func (fake *FakeProcess) PidReturns(result1 uint32) {
	fake.pidMutex.Lock()
	defer fake.pidMutex.Unlock()
	fake.PidStub = nil
	fake.pidReturns = struct {
		result1 uint32
	}{result1}
}

func (fake *FakeProcess) PidReturnsOnCall(i int, result1 uint32) {
	fake.pidMutex.Lock()
	defer fake.pidMutex.Unlock()
	fake.PidStub = nil
	if fake.pidReturnsOnCall == nil {
		fake.pidReturnsOnCall = make(map[int]struct {
			result1 uint32
		})
	}
	fake.pidReturnsOnCall[i] = struct {
		result1 uint32
	}{result1}
}

func (fake *FakeProcess) Resize(arg1 context.Context, arg2 uint32, arg3 uint32) error {
	fake.resizeMutex.Lock()
	ret, specificReturn := fake.resizeReturnsOnCall[len(fake.resizeArgsForCall)]
	fake.resizeArgsForCall = append(fake.resizeArgsForCall, struct {
		arg1 context.Context
		arg2 uint32
		arg3 uint32
	}{arg1, arg2, arg3})
	fake.recordInvocation("Resize", []interface{}{arg1, arg2, arg3})
	fake.resizeMutex.Unlock()
	if fake.ResizeStub != nil {
		return fake.ResizeStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.resizeReturns
	return fakeReturns.result1
}

func (fake *FakeProcess) ResizeCallCount() int {
	fake.resizeMutex.RLock()
	defer fake.resizeMutex.RUnlock()
	return len(fake.resizeArgsForCall)
}

func (fake *FakeProcess) ResizeCalls(stub func(context.Context, uint32, uint32) error) {
	fake.resizeMutex.Lock()
	defer fake.resizeMutex.Unlock()
	fake.ResizeStub = stub
}

func (fake *FakeProcess) ResizeArgsForCall(i int) (context.Context, uint32, uint32) {
	fake.resizeMutex.RLock()
	defer fake.resizeMutex.RUnlock()
	argsForCall := fake.resizeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeProcess) ResizeReturns(result1 error) {
	fake.resizeMutex.Lock()
	defer fake.resizeMutex.Unlock()
	fake.ResizeStub = nil
	fake.resizeReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeProcess) ResizeReturnsOnCall(i int, result1 error) {
	fake.resizeMutex.Lock()
	defer fake.resizeMutex.Unlock()
	fake.ResizeStub = nil
	if fake.resizeReturnsOnCall == nil {
		fake.resizeReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.resizeReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeProcess) Start(arg1 context.Context) error {
	fake.startMutex.Lock()
	ret, specificReturn := fake.startReturnsOnCall[len(fake.startArgsForCall)]
	fake.startArgsForCall = append(fake.startArgsForCall, struct {
		arg1 context.Context
	}{arg1})
	fake.recordInvocation("Start", []interface{}{arg1})
	fake.startMutex.Unlock()
	if fake.StartStub != nil {
		return fake.StartStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.startReturns
	return fakeReturns.result1
}

func (fake *FakeProcess) StartCallCount() int {
	fake.startMutex.RLock()
	defer fake.startMutex.RUnlock()
	return len(fake.startArgsForCall)
}

func (fake *FakeProcess) StartCalls(stub func(context.Context) error) {
	fake.startMutex.Lock()
	defer fake.startMutex.Unlock()
	fake.StartStub = stub
}

func (fake *FakeProcess) StartArgsForCall(i int) context.Context {
	fake.startMutex.RLock()
	defer fake.startMutex.RUnlock()
	argsForCall := fake.startArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeProcess) StartReturns(result1 error) {
	fake.startMutex.Lock()
	defer fake.startMutex.Unlock()
	fake.StartStub = nil
	fake.startReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeProcess) StartReturnsOnCall(i int, result1 error) {
	fake.startMutex.Lock()
	defer fake.startMutex.Unlock()
	fake.StartStub = nil
	if fake.startReturnsOnCall == nil {
		fake.startReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.startReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeProcess) Status(arg1 context.Context) (containerd.Status, error) {
	fake.statusMutex.Lock()
	ret, specificReturn := fake.statusReturnsOnCall[len(fake.statusArgsForCall)]
	fake.statusArgsForCall = append(fake.statusArgsForCall, struct {
		arg1 context.Context
	}{arg1})
	fake.recordInvocation("Status", []interface{}{arg1})
	fake.statusMutex.Unlock()
	if fake.StatusStub != nil {
		return fake.StatusStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.statusReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeProcess) StatusCallCount() int {
	fake.statusMutex.RLock()
	defer fake.statusMutex.RUnlock()
	return len(fake.statusArgsForCall)
}

func (fake *FakeProcess) StatusCalls(stub func(context.Context) (containerd.Status, error)) {
	fake.statusMutex.Lock()
	defer fake.statusMutex.Unlock()
	fake.StatusStub = stub
}

func (fake *FakeProcess) StatusArgsForCall(i int) context.Context {
	fake.statusMutex.RLock()
	defer fake.statusMutex.RUnlock()
	argsForCall := fake.statusArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeProcess) StatusReturns(result1 containerd.Status, result2 error) {
	fake.statusMutex.Lock()
	defer fake.statusMutex.Unlock()
	fake.StatusStub = nil
	fake.statusReturns = struct {
		result1 containerd.Status
		result2 error
	}{result1, result2}
}

func (fake *FakeProcess) StatusReturnsOnCall(i int, result1 containerd.Status, result2 error) {
	fake.statusMutex.Lock()
	defer fake.statusMutex.Unlock()
	fake.StatusStub = nil
	if fake.statusReturnsOnCall == nil {
		fake.statusReturnsOnCall = make(map[int]struct {
			result1 containerd.Status
			result2 error
		})
	}
	fake.statusReturnsOnCall[i] = struct {
		result1 containerd.Status
		result2 error
	}{result1, result2}
}

func (fake *FakeProcess) Wait(arg1 context.Context) (<-chan containerd.ExitStatus, error) {
	fake.waitMutex.Lock()
	ret, specificReturn := fake.waitReturnsOnCall[len(fake.waitArgsForCall)]
	fake.waitArgsForCall = append(fake.waitArgsForCall, struct {
		arg1 context.Context
	}{arg1})
	fake.recordInvocation("Wait", []interface{}{arg1})
	fake.waitMutex.Unlock()
	if fake.WaitStub != nil {
		return fake.WaitStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.waitReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeProcess) WaitCallCount() int {
	fake.waitMutex.RLock()
	defer fake.waitMutex.RUnlock()
	return len(fake.waitArgsForCall)
}

func (fake *FakeProcess) WaitCalls(stub func(context.Context) (<-chan containerd.ExitStatus, error)) {
	fake.waitMutex.Lock()
	defer fake.waitMutex.Unlock()
	fake.WaitStub = stub
}

func (fake *FakeProcess) WaitArgsForCall(i int) context.Context {
	fake.waitMutex.RLock()
	defer fake.waitMutex.RUnlock()
	argsForCall := fake.waitArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeProcess) WaitReturns(result1 <-chan containerd.ExitStatus, result2 error) {
	fake.waitMutex.Lock()
	defer fake.waitMutex.Unlock()
	fake.WaitStub = nil
	fake.waitReturns = struct {
		result1 <-chan containerd.ExitStatus
		result2 error
	}{result1, result2}
}

func (fake *FakeProcess) WaitReturnsOnCall(i int, result1 <-chan containerd.ExitStatus, result2 error) {
	fake.waitMutex.Lock()
	defer fake.waitMutex.Unlock()
	fake.WaitStub = nil
	if fake.waitReturnsOnCall == nil {
		fake.waitReturnsOnCall = make(map[int]struct {
			result1 <-chan containerd.ExitStatus
			result2 error
		})
	}
	fake.waitReturnsOnCall[i] = struct {
		result1 <-chan containerd.ExitStatus
		result2 error
	}{result1, result2}
}

func (fake *FakeProcess) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.closeIOMutex.RLock()
	defer fake.closeIOMutex.RUnlock()
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	fake.iDMutex.RLock()
	defer fake.iDMutex.RUnlock()
	fake.iOMutex.RLock()
	defer fake.iOMutex.RUnlock()
	fake.killMutex.RLock()
	defer fake.killMutex.RUnlock()
	fake.pidMutex.RLock()
	defer fake.pidMutex.RUnlock()
	fake.resizeMutex.RLock()
	defer fake.resizeMutex.RUnlock()
	fake.startMutex.RLock()
	defer fake.startMutex.RUnlock()
	fake.statusMutex.RLock()
	defer fake.statusMutex.RUnlock()
	fake.waitMutex.RLock()
	defer fake.waitMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeProcess) recordInvocation(key string, args []interface{}) {
	fake.invocationsMutex.Lock()
	defer fake.invocationsMutex.Unlock()
	if fake.invocations == nil {
		fake.invocations = map[string][][]interface{}{}
	}
	if fake.invocations[key] == nil {
		fake.invocations[key] = [][]interface{}{}
	}
	fake.invocations[key] = append(fake.invocations[key], args)
}

var _ containerd.Process = new(FakeProcess)