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

import (
	"io"
	"sync"

	"code.cloudfoundry.org/guardian/rundmc/runcontainerd"
	lager "code.cloudfoundry.org/lager/v3"
	"github.com/containerd/containerd/api/events"
	specs "github.com/opencontainers/runtime-spec/specs-go"
)

type FakeContainerManager struct {
	BundleIDsStub        func(...runcontainerd.ContainerFilter) ([]string, error)
	bundleIDsMutex       sync.RWMutex
	bundleIDsArgsForCall []struct {
		arg1 []runcontainerd.ContainerFilter
	}
	bundleIDsReturns struct {
		result1 []string
		result2 error
	}
	bundleIDsReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	CreateStub        func(lager.Logger, string, *specs.Spec, uint32, uint32, func() (io.Reader, io.Writer, io.Writer)) error
	createMutex       sync.RWMutex
	createArgsForCall []struct {
		arg1 lager.Logger
		arg2 string
		arg3 *specs.Spec
		arg4 uint32
		arg5 uint32
		arg6 func() (io.Reader, io.Writer, io.Writer)
	}
	createReturns struct {
		result1 error
	}
	createReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteStub        func(lager.Logger, string) error
	deleteMutex       sync.RWMutex
	deleteArgsForCall []struct {
		arg1 lager.Logger
		arg2 string
	}
	deleteReturns struct {
		result1 error
	}
	deleteReturnsOnCall map[int]struct {
		result1 error
	}
	ExecStub        func(lager.Logger, string, string, *specs.Process, func() (io.Reader, io.Writer, io.Writer, bool)) (runcontainerd.BackingProcess, error)
	execMutex       sync.RWMutex
	execArgsForCall []struct {
		arg1 lager.Logger
		arg2 string
		arg3 string
		arg4 *specs.Process
		arg5 func() (io.Reader, io.Writer, io.Writer, bool)
	}
	execReturns struct {
		result1 runcontainerd.BackingProcess
		result2 error
	}
	execReturnsOnCall map[int]struct {
		result1 runcontainerd.BackingProcess
		result2 error
	}
	GetContainerPIDStub        func(lager.Logger, string) (uint32, error)
	getContainerPIDMutex       sync.RWMutex
	getContainerPIDArgsForCall []struct {
		arg1 lager.Logger
		arg2 string
	}
	getContainerPIDReturns struct {
		result1 uint32
		result2 error
	}
	getContainerPIDReturnsOnCall map[int]struct {
		result1 uint32
		result2 error
	}
	OOMEventsStub        func(lager.Logger) <-chan *events.TaskOOM
	oOMEventsMutex       sync.RWMutex
	oOMEventsArgsForCall []struct {
		arg1 lager.Logger
	}
	oOMEventsReturns struct {
		result1 <-chan *events.TaskOOM
	}
	oOMEventsReturnsOnCall map[int]struct {
		result1 <-chan *events.TaskOOM
	}
	RemoveBundleStub        func(lager.Logger, string) error
	removeBundleMutex       sync.RWMutex
	removeBundleArgsForCall []struct {
		arg1 lager.Logger
		arg2 string
	}
	removeBundleReturns struct {
		result1 error
	}
	removeBundleReturnsOnCall map[int]struct {
		result1 error
	}
	SpecStub        func(lager.Logger, string) (*specs.Spec, error)
	specMutex       sync.RWMutex
	specArgsForCall []struct {
		arg1 lager.Logger
		arg2 string
	}
	specReturns struct {
		result1 *specs.Spec
		result2 error
	}
	specReturnsOnCall map[int]struct {
		result1 *specs.Spec
		result2 error
	}
	StateStub        func(lager.Logger, string) (int, string, error)
	stateMutex       sync.RWMutex
	stateArgsForCall []struct {
		arg1 lager.Logger
		arg2 string
	}
	stateReturns struct {
		result1 int
		result2 string
		result3 error
	}
	stateReturnsOnCall map[int]struct {
		result1 int
		result2 string
		result3 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeContainerManager) BundleIDs(arg1 ...runcontainerd.ContainerFilter) ([]string, error) {
	fake.bundleIDsMutex.Lock()
	ret, specificReturn := fake.bundleIDsReturnsOnCall[len(fake.bundleIDsArgsForCall)]
	fake.bundleIDsArgsForCall = append(fake.bundleIDsArgsForCall, struct {
		arg1 []runcontainerd.ContainerFilter
	}{arg1})
	stub := fake.BundleIDsStub
	fakeReturns := fake.bundleIDsReturns
	fake.recordInvocation("BundleIDs", []interface{}{arg1})
	fake.bundleIDsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerManager) BundleIDsCallCount() int {
	fake.bundleIDsMutex.RLock()
	defer fake.bundleIDsMutex.RUnlock()
	return len(fake.bundleIDsArgsForCall)
}

func (fake *FakeContainerManager) BundleIDsCalls(stub func(...runcontainerd.ContainerFilter) ([]string, error)) {
	fake.bundleIDsMutex.Lock()
	defer fake.bundleIDsMutex.Unlock()
	fake.BundleIDsStub = stub
}

func (fake *FakeContainerManager) BundleIDsArgsForCall(i int) []runcontainerd.ContainerFilter {
	fake.bundleIDsMutex.RLock()
	defer fake.bundleIDsMutex.RUnlock()
	argsForCall := fake.bundleIDsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerManager) BundleIDsReturns(result1 []string, result2 error) {
	fake.bundleIDsMutex.Lock()
	defer fake.bundleIDsMutex.Unlock()
	fake.BundleIDsStub = nil
	fake.bundleIDsReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerManager) BundleIDsReturnsOnCall(i int, result1 []string, result2 error) {
	fake.bundleIDsMutex.Lock()
	defer fake.bundleIDsMutex.Unlock()
	fake.BundleIDsStub = nil
	if fake.bundleIDsReturnsOnCall == nil {
		fake.bundleIDsReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.bundleIDsReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerManager) Create(arg1 lager.Logger, arg2 string, arg3 *specs.Spec, arg4 uint32, arg5 uint32, arg6 func() (io.Reader, io.Writer, io.Writer)) error {
	fake.createMutex.Lock()
	ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)]
	fake.createArgsForCall = append(fake.createArgsForCall, struct {
		arg1 lager.Logger
		arg2 string
		arg3 *specs.Spec
		arg4 uint32
		arg5 uint32
		arg6 func() (io.Reader, io.Writer, io.Writer)
	}{arg1, arg2, arg3, arg4, arg5, arg6})
	stub := fake.CreateStub
	fakeReturns := fake.createReturns
	fake.recordInvocation("Create", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
	fake.createMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5, arg6)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerManager) CreateCallCount() int {
	fake.createMutex.RLock()
	defer fake.createMutex.RUnlock()
	return len(fake.createArgsForCall)
}

func (fake *FakeContainerManager) CreateCalls(stub func(lager.Logger, string, *specs.Spec, uint32, uint32, func() (io.Reader, io.Writer, io.Writer)) error) {
	fake.createMutex.Lock()
	defer fake.createMutex.Unlock()
	fake.CreateStub = stub
}

func (fake *FakeContainerManager) CreateArgsForCall(i int) (lager.Logger, string, *specs.Spec, uint32, uint32, func() (io.Reader, io.Writer, io.Writer)) {
	fake.createMutex.RLock()
	defer fake.createMutex.RUnlock()
	argsForCall := fake.createArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6
}

func (fake *FakeContainerManager) CreateReturns(result1 error) {
	fake.createMutex.Lock()
	defer fake.createMutex.Unlock()
	fake.CreateStub = nil
	fake.createReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerManager) CreateReturnsOnCall(i int, result1 error) {
	fake.createMutex.Lock()
	defer fake.createMutex.Unlock()
	fake.CreateStub = nil
	if fake.createReturnsOnCall == nil {
		fake.createReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerManager) Delete(arg1 lager.Logger, arg2 string) error {
	fake.deleteMutex.Lock()
	ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)]
	fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct {
		arg1 lager.Logger
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteStub
	fakeReturns := fake.deleteReturns
	fake.recordInvocation("Delete", []interface{}{arg1, arg2})
	fake.deleteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

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

func (fake *FakeContainerManager) DeleteCalls(stub func(lager.Logger, string) error) {
	fake.deleteMutex.Lock()
	defer fake.deleteMutex.Unlock()
	fake.DeleteStub = stub
}

func (fake *FakeContainerManager) DeleteArgsForCall(i int) (lager.Logger, string) {
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	argsForCall := fake.deleteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerManager) DeleteReturns(result1 error) {
	fake.deleteMutex.Lock()
	defer fake.deleteMutex.Unlock()
	fake.DeleteStub = nil
	fake.deleteReturns = struct {
		result1 error
	}{result1}
}

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

func (fake *FakeContainerManager) Exec(arg1 lager.Logger, arg2 string, arg3 string, arg4 *specs.Process, arg5 func() (io.Reader, io.Writer, io.Writer, bool)) (runcontainerd.BackingProcess, error) {
	fake.execMutex.Lock()
	ret, specificReturn := fake.execReturnsOnCall[len(fake.execArgsForCall)]
	fake.execArgsForCall = append(fake.execArgsForCall, struct {
		arg1 lager.Logger
		arg2 string
		arg3 string
		arg4 *specs.Process
		arg5 func() (io.Reader, io.Writer, io.Writer, bool)
	}{arg1, arg2, arg3, arg4, arg5})
	stub := fake.ExecStub
	fakeReturns := fake.execReturns
	fake.recordInvocation("Exec", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.execMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerManager) ExecCallCount() int {
	fake.execMutex.RLock()
	defer fake.execMutex.RUnlock()
	return len(fake.execArgsForCall)
}

func (fake *FakeContainerManager) ExecCalls(stub func(lager.Logger, string, string, *specs.Process, func() (io.Reader, io.Writer, io.Writer, bool)) (runcontainerd.BackingProcess, error)) {
	fake.execMutex.Lock()
	defer fake.execMutex.Unlock()
	fake.ExecStub = stub
}

func (fake *FakeContainerManager) ExecArgsForCall(i int) (lager.Logger, string, string, *specs.Process, func() (io.Reader, io.Writer, io.Writer, bool)) {
	fake.execMutex.RLock()
	defer fake.execMutex.RUnlock()
	argsForCall := fake.execArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeContainerManager) ExecReturns(result1 runcontainerd.BackingProcess, result2 error) {
	fake.execMutex.Lock()
	defer fake.execMutex.Unlock()
	fake.ExecStub = nil
	fake.execReturns = struct {
		result1 runcontainerd.BackingProcess
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerManager) ExecReturnsOnCall(i int, result1 runcontainerd.BackingProcess, result2 error) {
	fake.execMutex.Lock()
	defer fake.execMutex.Unlock()
	fake.ExecStub = nil
	if fake.execReturnsOnCall == nil {
		fake.execReturnsOnCall = make(map[int]struct {
			result1 runcontainerd.BackingProcess
			result2 error
		})
	}
	fake.execReturnsOnCall[i] = struct {
		result1 runcontainerd.BackingProcess
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerManager) GetContainerPID(arg1 lager.Logger, arg2 string) (uint32, error) {
	fake.getContainerPIDMutex.Lock()
	ret, specificReturn := fake.getContainerPIDReturnsOnCall[len(fake.getContainerPIDArgsForCall)]
	fake.getContainerPIDArgsForCall = append(fake.getContainerPIDArgsForCall, struct {
		arg1 lager.Logger
		arg2 string
	}{arg1, arg2})
	stub := fake.GetContainerPIDStub
	fakeReturns := fake.getContainerPIDReturns
	fake.recordInvocation("GetContainerPID", []interface{}{arg1, arg2})
	fake.getContainerPIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerManager) GetContainerPIDCallCount() int {
	fake.getContainerPIDMutex.RLock()
	defer fake.getContainerPIDMutex.RUnlock()
	return len(fake.getContainerPIDArgsForCall)
}

func (fake *FakeContainerManager) GetContainerPIDCalls(stub func(lager.Logger, string) (uint32, error)) {
	fake.getContainerPIDMutex.Lock()
	defer fake.getContainerPIDMutex.Unlock()
	fake.GetContainerPIDStub = stub
}

func (fake *FakeContainerManager) GetContainerPIDArgsForCall(i int) (lager.Logger, string) {
	fake.getContainerPIDMutex.RLock()
	defer fake.getContainerPIDMutex.RUnlock()
	argsForCall := fake.getContainerPIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerManager) GetContainerPIDReturns(result1 uint32, result2 error) {
	fake.getContainerPIDMutex.Lock()
	defer fake.getContainerPIDMutex.Unlock()
	fake.GetContainerPIDStub = nil
	fake.getContainerPIDReturns = struct {
		result1 uint32
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerManager) GetContainerPIDReturnsOnCall(i int, result1 uint32, result2 error) {
	fake.getContainerPIDMutex.Lock()
	defer fake.getContainerPIDMutex.Unlock()
	fake.GetContainerPIDStub = nil
	if fake.getContainerPIDReturnsOnCall == nil {
		fake.getContainerPIDReturnsOnCall = make(map[int]struct {
			result1 uint32
			result2 error
		})
	}
	fake.getContainerPIDReturnsOnCall[i] = struct {
		result1 uint32
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerManager) OOMEvents(arg1 lager.Logger) <-chan *events.TaskOOM {
	fake.oOMEventsMutex.Lock()
	ret, specificReturn := fake.oOMEventsReturnsOnCall[len(fake.oOMEventsArgsForCall)]
	fake.oOMEventsArgsForCall = append(fake.oOMEventsArgsForCall, struct {
		arg1 lager.Logger
	}{arg1})
	stub := fake.OOMEventsStub
	fakeReturns := fake.oOMEventsReturns
	fake.recordInvocation("OOMEvents", []interface{}{arg1})
	fake.oOMEventsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerManager) OOMEventsCallCount() int {
	fake.oOMEventsMutex.RLock()
	defer fake.oOMEventsMutex.RUnlock()
	return len(fake.oOMEventsArgsForCall)
}

func (fake *FakeContainerManager) OOMEventsCalls(stub func(lager.Logger) <-chan *events.TaskOOM) {
	fake.oOMEventsMutex.Lock()
	defer fake.oOMEventsMutex.Unlock()
	fake.OOMEventsStub = stub
}

func (fake *FakeContainerManager) OOMEventsArgsForCall(i int) lager.Logger {
	fake.oOMEventsMutex.RLock()
	defer fake.oOMEventsMutex.RUnlock()
	argsForCall := fake.oOMEventsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeContainerManager) OOMEventsReturns(result1 <-chan *events.TaskOOM) {
	fake.oOMEventsMutex.Lock()
	defer fake.oOMEventsMutex.Unlock()
	fake.OOMEventsStub = nil
	fake.oOMEventsReturns = struct {
		result1 <-chan *events.TaskOOM
	}{result1}
}

func (fake *FakeContainerManager) OOMEventsReturnsOnCall(i int, result1 <-chan *events.TaskOOM) {
	fake.oOMEventsMutex.Lock()
	defer fake.oOMEventsMutex.Unlock()
	fake.OOMEventsStub = nil
	if fake.oOMEventsReturnsOnCall == nil {
		fake.oOMEventsReturnsOnCall = make(map[int]struct {
			result1 <-chan *events.TaskOOM
		})
	}
	fake.oOMEventsReturnsOnCall[i] = struct {
		result1 <-chan *events.TaskOOM
	}{result1}
}

func (fake *FakeContainerManager) RemoveBundle(arg1 lager.Logger, arg2 string) error {
	fake.removeBundleMutex.Lock()
	ret, specificReturn := fake.removeBundleReturnsOnCall[len(fake.removeBundleArgsForCall)]
	fake.removeBundleArgsForCall = append(fake.removeBundleArgsForCall, struct {
		arg1 lager.Logger
		arg2 string
	}{arg1, arg2})
	stub := fake.RemoveBundleStub
	fakeReturns := fake.removeBundleReturns
	fake.recordInvocation("RemoveBundle", []interface{}{arg1, arg2})
	fake.removeBundleMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeContainerManager) RemoveBundleCallCount() int {
	fake.removeBundleMutex.RLock()
	defer fake.removeBundleMutex.RUnlock()
	return len(fake.removeBundleArgsForCall)
}

func (fake *FakeContainerManager) RemoveBundleCalls(stub func(lager.Logger, string) error) {
	fake.removeBundleMutex.Lock()
	defer fake.removeBundleMutex.Unlock()
	fake.RemoveBundleStub = stub
}

func (fake *FakeContainerManager) RemoveBundleArgsForCall(i int) (lager.Logger, string) {
	fake.removeBundleMutex.RLock()
	defer fake.removeBundleMutex.RUnlock()
	argsForCall := fake.removeBundleArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerManager) RemoveBundleReturns(result1 error) {
	fake.removeBundleMutex.Lock()
	defer fake.removeBundleMutex.Unlock()
	fake.RemoveBundleStub = nil
	fake.removeBundleReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerManager) RemoveBundleReturnsOnCall(i int, result1 error) {
	fake.removeBundleMutex.Lock()
	defer fake.removeBundleMutex.Unlock()
	fake.RemoveBundleStub = nil
	if fake.removeBundleReturnsOnCall == nil {
		fake.removeBundleReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.removeBundleReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeContainerManager) Spec(arg1 lager.Logger, arg2 string) (*specs.Spec, error) {
	fake.specMutex.Lock()
	ret, specificReturn := fake.specReturnsOnCall[len(fake.specArgsForCall)]
	fake.specArgsForCall = append(fake.specArgsForCall, struct {
		arg1 lager.Logger
		arg2 string
	}{arg1, arg2})
	stub := fake.SpecStub
	fakeReturns := fake.specReturns
	fake.recordInvocation("Spec", []interface{}{arg1, arg2})
	fake.specMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeContainerManager) SpecCallCount() int {
	fake.specMutex.RLock()
	defer fake.specMutex.RUnlock()
	return len(fake.specArgsForCall)
}

func (fake *FakeContainerManager) SpecCalls(stub func(lager.Logger, string) (*specs.Spec, error)) {
	fake.specMutex.Lock()
	defer fake.specMutex.Unlock()
	fake.SpecStub = stub
}

func (fake *FakeContainerManager) SpecArgsForCall(i int) (lager.Logger, string) {
	fake.specMutex.RLock()
	defer fake.specMutex.RUnlock()
	argsForCall := fake.specArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerManager) SpecReturns(result1 *specs.Spec, result2 error) {
	fake.specMutex.Lock()
	defer fake.specMutex.Unlock()
	fake.SpecStub = nil
	fake.specReturns = struct {
		result1 *specs.Spec
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerManager) SpecReturnsOnCall(i int, result1 *specs.Spec, result2 error) {
	fake.specMutex.Lock()
	defer fake.specMutex.Unlock()
	fake.SpecStub = nil
	if fake.specReturnsOnCall == nil {
		fake.specReturnsOnCall = make(map[int]struct {
			result1 *specs.Spec
			result2 error
		})
	}
	fake.specReturnsOnCall[i] = struct {
		result1 *specs.Spec
		result2 error
	}{result1, result2}
}

func (fake *FakeContainerManager) State(arg1 lager.Logger, arg2 string) (int, string, error) {
	fake.stateMutex.Lock()
	ret, specificReturn := fake.stateReturnsOnCall[len(fake.stateArgsForCall)]
	fake.stateArgsForCall = append(fake.stateArgsForCall, struct {
		arg1 lager.Logger
		arg2 string
	}{arg1, arg2})
	stub := fake.StateStub
	fakeReturns := fake.stateReturns
	fake.recordInvocation("State", []interface{}{arg1, arg2})
	fake.stateMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeContainerManager) StateCallCount() int {
	fake.stateMutex.RLock()
	defer fake.stateMutex.RUnlock()
	return len(fake.stateArgsForCall)
}

func (fake *FakeContainerManager) StateCalls(stub func(lager.Logger, string) (int, string, error)) {
	fake.stateMutex.Lock()
	defer fake.stateMutex.Unlock()
	fake.StateStub = stub
}

func (fake *FakeContainerManager) StateArgsForCall(i int) (lager.Logger, string) {
	fake.stateMutex.RLock()
	defer fake.stateMutex.RUnlock()
	argsForCall := fake.stateArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeContainerManager) StateReturns(result1 int, result2 string, result3 error) {
	fake.stateMutex.Lock()
	defer fake.stateMutex.Unlock()
	fake.StateStub = nil
	fake.stateReturns = struct {
		result1 int
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerManager) StateReturnsOnCall(i int, result1 int, result2 string, result3 error) {
	fake.stateMutex.Lock()
	defer fake.stateMutex.Unlock()
	fake.StateStub = nil
	if fake.stateReturnsOnCall == nil {
		fake.stateReturnsOnCall = make(map[int]struct {
			result1 int
			result2 string
			result3 error
		})
	}
	fake.stateReturnsOnCall[i] = struct {
		result1 int
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeContainerManager) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.bundleIDsMutex.RLock()
	defer fake.bundleIDsMutex.RUnlock()
	fake.createMutex.RLock()
	defer fake.createMutex.RUnlock()
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	fake.execMutex.RLock()
	defer fake.execMutex.RUnlock()
	fake.getContainerPIDMutex.RLock()
	defer fake.getContainerPIDMutex.RUnlock()
	fake.oOMEventsMutex.RLock()
	defer fake.oOMEventsMutex.RUnlock()
	fake.removeBundleMutex.RLock()
	defer fake.removeBundleMutex.RUnlock()
	fake.specMutex.RLock()
	defer fake.specMutex.RUnlock()
	fake.stateMutex.RLock()
	defer fake.stateMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeContainerManager) 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 _ runcontainerd.ContainerManager = new(FakeContainerManager)
