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

package mocks

import (
	libbpfgo "github.com/aquasecurity/libbpfgo"
	mock "github.com/stretchr/testify/mock"
)

// MockBPFI is an autogenerated mock type for the BPFI type
type MockBPFI struct {
	mock.Mock
}

type MockBPFI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBPFI) EXPECT() *MockBPFI_Expecter {
	return &MockBPFI_Expecter{mock: &_m.Mock}
}

// AttachGoUProbe provides a mock function with given fields: funcName, exitFuncName, probeFuncName, binaryPath
func (_m *MockBPFI) AttachGoUProbe(funcName string, exitFuncName string, probeFuncName string, binaryPath string) ([]*libbpfgo.BPFLink, error) {
	ret := _m.Called(funcName, exitFuncName, probeFuncName, binaryPath)

	if len(ret) == 0 {
		panic("no return value specified for AttachGoUProbe")
	}

	var r0 []*libbpfgo.BPFLink
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, string, string) ([]*libbpfgo.BPFLink, error)); ok {
		return rf(funcName, exitFuncName, probeFuncName, binaryPath)
	}
	if rf, ok := ret.Get(0).(func(string, string, string, string) []*libbpfgo.BPFLink); ok {
		r0 = rf(funcName, exitFuncName, probeFuncName, binaryPath)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*libbpfgo.BPFLink)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, string, string) error); ok {
		r1 = rf(funcName, exitFuncName, probeFuncName, binaryPath)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AttachGoUProbe is a helper method to define mock.On call
//   - funcName string
//   - exitFuncName string
//   - probeFuncName string
//   - binaryPath string
func (_e *MockBPFI_Expecter) AttachGoUProbe(funcName interface{}, exitFuncName interface{}, probeFuncName interface{}, binaryPath interface{}) *MockBPFI_AttachGoUProbe_Call {
	return &MockBPFI_AttachGoUProbe_Call{Call: _e.mock.On("AttachGoUProbe", funcName, exitFuncName, probeFuncName, binaryPath)}
}

func (_c *MockBPFI_AttachGoUProbe_Call) Run(run func(funcName string, exitFuncName string, probeFuncName string, binaryPath string)) *MockBPFI_AttachGoUProbe_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockBPFI_AttachGoUProbe_Call) Return(_a0 []*libbpfgo.BPFLink, _a1 error) *MockBPFI_AttachGoUProbe_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockBPFI_AttachGoUProbe_Call) RunAndReturn(run func(string, string, string, string) ([]*libbpfgo.BPFLink, error)) *MockBPFI_AttachGoUProbe_Call {
	_c.Call.Return(run)
	return _c
}

// AttachKProbe provides a mock function with given fields: funcName, probeFuncName
func (_m *MockBPFI) AttachKProbe(funcName string, probeFuncName string) (*libbpfgo.BPFLink, error) {
	ret := _m.Called(funcName, probeFuncName)

	if len(ret) == 0 {
		panic("no return value specified for AttachKProbe")
	}

	var r0 *libbpfgo.BPFLink
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string) (*libbpfgo.BPFLink, error)); ok {
		return rf(funcName, probeFuncName)
	}
	if rf, ok := ret.Get(0).(func(string, string) *libbpfgo.BPFLink); ok {
		r0 = rf(funcName, probeFuncName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*libbpfgo.BPFLink)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(funcName, probeFuncName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AttachKProbe is a helper method to define mock.On call
//   - funcName string
//   - probeFuncName string
func (_e *MockBPFI_Expecter) AttachKProbe(funcName interface{}, probeFuncName interface{}) *MockBPFI_AttachKProbe_Call {
	return &MockBPFI_AttachKProbe_Call{Call: _e.mock.On("AttachKProbe", funcName, probeFuncName)}
}

func (_c *MockBPFI_AttachKProbe_Call) Run(run func(funcName string, probeFuncName string)) *MockBPFI_AttachKProbe_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

func (_c *MockBPFI_AttachKProbe_Call) Return(_a0 *libbpfgo.BPFLink, _a1 error) *MockBPFI_AttachKProbe_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockBPFI_AttachKProbe_Call) RunAndReturn(run func(string, string) (*libbpfgo.BPFLink, error)) *MockBPFI_AttachKProbe_Call {
	_c.Call.Return(run)
	return _c
}

// AttachKRetProbe provides a mock function with given fields: funcName, probeFuncName
func (_m *MockBPFI) AttachKRetProbe(funcName string, probeFuncName string) (*libbpfgo.BPFLink, error) {
	ret := _m.Called(funcName, probeFuncName)

	if len(ret) == 0 {
		panic("no return value specified for AttachKRetProbe")
	}

	var r0 *libbpfgo.BPFLink
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string) (*libbpfgo.BPFLink, error)); ok {
		return rf(funcName, probeFuncName)
	}
	if rf, ok := ret.Get(0).(func(string, string) *libbpfgo.BPFLink); ok {
		r0 = rf(funcName, probeFuncName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*libbpfgo.BPFLink)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string) error); ok {
		r1 = rf(funcName, probeFuncName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AttachKRetProbe is a helper method to define mock.On call
//   - funcName string
//   - probeFuncName string
func (_e *MockBPFI_Expecter) AttachKRetProbe(funcName interface{}, probeFuncName interface{}) *MockBPFI_AttachKRetProbe_Call {
	return &MockBPFI_AttachKRetProbe_Call{Call: _e.mock.On("AttachKRetProbe", funcName, probeFuncName)}
}

func (_c *MockBPFI_AttachKRetProbe_Call) Run(run func(funcName string, probeFuncName string)) *MockBPFI_AttachKRetProbe_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

func (_c *MockBPFI_AttachKRetProbe_Call) Return(_a0 *libbpfgo.BPFLink, _a1 error) *MockBPFI_AttachKRetProbe_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockBPFI_AttachKRetProbe_Call) RunAndReturn(run func(string, string) (*libbpfgo.BPFLink, error)) *MockBPFI_AttachKRetProbe_Call {
	_c.Call.Return(run)
	return _c
}

// AttachUProbe provides a mock function with given fields: funcName, probeFuncName, binaryPath
func (_m *MockBPFI) AttachUProbe(funcName string, probeFuncName string, binaryPath string) (*libbpfgo.BPFLink, error) {
	ret := _m.Called(funcName, probeFuncName, binaryPath)

	if len(ret) == 0 {
		panic("no return value specified for AttachUProbe")
	}

	var r0 *libbpfgo.BPFLink
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, string) (*libbpfgo.BPFLink, error)); ok {
		return rf(funcName, probeFuncName, binaryPath)
	}
	if rf, ok := ret.Get(0).(func(string, string, string) *libbpfgo.BPFLink); ok {
		r0 = rf(funcName, probeFuncName, binaryPath)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*libbpfgo.BPFLink)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, string) error); ok {
		r1 = rf(funcName, probeFuncName, binaryPath)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AttachUProbe is a helper method to define mock.On call
//   - funcName string
//   - probeFuncName string
//   - binaryPath string
func (_e *MockBPFI_Expecter) AttachUProbe(funcName interface{}, probeFuncName interface{}, binaryPath interface{}) *MockBPFI_AttachUProbe_Call {
	return &MockBPFI_AttachUProbe_Call{Call: _e.mock.On("AttachUProbe", funcName, probeFuncName, binaryPath)}
}

func (_c *MockBPFI_AttachUProbe_Call) Run(run func(funcName string, probeFuncName string, binaryPath string)) *MockBPFI_AttachUProbe_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockBPFI_AttachUProbe_Call) Return(_a0 *libbpfgo.BPFLink, _a1 error) *MockBPFI_AttachUProbe_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockBPFI_AttachUProbe_Call) RunAndReturn(run func(string, string, string) (*libbpfgo.BPFLink, error)) *MockBPFI_AttachUProbe_Call {
	_c.Call.Return(run)
	return _c
}

// AttachURetProbe provides a mock function with given fields: funcName, probeFuncName, binaryPath
func (_m *MockBPFI) AttachURetProbe(funcName string, probeFuncName string, binaryPath string) (*libbpfgo.BPFLink, error) {
	ret := _m.Called(funcName, probeFuncName, binaryPath)

	if len(ret) == 0 {
		panic("no return value specified for AttachURetProbe")
	}

	var r0 *libbpfgo.BPFLink
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, string) (*libbpfgo.BPFLink, error)); ok {
		return rf(funcName, probeFuncName, binaryPath)
	}
	if rf, ok := ret.Get(0).(func(string, string, string) *libbpfgo.BPFLink); ok {
		r0 = rf(funcName, probeFuncName, binaryPath)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*libbpfgo.BPFLink)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, string) error); ok {
		r1 = rf(funcName, probeFuncName, binaryPath)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AttachURetProbe is a helper method to define mock.On call
//   - funcName string
//   - probeFuncName string
//   - binaryPath string
func (_e *MockBPFI_Expecter) AttachURetProbe(funcName interface{}, probeFuncName interface{}, binaryPath interface{}) *MockBPFI_AttachURetProbe_Call {
	return &MockBPFI_AttachURetProbe_Call{Call: _e.mock.On("AttachURetProbe", funcName, probeFuncName, binaryPath)}
}

func (_c *MockBPFI_AttachURetProbe_Call) Run(run func(funcName string, probeFuncName string, binaryPath string)) *MockBPFI_AttachURetProbe_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockBPFI_AttachURetProbe_Call) Return(_a0 *libbpfgo.BPFLink, _a1 error) *MockBPFI_AttachURetProbe_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockBPFI_AttachURetProbe_Call) RunAndReturn(run func(string, string, string) (*libbpfgo.BPFLink, error)) *MockBPFI_AttachURetProbe_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function with given fields:
func (_m *MockBPFI) Close() {
	_m.Called()
}

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

// Close is a helper method to define mock.On call
func (_e *MockBPFI_Expecter) Close() *MockBPFI_Close_Call {
	return &MockBPFI_Close_Call{Call: _e.mock.On("Close")}
}

func (_c *MockBPFI_Close_Call) Run(run func()) *MockBPFI_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

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

func (_c *MockBPFI_Close_Call) RunAndReturn(run func()) *MockBPFI_Close_Call {
	_c.Call.Return(run)
	return _c
}

// DestroyProbe provides a mock function with given fields: probe
func (_m *MockBPFI) DestroyProbe(probe *libbpfgo.BPFLink) error {
	ret := _m.Called(probe)

	if len(ret) == 0 {
		panic("no return value specified for DestroyProbe")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(*libbpfgo.BPFLink) error); ok {
		r0 = rf(probe)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// DestroyProbe is a helper method to define mock.On call
//   - probe *libbpfgo.BPFLink
func (_e *MockBPFI_Expecter) DestroyProbe(probe interface{}) *MockBPFI_DestroyProbe_Call {
	return &MockBPFI_DestroyProbe_Call{Call: _e.mock.On("DestroyProbe", probe)}
}

func (_c *MockBPFI_DestroyProbe_Call) Run(run func(probe *libbpfgo.BPFLink)) *MockBPFI_DestroyProbe_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*libbpfgo.BPFLink))
	})
	return _c
}

func (_c *MockBPFI_DestroyProbe_Call) Return(_a0 error) *MockBPFI_DestroyProbe_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockBPFI_DestroyProbe_Call) RunAndReturn(run func(*libbpfgo.BPFLink) error) *MockBPFI_DestroyProbe_Call {
	_c.Call.Return(run)
	return _c
}

// GetMap provides a mock function with given fields: mapName
func (_m *MockBPFI) GetMap(mapName string) (*libbpfgo.BPFMap, error) {
	ret := _m.Called(mapName)

	if len(ret) == 0 {
		panic("no return value specified for GetMap")
	}

	var r0 *libbpfgo.BPFMap
	var r1 error
	if rf, ok := ret.Get(0).(func(string) (*libbpfgo.BPFMap, error)); ok {
		return rf(mapName)
	}
	if rf, ok := ret.Get(0).(func(string) *libbpfgo.BPFMap); ok {
		r0 = rf(mapName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*libbpfgo.BPFMap)
		}
	}

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(mapName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetMap is a helper method to define mock.On call
//   - mapName string
func (_e *MockBPFI_Expecter) GetMap(mapName interface{}) *MockBPFI_GetMap_Call {
	return &MockBPFI_GetMap_Call{Call: _e.mock.On("GetMap", mapName)}
}

func (_c *MockBPFI_GetMap_Call) Run(run func(mapName string)) *MockBPFI_GetMap_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockBPFI_GetMap_Call) Return(_a0 *libbpfgo.BPFMap, _a1 error) *MockBPFI_GetMap_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockBPFI_GetMap_Call) RunAndReturn(run func(string) (*libbpfgo.BPFMap, error)) *MockBPFI_GetMap_Call {
	_c.Call.Return(run)
	return _c
}

// InitRingBuf provides a mock function with given fields: mapName, eventsChan
func (_m *MockBPFI) InitRingBuf(mapName string, eventsChan chan []byte) (*libbpfgo.RingBuffer, error) {
	ret := _m.Called(mapName, eventsChan)

	if len(ret) == 0 {
		panic("no return value specified for InitRingBuf")
	}

	var r0 *libbpfgo.RingBuffer
	var r1 error
	if rf, ok := ret.Get(0).(func(string, chan []byte) (*libbpfgo.RingBuffer, error)); ok {
		return rf(mapName, eventsChan)
	}
	if rf, ok := ret.Get(0).(func(string, chan []byte) *libbpfgo.RingBuffer); ok {
		r0 = rf(mapName, eventsChan)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*libbpfgo.RingBuffer)
		}
	}

	if rf, ok := ret.Get(1).(func(string, chan []byte) error); ok {
		r1 = rf(mapName, eventsChan)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// InitRingBuf is a helper method to define mock.On call
//   - mapName string
//   - eventsChan chan []byte
func (_e *MockBPFI_Expecter) InitRingBuf(mapName interface{}, eventsChan interface{}) *MockBPFI_InitRingBuf_Call {
	return &MockBPFI_InitRingBuf_Call{Call: _e.mock.On("InitRingBuf", mapName, eventsChan)}
}

func (_c *MockBPFI_InitRingBuf_Call) Run(run func(mapName string, eventsChan chan []byte)) *MockBPFI_InitRingBuf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(chan []byte))
	})
	return _c
}

func (_c *MockBPFI_InitRingBuf_Call) Return(_a0 *libbpfgo.RingBuffer, _a1 error) *MockBPFI_InitRingBuf_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockBPFI_InitRingBuf_Call) RunAndReturn(run func(string, chan []byte) (*libbpfgo.RingBuffer, error)) *MockBPFI_InitRingBuf_Call {
	_c.Call.Return(run)
	return _c
}

// LoadProgram provides a mock function with given fields:
func (_m *MockBPFI) LoadProgram() error {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for LoadProgram")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// LoadProgram is a helper method to define mock.On call
func (_e *MockBPFI_Expecter) LoadProgram() *MockBPFI_LoadProgram_Call {
	return &MockBPFI_LoadProgram_Call{Call: _e.mock.On("LoadProgram")}
}

func (_c *MockBPFI_LoadProgram_Call) Run(run func()) *MockBPFI_LoadProgram_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBPFI_LoadProgram_Call) Return(_a0 error) *MockBPFI_LoadProgram_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockBPFI_LoadProgram_Call) RunAndReturn(run func() error) *MockBPFI_LoadProgram_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockBPFI creates a new instance of MockBPFI. 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 NewMockBPFI(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBPFI {
	mock := &MockBPFI{}
	mock.Mock.Test(t)

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

	return mock
}
