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

package neferclient

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

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

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

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

	return mock
}

// mocksurfaceRequests is an autogenerated mock type for the surfaceRequests type
type mocksurfaceRequests struct {
	mock.Mock
}

type mocksurfaceRequests_Expecter struct {
	mock *mock.Mock
}

func (_m *mocksurfaceRequests) EXPECT() *mocksurfaceRequests_Expecter {
	return &mocksurfaceRequests_Expecter{mock: &_m.Mock}
}

// attach provides a mock function for the type mocksurfaceRequests
func (_mock *mocksurfaceRequests) attach(buffer uint64) error {
	ret := _mock.Called(buffer)

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

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

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

// attach is a helper method to define mock.On call
//   - buffer uint64
func (_e *mocksurfaceRequests_Expecter) attach(buffer any) *mocksurfaceRequests_attach_Call {
	return &mocksurfaceRequests_attach_Call{Call: _e.mock.On("attach", buffer)}
}

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

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

func (_c *mocksurfaceRequests_attach_Call) RunAndReturn(run func(buffer uint64) error) *mocksurfaceRequests_attach_Call {
	_c.Call.Return(run)
	return _c
}

// commit provides a mock function for the type mocksurfaceRequests
func (_mock *mocksurfaceRequests) commit() error {
	ret := _mock.Called()

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

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

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

// commit is a helper method to define mock.On call
func (_e *mocksurfaceRequests_Expecter) commit() *mocksurfaceRequests_commit_Call {
	return &mocksurfaceRequests_commit_Call{Call: _e.mock.On("commit")}
}

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

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

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

// damageBuffer provides a mock function for the type mocksurfaceRequests
func (_mock *mocksurfaceRequests) damageBuffer(r Rect) error {
	ret := _mock.Called(r)

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

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

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

// damageBuffer is a helper method to define mock.On call
//   - r Rect
func (_e *mocksurfaceRequests_Expecter) damageBuffer(r any) *mocksurfaceRequests_damageBuffer_Call {
	return &mocksurfaceRequests_damageBuffer_Call{Call: _e.mock.On("damageBuffer", r)}
}

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

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

func (_c *mocksurfaceRequests_damageBuffer_Call) RunAndReturn(run func(r Rect) error) *mocksurfaceRequests_damageBuffer_Call {
	_c.Call.Return(run)
	return _c
}

// frame provides a mock function for the type mocksurfaceRequests
func (_mock *mocksurfaceRequests) frame() error {
	ret := _mock.Called()

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

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

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

// frame is a helper method to define mock.On call
func (_e *mocksurfaceRequests_Expecter) frame() *mocksurfaceRequests_frame_Call {
	return &mocksurfaceRequests_frame_Call{Call: _e.mock.On("frame")}
}

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

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

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

// setAcquire provides a mock function for the type mocksurfaceRequests
func (_mock *mocksurfaceRequests) setAcquire(timeline uint64, point uint64) error {
	ret := _mock.Called(timeline, point)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(uint64, uint64) error); ok {
		r0 = returnFunc(timeline, point)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// setAcquire is a helper method to define mock.On call
//   - timeline uint64
//   - point uint64
func (_e *mocksurfaceRequests_Expecter) setAcquire(timeline any, point any) *mocksurfaceRequests_setAcquire_Call {
	return &mocksurfaceRequests_setAcquire_Call{Call: _e.mock.On("setAcquire", timeline, point)}
}

func (_c *mocksurfaceRequests_setAcquire_Call) Run(run func(timeline uint64, point uint64)) *mocksurfaceRequests_setAcquire_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uint64
		if args[0] != nil {
			arg0 = args[0].(uint64)
		}
		var arg1 uint64
		if args[1] != nil {
			arg1 = args[1].(uint64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *mocksurfaceRequests_setAcquire_Call) RunAndReturn(run func(timeline uint64, point uint64) error) *mocksurfaceRequests_setAcquire_Call {
	_c.Call.Return(run)
	return _c
}

// setBufferScale provides a mock function for the type mocksurfaceRequests
func (_mock *mocksurfaceRequests) setBufferScale(n int32) error {
	ret := _mock.Called(n)

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

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

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

// setBufferScale is a helper method to define mock.On call
//   - n int32
func (_e *mocksurfaceRequests_Expecter) setBufferScale(n any) *mocksurfaceRequests_setBufferScale_Call {
	return &mocksurfaceRequests_setBufferScale_Call{Call: _e.mock.On("setBufferScale", n)}
}

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

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

func (_c *mocksurfaceRequests_setBufferScale_Call) RunAndReturn(run func(n int32) error) *mocksurfaceRequests_setBufferScale_Call {
	_c.Call.Return(run)
	return _c
}

// setDestination provides a mock function for the type mocksurfaceRequests
func (_mock *mocksurfaceRequests) setDestination(w int32, h int32) error {
	ret := _mock.Called(w, h)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(int32, int32) error); ok {
		r0 = returnFunc(w, h)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// setDestination is a helper method to define mock.On call
//   - w int32
//   - h int32
func (_e *mocksurfaceRequests_Expecter) setDestination(w any, h any) *mocksurfaceRequests_setDestination_Call {
	return &mocksurfaceRequests_setDestination_Call{Call: _e.mock.On("setDestination", w, h)}
}

func (_c *mocksurfaceRequests_setDestination_Call) Run(run func(w int32, h int32)) *mocksurfaceRequests_setDestination_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int32
		if args[0] != nil {
			arg0 = args[0].(int32)
		}
		var arg1 int32
		if args[1] != nil {
			arg1 = args[1].(int32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *mocksurfaceRequests_setDestination_Call) RunAndReturn(run func(w int32, h int32) error) *mocksurfaceRequests_setDestination_Call {
	_c.Call.Return(run)
	return _c
}

// setOpaqueRegion provides a mock function for the type mocksurfaceRequests
func (_mock *mocksurfaceRequests) setOpaqueRegion(w int32, h int32, opaque bool) error {
	ret := _mock.Called(w, h, opaque)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(int32, int32, bool) error); ok {
		r0 = returnFunc(w, h, opaque)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// setOpaqueRegion is a helper method to define mock.On call
//   - w int32
//   - h int32
//   - opaque bool
func (_e *mocksurfaceRequests_Expecter) setOpaqueRegion(w any, h any, opaque any) *mocksurfaceRequests_setOpaqueRegion_Call {
	return &mocksurfaceRequests_setOpaqueRegion_Call{Call: _e.mock.On("setOpaqueRegion", w, h, opaque)}
}

func (_c *mocksurfaceRequests_setOpaqueRegion_Call) Run(run func(w int32, h int32, opaque bool)) *mocksurfaceRequests_setOpaqueRegion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int32
		if args[0] != nil {
			arg0 = args[0].(int32)
		}
		var arg1 int32
		if args[1] != nil {
			arg1 = args[1].(int32)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *mocksurfaceRequests_setOpaqueRegion_Call) RunAndReturn(run func(w int32, h int32, opaque bool) error) *mocksurfaceRequests_setOpaqueRegion_Call {
	_c.Call.Return(run)
	return _c
}

// setRelease provides a mock function for the type mocksurfaceRequests
func (_mock *mocksurfaceRequests) setRelease(timeline uint64, point uint64) error {
	ret := _mock.Called(timeline, point)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(uint64, uint64) error); ok {
		r0 = returnFunc(timeline, point)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// setRelease is a helper method to define mock.On call
//   - timeline uint64
//   - point uint64
func (_e *mocksurfaceRequests_Expecter) setRelease(timeline any, point any) *mocksurfaceRequests_setRelease_Call {
	return &mocksurfaceRequests_setRelease_Call{Call: _e.mock.On("setRelease", timeline, point)}
}

func (_c *mocksurfaceRequests_setRelease_Call) Run(run func(timeline uint64, point uint64)) *mocksurfaceRequests_setRelease_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 uint64
		if args[0] != nil {
			arg0 = args[0].(uint64)
		}
		var arg1 uint64
		if args[1] != nil {
			arg1 = args[1].(uint64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *mocksurfaceRequests_setRelease_Call) RunAndReturn(run func(timeline uint64, point uint64) error) *mocksurfaceRequests_setRelease_Call {
	_c.Call.Return(run)
	return _c
}