// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package libinput

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

// newMockdeviceConfig creates a new instance of mockdeviceConfig. 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 newMockdeviceConfig(t interface {
	mock.TestingT
	Cleanup(func())
}) *mockdeviceConfig {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &mockdeviceConfig{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// mockdeviceConfig is an autogenerated mock type for the deviceConfig type
type mockdeviceConfig struct {
	mock.Mock
}

type mockdeviceConfig_Expecter struct {
	mock *mock.Mock
}

func (_m *mockdeviceConfig) EXPECT() *mockdeviceConfig_Expecter {
	return &mockdeviceConfig_Expecter{mock: &_m.Mock}
}

// IsPointer provides a mock function for the type mockdeviceConfig
func (_mock *mockdeviceConfig) IsPointer(dev uintptr) bool {
	ret := _mock.Called(dev)

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

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(uintptr) bool); ok {
		r0 = returnFunc(dev)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

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

// IsPointer is a helper method to define mock.On call
//   - dev uintptr
func (_e *mockdeviceConfig_Expecter) IsPointer(dev any) *mockdeviceConfig_IsPointer_Call {
	return &mockdeviceConfig_IsPointer_Call{Call: _e.mock.On("IsPointer", dev)}
}

func (_c *mockdeviceConfig_IsPointer_Call) Run(run func(dev uintptr)) *mockdeviceConfig_IsPointer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uintptr
		if args[0] != nil {
			arg0 = args[0].(uintptr)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockdeviceConfig_IsPointer_Call) Return(b bool) *mockdeviceConfig_IsPointer_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *mockdeviceConfig_IsPointer_Call) RunAndReturn(run func(dev uintptr) bool) *mockdeviceConfig_IsPointer_Call {
	_c.Call.Return(run)
	return _c
}

// IsTouchpad provides a mock function for the type mockdeviceConfig
func (_mock *mockdeviceConfig) IsTouchpad(dev uintptr) bool {
	ret := _mock.Called(dev)

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

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(uintptr) bool); ok {
		r0 = returnFunc(dev)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

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

// IsTouchpad is a helper method to define mock.On call
//   - dev uintptr
func (_e *mockdeviceConfig_Expecter) IsTouchpad(dev any) *mockdeviceConfig_IsTouchpad_Call {
	return &mockdeviceConfig_IsTouchpad_Call{Call: _e.mock.On("IsTouchpad", dev)}
}

func (_c *mockdeviceConfig_IsTouchpad_Call) Run(run func(dev uintptr)) *mockdeviceConfig_IsTouchpad_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uintptr
		if args[0] != nil {
			arg0 = args[0].(uintptr)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockdeviceConfig_IsTouchpad_Call) Return(b bool) *mockdeviceConfig_IsTouchpad_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *mockdeviceConfig_IsTouchpad_Call) RunAndReturn(run func(dev uintptr) bool) *mockdeviceConfig_IsTouchpad_Call {
	_c.Call.Return(run)
	return _c
}

// Name provides a mock function for the type mockdeviceConfig
func (_mock *mockdeviceConfig) Name(dev uintptr) string {
	ret := _mock.Called(dev)

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

	var r0 string
	if returnFunc, ok := ret.Get(0).(func(uintptr) string); ok {
		r0 = returnFunc(dev)
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

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

// Name is a helper method to define mock.On call
//   - dev uintptr
func (_e *mockdeviceConfig_Expecter) Name(dev any) *mockdeviceConfig_Name_Call {
	return &mockdeviceConfig_Name_Call{Call: _e.mock.On("Name", dev)}
}

func (_c *mockdeviceConfig_Name_Call) Run(run func(dev uintptr)) *mockdeviceConfig_Name_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uintptr
		if args[0] != nil {
			arg0 = args[0].(uintptr)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *mockdeviceConfig_Name_Call) Return(s string) *mockdeviceConfig_Name_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *mockdeviceConfig_Name_Call) RunAndReturn(run func(dev uintptr) string) *mockdeviceConfig_Name_Call {
	_c.Call.Return(run)
	return _c
}

// SetAccel provides a mock function for the type mockdeviceConfig
func (_mock *mockdeviceConfig) SetAccel(dev uintptr, speed float64, profile string) error {
	ret := _mock.Called(dev, speed, profile)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(uintptr, float64, string) error); ok {
		r0 = returnFunc(dev, speed, profile)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetAccel is a helper method to define mock.On call
//   - dev uintptr
//   - speed float64
//   - profile string
func (_e *mockdeviceConfig_Expecter) SetAccel(dev any, speed any, profile any) *mockdeviceConfig_SetAccel_Call {
	return &mockdeviceConfig_SetAccel_Call{Call: _e.mock.On("SetAccel", dev, speed, profile)}
}

func (_c *mockdeviceConfig_SetAccel_Call) Run(run func(dev uintptr, speed float64, profile string)) *mockdeviceConfig_SetAccel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uintptr
		if args[0] != nil {
			arg0 = args[0].(uintptr)
		}
		var arg1 float64
		if args[1] != nil {
			arg1 = args[1].(float64)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockdeviceConfig_SetAccel_Call) Return(err error) *mockdeviceConfig_SetAccel_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockdeviceConfig_SetAccel_Call) RunAndReturn(run func(dev uintptr, speed float64, profile string) error) *mockdeviceConfig_SetAccel_Call {
	_c.Call.Return(run)
	return _c
}

// SetLeftHanded provides a mock function for the type mockdeviceConfig
func (_mock *mockdeviceConfig) SetLeftHanded(dev uintptr, on bool) error {
	ret := _mock.Called(dev, on)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(uintptr, bool) error); ok {
		r0 = returnFunc(dev, on)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetLeftHanded is a helper method to define mock.On call
//   - dev uintptr
//   - on bool
func (_e *mockdeviceConfig_Expecter) SetLeftHanded(dev any, on any) *mockdeviceConfig_SetLeftHanded_Call {
	return &mockdeviceConfig_SetLeftHanded_Call{Call: _e.mock.On("SetLeftHanded", dev, on)}
}

func (_c *mockdeviceConfig_SetLeftHanded_Call) Run(run func(dev uintptr, on bool)) *mockdeviceConfig_SetLeftHanded_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uintptr
		if args[0] != nil {
			arg0 = args[0].(uintptr)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockdeviceConfig_SetLeftHanded_Call) Return(err error) *mockdeviceConfig_SetLeftHanded_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockdeviceConfig_SetLeftHanded_Call) RunAndReturn(run func(dev uintptr, on bool) error) *mockdeviceConfig_SetLeftHanded_Call {
	_c.Call.Return(run)
	return _c
}

// SetNaturalScroll provides a mock function for the type mockdeviceConfig
func (_mock *mockdeviceConfig) SetNaturalScroll(dev uintptr, on bool) error {
	ret := _mock.Called(dev, on)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(uintptr, bool) error); ok {
		r0 = returnFunc(dev, on)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetNaturalScroll is a helper method to define mock.On call
//   - dev uintptr
//   - on bool
func (_e *mockdeviceConfig_Expecter) SetNaturalScroll(dev any, on any) *mockdeviceConfig_SetNaturalScroll_Call {
	return &mockdeviceConfig_SetNaturalScroll_Call{Call: _e.mock.On("SetNaturalScroll", dev, on)}
}

func (_c *mockdeviceConfig_SetNaturalScroll_Call) Run(run func(dev uintptr, on bool)) *mockdeviceConfig_SetNaturalScroll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uintptr
		if args[0] != nil {
			arg0 = args[0].(uintptr)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockdeviceConfig_SetNaturalScroll_Call) Return(err error) *mockdeviceConfig_SetNaturalScroll_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockdeviceConfig_SetNaturalScroll_Call) RunAndReturn(run func(dev uintptr, on bool) error) *mockdeviceConfig_SetNaturalScroll_Call {
	_c.Call.Return(run)
	return _c
}

// SetTap provides a mock function for the type mockdeviceConfig
func (_mock *mockdeviceConfig) SetTap(dev uintptr, on bool) error {
	ret := _mock.Called(dev, on)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(uintptr, bool) error); ok {
		r0 = returnFunc(dev, on)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetTap is a helper method to define mock.On call
//   - dev uintptr
//   - on bool
func (_e *mockdeviceConfig_Expecter) SetTap(dev any, on any) *mockdeviceConfig_SetTap_Call {
	return &mockdeviceConfig_SetTap_Call{Call: _e.mock.On("SetTap", dev, on)}
}

func (_c *mockdeviceConfig_SetTap_Call) Run(run func(dev uintptr, on bool)) *mockdeviceConfig_SetTap_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uintptr
		if args[0] != nil {
			arg0 = args[0].(uintptr)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockdeviceConfig_SetTap_Call) Return(err error) *mockdeviceConfig_SetTap_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockdeviceConfig_SetTap_Call) RunAndReturn(run func(dev uintptr, on bool) error) *mockdeviceConfig_SetTap_Call {
	_c.Call.Return(run)
	return _c
}