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

import (
	"sync"

	"github.com/ehsaniara/joblet/internal/joblet/telemetry"
)

type FakeEventPersister struct {
	PersistAcceptEventStub        func(string, int64, uint64, *telemetry.AcceptData) error
	persistAcceptEventMutex       sync.RWMutex
	persistAcceptEventArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.AcceptData
	}
	persistAcceptEventReturns struct {
		result1 error
	}
	persistAcceptEventReturnsOnCall map[int]struct {
		result1 error
	}
	PersistConnectEventStub        func(string, int64, uint64, *telemetry.ConnectData) error
	persistConnectEventMutex       sync.RWMutex
	persistConnectEventArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.ConnectData
	}
	persistConnectEventReturns struct {
		result1 error
	}
	persistConnectEventReturnsOnCall map[int]struct {
		result1 error
	}
	PersistExecEventStub        func(string, int64, uint64, *telemetry.ExecData) error
	persistExecEventMutex       sync.RWMutex
	persistExecEventArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.ExecData
	}
	persistExecEventReturns struct {
		result1 error
	}
	persistExecEventReturnsOnCall map[int]struct {
		result1 error
	}
	PersistFileEventStub        func(string, int64, uint64, *telemetry.FileData) error
	persistFileEventMutex       sync.RWMutex
	persistFileEventArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.FileData
	}
	persistFileEventReturns struct {
		result1 error
	}
	persistFileEventReturnsOnCall map[int]struct {
		result1 error
	}
	PersistMetricsStub        func(string, int64, uint64, *telemetry.MetricsData) error
	persistMetricsMutex       sync.RWMutex
	persistMetricsArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.MetricsData
	}
	persistMetricsReturns struct {
		result1 error
	}
	persistMetricsReturnsOnCall map[int]struct {
		result1 error
	}
	PersistMmapEventStub        func(string, int64, uint64, *telemetry.MmapData) error
	persistMmapEventMutex       sync.RWMutex
	persistMmapEventArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.MmapData
	}
	persistMmapEventReturns struct {
		result1 error
	}
	persistMmapEventReturnsOnCall map[int]struct {
		result1 error
	}
	PersistMprotectEventStub        func(string, int64, uint64, *telemetry.MprotectData) error
	persistMprotectEventMutex       sync.RWMutex
	persistMprotectEventArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.MprotectData
	}
	persistMprotectEventReturns struct {
		result1 error
	}
	persistMprotectEventReturnsOnCall map[int]struct {
		result1 error
	}
	PersistSocketDataEventStub        func(string, int64, uint64, *telemetry.SocketDataData) error
	persistSocketDataEventMutex       sync.RWMutex
	persistSocketDataEventArgsForCall []struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.SocketDataData
	}
	persistSocketDataEventReturns struct {
		result1 error
	}
	persistSocketDataEventReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeEventPersister) PersistAcceptEvent(arg1 string, arg2 int64, arg3 uint64, arg4 *telemetry.AcceptData) error {
	fake.persistAcceptEventMutex.Lock()
	ret, specificReturn := fake.persistAcceptEventReturnsOnCall[len(fake.persistAcceptEventArgsForCall)]
	fake.persistAcceptEventArgsForCall = append(fake.persistAcceptEventArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.AcceptData
	}{arg1, arg2, arg3, arg4})
	stub := fake.PersistAcceptEventStub
	fakeReturns := fake.persistAcceptEventReturns
	fake.recordInvocation("PersistAcceptEvent", []interface{}{arg1, arg2, arg3, arg4})
	fake.persistAcceptEventMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeEventPersister) PersistAcceptEventCallCount() int {
	fake.persistAcceptEventMutex.RLock()
	defer fake.persistAcceptEventMutex.RUnlock()
	return len(fake.persistAcceptEventArgsForCall)
}

func (fake *FakeEventPersister) PersistAcceptEventCalls(stub func(string, int64, uint64, *telemetry.AcceptData) error) {
	fake.persistAcceptEventMutex.Lock()
	defer fake.persistAcceptEventMutex.Unlock()
	fake.PersistAcceptEventStub = stub
}

func (fake *FakeEventPersister) PersistAcceptEventArgsForCall(i int) (string, int64, uint64, *telemetry.AcceptData) {
	fake.persistAcceptEventMutex.RLock()
	defer fake.persistAcceptEventMutex.RUnlock()
	argsForCall := fake.persistAcceptEventArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeEventPersister) PersistAcceptEventReturns(result1 error) {
	fake.persistAcceptEventMutex.Lock()
	defer fake.persistAcceptEventMutex.Unlock()
	fake.PersistAcceptEventStub = nil
	fake.persistAcceptEventReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistAcceptEventReturnsOnCall(i int, result1 error) {
	fake.persistAcceptEventMutex.Lock()
	defer fake.persistAcceptEventMutex.Unlock()
	fake.PersistAcceptEventStub = nil
	if fake.persistAcceptEventReturnsOnCall == nil {
		fake.persistAcceptEventReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.persistAcceptEventReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistConnectEvent(arg1 string, arg2 int64, arg3 uint64, arg4 *telemetry.ConnectData) error {
	fake.persistConnectEventMutex.Lock()
	ret, specificReturn := fake.persistConnectEventReturnsOnCall[len(fake.persistConnectEventArgsForCall)]
	fake.persistConnectEventArgsForCall = append(fake.persistConnectEventArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.ConnectData
	}{arg1, arg2, arg3, arg4})
	stub := fake.PersistConnectEventStub
	fakeReturns := fake.persistConnectEventReturns
	fake.recordInvocation("PersistConnectEvent", []interface{}{arg1, arg2, arg3, arg4})
	fake.persistConnectEventMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeEventPersister) PersistConnectEventCallCount() int {
	fake.persistConnectEventMutex.RLock()
	defer fake.persistConnectEventMutex.RUnlock()
	return len(fake.persistConnectEventArgsForCall)
}

func (fake *FakeEventPersister) PersistConnectEventCalls(stub func(string, int64, uint64, *telemetry.ConnectData) error) {
	fake.persistConnectEventMutex.Lock()
	defer fake.persistConnectEventMutex.Unlock()
	fake.PersistConnectEventStub = stub
}

func (fake *FakeEventPersister) PersistConnectEventArgsForCall(i int) (string, int64, uint64, *telemetry.ConnectData) {
	fake.persistConnectEventMutex.RLock()
	defer fake.persistConnectEventMutex.RUnlock()
	argsForCall := fake.persistConnectEventArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeEventPersister) PersistConnectEventReturns(result1 error) {
	fake.persistConnectEventMutex.Lock()
	defer fake.persistConnectEventMutex.Unlock()
	fake.PersistConnectEventStub = nil
	fake.persistConnectEventReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistConnectEventReturnsOnCall(i int, result1 error) {
	fake.persistConnectEventMutex.Lock()
	defer fake.persistConnectEventMutex.Unlock()
	fake.PersistConnectEventStub = nil
	if fake.persistConnectEventReturnsOnCall == nil {
		fake.persistConnectEventReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.persistConnectEventReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistExecEvent(arg1 string, arg2 int64, arg3 uint64, arg4 *telemetry.ExecData) error {
	fake.persistExecEventMutex.Lock()
	ret, specificReturn := fake.persistExecEventReturnsOnCall[len(fake.persistExecEventArgsForCall)]
	fake.persistExecEventArgsForCall = append(fake.persistExecEventArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.ExecData
	}{arg1, arg2, arg3, arg4})
	stub := fake.PersistExecEventStub
	fakeReturns := fake.persistExecEventReturns
	fake.recordInvocation("PersistExecEvent", []interface{}{arg1, arg2, arg3, arg4})
	fake.persistExecEventMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeEventPersister) PersistExecEventCallCount() int {
	fake.persistExecEventMutex.RLock()
	defer fake.persistExecEventMutex.RUnlock()
	return len(fake.persistExecEventArgsForCall)
}

func (fake *FakeEventPersister) PersistExecEventCalls(stub func(string, int64, uint64, *telemetry.ExecData) error) {
	fake.persistExecEventMutex.Lock()
	defer fake.persistExecEventMutex.Unlock()
	fake.PersistExecEventStub = stub
}

func (fake *FakeEventPersister) PersistExecEventArgsForCall(i int) (string, int64, uint64, *telemetry.ExecData) {
	fake.persistExecEventMutex.RLock()
	defer fake.persistExecEventMutex.RUnlock()
	argsForCall := fake.persistExecEventArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeEventPersister) PersistExecEventReturns(result1 error) {
	fake.persistExecEventMutex.Lock()
	defer fake.persistExecEventMutex.Unlock()
	fake.PersistExecEventStub = nil
	fake.persistExecEventReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistExecEventReturnsOnCall(i int, result1 error) {
	fake.persistExecEventMutex.Lock()
	defer fake.persistExecEventMutex.Unlock()
	fake.PersistExecEventStub = nil
	if fake.persistExecEventReturnsOnCall == nil {
		fake.persistExecEventReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.persistExecEventReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistFileEvent(arg1 string, arg2 int64, arg3 uint64, arg4 *telemetry.FileData) error {
	fake.persistFileEventMutex.Lock()
	ret, specificReturn := fake.persistFileEventReturnsOnCall[len(fake.persistFileEventArgsForCall)]
	fake.persistFileEventArgsForCall = append(fake.persistFileEventArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.FileData
	}{arg1, arg2, arg3, arg4})
	stub := fake.PersistFileEventStub
	fakeReturns := fake.persistFileEventReturns
	fake.recordInvocation("PersistFileEvent", []interface{}{arg1, arg2, arg3, arg4})
	fake.persistFileEventMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeEventPersister) PersistFileEventCallCount() int {
	fake.persistFileEventMutex.RLock()
	defer fake.persistFileEventMutex.RUnlock()
	return len(fake.persistFileEventArgsForCall)
}

func (fake *FakeEventPersister) PersistFileEventCalls(stub func(string, int64, uint64, *telemetry.FileData) error) {
	fake.persistFileEventMutex.Lock()
	defer fake.persistFileEventMutex.Unlock()
	fake.PersistFileEventStub = stub
}

func (fake *FakeEventPersister) PersistFileEventArgsForCall(i int) (string, int64, uint64, *telemetry.FileData) {
	fake.persistFileEventMutex.RLock()
	defer fake.persistFileEventMutex.RUnlock()
	argsForCall := fake.persistFileEventArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeEventPersister) PersistFileEventReturns(result1 error) {
	fake.persistFileEventMutex.Lock()
	defer fake.persistFileEventMutex.Unlock()
	fake.PersistFileEventStub = nil
	fake.persistFileEventReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistFileEventReturnsOnCall(i int, result1 error) {
	fake.persistFileEventMutex.Lock()
	defer fake.persistFileEventMutex.Unlock()
	fake.PersistFileEventStub = nil
	if fake.persistFileEventReturnsOnCall == nil {
		fake.persistFileEventReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.persistFileEventReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistMetrics(arg1 string, arg2 int64, arg3 uint64, arg4 *telemetry.MetricsData) error {
	fake.persistMetricsMutex.Lock()
	ret, specificReturn := fake.persistMetricsReturnsOnCall[len(fake.persistMetricsArgsForCall)]
	fake.persistMetricsArgsForCall = append(fake.persistMetricsArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.MetricsData
	}{arg1, arg2, arg3, arg4})
	stub := fake.PersistMetricsStub
	fakeReturns := fake.persistMetricsReturns
	fake.recordInvocation("PersistMetrics", []interface{}{arg1, arg2, arg3, arg4})
	fake.persistMetricsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeEventPersister) PersistMetricsCallCount() int {
	fake.persistMetricsMutex.RLock()
	defer fake.persistMetricsMutex.RUnlock()
	return len(fake.persistMetricsArgsForCall)
}

func (fake *FakeEventPersister) PersistMetricsCalls(stub func(string, int64, uint64, *telemetry.MetricsData) error) {
	fake.persistMetricsMutex.Lock()
	defer fake.persistMetricsMutex.Unlock()
	fake.PersistMetricsStub = stub
}

func (fake *FakeEventPersister) PersistMetricsArgsForCall(i int) (string, int64, uint64, *telemetry.MetricsData) {
	fake.persistMetricsMutex.RLock()
	defer fake.persistMetricsMutex.RUnlock()
	argsForCall := fake.persistMetricsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeEventPersister) PersistMetricsReturns(result1 error) {
	fake.persistMetricsMutex.Lock()
	defer fake.persistMetricsMutex.Unlock()
	fake.PersistMetricsStub = nil
	fake.persistMetricsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistMetricsReturnsOnCall(i int, result1 error) {
	fake.persistMetricsMutex.Lock()
	defer fake.persistMetricsMutex.Unlock()
	fake.PersistMetricsStub = nil
	if fake.persistMetricsReturnsOnCall == nil {
		fake.persistMetricsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.persistMetricsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistMmapEvent(arg1 string, arg2 int64, arg3 uint64, arg4 *telemetry.MmapData) error {
	fake.persistMmapEventMutex.Lock()
	ret, specificReturn := fake.persistMmapEventReturnsOnCall[len(fake.persistMmapEventArgsForCall)]
	fake.persistMmapEventArgsForCall = append(fake.persistMmapEventArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.MmapData
	}{arg1, arg2, arg3, arg4})
	stub := fake.PersistMmapEventStub
	fakeReturns := fake.persistMmapEventReturns
	fake.recordInvocation("PersistMmapEvent", []interface{}{arg1, arg2, arg3, arg4})
	fake.persistMmapEventMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeEventPersister) PersistMmapEventCallCount() int {
	fake.persistMmapEventMutex.RLock()
	defer fake.persistMmapEventMutex.RUnlock()
	return len(fake.persistMmapEventArgsForCall)
}

func (fake *FakeEventPersister) PersistMmapEventCalls(stub func(string, int64, uint64, *telemetry.MmapData) error) {
	fake.persistMmapEventMutex.Lock()
	defer fake.persistMmapEventMutex.Unlock()
	fake.PersistMmapEventStub = stub
}

func (fake *FakeEventPersister) PersistMmapEventArgsForCall(i int) (string, int64, uint64, *telemetry.MmapData) {
	fake.persistMmapEventMutex.RLock()
	defer fake.persistMmapEventMutex.RUnlock()
	argsForCall := fake.persistMmapEventArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeEventPersister) PersistMmapEventReturns(result1 error) {
	fake.persistMmapEventMutex.Lock()
	defer fake.persistMmapEventMutex.Unlock()
	fake.PersistMmapEventStub = nil
	fake.persistMmapEventReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistMmapEventReturnsOnCall(i int, result1 error) {
	fake.persistMmapEventMutex.Lock()
	defer fake.persistMmapEventMutex.Unlock()
	fake.PersistMmapEventStub = nil
	if fake.persistMmapEventReturnsOnCall == nil {
		fake.persistMmapEventReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.persistMmapEventReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistMprotectEvent(arg1 string, arg2 int64, arg3 uint64, arg4 *telemetry.MprotectData) error {
	fake.persistMprotectEventMutex.Lock()
	ret, specificReturn := fake.persistMprotectEventReturnsOnCall[len(fake.persistMprotectEventArgsForCall)]
	fake.persistMprotectEventArgsForCall = append(fake.persistMprotectEventArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.MprotectData
	}{arg1, arg2, arg3, arg4})
	stub := fake.PersistMprotectEventStub
	fakeReturns := fake.persistMprotectEventReturns
	fake.recordInvocation("PersistMprotectEvent", []interface{}{arg1, arg2, arg3, arg4})
	fake.persistMprotectEventMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeEventPersister) PersistMprotectEventCallCount() int {
	fake.persistMprotectEventMutex.RLock()
	defer fake.persistMprotectEventMutex.RUnlock()
	return len(fake.persistMprotectEventArgsForCall)
}

func (fake *FakeEventPersister) PersistMprotectEventCalls(stub func(string, int64, uint64, *telemetry.MprotectData) error) {
	fake.persistMprotectEventMutex.Lock()
	defer fake.persistMprotectEventMutex.Unlock()
	fake.PersistMprotectEventStub = stub
}

func (fake *FakeEventPersister) PersistMprotectEventArgsForCall(i int) (string, int64, uint64, *telemetry.MprotectData) {
	fake.persistMprotectEventMutex.RLock()
	defer fake.persistMprotectEventMutex.RUnlock()
	argsForCall := fake.persistMprotectEventArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeEventPersister) PersistMprotectEventReturns(result1 error) {
	fake.persistMprotectEventMutex.Lock()
	defer fake.persistMprotectEventMutex.Unlock()
	fake.PersistMprotectEventStub = nil
	fake.persistMprotectEventReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistMprotectEventReturnsOnCall(i int, result1 error) {
	fake.persistMprotectEventMutex.Lock()
	defer fake.persistMprotectEventMutex.Unlock()
	fake.PersistMprotectEventStub = nil
	if fake.persistMprotectEventReturnsOnCall == nil {
		fake.persistMprotectEventReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.persistMprotectEventReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistSocketDataEvent(arg1 string, arg2 int64, arg3 uint64, arg4 *telemetry.SocketDataData) error {
	fake.persistSocketDataEventMutex.Lock()
	ret, specificReturn := fake.persistSocketDataEventReturnsOnCall[len(fake.persistSocketDataEventArgsForCall)]
	fake.persistSocketDataEventArgsForCall = append(fake.persistSocketDataEventArgsForCall, struct {
		arg1 string
		arg2 int64
		arg3 uint64
		arg4 *telemetry.SocketDataData
	}{arg1, arg2, arg3, arg4})
	stub := fake.PersistSocketDataEventStub
	fakeReturns := fake.persistSocketDataEventReturns
	fake.recordInvocation("PersistSocketDataEvent", []interface{}{arg1, arg2, arg3, arg4})
	fake.persistSocketDataEventMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeEventPersister) PersistSocketDataEventCallCount() int {
	fake.persistSocketDataEventMutex.RLock()
	defer fake.persistSocketDataEventMutex.RUnlock()
	return len(fake.persistSocketDataEventArgsForCall)
}

func (fake *FakeEventPersister) PersistSocketDataEventCalls(stub func(string, int64, uint64, *telemetry.SocketDataData) error) {
	fake.persistSocketDataEventMutex.Lock()
	defer fake.persistSocketDataEventMutex.Unlock()
	fake.PersistSocketDataEventStub = stub
}

func (fake *FakeEventPersister) PersistSocketDataEventArgsForCall(i int) (string, int64, uint64, *telemetry.SocketDataData) {
	fake.persistSocketDataEventMutex.RLock()
	defer fake.persistSocketDataEventMutex.RUnlock()
	argsForCall := fake.persistSocketDataEventArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeEventPersister) PersistSocketDataEventReturns(result1 error) {
	fake.persistSocketDataEventMutex.Lock()
	defer fake.persistSocketDataEventMutex.Unlock()
	fake.PersistSocketDataEventStub = nil
	fake.persistSocketDataEventReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) PersistSocketDataEventReturnsOnCall(i int, result1 error) {
	fake.persistSocketDataEventMutex.Lock()
	defer fake.persistSocketDataEventMutex.Unlock()
	fake.PersistSocketDataEventStub = nil
	if fake.persistSocketDataEventReturnsOnCall == nil {
		fake.persistSocketDataEventReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.persistSocketDataEventReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeEventPersister) 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 *FakeEventPersister) 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 _ telemetry.EventPersister = new(FakeEventPersister)
