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

package portsmocks

import (
	"image"
	"os"
	"time"

	"github.com/bnema/neferwl/internal/ports"
	mock "github.com/stretchr/testify/mock"
)

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

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

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

	return mock
}

// MockCaptureFrame is an autogenerated mock type for the CaptureFrame type
type MockCaptureFrame struct {
	mock.Mock
}

type MockCaptureFrame_Expecter struct {
	mock *mock.Mock
}

func (_m *MockCaptureFrame) EXPECT() *MockCaptureFrame_Expecter {
	return &MockCaptureFrame_Expecter{mock: &_m.Mock}
}

// Done provides a mock function for the type MockCaptureFrame
func (_mock *MockCaptureFrame) Done() *os.File {
	ret := _mock.Called()

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

	var r0 *os.File
	if returnFunc, ok := ret.Get(0).(func() *os.File); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*os.File)
		}
	}
	return r0
}

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

// Done is a helper method to define mock.On call
func (_e *MockCaptureFrame_Expecter) Done() *MockCaptureFrame_Done_Call {
	return &MockCaptureFrame_Done_Call{Call: _e.mock.On("Done")}
}

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

func (_c *MockCaptureFrame_Done_Call) Return(file *os.File) *MockCaptureFrame_Done_Call {
	_c.Call.Return(file)
	return _c
}

func (_c *MockCaptureFrame_Done_Call) RunAndReturn(run func() *os.File) *MockCaptureFrame_Done_Call {
	_c.Call.Return(run)
	return _c
}

// Read provides a mock function for the type MockCaptureFrame
func (_mock *MockCaptureFrame) Read(region image.Rectangle, dst []byte, stride int) error {
	ret := _mock.Called(region, dst, stride)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(image.Rectangle, []byte, int) error); ok {
		r0 = returnFunc(region, dst, stride)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Read is a helper method to define mock.On call
//   - region image.Rectangle
//   - dst []byte
//   - stride int
func (_e *MockCaptureFrame_Expecter) Read(region any, dst any, stride any) *MockCaptureFrame_Read_Call {
	return &MockCaptureFrame_Read_Call{Call: _e.mock.On("Read", region, dst, stride)}
}

func (_c *MockCaptureFrame_Read_Call) Run(run func(region image.Rectangle, dst []byte, stride int)) *MockCaptureFrame_Read_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 image.Rectangle
		if args[0] != nil {
			arg0 = args[0].(image.Rectangle)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockCaptureFrame_Read_Call) RunAndReturn(run func(region image.Rectangle, dst []byte, stride int) error) *MockCaptureFrame_Read_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return mock
}

// MockRenderer is an autogenerated mock type for the Renderer type
type MockRenderer struct {
	mock.Mock
}

type MockRenderer_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRenderer) EXPECT() *MockRenderer_Expecter {
	return &MockRenderer_Expecter{mock: &_m.Mock}
}

// BeginCapture provides a mock function for the type MockRenderer
func (_mock *MockRenderer) BeginCapture() (ports.CaptureFrame, error) {
	ret := _mock.Called()

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

	var r0 ports.CaptureFrame
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (ports.CaptureFrame, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() ports.CaptureFrame); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ports.CaptureFrame)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// BeginCapture is a helper method to define mock.On call
func (_e *MockRenderer_Expecter) BeginCapture() *MockRenderer_BeginCapture_Call {
	return &MockRenderer_BeginCapture_Call{Call: _e.mock.On("BeginCapture")}
}

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

func (_c *MockRenderer_BeginCapture_Call) Return(captureFrame ports.CaptureFrame, err error) *MockRenderer_BeginCapture_Call {
	_c.Call.Return(captureFrame, err)
	return _c
}

func (_c *MockRenderer_BeginCapture_Call) RunAndReturn(run func() (ports.CaptureFrame, error)) *MockRenderer_BeginCapture_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function for the type MockRenderer
func (_mock *MockRenderer) Close() {
	_mock.Called()
	return
}

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

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

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

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

func (_c *MockRenderer_Close_Call) RunAndReturn(run func()) *MockRenderer_Close_Call {
	_c.Run(run)
	return _c
}

// CursorBuffers provides a mock function for the type MockRenderer
func (_mock *MockRenderer) CursorBuffers(size int) ([2]ports.DMABuf, error) {
	ret := _mock.Called(size)

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

	var r0 [2]ports.DMABuf
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int) ([2]ports.DMABuf, error)); ok {
		return returnFunc(size)
	}
	if returnFunc, ok := ret.Get(0).(func(int) [2]ports.DMABuf); ok {
		r0 = returnFunc(size)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([2]ports.DMABuf)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int) error); ok {
		r1 = returnFunc(size)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CursorBuffers is a helper method to define mock.On call
//   - size int
func (_e *MockRenderer_Expecter) CursorBuffers(size any) *MockRenderer_CursorBuffers_Call {
	return &MockRenderer_CursorBuffers_Call{Call: _e.mock.On("CursorBuffers", size)}
}

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

func (_c *MockRenderer_CursorBuffers_Call) Return(dMABufs [2]ports.DMABuf, err error) *MockRenderer_CursorBuffers_Call {
	_c.Call.Return(dMABufs, err)
	return _c
}

func (_c *MockRenderer_CursorBuffers_Call) RunAndReturn(run func(size int) ([2]ports.DMABuf, error)) *MockRenderer_CursorBuffers_Call {
	_c.Call.Return(run)
	return _c
}

// EndCapture provides a mock function for the type MockRenderer
func (_mock *MockRenderer) EndCapture(captureFrame ports.CaptureFrame) {
	_mock.Called(captureFrame)
	return
}

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

// EndCapture is a helper method to define mock.On call
//   - captureFrame ports.CaptureFrame
func (_e *MockRenderer_Expecter) EndCapture(captureFrame any) *MockRenderer_EndCapture_Call {
	return &MockRenderer_EndCapture_Call{Call: _e.mock.On("EndCapture", captureFrame)}
}

func (_c *MockRenderer_EndCapture_Call) Run(run func(captureFrame ports.CaptureFrame)) *MockRenderer_EndCapture_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.CaptureFrame
		if args[0] != nil {
			arg0 = args[0].(ports.CaptureFrame)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockRenderer_EndCapture_Call) RunAndReturn(run func(captureFrame ports.CaptureFrame)) *MockRenderer_EndCapture_Call {
	_c.Run(run)
	return _c
}

// ExportTargets provides a mock function for the type MockRenderer
func (_mock *MockRenderer) ExportTargets(n int, modifiers []uint64, singlePlane bool) ([]ports.DMABuf, error) {
	ret := _mock.Called(n, modifiers, singlePlane)

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

	var r0 []ports.DMABuf
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int, []uint64, bool) ([]ports.DMABuf, error)); ok {
		return returnFunc(n, modifiers, singlePlane)
	}
	if returnFunc, ok := ret.Get(0).(func(int, []uint64, bool) []ports.DMABuf); ok {
		r0 = returnFunc(n, modifiers, singlePlane)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]ports.DMABuf)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int, []uint64, bool) error); ok {
		r1 = returnFunc(n, modifiers, singlePlane)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ExportTargets is a helper method to define mock.On call
//   - n int
//   - modifiers []uint64
//   - singlePlane bool
func (_e *MockRenderer_Expecter) ExportTargets(n any, modifiers any, singlePlane any) *MockRenderer_ExportTargets_Call {
	return &MockRenderer_ExportTargets_Call{Call: _e.mock.On("ExportTargets", n, modifiers, singlePlane)}
}

func (_c *MockRenderer_ExportTargets_Call) Run(run func(n int, modifiers []uint64, singlePlane bool)) *MockRenderer_ExportTargets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 []uint64
		if args[1] != nil {
			arg1 = args[1].([]uint64)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockRenderer_ExportTargets_Call) Return(dMABufs []ports.DMABuf, err error) *MockRenderer_ExportTargets_Call {
	_c.Call.Return(dMABufs, err)
	return _c
}

func (_c *MockRenderer_ExportTargets_Call) RunAndReturn(run func(n int, modifiers []uint64, singlePlane bool) ([]ports.DMABuf, error)) *MockRenderer_ExportTargets_Call {
	_c.Call.Return(run)
	return _c
}

// HDRPixels provides a mock function for the type MockRenderer
func (_mock *MockRenderer) HDRPixels() *image.RGBA64 {
	ret := _mock.Called()

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

	var r0 *image.RGBA64
	if returnFunc, ok := ret.Get(0).(func() *image.RGBA64); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*image.RGBA64)
		}
	}
	return r0
}

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

// HDRPixels is a helper method to define mock.On call
func (_e *MockRenderer_Expecter) HDRPixels() *MockRenderer_HDRPixels_Call {
	return &MockRenderer_HDRPixels_Call{Call: _e.mock.On("HDRPixels")}
}

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

func (_c *MockRenderer_HDRPixels_Call) Return(rGBA64 *image.RGBA64) *MockRenderer_HDRPixels_Call {
	_c.Call.Return(rGBA64)
	return _c
}

func (_c *MockRenderer_HDRPixels_Call) RunAndReturn(run func() *image.RGBA64) *MockRenderer_HDRPixels_Call {
	_c.Call.Return(run)
	return _c
}

// Pixels provides a mock function for the type MockRenderer
func (_mock *MockRenderer) Pixels() *image.RGBA {
	ret := _mock.Called()

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

	var r0 *image.RGBA
	if returnFunc, ok := ret.Get(0).(func() *image.RGBA); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*image.RGBA)
		}
	}
	return r0
}

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

// Pixels is a helper method to define mock.On call
func (_e *MockRenderer_Expecter) Pixels() *MockRenderer_Pixels_Call {
	return &MockRenderer_Pixels_Call{Call: _e.mock.On("Pixels")}
}

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

func (_c *MockRenderer_Pixels_Call) Return(rGBA *image.RGBA) *MockRenderer_Pixels_Call {
	_c.Call.Return(rGBA)
	return _c
}

func (_c *MockRenderer_Pixels_Call) RunAndReturn(run func() *image.RGBA) *MockRenderer_Pixels_Call {
	_c.Call.Return(run)
	return _c
}

// Render provides a mock function for the type MockRenderer
func (_mock *MockRenderer) Render(scene ports.Scene, windowIDToSurfaceContent map[ports.WindowID]ports.SurfaceContent) (*os.File, error) {
	ret := _mock.Called(scene, windowIDToSurfaceContent)

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

	var r0 *os.File
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(ports.Scene, map[ports.WindowID]ports.SurfaceContent) (*os.File, error)); ok {
		return returnFunc(scene, windowIDToSurfaceContent)
	}
	if returnFunc, ok := ret.Get(0).(func(ports.Scene, map[ports.WindowID]ports.SurfaceContent) *os.File); ok {
		r0 = returnFunc(scene, windowIDToSurfaceContent)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*os.File)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(ports.Scene, map[ports.WindowID]ports.SurfaceContent) error); ok {
		r1 = returnFunc(scene, windowIDToSurfaceContent)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Render is a helper method to define mock.On call
//   - scene ports.Scene
//   - windowIDToSurfaceContent map[ports.WindowID]ports.SurfaceContent
func (_e *MockRenderer_Expecter) Render(scene any, windowIDToSurfaceContent any) *MockRenderer_Render_Call {
	return &MockRenderer_Render_Call{Call: _e.mock.On("Render", scene, windowIDToSurfaceContent)}
}

func (_c *MockRenderer_Render_Call) Run(run func(scene ports.Scene, windowIDToSurfaceContent map[ports.WindowID]ports.SurfaceContent)) *MockRenderer_Render_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.Scene
		if args[0] != nil {
			arg0 = args[0].(ports.Scene)
		}
		var arg1 map[ports.WindowID]ports.SurfaceContent
		if args[1] != nil {
			arg1 = args[1].(map[ports.WindowID]ports.SurfaceContent)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockRenderer_Render_Call) Return(done *os.File, err error) *MockRenderer_Render_Call {
	_c.Call.Return(done, err)
	return _c
}

func (_c *MockRenderer_Render_Call) RunAndReturn(run func(scene ports.Scene, windowIDToSurfaceContent map[ports.WindowID]ports.SurfaceContent) (*os.File, error)) *MockRenderer_Render_Call {
	_c.Call.Return(run)
	return _c
}

// SetHDR provides a mock function for the type MockRenderer
func (_mock *MockRenderer) SetHDR(sdrNits float64) {
	_mock.Called(sdrNits)
	return
}

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

// SetHDR is a helper method to define mock.On call
//   - sdrNits float64
func (_e *MockRenderer_Expecter) SetHDR(sdrNits any) *MockRenderer_SetHDR_Call {
	return &MockRenderer_SetHDR_Call{Call: _e.mock.On("SetHDR", sdrNits)}
}

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

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

func (_c *MockRenderer_SetHDR_Call) RunAndReturn(run func(sdrNits float64)) *MockRenderer_SetHDR_Call {
	_c.Run(run)
	return _c
}

// TakeRedrawn provides a mock function for the type MockRenderer
func (_mock *MockRenderer) TakeRedrawn() int {
	ret := _mock.Called()

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

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

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

// TakeRedrawn is a helper method to define mock.On call
func (_e *MockRenderer_Expecter) TakeRedrawn() *MockRenderer_TakeRedrawn_Call {
	return &MockRenderer_TakeRedrawn_Call{Call: _e.mock.On("TakeRedrawn")}
}

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

func (_c *MockRenderer_TakeRedrawn_Call) Return(n int) *MockRenderer_TakeRedrawn_Call {
	_c.Call.Return(n)
	return _c
}

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

// Trim provides a mock function for the type MockRenderer
func (_mock *MockRenderer) Trim(now time.Time) error {
	ret := _mock.Called(now)

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

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

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

// Trim is a helper method to define mock.On call
//   - now time.Time
func (_e *MockRenderer_Expecter) Trim(now any) *MockRenderer_Trim_Call {
	return &MockRenderer_Trim_Call{Call: _e.mock.On("Trim", now)}
}

func (_c *MockRenderer_Trim_Call) Run(run func(now time.Time)) *MockRenderer_Trim_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 time.Time
		if args[0] != nil {
			arg0 = args[0].(time.Time)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockRenderer_Trim_Call) RunAndReturn(run func(now time.Time) error) *MockRenderer_Trim_Call {
	_c.Call.Return(run)
	return _c
}

// UseTarget provides a mock function for the type MockRenderer
func (_mock *MockRenderer) UseTarget(i int) {
	_mock.Called(i)
	return
}

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

// UseTarget is a helper method to define mock.On call
//   - i int
func (_e *MockRenderer_Expecter) UseTarget(i any) *MockRenderer_UseTarget_Call {
	return &MockRenderer_UseTarget_Call{Call: _e.mock.On("UseTarget", i)}
}

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

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

func (_c *MockRenderer_UseTarget_Call) RunAndReturn(run func(i int)) *MockRenderer_UseTarget_Call {
	_c.Run(run)
	return _c
}

// WriteCursor provides a mock function for the type MockRenderer
func (_mock *MockRenderer) WriteCursor(i int, pixels []byte, w int, h int) error {
	ret := _mock.Called(i, pixels, w, h)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(int, []byte, int, int) error); ok {
		r0 = returnFunc(i, pixels, w, h)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// WriteCursor is a helper method to define mock.On call
//   - i int
//   - pixels []byte
//   - w int
//   - h int
func (_e *MockRenderer_Expecter) WriteCursor(i any, pixels any, w any, h any) *MockRenderer_WriteCursor_Call {
	return &MockRenderer_WriteCursor_Call{Call: _e.mock.On("WriteCursor", i, pixels, w, h)}
}

func (_c *MockRenderer_WriteCursor_Call) Run(run func(i int, pixels []byte, w int, h int)) *MockRenderer_WriteCursor_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		var arg3 int
		if args[3] != nil {
			arg3 = args[3].(int)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *MockRenderer_WriteCursor_Call) RunAndReturn(run func(i int, pixels []byte, w int, h int) error) *MockRenderer_WriteCursor_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return mock
}

// MockSeat is an autogenerated mock type for the Seat type
type MockSeat struct {
	mock.Mock
}

type MockSeat_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSeat) EXPECT() *MockSeat_Expecter {
	return &MockSeat_Expecter{mock: &_m.Mock}
}

// CloseDevice provides a mock function for the type MockSeat
func (_mock *MockSeat) CloseDevice(fd int) {
	_mock.Called(fd)
	return
}

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

// CloseDevice is a helper method to define mock.On call
//   - fd int
func (_e *MockSeat_Expecter) CloseDevice(fd any) *MockSeat_CloseDevice_Call {
	return &MockSeat_CloseDevice_Call{Call: _e.mock.On("CloseDevice", fd)}
}

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

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

func (_c *MockSeat_CloseDevice_Call) RunAndReturn(run func(fd int)) *MockSeat_CloseDevice_Call {
	_c.Run(run)
	return _c
}

// OpenDevice provides a mock function for the type MockSeat
func (_mock *MockSeat) OpenDevice(path string) (int, error) {
	ret := _mock.Called(path)

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

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

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

// OpenDevice is a helper method to define mock.On call
//   - path string
func (_e *MockSeat_Expecter) OpenDevice(path any) *MockSeat_OpenDevice_Call {
	return &MockSeat_OpenDevice_Call{Call: _e.mock.On("OpenDevice", path)}
}

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

func (_c *MockSeat_OpenDevice_Call) Return(n int, err error) *MockSeat_OpenDevice_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *MockSeat_OpenDevice_Call) RunAndReturn(run func(path string) (int, error)) *MockSeat_OpenDevice_Call {
	_c.Call.Return(run)
	return _c
}

// SwitchVT provides a mock function for the type MockSeat
func (_mock *MockSeat) SwitchVT(vt int) {
	_mock.Called(vt)
	return
}

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

// SwitchVT is a helper method to define mock.On call
//   - vt int
func (_e *MockSeat_Expecter) SwitchVT(vt any) *MockSeat_SwitchVT_Call {
	return &MockSeat_SwitchVT_Call{Call: _e.mock.On("SwitchVT", vt)}
}

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

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

func (_c *MockSeat_SwitchVT_Call) RunAndReturn(run func(vt int)) *MockSeat_SwitchVT_Call {
	_c.Run(run)
	return _c
}