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

import (
	"sync"

	"github.com/ehsaniara/joblet/internal/joblet/ebpf/telematics"
)

type FakeCgroupOps struct {
	CgroupIDFromPathStub        func(string) (uint64, error)
	cgroupIDFromPathMutex       sync.RWMutex
	cgroupIDFromPathArgsForCall []struct {
		arg1 string
	}
	cgroupIDFromPathReturns struct {
		result1 uint64
		result2 error
	}
	cgroupIDFromPathReturnsOnCall map[int]struct {
		result1 uint64
		result2 error
	}
	GetCgroupControllersStub        func(string) ([]string, error)
	getCgroupControllersMutex       sync.RWMutex
	getCgroupControllersArgsForCall []struct {
		arg1 string
	}
	getCgroupControllersReturns struct {
		result1 []string
		result2 error
	}
	getCgroupControllersReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetCgroupIDStub        func(string) (uint64, error)
	getCgroupIDMutex       sync.RWMutex
	getCgroupIDArgsForCall []struct {
		arg1 string
	}
	getCgroupIDReturns struct {
		result1 uint64
		result2 error
	}
	getCgroupIDReturnsOnCall map[int]struct {
		result1 uint64
		result2 error
	}
	GetCgroupIDFromFDStub        func(int) (uint64, error)
	getCgroupIDFromFDMutex       sync.RWMutex
	getCgroupIDFromFDArgsForCall []struct {
		arg1 int
	}
	getCgroupIDFromFDReturns struct {
		result1 uint64
		result2 error
	}
	getCgroupIDFromFDReturnsOnCall map[int]struct {
		result1 uint64
		result2 error
	}
	GetProcessCgroupIDStub        func(int) (uint64, error)
	getProcessCgroupIDMutex       sync.RWMutex
	getProcessCgroupIDArgsForCall []struct {
		arg1 int
	}
	getProcessCgroupIDReturns struct {
		result1 uint64
		result2 error
	}
	getProcessCgroupIDReturnsOnCall map[int]struct {
		result1 uint64
		result2 error
	}
	GetProcessCgroupPathStub        func(int) (string, error)
	getProcessCgroupPathMutex       sync.RWMutex
	getProcessCgroupPathArgsForCall []struct {
		arg1 int
	}
	getProcessCgroupPathReturns struct {
		result1 string
		result2 error
	}
	getProcessCgroupPathReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	IsCgroupV2Stub        func() bool
	isCgroupV2Mutex       sync.RWMutex
	isCgroupV2ArgsForCall []struct {
	}
	isCgroupV2Returns struct {
		result1 bool
	}
	isCgroupV2ReturnsOnCall map[int]struct {
		result1 bool
	}
	ReadCgroupStatStub        func(string, string) (uint64, error)
	readCgroupStatMutex       sync.RWMutex
	readCgroupStatArgsForCall []struct {
		arg1 string
		arg2 string
	}
	readCgroupStatReturns struct {
		result1 uint64
		result2 error
	}
	readCgroupStatReturnsOnCall map[int]struct {
		result1 uint64
		result2 error
	}
	ValidateCgroupPathStub        func(string) error
	validateCgroupPathMutex       sync.RWMutex
	validateCgroupPathArgsForCall []struct {
		arg1 string
	}
	validateCgroupPathReturns struct {
		result1 error
	}
	validateCgroupPathReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeCgroupOps) CgroupIDFromPath(arg1 string) (uint64, error) {
	fake.cgroupIDFromPathMutex.Lock()
	ret, specificReturn := fake.cgroupIDFromPathReturnsOnCall[len(fake.cgroupIDFromPathArgsForCall)]
	fake.cgroupIDFromPathArgsForCall = append(fake.cgroupIDFromPathArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.CgroupIDFromPathStub
	fakeReturns := fake.cgroupIDFromPathReturns
	fake.recordInvocation("CgroupIDFromPath", []interface{}{arg1})
	fake.cgroupIDFromPathMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCgroupOps) CgroupIDFromPathCallCount() int {
	fake.cgroupIDFromPathMutex.RLock()
	defer fake.cgroupIDFromPathMutex.RUnlock()
	return len(fake.cgroupIDFromPathArgsForCall)
}

func (fake *FakeCgroupOps) CgroupIDFromPathCalls(stub func(string) (uint64, error)) {
	fake.cgroupIDFromPathMutex.Lock()
	defer fake.cgroupIDFromPathMutex.Unlock()
	fake.CgroupIDFromPathStub = stub
}

func (fake *FakeCgroupOps) CgroupIDFromPathArgsForCall(i int) string {
	fake.cgroupIDFromPathMutex.RLock()
	defer fake.cgroupIDFromPathMutex.RUnlock()
	argsForCall := fake.cgroupIDFromPathArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCgroupOps) CgroupIDFromPathReturns(result1 uint64, result2 error) {
	fake.cgroupIDFromPathMutex.Lock()
	defer fake.cgroupIDFromPathMutex.Unlock()
	fake.CgroupIDFromPathStub = nil
	fake.cgroupIDFromPathReturns = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) CgroupIDFromPathReturnsOnCall(i int, result1 uint64, result2 error) {
	fake.cgroupIDFromPathMutex.Lock()
	defer fake.cgroupIDFromPathMutex.Unlock()
	fake.CgroupIDFromPathStub = nil
	if fake.cgroupIDFromPathReturnsOnCall == nil {
		fake.cgroupIDFromPathReturnsOnCall = make(map[int]struct {
			result1 uint64
			result2 error
		})
	}
	fake.cgroupIDFromPathReturnsOnCall[i] = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) GetCgroupControllers(arg1 string) ([]string, error) {
	fake.getCgroupControllersMutex.Lock()
	ret, specificReturn := fake.getCgroupControllersReturnsOnCall[len(fake.getCgroupControllersArgsForCall)]
	fake.getCgroupControllersArgsForCall = append(fake.getCgroupControllersArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetCgroupControllersStub
	fakeReturns := fake.getCgroupControllersReturns
	fake.recordInvocation("GetCgroupControllers", []interface{}{arg1})
	fake.getCgroupControllersMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCgroupOps) GetCgroupControllersCallCount() int {
	fake.getCgroupControllersMutex.RLock()
	defer fake.getCgroupControllersMutex.RUnlock()
	return len(fake.getCgroupControllersArgsForCall)
}

func (fake *FakeCgroupOps) GetCgroupControllersCalls(stub func(string) ([]string, error)) {
	fake.getCgroupControllersMutex.Lock()
	defer fake.getCgroupControllersMutex.Unlock()
	fake.GetCgroupControllersStub = stub
}

func (fake *FakeCgroupOps) GetCgroupControllersArgsForCall(i int) string {
	fake.getCgroupControllersMutex.RLock()
	defer fake.getCgroupControllersMutex.RUnlock()
	argsForCall := fake.getCgroupControllersArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCgroupOps) GetCgroupControllersReturns(result1 []string, result2 error) {
	fake.getCgroupControllersMutex.Lock()
	defer fake.getCgroupControllersMutex.Unlock()
	fake.GetCgroupControllersStub = nil
	fake.getCgroupControllersReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) GetCgroupControllersReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getCgroupControllersMutex.Lock()
	defer fake.getCgroupControllersMutex.Unlock()
	fake.GetCgroupControllersStub = nil
	if fake.getCgroupControllersReturnsOnCall == nil {
		fake.getCgroupControllersReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getCgroupControllersReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) GetCgroupID(arg1 string) (uint64, error) {
	fake.getCgroupIDMutex.Lock()
	ret, specificReturn := fake.getCgroupIDReturnsOnCall[len(fake.getCgroupIDArgsForCall)]
	fake.getCgroupIDArgsForCall = append(fake.getCgroupIDArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetCgroupIDStub
	fakeReturns := fake.getCgroupIDReturns
	fake.recordInvocation("GetCgroupID", []interface{}{arg1})
	fake.getCgroupIDMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCgroupOps) GetCgroupIDCallCount() int {
	fake.getCgroupIDMutex.RLock()
	defer fake.getCgroupIDMutex.RUnlock()
	return len(fake.getCgroupIDArgsForCall)
}

func (fake *FakeCgroupOps) GetCgroupIDCalls(stub func(string) (uint64, error)) {
	fake.getCgroupIDMutex.Lock()
	defer fake.getCgroupIDMutex.Unlock()
	fake.GetCgroupIDStub = stub
}

func (fake *FakeCgroupOps) GetCgroupIDArgsForCall(i int) string {
	fake.getCgroupIDMutex.RLock()
	defer fake.getCgroupIDMutex.RUnlock()
	argsForCall := fake.getCgroupIDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCgroupOps) GetCgroupIDReturns(result1 uint64, result2 error) {
	fake.getCgroupIDMutex.Lock()
	defer fake.getCgroupIDMutex.Unlock()
	fake.GetCgroupIDStub = nil
	fake.getCgroupIDReturns = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) GetCgroupIDReturnsOnCall(i int, result1 uint64, result2 error) {
	fake.getCgroupIDMutex.Lock()
	defer fake.getCgroupIDMutex.Unlock()
	fake.GetCgroupIDStub = nil
	if fake.getCgroupIDReturnsOnCall == nil {
		fake.getCgroupIDReturnsOnCall = make(map[int]struct {
			result1 uint64
			result2 error
		})
	}
	fake.getCgroupIDReturnsOnCall[i] = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) GetCgroupIDFromFD(arg1 int) (uint64, error) {
	fake.getCgroupIDFromFDMutex.Lock()
	ret, specificReturn := fake.getCgroupIDFromFDReturnsOnCall[len(fake.getCgroupIDFromFDArgsForCall)]
	fake.getCgroupIDFromFDArgsForCall = append(fake.getCgroupIDFromFDArgsForCall, struct {
		arg1 int
	}{arg1})
	stub := fake.GetCgroupIDFromFDStub
	fakeReturns := fake.getCgroupIDFromFDReturns
	fake.recordInvocation("GetCgroupIDFromFD", []interface{}{arg1})
	fake.getCgroupIDFromFDMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCgroupOps) GetCgroupIDFromFDCallCount() int {
	fake.getCgroupIDFromFDMutex.RLock()
	defer fake.getCgroupIDFromFDMutex.RUnlock()
	return len(fake.getCgroupIDFromFDArgsForCall)
}

func (fake *FakeCgroupOps) GetCgroupIDFromFDCalls(stub func(int) (uint64, error)) {
	fake.getCgroupIDFromFDMutex.Lock()
	defer fake.getCgroupIDFromFDMutex.Unlock()
	fake.GetCgroupIDFromFDStub = stub
}

func (fake *FakeCgroupOps) GetCgroupIDFromFDArgsForCall(i int) int {
	fake.getCgroupIDFromFDMutex.RLock()
	defer fake.getCgroupIDFromFDMutex.RUnlock()
	argsForCall := fake.getCgroupIDFromFDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCgroupOps) GetCgroupIDFromFDReturns(result1 uint64, result2 error) {
	fake.getCgroupIDFromFDMutex.Lock()
	defer fake.getCgroupIDFromFDMutex.Unlock()
	fake.GetCgroupIDFromFDStub = nil
	fake.getCgroupIDFromFDReturns = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) GetCgroupIDFromFDReturnsOnCall(i int, result1 uint64, result2 error) {
	fake.getCgroupIDFromFDMutex.Lock()
	defer fake.getCgroupIDFromFDMutex.Unlock()
	fake.GetCgroupIDFromFDStub = nil
	if fake.getCgroupIDFromFDReturnsOnCall == nil {
		fake.getCgroupIDFromFDReturnsOnCall = make(map[int]struct {
			result1 uint64
			result2 error
		})
	}
	fake.getCgroupIDFromFDReturnsOnCall[i] = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) GetProcessCgroupID(arg1 int) (uint64, error) {
	fake.getProcessCgroupIDMutex.Lock()
	ret, specificReturn := fake.getProcessCgroupIDReturnsOnCall[len(fake.getProcessCgroupIDArgsForCall)]
	fake.getProcessCgroupIDArgsForCall = append(fake.getProcessCgroupIDArgsForCall, struct {
		arg1 int
	}{arg1})
	stub := fake.GetProcessCgroupIDStub
	fakeReturns := fake.getProcessCgroupIDReturns
	fake.recordInvocation("GetProcessCgroupID", []interface{}{arg1})
	fake.getProcessCgroupIDMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCgroupOps) GetProcessCgroupIDCallCount() int {
	fake.getProcessCgroupIDMutex.RLock()
	defer fake.getProcessCgroupIDMutex.RUnlock()
	return len(fake.getProcessCgroupIDArgsForCall)
}

func (fake *FakeCgroupOps) GetProcessCgroupIDCalls(stub func(int) (uint64, error)) {
	fake.getProcessCgroupIDMutex.Lock()
	defer fake.getProcessCgroupIDMutex.Unlock()
	fake.GetProcessCgroupIDStub = stub
}

func (fake *FakeCgroupOps) GetProcessCgroupIDArgsForCall(i int) int {
	fake.getProcessCgroupIDMutex.RLock()
	defer fake.getProcessCgroupIDMutex.RUnlock()
	argsForCall := fake.getProcessCgroupIDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCgroupOps) GetProcessCgroupIDReturns(result1 uint64, result2 error) {
	fake.getProcessCgroupIDMutex.Lock()
	defer fake.getProcessCgroupIDMutex.Unlock()
	fake.GetProcessCgroupIDStub = nil
	fake.getProcessCgroupIDReturns = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) GetProcessCgroupIDReturnsOnCall(i int, result1 uint64, result2 error) {
	fake.getProcessCgroupIDMutex.Lock()
	defer fake.getProcessCgroupIDMutex.Unlock()
	fake.GetProcessCgroupIDStub = nil
	if fake.getProcessCgroupIDReturnsOnCall == nil {
		fake.getProcessCgroupIDReturnsOnCall = make(map[int]struct {
			result1 uint64
			result2 error
		})
	}
	fake.getProcessCgroupIDReturnsOnCall[i] = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) GetProcessCgroupPath(arg1 int) (string, error) {
	fake.getProcessCgroupPathMutex.Lock()
	ret, specificReturn := fake.getProcessCgroupPathReturnsOnCall[len(fake.getProcessCgroupPathArgsForCall)]
	fake.getProcessCgroupPathArgsForCall = append(fake.getProcessCgroupPathArgsForCall, struct {
		arg1 int
	}{arg1})
	stub := fake.GetProcessCgroupPathStub
	fakeReturns := fake.getProcessCgroupPathReturns
	fake.recordInvocation("GetProcessCgroupPath", []interface{}{arg1})
	fake.getProcessCgroupPathMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCgroupOps) GetProcessCgroupPathCallCount() int {
	fake.getProcessCgroupPathMutex.RLock()
	defer fake.getProcessCgroupPathMutex.RUnlock()
	return len(fake.getProcessCgroupPathArgsForCall)
}

func (fake *FakeCgroupOps) GetProcessCgroupPathCalls(stub func(int) (string, error)) {
	fake.getProcessCgroupPathMutex.Lock()
	defer fake.getProcessCgroupPathMutex.Unlock()
	fake.GetProcessCgroupPathStub = stub
}

func (fake *FakeCgroupOps) GetProcessCgroupPathArgsForCall(i int) int {
	fake.getProcessCgroupPathMutex.RLock()
	defer fake.getProcessCgroupPathMutex.RUnlock()
	argsForCall := fake.getProcessCgroupPathArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCgroupOps) GetProcessCgroupPathReturns(result1 string, result2 error) {
	fake.getProcessCgroupPathMutex.Lock()
	defer fake.getProcessCgroupPathMutex.Unlock()
	fake.GetProcessCgroupPathStub = nil
	fake.getProcessCgroupPathReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) GetProcessCgroupPathReturnsOnCall(i int, result1 string, result2 error) {
	fake.getProcessCgroupPathMutex.Lock()
	defer fake.getProcessCgroupPathMutex.Unlock()
	fake.GetProcessCgroupPathStub = nil
	if fake.getProcessCgroupPathReturnsOnCall == nil {
		fake.getProcessCgroupPathReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.getProcessCgroupPathReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) IsCgroupV2() bool {
	fake.isCgroupV2Mutex.Lock()
	ret, specificReturn := fake.isCgroupV2ReturnsOnCall[len(fake.isCgroupV2ArgsForCall)]
	fake.isCgroupV2ArgsForCall = append(fake.isCgroupV2ArgsForCall, struct {
	}{})
	stub := fake.IsCgroupV2Stub
	fakeReturns := fake.isCgroupV2Returns
	fake.recordInvocation("IsCgroupV2", []interface{}{})
	fake.isCgroupV2Mutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeCgroupOps) IsCgroupV2CallCount() int {
	fake.isCgroupV2Mutex.RLock()
	defer fake.isCgroupV2Mutex.RUnlock()
	return len(fake.isCgroupV2ArgsForCall)
}

func (fake *FakeCgroupOps) IsCgroupV2Calls(stub func() bool) {
	fake.isCgroupV2Mutex.Lock()
	defer fake.isCgroupV2Mutex.Unlock()
	fake.IsCgroupV2Stub = stub
}

func (fake *FakeCgroupOps) IsCgroupV2Returns(result1 bool) {
	fake.isCgroupV2Mutex.Lock()
	defer fake.isCgroupV2Mutex.Unlock()
	fake.IsCgroupV2Stub = nil
	fake.isCgroupV2Returns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeCgroupOps) IsCgroupV2ReturnsOnCall(i int, result1 bool) {
	fake.isCgroupV2Mutex.Lock()
	defer fake.isCgroupV2Mutex.Unlock()
	fake.IsCgroupV2Stub = nil
	if fake.isCgroupV2ReturnsOnCall == nil {
		fake.isCgroupV2ReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isCgroupV2ReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeCgroupOps) ReadCgroupStat(arg1 string, arg2 string) (uint64, error) {
	fake.readCgroupStatMutex.Lock()
	ret, specificReturn := fake.readCgroupStatReturnsOnCall[len(fake.readCgroupStatArgsForCall)]
	fake.readCgroupStatArgsForCall = append(fake.readCgroupStatArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.ReadCgroupStatStub
	fakeReturns := fake.readCgroupStatReturns
	fake.recordInvocation("ReadCgroupStat", []interface{}{arg1, arg2})
	fake.readCgroupStatMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCgroupOps) ReadCgroupStatCallCount() int {
	fake.readCgroupStatMutex.RLock()
	defer fake.readCgroupStatMutex.RUnlock()
	return len(fake.readCgroupStatArgsForCall)
}

func (fake *FakeCgroupOps) ReadCgroupStatCalls(stub func(string, string) (uint64, error)) {
	fake.readCgroupStatMutex.Lock()
	defer fake.readCgroupStatMutex.Unlock()
	fake.ReadCgroupStatStub = stub
}

func (fake *FakeCgroupOps) ReadCgroupStatArgsForCall(i int) (string, string) {
	fake.readCgroupStatMutex.RLock()
	defer fake.readCgroupStatMutex.RUnlock()
	argsForCall := fake.readCgroupStatArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCgroupOps) ReadCgroupStatReturns(result1 uint64, result2 error) {
	fake.readCgroupStatMutex.Lock()
	defer fake.readCgroupStatMutex.Unlock()
	fake.ReadCgroupStatStub = nil
	fake.readCgroupStatReturns = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) ReadCgroupStatReturnsOnCall(i int, result1 uint64, result2 error) {
	fake.readCgroupStatMutex.Lock()
	defer fake.readCgroupStatMutex.Unlock()
	fake.ReadCgroupStatStub = nil
	if fake.readCgroupStatReturnsOnCall == nil {
		fake.readCgroupStatReturnsOnCall = make(map[int]struct {
			result1 uint64
			result2 error
		})
	}
	fake.readCgroupStatReturnsOnCall[i] = struct {
		result1 uint64
		result2 error
	}{result1, result2}
}

func (fake *FakeCgroupOps) ValidateCgroupPath(arg1 string) error {
	fake.validateCgroupPathMutex.Lock()
	ret, specificReturn := fake.validateCgroupPathReturnsOnCall[len(fake.validateCgroupPathArgsForCall)]
	fake.validateCgroupPathArgsForCall = append(fake.validateCgroupPathArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.ValidateCgroupPathStub
	fakeReturns := fake.validateCgroupPathReturns
	fake.recordInvocation("ValidateCgroupPath", []interface{}{arg1})
	fake.validateCgroupPathMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeCgroupOps) ValidateCgroupPathCallCount() int {
	fake.validateCgroupPathMutex.RLock()
	defer fake.validateCgroupPathMutex.RUnlock()
	return len(fake.validateCgroupPathArgsForCall)
}

func (fake *FakeCgroupOps) ValidateCgroupPathCalls(stub func(string) error) {
	fake.validateCgroupPathMutex.Lock()
	defer fake.validateCgroupPathMutex.Unlock()
	fake.ValidateCgroupPathStub = stub
}

func (fake *FakeCgroupOps) ValidateCgroupPathArgsForCall(i int) string {
	fake.validateCgroupPathMutex.RLock()
	defer fake.validateCgroupPathMutex.RUnlock()
	argsForCall := fake.validateCgroupPathArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCgroupOps) ValidateCgroupPathReturns(result1 error) {
	fake.validateCgroupPathMutex.Lock()
	defer fake.validateCgroupPathMutex.Unlock()
	fake.ValidateCgroupPathStub = nil
	fake.validateCgroupPathReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeCgroupOps) ValidateCgroupPathReturnsOnCall(i int, result1 error) {
	fake.validateCgroupPathMutex.Lock()
	defer fake.validateCgroupPathMutex.Unlock()
	fake.ValidateCgroupPathStub = nil
	if fake.validateCgroupPathReturnsOnCall == nil {
		fake.validateCgroupPathReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.validateCgroupPathReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeCgroupOps) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeCgroupOps) 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 _ telematics.CgroupOps = new(FakeCgroupOps)
