// Code generated by mockery v2.53.5. DO NOT EDIT.

package mocks

import (
	net "net"

	mock "github.com/stretchr/testify/mock"
)

// MockEventLogger is an autogenerated mock type for the EventLogger type
type MockEventLogger struct {
	mock.Mock
}

type MockEventLogger_Expecter struct {
	mock *mock.Mock
}

func (_m *MockEventLogger) EXPECT() *MockEventLogger_Expecter {
	return &MockEventLogger_Expecter{mock: &_m.Mock}
}

// Connect provides a mock function with given fields: addr, id, tx
func (_m *MockEventLogger) Connect(addr net.Addr, id string, tx uint64) {
	_m.Called(addr, id, tx)
}

// MockEventLogger_Connect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Connect'
type MockEventLogger_Connect_Call struct {
	*mock.Call
}

// Connect is a helper method to define mock.On call
//   - addr net.Addr
//   - id string
//   - tx uint64
func (_e *MockEventLogger_Expecter) Connect(addr interface{}, id interface{}, tx interface{}) *MockEventLogger_Connect_Call {
	return &MockEventLogger_Connect_Call{Call: _e.mock.On("Connect", addr, id, tx)}
}

func (_c *MockEventLogger_Connect_Call) Run(run func(addr net.Addr, id string, tx uint64)) *MockEventLogger_Connect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(net.Addr), args[1].(string), args[2].(uint64))
	})
	return _c
}

func (_c *MockEventLogger_Connect_Call) Return() *MockEventLogger_Connect_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockEventLogger_Connect_Call) RunAndReturn(run func(net.Addr, string, uint64)) *MockEventLogger_Connect_Call {
	_c.Run(run)
	return _c
}

// Disconnect provides a mock function with given fields: addr, id, err
func (_m *MockEventLogger) Disconnect(addr net.Addr, id string, err error) {
	_m.Called(addr, id, err)
}

// MockEventLogger_Disconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Disconnect'
type MockEventLogger_Disconnect_Call struct {
	*mock.Call
}

// Disconnect is a helper method to define mock.On call
//   - addr net.Addr
//   - id string
//   - err error
func (_e *MockEventLogger_Expecter) Disconnect(addr interface{}, id interface{}, err interface{}) *MockEventLogger_Disconnect_Call {
	return &MockEventLogger_Disconnect_Call{Call: _e.mock.On("Disconnect", addr, id, err)}
}

func (_c *MockEventLogger_Disconnect_Call) Run(run func(addr net.Addr, id string, err error)) *MockEventLogger_Disconnect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(net.Addr), args[1].(string), args[2].(error))
	})
	return _c
}

func (_c *MockEventLogger_Disconnect_Call) Return() *MockEventLogger_Disconnect_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockEventLogger_Disconnect_Call) RunAndReturn(run func(net.Addr, string, error)) *MockEventLogger_Disconnect_Call {
	_c.Run(run)
	return _c
}

// TCPError provides a mock function with given fields: addr, id, reqAddr, err
func (_m *MockEventLogger) TCPError(addr net.Addr, id string, reqAddr string, err error) {
	_m.Called(addr, id, reqAddr, err)
}

// MockEventLogger_TCPError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TCPError'
type MockEventLogger_TCPError_Call struct {
	*mock.Call
}

// TCPError is a helper method to define mock.On call
//   - addr net.Addr
//   - id string
//   - reqAddr string
//   - err error
func (_e *MockEventLogger_Expecter) TCPError(addr interface{}, id interface{}, reqAddr interface{}, err interface{}) *MockEventLogger_TCPError_Call {
	return &MockEventLogger_TCPError_Call{Call: _e.mock.On("TCPError", addr, id, reqAddr, err)}
}

func (_c *MockEventLogger_TCPError_Call) Run(run func(addr net.Addr, id string, reqAddr string, err error)) *MockEventLogger_TCPError_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(net.Addr), args[1].(string), args[2].(string), args[3].(error))
	})
	return _c
}

func (_c *MockEventLogger_TCPError_Call) Return() *MockEventLogger_TCPError_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockEventLogger_TCPError_Call) RunAndReturn(run func(net.Addr, string, string, error)) *MockEventLogger_TCPError_Call {
	_c.Run(run)
	return _c
}

// TCPRequest provides a mock function with given fields: addr, id, reqAddr
func (_m *MockEventLogger) TCPRequest(addr net.Addr, id string, reqAddr string) {
	_m.Called(addr, id, reqAddr)
}

// MockEventLogger_TCPRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TCPRequest'
type MockEventLogger_TCPRequest_Call struct {
	*mock.Call
}

// TCPRequest is a helper method to define mock.On call
//   - addr net.Addr
//   - id string
//   - reqAddr string
func (_e *MockEventLogger_Expecter) TCPRequest(addr interface{}, id interface{}, reqAddr interface{}) *MockEventLogger_TCPRequest_Call {
	return &MockEventLogger_TCPRequest_Call{Call: _e.mock.On("TCPRequest", addr, id, reqAddr)}
}

func (_c *MockEventLogger_TCPRequest_Call) Run(run func(addr net.Addr, id string, reqAddr string)) *MockEventLogger_TCPRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(net.Addr), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockEventLogger_TCPRequest_Call) Return() *MockEventLogger_TCPRequest_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockEventLogger_TCPRequest_Call) RunAndReturn(run func(net.Addr, string, string)) *MockEventLogger_TCPRequest_Call {
	_c.Run(run)
	return _c
}

// UDPError provides a mock function with given fields: addr, id, sessionID, err
func (_m *MockEventLogger) UDPError(addr net.Addr, id string, sessionID uint32, err error) {
	_m.Called(addr, id, sessionID, err)
}

// MockEventLogger_UDPError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UDPError'
type MockEventLogger_UDPError_Call struct {
	*mock.Call
}

// UDPError is a helper method to define mock.On call
//   - addr net.Addr
//   - id string
//   - sessionID uint32
//   - err error
func (_e *MockEventLogger_Expecter) UDPError(addr interface{}, id interface{}, sessionID interface{}, err interface{}) *MockEventLogger_UDPError_Call {
	return &MockEventLogger_UDPError_Call{Call: _e.mock.On("UDPError", addr, id, sessionID, err)}
}

func (_c *MockEventLogger_UDPError_Call) Run(run func(addr net.Addr, id string, sessionID uint32, err error)) *MockEventLogger_UDPError_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(net.Addr), args[1].(string), args[2].(uint32), args[3].(error))
	})
	return _c
}

func (_c *MockEventLogger_UDPError_Call) Return() *MockEventLogger_UDPError_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockEventLogger_UDPError_Call) RunAndReturn(run func(net.Addr, string, uint32, error)) *MockEventLogger_UDPError_Call {
	_c.Run(run)
	return _c
}

// UDPRequest provides a mock function with given fields: addr, id, sessionID, reqAddr
func (_m *MockEventLogger) UDPRequest(addr net.Addr, id string, sessionID uint32, reqAddr string) {
	_m.Called(addr, id, sessionID, reqAddr)
}

// MockEventLogger_UDPRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UDPRequest'
type MockEventLogger_UDPRequest_Call struct {
	*mock.Call
}

// UDPRequest is a helper method to define mock.On call
//   - addr net.Addr
//   - id string
//   - sessionID uint32
//   - reqAddr string
func (_e *MockEventLogger_Expecter) UDPRequest(addr interface{}, id interface{}, sessionID interface{}, reqAddr interface{}) *MockEventLogger_UDPRequest_Call {
	return &MockEventLogger_UDPRequest_Call{Call: _e.mock.On("UDPRequest", addr, id, sessionID, reqAddr)}
}

func (_c *MockEventLogger_UDPRequest_Call) Run(run func(addr net.Addr, id string, sessionID uint32, reqAddr string)) *MockEventLogger_UDPRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(net.Addr), args[1].(string), args[2].(uint32), args[3].(string))
	})
	return _c
}

func (_c *MockEventLogger_UDPRequest_Call) Return() *MockEventLogger_UDPRequest_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockEventLogger_UDPRequest_Call) RunAndReturn(run func(net.Addr, string, uint32, string)) *MockEventLogger_UDPRequest_Call {
	_c.Run(run)
	return _c
}

// NewMockEventLogger creates a new instance of MockEventLogger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockEventLogger(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockEventLogger {
	mock := &MockEventLogger{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
