chore(mocks): generate testify mocks for ports

Runs mockery (v3.7.1, testify template) over internal/ports, producing
internal/ports/mocks/mocks.go with mocks for PTY, PTYFactory, Terminal,
Transport, Listener, Clock, and Timer. testify enters go.mod as a
dependency of the mocks package only; the production binary (main)
pulls in zero testify packages, verified via `go list -deps .`.

`go mod tidy` also dropped golang.org/x/sys and golang.org/x/term as
unused indirect requires — nothing currently imports them.

commit: 63e4fd6247d1d8bdf55c0650358166d6519c0391
author: brice · 3mo ago · 2026-07-02 10:57 UTC
parent: 621dedb
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email

3 files · +1379 -6

M go.mod +6 -2


@@ -2,7 +2,11 @@ module github.com/bnema/vev
2	2
3	3		go 1.26
4	4
	5	+	require github.com/stretchr/testify v1.11.1
	6	+
5	7		require (
6		-	golang.org/x/sys v0.46.0 // indirect
7		-	golang.org/x/term v0.44.0 // indirect
	8	+	github.com/davecgh/go-spew v1.1.1 // indirect
	9	+	github.com/pmezard/go-difflib v1.0.0 // indirect
	10	+	github.com/stretchr/objx v0.5.2 // indirect
	11	+	gopkg.in/yaml.v3 v3.0.1 // indirect
8	12		)

 go 1.26
+require github.com/stretchr/testify v1.11.1
 require (
-	golang.org/x/sys v0.46.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
-	golang.org/x/term v0.44.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/stretchr/objx v0.5.2 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

M go.sum +12 -4 generated file: collapsed

load diff

A internal/ports/mocks/mocks.go +1361 -0

@@ -0,0 +1,1361 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package portsmocks
	6	+
	7	+	import (
	8	+	"io"
	9	+	"time"
	10	+
	11	+	"github.com/bnema/vev/internal/domain"
	12	+	"github.com/bnema/vev/internal/ports"
	13	+	mock "github.com/stretchr/testify/mock"
	14	+	)
	15	+
	16	+	// NewMockPTY creates a new instance of MockPTY. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	17	+	// The first argument is typically a *testing.T value.
	18	+	func NewMockPTY(t interface {
	19	+	mock.TestingT
	20	+	Cleanup(func())
	21	+	}) *MockPTY {
	22	+	mock := &MockPTY{}
	23	+	mock.Mock.Test(t)
	24	+
	25	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	26	+
	27	+	return mock
	28	+	}
	29	+
	30	+	// MockPTY is an autogenerated mock type for the PTY type
	31	+	type MockPTY struct {
	32	+	mock.Mock
	33	+	}
	34	+
	35	+	type MockPTY_Expecter struct {
	36	+	mock *mock.Mock
	37	+	}
	38	+
	39	+	func (_m MockPTY) EXPECT() MockPTY_Expecter {
	40	+	return &MockPTY_Expecter{mock: &_m.Mock}
	41	+	}
	42	+
	43	+	// Close provides a mock function for the type MockPTY
	44	+	func (_mock *MockPTY) Close() error {
	45	+	ret := _mock.Called()
	46	+
	47	+	if len(ret) == 0 {
	48	+	panic("no return value specified for Close")
	49	+	}
	50	+
	51	+	var r0 error
	52	+	if returnFunc, ok := ret.Get(0).(func() error); ok {
	53	+	r0 = returnFunc()
	54	+	} else {
	55	+	r0 = ret.Error(0)
	56	+	}
	57	+	return r0
	58	+	}
	59	+
	60	+	// MockPTY_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
	61	+	type MockPTY_Close_Call struct {
	62	+	*mock.Call
	63	+	}
	64	+
	65	+	// Close is a helper method to define mock.On call
	66	+	func (_e MockPTY_Expecter) Close() MockPTY_Close_Call {
	67	+	return &MockPTY_Close_Call{Call: _e.mock.On("Close")}
	68	+	}
	69	+
	70	+	func (_c MockPTY_Close_Call) Run(run func()) MockPTY_Close_Call {
	71	+	_c.Call.Run(func(args mock.Arguments) {
	72	+	run()
	73	+	})
	74	+	return _c
	75	+	}
	76	+
	77	+	func (_c MockPTY_Close_Call) Return(err error) MockPTY_Close_Call {
	78	+	_c.Call.Return(err)
	79	+	return _c
	80	+	}
	81	+
	82	+	func (_c MockPTY_Close_Call) RunAndReturn(run func() error) MockPTY_Close_Call {
	83	+	_c.Call.Return(run)
	84	+	return _c
	85	+	}
	86	+
	87	+	// Pid provides a mock function for the type MockPTY
	88	+	func (_mock *MockPTY) Pid() int {
	89	+	ret := _mock.Called()
	90	+
	91	+	if len(ret) == 0 {
	92	+	panic("no return value specified for Pid")
	93	+	}
	94	+
	95	+	var r0 int
	96	+	if returnFunc, ok := ret.Get(0).(func() int); ok {
	97	+	r0 = returnFunc()
	98	+	} else {
	99	+	r0 = ret.Get(0).(int)
	100	+	}
	101	+	return r0
	102	+	}
	103	+
	104	+	// MockPTY_Pid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pid'
	105	+	type MockPTY_Pid_Call struct {
	106	+	*mock.Call
	107	+	}
	108	+
	109	+	// Pid is a helper method to define mock.On call
	110	+	func (_e MockPTY_Expecter) Pid() MockPTY_Pid_Call {
	111	+	return &MockPTY_Pid_Call{Call: _e.mock.On("Pid")}
	112	+	}
	113	+
	114	+	func (_c MockPTY_Pid_Call) Run(run func()) MockPTY_Pid_Call {
	115	+	_c.Call.Run(func(args mock.Arguments) {
	116	+	run()
	117	+	})
	118	+	return _c
	119	+	}
	120	+
	121	+	func (_c MockPTY_Pid_Call) Return(n int) MockPTY_Pid_Call {
	122	+	_c.Call.Return(n)
	123	+	return _c
	124	+	}
	125	+
	126	+	func (_c MockPTY_Pid_Call) RunAndReturn(run func() int) MockPTY_Pid_Call {
	127	+	_c.Call.Return(run)
	128	+	return _c
	129	+	}
	130	+
	131	+	// Read provides a mock function for the type MockPTY
	132	+	func (_mock *MockPTY) Read(p []byte) (int, error) {
	133	+	ret := _mock.Called(p)
	134	+
	135	+	if len(ret) == 0 {
	136	+	panic("no return value specified for Read")
	137	+	}
	138	+
	139	+	var r0 int
	140	+	var r1 error
	141	+	if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
	142	+	return returnFunc(p)
	143	+	}
	144	+	if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
	145	+	r0 = returnFunc(p)
	146	+	} else {
	147	+	r0 = ret.Get(0).(int)
	148	+	}
	149	+	if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
	150	+	r1 = returnFunc(p)
	151	+	} else {
	152	+	r1 = ret.Error(1)
	153	+	}
	154	+	return r0, r1
	155	+	}
	156	+
	157	+	// MockPTY_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
	158	+	type MockPTY_Read_Call struct {
	159	+	*mock.Call
	160	+	}
	161	+
	162	+	// Read is a helper method to define mock.On call
	163	+	// - p []byte
	164	+	func (_e MockPTY_Expecter) Read(p any) MockPTY_Read_Call {
	165	+	return &MockPTY_Read_Call{Call: _e.mock.On("Read", p)}
	166	+	}
	167	+
	168	+	func (_c MockPTY_Read_Call) Run(run func(p []byte)) MockPTY_Read_Call {
	169	+	_c.Call.Run(func(args mock.Arguments) {
	170	+	var arg0 []byte
	171	+	if args[0] != nil {
	172	+	arg0 = args[0].([]byte)
	173	+	}
	174	+	run(
	175	+	arg0,
	176	+	)
	177	+	})
	178	+	return _c
	179	+	}
	180	+
	181	+	func (_c MockPTY_Read_Call) Return(n int, err error) MockPTY_Read_Call {
	182	+	_c.Call.Return(n, err)
	183	+	return _c
	184	+	}
	185	+
	186	+	func (_c MockPTY_Read_Call) RunAndReturn(run func(p []byte) (int, error)) MockPTY_Read_Call {
	187	+	_c.Call.Return(run)
	188	+	return _c
	189	+	}
	190	+
	191	+	// Resize provides a mock function for the type MockPTY
	192	+	func (_mock *MockPTY) Resize(sz domain.Size) error {
	193	+	ret := _mock.Called(sz)
	194	+
	195	+	if len(ret) == 0 {
	196	+	panic("no return value specified for Resize")
	197	+	}
	198	+
	199	+	var r0 error
	200	+	if returnFunc, ok := ret.Get(0).(func(domain.Size) error); ok {
	201	+	r0 = returnFunc(sz)
	202	+	} else {
	203	+	r0 = ret.Error(0)
	204	+	}
	205	+	return r0
	206	+	}
	207	+
	208	+	// MockPTY_Resize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resize'
	209	+	type MockPTY_Resize_Call struct {
	210	+	*mock.Call
	211	+	}
	212	+
	213	+	// Resize is a helper method to define mock.On call
	214	+	// - sz domain.Size
	215	+	func (_e MockPTY_Expecter) Resize(sz any) MockPTY_Resize_Call {
	216	+	return &MockPTY_Resize_Call{Call: _e.mock.On("Resize", sz)}
	217	+	}
	218	+
	219	+	func (_c MockPTY_Resize_Call) Run(run func(sz domain.Size)) MockPTY_Resize_Call {
	220	+	_c.Call.Run(func(args mock.Arguments) {
	221	+	var arg0 domain.Size
	222	+	if args[0] != nil {
	223	+	arg0 = args[0].(domain.Size)
	224	+	}
	225	+	run(
	226	+	arg0,
	227	+	)
	228	+	})
	229	+	return _c
	230	+	}
	231	+
	232	+	func (_c MockPTY_Resize_Call) Return(err error) MockPTY_Resize_Call {
	233	+	_c.Call.Return(err)
	234	+	return _c
	235	+	}
	236	+
	237	+	func (_c MockPTY_Resize_Call) RunAndReturn(run func(sz domain.Size) error) MockPTY_Resize_Call {
	238	+	_c.Call.Return(run)
	239	+	return _c
	240	+	}
	241	+
	242	+	// Write provides a mock function for the type MockPTY
	243	+	func (_mock *MockPTY) Write(p []byte) (int, error) {
	244	+	ret := _mock.Called(p)
	245	+
	246	+	if len(ret) == 0 {
	247	+	panic("no return value specified for Write")
	248	+	}
	249	+
	250	+	var r0 int
	251	+	var r1 error
	252	+	if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
	253	+	return returnFunc(p)
	254	+	}
	255	+	if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
	256	+	r0 = returnFunc(p)
	257	+	} else {
	258	+	r0 = ret.Get(0).(int)
	259	+	}
	260	+	if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
	261	+	r1 = returnFunc(p)
	262	+	} else {
	263	+	r1 = ret.Error(1)
	264	+	}
	265	+	return r0, r1
	266	+	}
	267	+
	268	+	// MockPTY_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
	269	+	type MockPTY_Write_Call struct {
	270	+	*mock.Call
	271	+	}
	272	+
	273	+	// Write is a helper method to define mock.On call
	274	+	// - p []byte
	275	+	func (_e MockPTY_Expecter) Write(p any) MockPTY_Write_Call {
	276	+	return &MockPTY_Write_Call{Call: _e.mock.On("Write", p)}
	277	+	}
	278	+
	279	+	func (_c MockPTY_Write_Call) Run(run func(p []byte)) MockPTY_Write_Call {
	280	+	_c.Call.Run(func(args mock.Arguments) {
	281	+	var arg0 []byte
	282	+	if args[0] != nil {
	283	+	arg0 = args[0].([]byte)
	284	+	}
	285	+	run(
	286	+	arg0,
	287	+	)
	288	+	})
	289	+	return _c
	290	+	}
	291	+
	292	+	func (_c MockPTY_Write_Call) Return(n int, err error) MockPTY_Write_Call {
	293	+	_c.Call.Return(n, err)
	294	+	return _c
	295	+	}
	296	+
	297	+	func (_c MockPTY_Write_Call) RunAndReturn(run func(p []byte) (int, error)) MockPTY_Write_Call {
	298	+	_c.Call.Return(run)
	299	+	return _c
	300	+	}
	301	+
	302	+	// NewMockPTYFactory creates a new instance of MockPTYFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	303	+	// The first argument is typically a *testing.T value.
	304	+	func NewMockPTYFactory(t interface {
	305	+	mock.TestingT
	306	+	Cleanup(func())
	307	+	}) *MockPTYFactory {
	308	+	mock := &MockPTYFactory{}
	309	+	mock.Mock.Test(t)
	310	+
	311	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	312	+
	313	+	return mock
	314	+	}
	315	+
	316	+	// MockPTYFactory is an autogenerated mock type for the PTYFactory type
	317	+	type MockPTYFactory struct {
	318	+	mock.Mock
	319	+	}
	320	+
	321	+	type MockPTYFactory_Expecter struct {
	322	+	mock *mock.Mock
	323	+	}
	324	+
	325	+	func (_m MockPTYFactory) EXPECT() MockPTYFactory_Expecter {
	326	+	return &MockPTYFactory_Expecter{mock: &_m.Mock}
	327	+	}
	328	+
	329	+	// Open provides a mock function for the type MockPTYFactory
	330	+	func (_mock *MockPTYFactory) Open(cmd string, args []string, env []string, sz domain.Size) (ports.PTY, error) {
	331	+	ret := _mock.Called(cmd, args, env, sz)
	332	+
	333	+	if len(ret) == 0 {
	334	+	panic("no return value specified for Open")
	335	+	}
	336	+
	337	+	var r0 ports.PTY
	338	+	var r1 error
	339	+	if returnFunc, ok := ret.Get(0).(func(string, []string, []string, domain.Size) (ports.PTY, error)); ok {
	340	+	return returnFunc(cmd, args, env, sz)
	341	+	}
	342	+	if returnFunc, ok := ret.Get(0).(func(string, []string, []string, domain.Size) ports.PTY); ok {
	343	+	r0 = returnFunc(cmd, args, env, sz)
	344	+	} else {
	345	+	if ret.Get(0) != nil {
	346	+	r0 = ret.Get(0).(ports.PTY)
	347	+	}
	348	+	}
	349	+	if returnFunc, ok := ret.Get(1).(func(string, []string, []string, domain.Size) error); ok {
	350	+	r1 = returnFunc(cmd, args, env, sz)
	351	+	} else {
	352	+	r1 = ret.Error(1)
	353	+	}
	354	+	return r0, r1
	355	+	}
	356	+
	357	+	// MockPTYFactory_Open_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Open'
	358	+	type MockPTYFactory_Open_Call struct {
	359	+	*mock.Call
	360	+	}
	361	+
	362	+	// Open is a helper method to define mock.On call
	363	+	// - cmd string
	364	+	// - args []string
	365	+	// - env []string
	366	+	// - sz domain.Size
	367	+	func (_e MockPTYFactory_Expecter) Open(cmd any, args any, env any, sz any) MockPTYFactory_Open_Call {
	368	+	return &MockPTYFactory_Open_Call{Call: _e.mock.On("Open", cmd, args, env, sz)}
	369	+	}
	370	+
	371	+	func (_c MockPTYFactory_Open_Call) Run(run func(cmd string, args []string, env []string, sz domain.Size)) MockPTYFactory_Open_Call {
	372	+	_c.Call.Run(func(args mock.Arguments) {
	373	+	var arg0 string
	374	+	if args[0] != nil {
	375	+	arg0 = args[0].(string)
	376	+	}
	377	+	var arg1 []string
	378	+	if args[1] != nil {
	379	+	arg1 = args[1].([]string)
	380	+	}
	381	+	var arg2 []string
	382	+	if args[2] != nil {
	383	+	arg2 = args[2].([]string)
	384	+	}
	385	+	var arg3 domain.Size
	386	+	if args[3] != nil {
	387	+	arg3 = args[3].(domain.Size)
	388	+	}
	389	+	run(
	390	+	arg0,
	391	+	arg1,
	392	+	arg2,
	393	+	arg3,
	394	+	)
	395	+	})
	396	+	return _c
	397	+	}
	398	+
	399	+	func (_c MockPTYFactory_Open_Call) Return(pTY ports.PTY, err error) MockPTYFactory_Open_Call {
	400	+	_c.Call.Return(pTY, err)
	401	+	return _c
	402	+	}
	403	+
	404	+	func (_c MockPTYFactory_Open_Call) RunAndReturn(run func(cmd string, args []string, env []string, sz domain.Size) (ports.PTY, error)) MockPTYFactory_Open_Call {
	405	+	_c.Call.Return(run)
	406	+	return _c
	407	+	}
	408	+
	409	+	// NewMockTerminal creates a new instance of MockTerminal. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	410	+	// The first argument is typically a *testing.T value.
	411	+	func NewMockTerminal(t interface {
	412	+	mock.TestingT
	413	+	Cleanup(func())
	414	+	}) *MockTerminal {
	415	+	mock := &MockTerminal{}
	416	+	mock.Mock.Test(t)
	417	+
	418	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	419	+
	420	+	return mock
	421	+	}
	422	+
	423	+	// MockTerminal is an autogenerated mock type for the Terminal type
	424	+	type MockTerminal struct {
	425	+	mock.Mock
	426	+	}
	427	+
	428	+	type MockTerminal_Expecter struct {
	429	+	mock *mock.Mock
	430	+	}
	431	+
	432	+	func (_m MockTerminal) EXPECT() MockTerminal_Expecter {
	433	+	return &MockTerminal_Expecter{mock: &_m.Mock}
	434	+	}
	435	+
	436	+	// EnterRaw provides a mock function for the type MockTerminal
	437	+	func (_mock *MockTerminal) EnterRaw() (func() error, error) {
	438	+	ret := _mock.Called()
	439	+
	440	+	if len(ret) == 0 {
	441	+	panic("no return value specified for EnterRaw")
	442	+	}
	443	+
	444	+	var r0 func() error
	445	+	var r1 error
	446	+	if returnFunc, ok := ret.Get(0).(func() (func() error, error)); ok {
	447	+	return returnFunc()
	448	+	}
	449	+	if returnFunc, ok := ret.Get(0).(func() func() error); ok {
	450	+	r0 = returnFunc()
	451	+	} else {
	452	+	if ret.Get(0) != nil {
	453	+	r0 = ret.Get(0).(func() error)
	454	+	}
	455	+	}
	456	+	if returnFunc, ok := ret.Get(1).(func() error); ok {
	457	+	r1 = returnFunc()
	458	+	} else {
	459	+	r1 = ret.Error(1)
	460	+	}
	461	+	return r0, r1
	462	+	}
	463	+
	464	+	// MockTerminal_EnterRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnterRaw'
	465	+	type MockTerminal_EnterRaw_Call struct {
	466	+	*mock.Call
	467	+	}
	468	+
	469	+	// EnterRaw is a helper method to define mock.On call
	470	+	func (_e MockTerminal_Expecter) EnterRaw() MockTerminal_EnterRaw_Call {
	471	+	return &MockTerminal_EnterRaw_Call{Call: _e.mock.On("EnterRaw")}
	472	+	}
	473	+
	474	+	func (_c MockTerminal_EnterRaw_Call) Run(run func()) MockTerminal_EnterRaw_Call {
	475	+	_c.Call.Run(func(args mock.Arguments) {
	476	+	run()
	477	+	})
	478	+	return _c
	479	+	}
	480	+
	481	+	func (_c MockTerminal_EnterRaw_Call) Return(restore func() error, err error) MockTerminal_EnterRaw_Call {
	482	+	_c.Call.Return(restore, err)
	483	+	return _c
	484	+	}
	485	+
	486	+	func (_c MockTerminal_EnterRaw_Call) RunAndReturn(run func() (func() error, error)) MockTerminal_EnterRaw_Call {
	487	+	_c.Call.Return(run)
	488	+	return _c
	489	+	}
	490	+
	491	+	// Flush provides a mock function for the type MockTerminal
	492	+	func (_mock *MockTerminal) Flush() error {
	493	+	ret := _mock.Called()
	494	+
	495	+	if len(ret) == 0 {
	496	+	panic("no return value specified for Flush")
	497	+	}
	498	+
	499	+	var r0 error
	500	+	if returnFunc, ok := ret.Get(0).(func() error); ok {
	501	+	r0 = returnFunc()
	502	+	} else {
	503	+	r0 = ret.Error(0)
	504	+	}
	505	+	return r0
	506	+	}
	507	+
	508	+	// MockTerminal_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
	509	+	type MockTerminal_Flush_Call struct {
	510	+	*mock.Call
	511	+	}
	512	+
	513	+	// Flush is a helper method to define mock.On call
	514	+	func (_e MockTerminal_Expecter) Flush() MockTerminal_Flush_Call {
	515	+	return &MockTerminal_Flush_Call{Call: _e.mock.On("Flush")}
	516	+	}
	517	+
	518	+	func (_c MockTerminal_Flush_Call) Run(run func()) MockTerminal_Flush_Call {
	519	+	_c.Call.Run(func(args mock.Arguments) {
	520	+	run()
	521	+	})
	522	+	return _c
	523	+	}
	524	+
	525	+	func (_c MockTerminal_Flush_Call) Return(err error) MockTerminal_Flush_Call {
	526	+	_c.Call.Return(err)
	527	+	return _c
	528	+	}
	529	+
	530	+	func (_c MockTerminal_Flush_Call) RunAndReturn(run func() error) MockTerminal_Flush_Call {
	531	+	_c.Call.Return(run)
	532	+	return _c
	533	+	}
	534	+
	535	+	// In provides a mock function for the type MockTerminal
	536	+	func (_mock *MockTerminal) In() io.Reader {
	537	+	ret := _mock.Called()
	538	+
	539	+	if len(ret) == 0 {
	540	+	panic("no return value specified for In")
	541	+	}
	542	+
	543	+	var r0 io.Reader
	544	+	if returnFunc, ok := ret.Get(0).(func() io.Reader); ok {
	545	+	r0 = returnFunc()
	546	+	} else {
	547	+	if ret.Get(0) != nil {
	548	+	r0 = ret.Get(0).(io.Reader)
	549	+	}
	550	+	}
	551	+	return r0
	552	+	}
	553	+
	554	+	// MockTerminal_In_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'In'
	555	+	type MockTerminal_In_Call struct {
	556	+	*mock.Call
	557	+	}
	558	+
	559	+	// In is a helper method to define mock.On call
	560	+	func (_e MockTerminal_Expecter) In() MockTerminal_In_Call {
	561	+	return &MockTerminal_In_Call{Call: _e.mock.On("In")}
	562	+	}
	563	+
	564	+	func (_c MockTerminal_In_Call) Run(run func()) MockTerminal_In_Call {
	565	+	_c.Call.Run(func(args mock.Arguments) {
	566	+	run()
	567	+	})
	568	+	return _c
	569	+	}
	570	+
	571	+	func (_c MockTerminal_In_Call) Return(reader io.Reader) MockTerminal_In_Call {
	572	+	_c.Call.Return(reader)
	573	+	return _c
	574	+	}
	575	+
	576	+	func (_c MockTerminal_In_Call) RunAndReturn(run func() io.Reader) MockTerminal_In_Call {
	577	+	_c.Call.Return(run)
	578	+	return _c
	579	+	}
	580	+
	581	+	// Out provides a mock function for the type MockTerminal
	582	+	func (_mock *MockTerminal) Out() io.Writer {
	583	+	ret := _mock.Called()
	584	+
	585	+	if len(ret) == 0 {
	586	+	panic("no return value specified for Out")
	587	+	}
	588	+
	589	+	var r0 io.Writer
	590	+	if returnFunc, ok := ret.Get(0).(func() io.Writer); ok {
	591	+	r0 = returnFunc()
	592	+	} else {
	593	+	if ret.Get(0) != nil {
	594	+	r0 = ret.Get(0).(io.Writer)
	595	+	}
	596	+	}
	597	+	return r0
	598	+	}
	599	+
	600	+	// MockTerminal_Out_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Out'
	601	+	type MockTerminal_Out_Call struct {
	602	+	*mock.Call
	603	+	}
	604	+
	605	+	// Out is a helper method to define mock.On call
	606	+	func (_e MockTerminal_Expecter) Out() MockTerminal_Out_Call {
	607	+	return &MockTerminal_Out_Call{Call: _e.mock.On("Out")}
	608	+	}
	609	+
	610	+	func (_c MockTerminal_Out_Call) Run(run func()) MockTerminal_Out_Call {
	611	+	_c.Call.Run(func(args mock.Arguments) {
	612	+	run()
	613	+	})
	614	+	return _c
	615	+	}
	616	+
	617	+	func (_c MockTerminal_Out_Call) Return(writer io.Writer) MockTerminal_Out_Call {
	618	+	_c.Call.Return(writer)
	619	+	return _c
	620	+	}
	621	+
	622	+	func (_c MockTerminal_Out_Call) RunAndReturn(run func() io.Writer) MockTerminal_Out_Call {
	623	+	_c.Call.Return(run)
	624	+	return _c
	625	+	}
	626	+
	627	+	// ResizeEvents provides a mock function for the type MockTerminal
	628	+	func (_mock *MockTerminal) ResizeEvents() <-chan domain.Size {
	629	+	ret := _mock.Called()
	630	+
	631	+	if len(ret) == 0 {
	632	+	panic("no return value specified for ResizeEvents")
	633	+	}
	634	+
	635	+	var r0 <-chan domain.Size
	636	+	if returnFunc, ok := ret.Get(0).(func() <-chan domain.Size); ok {
	637	+	r0 = returnFunc()
	638	+	} else {
	639	+	if ret.Get(0) != nil {
	640	+	r0 = ret.Get(0).(<-chan domain.Size)
	641	+	}
	642	+	}
	643	+	return r0
	644	+	}
	645	+
	646	+	// MockTerminal_ResizeEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResizeEvents'
	647	+	type MockTerminal_ResizeEvents_Call struct {
	648	+	*mock.Call
	649	+	}
	650	+
	651	+	// ResizeEvents is a helper method to define mock.On call
	652	+	func (_e MockTerminal_Expecter) ResizeEvents() MockTerminal_ResizeEvents_Call {
	653	+	return &MockTerminal_ResizeEvents_Call{Call: _e.mock.On("ResizeEvents")}
	654	+	}
	655	+
	656	+	func (_c MockTerminal_ResizeEvents_Call) Run(run func()) MockTerminal_ResizeEvents_Call {
	657	+	_c.Call.Run(func(args mock.Arguments) {
	658	+	run()
	659	+	})
	660	+	return _c
	661	+	}
	662	+
	663	+	func (_c MockTerminal_ResizeEvents_Call) Return(sizeCh <-chan domain.Size) MockTerminal_ResizeEvents_Call {
	664	+	_c.Call.Return(sizeCh)
	665	+	return _c
	666	+	}
	667	+
	668	+	func (_c MockTerminal_ResizeEvents_Call) RunAndReturn(run func() <-chan domain.Size) MockTerminal_ResizeEvents_Call {
	669	+	_c.Call.Return(run)
	670	+	return _c
	671	+	}
	672	+
	673	+	// Size provides a mock function for the type MockTerminal
	674	+	func (_mock *MockTerminal) Size() (domain.Size, error) {
	675	+	ret := _mock.Called()
	676	+
	677	+	if len(ret) == 0 {
	678	+	panic("no return value specified for Size")
	679	+	}
	680	+
	681	+	var r0 domain.Size
	682	+	var r1 error
	683	+	if returnFunc, ok := ret.Get(0).(func() (domain.Size, error)); ok {
	684	+	return returnFunc()
	685	+	}
	686	+	if returnFunc, ok := ret.Get(0).(func() domain.Size); ok {
	687	+	r0 = returnFunc()
	688	+	} else {
	689	+	r0 = ret.Get(0).(domain.Size)
	690	+	}
	691	+	if returnFunc, ok := ret.Get(1).(func() error); ok {
	692	+	r1 = returnFunc()
	693	+	} else {
	694	+	r1 = ret.Error(1)
	695	+	}
	696	+	return r0, r1
	697	+	}
	698	+
	699	+	// MockTerminal_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
	700	+	type MockTerminal_Size_Call struct {
	701	+	*mock.Call
	702	+	}
	703	+
	704	+	// Size is a helper method to define mock.On call
	705	+	func (_e MockTerminal_Expecter) Size() MockTerminal_Size_Call {
	706	+	return &MockTerminal_Size_Call{Call: _e.mock.On("Size")}
	707	+	}
	708	+
	709	+	func (_c MockTerminal_Size_Call) Run(run func()) MockTerminal_Size_Call {
	710	+	_c.Call.Run(func(args mock.Arguments) {
	711	+	run()
	712	+	})
	713	+	return _c
	714	+	}
	715	+
	716	+	func (_c MockTerminal_Size_Call) Return(size domain.Size, err error) MockTerminal_Size_Call {
	717	+	_c.Call.Return(size, err)
	718	+	return _c
	719	+	}
	720	+
	721	+	func (_c MockTerminal_Size_Call) RunAndReturn(run func() (domain.Size, error)) MockTerminal_Size_Call {
	722	+	_c.Call.Return(run)
	723	+	return _c
	724	+	}
	725	+
	726	+	// NewMockTransport creates a new instance of MockTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	727	+	// The first argument is typically a *testing.T value.
	728	+	func NewMockTransport(t interface {
	729	+	mock.TestingT
	730	+	Cleanup(func())
	731	+	}) *MockTransport {
	732	+	mock := &MockTransport{}
	733	+	mock.Mock.Test(t)
	734	+
	735	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	736	+
	737	+	return mock
	738	+	}
	739	+
	740	+	// MockTransport is an autogenerated mock type for the Transport type
	741	+	type MockTransport struct {
	742	+	mock.Mock
	743	+	}
	744	+
	745	+	type MockTransport_Expecter struct {
	746	+	mock *mock.Mock
	747	+	}
	748	+
	749	+	func (_m MockTransport) EXPECT() MockTransport_Expecter {
	750	+	return &MockTransport_Expecter{mock: &_m.Mock}
	751	+	}
	752	+
	753	+	// Close provides a mock function for the type MockTransport
	754	+	func (_mock *MockTransport) Close() error {
	755	+	ret := _mock.Called()
	756	+
	757	+	if len(ret) == 0 {
	758	+	panic("no return value specified for Close")
	759	+	}
	760	+
	761	+	var r0 error
	762	+	if returnFunc, ok := ret.Get(0).(func() error); ok {
	763	+	r0 = returnFunc()
	764	+	} else {
	765	+	r0 = ret.Error(0)
	766	+	}
	767	+	return r0
	768	+	}
	769	+
	770	+	// MockTransport_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
	771	+	type MockTransport_Close_Call struct {
	772	+	*mock.Call
	773	+	}
	774	+
	775	+	// Close is a helper method to define mock.On call
	776	+	func (_e MockTransport_Expecter) Close() MockTransport_Close_Call {
	777	+	return &MockTransport_Close_Call{Call: _e.mock.On("Close")}
	778	+	}
	779	+
	780	+	func (_c MockTransport_Close_Call) Run(run func()) MockTransport_Close_Call {
	781	+	_c.Call.Run(func(args mock.Arguments) {
	782	+	run()
	783	+	})
	784	+	return _c
	785	+	}
	786	+
	787	+	func (_c MockTransport_Close_Call) Return(err error) MockTransport_Close_Call {
	788	+	_c.Call.Return(err)
	789	+	return _c
	790	+	}
	791	+
	792	+	func (_c MockTransport_Close_Call) RunAndReturn(run func() error) MockTransport_Close_Call {
	793	+	_c.Call.Return(run)
	794	+	return _c
	795	+	}
	796	+
	797	+	// Recv provides a mock function for the type MockTransport
	798	+	func (_mock *MockTransport) Recv() (ports.Frame, error) {
	799	+	ret := _mock.Called()
	800	+
	801	+	if len(ret) == 0 {
	802	+	panic("no return value specified for Recv")
	803	+	}
	804	+
	805	+	var r0 ports.Frame
	806	+	var r1 error
	807	+	if returnFunc, ok := ret.Get(0).(func() (ports.Frame, error)); ok {
	808	+	return returnFunc()
	809	+	}
	810	+	if returnFunc, ok := ret.Get(0).(func() ports.Frame); ok {
	811	+	r0 = returnFunc()
	812	+	} else {
	813	+	r0 = ret.Get(0).(ports.Frame)
	814	+	}
	815	+	if returnFunc, ok := ret.Get(1).(func() error); ok {
	816	+	r1 = returnFunc()
	817	+	} else {
	818	+	r1 = ret.Error(1)
	819	+	}
	820	+	return r0, r1
	821	+	}
	822	+
	823	+	// MockTransport_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
	824	+	type MockTransport_Recv_Call struct {
	825	+	*mock.Call
	826	+	}
	827	+
	828	+	// Recv is a helper method to define mock.On call
	829	+	func (_e MockTransport_Expecter) Recv() MockTransport_Recv_Call {
	830	+	return &MockTransport_Recv_Call{Call: _e.mock.On("Recv")}
	831	+	}
	832	+
	833	+	func (_c MockTransport_Recv_Call) Run(run func()) MockTransport_Recv_Call {
	834	+	_c.Call.Run(func(args mock.Arguments) {
	835	+	run()
	836	+	})
	837	+	return _c
	838	+	}
	839	+
	840	+	func (_c MockTransport_Recv_Call) Return(frame ports.Frame, err error) MockTransport_Recv_Call {
	841	+	_c.Call.Return(frame, err)
	842	+	return _c
	843	+	}
	844	+
	845	+	func (_c MockTransport_Recv_Call) RunAndReturn(run func() (ports.Frame, error)) MockTransport_Recv_Call {
	846	+	_c.Call.Return(run)
	847	+	return _c
	848	+	}
	849	+
	850	+	// Send provides a mock function for the type MockTransport
	851	+	func (_mock *MockTransport) Send(frame ports.Frame) error {
	852	+	ret := _mock.Called(frame)
	853	+
	854	+	if len(ret) == 0 {
	855	+	panic("no return value specified for Send")
	856	+	}
	857	+
	858	+	var r0 error
	859	+	if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
	860	+	r0 = returnFunc(frame)
	861	+	} else {
	862	+	r0 = ret.Error(0)
	863	+	}
	864	+	return r0
	865	+	}
	866	+
	867	+	// MockTransport_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
	868	+	type MockTransport_Send_Call struct {
	869	+	*mock.Call
	870	+	}
	871	+
	872	+	// Send is a helper method to define mock.On call
	873	+	// - frame ports.Frame
	874	+	func (_e MockTransport_Expecter) Send(frame any) MockTransport_Send_Call {
	875	+	return &MockTransport_Send_Call{Call: _e.mock.On("Send", frame)}
	876	+	}
	877	+
	878	+	func (_c MockTransport_Send_Call) Run(run func(frame ports.Frame)) MockTransport_Send_Call {
	879	+	_c.Call.Run(func(args mock.Arguments) {
	880	+	var arg0 ports.Frame
	881	+	if args[0] != nil {
	882	+	arg0 = args[0].(ports.Frame)
	883	+	}
	884	+	run(
	885	+	arg0,
	886	+	)
	887	+	})
	888	+	return _c
	889	+	}
	890	+
	891	+	func (_c MockTransport_Send_Call) Return(err error) MockTransport_Send_Call {
	892	+	_c.Call.Return(err)
	893	+	return _c
	894	+	}
	895	+
	896	+	func (_c MockTransport_Send_Call) RunAndReturn(run func(frame ports.Frame) error) MockTransport_Send_Call {
	897	+	_c.Call.Return(run)
	898	+	return _c
	899	+	}
	900	+
	901	+	// NewMockListener creates a new instance of MockListener. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	902	+	// The first argument is typically a *testing.T value.
	903	+	func NewMockListener(t interface {
	904	+	mock.TestingT
	905	+	Cleanup(func())
	906	+	}) *MockListener {
	907	+	mock := &MockListener{}
	908	+	mock.Mock.Test(t)
	909	+
	910	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	911	+
	912	+	return mock
	913	+	}
	914	+
	915	+	// MockListener is an autogenerated mock type for the Listener type
	916	+	type MockListener struct {
	917	+	mock.Mock
	918	+	}
	919	+
	920	+	type MockListener_Expecter struct {
	921	+	mock *mock.Mock
	922	+	}
	923	+
	924	+	func (_m MockListener) EXPECT() MockListener_Expecter {
	925	+	return &MockListener_Expecter{mock: &_m.Mock}
	926	+	}
	927	+
	928	+	// Accept provides a mock function for the type MockListener
	929	+	func (_mock *MockListener) Accept() (ports.Transport, error) {
	930	+	ret := _mock.Called()
	931	+
	932	+	if len(ret) == 0 {
	933	+	panic("no return value specified for Accept")
	934	+	}
	935	+
	936	+	var r0 ports.Transport
	937	+	var r1 error
	938	+	if returnFunc, ok := ret.Get(0).(func() (ports.Transport, error)); ok {
	939	+	return returnFunc()
	940	+	}
	941	+	if returnFunc, ok := ret.Get(0).(func() ports.Transport); ok {
	942	+	r0 = returnFunc()
	943	+	} else {
	944	+	if ret.Get(0) != nil {
	945	+	r0 = ret.Get(0).(ports.Transport)
	946	+	}
	947	+	}
	948	+	if returnFunc, ok := ret.Get(1).(func() error); ok {
	949	+	r1 = returnFunc()
	950	+	} else {
	951	+	r1 = ret.Error(1)
	952	+	}
	953	+	return r0, r1
	954	+	}
	955	+
	956	+	// MockListener_Accept_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Accept'
	957	+	type MockListener_Accept_Call struct {
	958	+	*mock.Call
	959	+	}
	960	+
	961	+	// Accept is a helper method to define mock.On call
	962	+	func (_e MockListener_Expecter) Accept() MockListener_Accept_Call {
	963	+	return &MockListener_Accept_Call{Call: _e.mock.On("Accept")}
	964	+	}
	965	+
	966	+	func (_c MockListener_Accept_Call) Run(run func()) MockListener_Accept_Call {
	967	+	_c.Call.Run(func(args mock.Arguments) {
	968	+	run()
	969	+	})
	970	+	return _c
	971	+	}
	972	+
	973	+	func (_c MockListener_Accept_Call) Return(transport ports.Transport, err error) MockListener_Accept_Call {
	974	+	_c.Call.Return(transport, err)
	975	+	return _c
	976	+	}
	977	+
	978	+	func (_c MockListener_Accept_Call) RunAndReturn(run func() (ports.Transport, error)) MockListener_Accept_Call {
	979	+	_c.Call.Return(run)
	980	+	return _c
	981	+	}
	982	+
	983	+	// Addr provides a mock function for the type MockListener
	984	+	func (_mock *MockListener) Addr() string {
	985	+	ret := _mock.Called()
	986	+
	987	+	if len(ret) == 0 {
	988	+	panic("no return value specified for Addr")
	989	+	}
	990	+
	991	+	var r0 string
	992	+	if returnFunc, ok := ret.Get(0).(func() string); ok {
	993	+	r0 = returnFunc()
	994	+	} else {
	995	+	r0 = ret.Get(0).(string)
	996	+	}
	997	+	return r0
	998	+	}
	999	+
	1000	+	// MockListener_Addr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Addr'
	1001	+	type MockListener_Addr_Call struct {
	1002	+	*mock.Call
	1003	+	}
	1004	+
	1005	+	// Addr is a helper method to define mock.On call
	1006	+	func (_e MockListener_Expecter) Addr() MockListener_Addr_Call {
	1007	+	return &MockListener_Addr_Call{Call: _e.mock.On("Addr")}
	1008	+	}
	1009	+
	1010	+	func (_c MockListener_Addr_Call) Run(run func()) MockListener_Addr_Call {
	1011	+	_c.Call.Run(func(args mock.Arguments) {
	1012	+	run()
	1013	+	})
	1014	+	return _c
	1015	+	}
	1016	+
	1017	+	func (_c MockListener_Addr_Call) Return(s string) MockListener_Addr_Call {
	1018	+	_c.Call.Return(s)
	1019	+	return _c
	1020	+	}
	1021	+
	1022	+	func (_c MockListener_Addr_Call) RunAndReturn(run func() string) MockListener_Addr_Call {
	1023	+	_c.Call.Return(run)
	1024	+	return _c
	1025	+	}
	1026	+
	1027	+	// Close provides a mock function for the type MockListener
	1028	+	func (_mock *MockListener) Close() error {
	1029	+	ret := _mock.Called()
	1030	+
	1031	+	if len(ret) == 0 {
	1032	+	panic("no return value specified for Close")
	1033	+	}
	1034	+
	1035	+	var r0 error
	1036	+	if returnFunc, ok := ret.Get(0).(func() error); ok {
	1037	+	r0 = returnFunc()
	1038	+	} else {
	1039	+	r0 = ret.Error(0)
	1040	+	}
	1041	+	return r0
	1042	+	}
	1043	+
	1044	+	// MockListener_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
	1045	+	type MockListener_Close_Call struct {
	1046	+	*mock.Call
	1047	+	}
	1048	+
	1049	+	// Close is a helper method to define mock.On call
	1050	+	func (_e MockListener_Expecter) Close() MockListener_Close_Call {
	1051	+	return &MockListener_Close_Call{Call: _e.mock.On("Close")}
	1052	+	}
	1053	+
	1054	+	func (_c MockListener_Close_Call) Run(run func()) MockListener_Close_Call {
	1055	+	_c.Call.Run(func(args mock.Arguments) {
	1056	+	run()
	1057	+	})
	1058	+	return _c
	1059	+	}
	1060	+
	1061	+	func (_c MockListener_Close_Call) Return(err error) MockListener_Close_Call {
	1062	+	_c.Call.Return(err)
	1063	+	return _c
	1064	+	}
	1065	+
	1066	+	func (_c MockListener_Close_Call) RunAndReturn(run func() error) MockListener_Close_Call {
	1067	+	_c.Call.Return(run)
	1068	+	return _c
	1069	+	}
	1070	+
	1071	+	// NewMockClock creates a new instance of MockClock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	1072	+	// The first argument is typically a *testing.T value.
	1073	+	func NewMockClock(t interface {
	1074	+	mock.TestingT
	1075	+	Cleanup(func())
	1076	+	}) *MockClock {
	1077	+	mock := &MockClock{}
	1078	+	mock.Mock.Test(t)
	1079	+
	1080	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	1081	+
	1082	+	return mock
	1083	+	}
	1084	+
	1085	+	// MockClock is an autogenerated mock type for the Clock type
	1086	+	type MockClock struct {
	1087	+	mock.Mock
	1088	+	}
	1089	+
	1090	+	type MockClock_Expecter struct {
	1091	+	mock *mock.Mock
	1092	+	}
	1093	+
	1094	+	func (_m MockClock) EXPECT() MockClock_Expecter {
	1095	+	return &MockClock_Expecter{mock: &_m.Mock}
	1096	+	}
	1097	+
	1098	+	// NewTimer provides a mock function for the type MockClock
	1099	+	func (_mock *MockClock) NewTimer(d time.Duration) ports.Timer {
	1100	+	ret := _mock.Called(d)
	1101	+
	1102	+	if len(ret) == 0 {
	1103	+	panic("no return value specified for NewTimer")
	1104	+	}
	1105	+
	1106	+	var r0 ports.Timer
	1107	+	if returnFunc, ok := ret.Get(0).(func(time.Duration) ports.Timer); ok {
	1108	+	r0 = returnFunc(d)
	1109	+	} else {
	1110	+	if ret.Get(0) != nil {
	1111	+	r0 = ret.Get(0).(ports.Timer)
	1112	+	}
	1113	+	}
	1114	+	return r0
	1115	+	}
	1116	+
	1117	+	// MockClock_NewTimer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewTimer'
	1118	+	type MockClock_NewTimer_Call struct {
	1119	+	*mock.Call
	1120	+	}
	1121	+
	1122	+	// NewTimer is a helper method to define mock.On call
	1123	+	// - d time.Duration
	1124	+	func (_e MockClock_Expecter) NewTimer(d any) MockClock_NewTimer_Call {
	1125	+	return &MockClock_NewTimer_Call{Call: _e.mock.On("NewTimer", d)}
	1126	+	}
	1127	+
	1128	+	func (_c MockClock_NewTimer_Call) Run(run func(d time.Duration)) MockClock_NewTimer_Call {
	1129	+	_c.Call.Run(func(args mock.Arguments) {
	1130	+	var arg0 time.Duration
	1131	+	if args[0] != nil {
	1132	+	arg0 = args[0].(time.Duration)
	1133	+	}
	1134	+	run(
	1135	+	arg0,
	1136	+	)
	1137	+	})
	1138	+	return _c
	1139	+	}
	1140	+
	1141	+	func (_c MockClock_NewTimer_Call) Return(timer ports.Timer) MockClock_NewTimer_Call {
	1142	+	_c.Call.Return(timer)
	1143	+	return _c
	1144	+	}
	1145	+
	1146	+	func (_c MockClock_NewTimer_Call) RunAndReturn(run func(d time.Duration) ports.Timer) MockClock_NewTimer_Call {
	1147	+	_c.Call.Return(run)
	1148	+	return _c
	1149	+	}
	1150	+
	1151	+	// Now provides a mock function for the type MockClock
	1152	+	func (_mock *MockClock) Now() time.Time {
	1153	+	ret := _mock.Called()
	1154	+
	1155	+	if len(ret) == 0 {
	1156	+	panic("no return value specified for Now")
	1157	+	}
	1158	+
	1159	+	var r0 time.Time
	1160	+	if returnFunc, ok := ret.Get(0).(func() time.Time); ok {
	1161	+	r0 = returnFunc()
	1162	+	} else {
	1163	+	r0 = ret.Get(0).(time.Time)
	1164	+	}
	1165	+	return r0
	1166	+	}
	1167	+
	1168	+	// MockClock_Now_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Now'
	1169	+	type MockClock_Now_Call struct {
	1170	+	*mock.Call
	1171	+	}
	1172	+
	1173	+	// Now is a helper method to define mock.On call
	1174	+	func (_e MockClock_Expecter) Now() MockClock_Now_Call {
	1175	+	return &MockClock_Now_Call{Call: _e.mock.On("Now")}
	1176	+	}
	1177	+
	1178	+	func (_c MockClock_Now_Call) Run(run func()) MockClock_Now_Call {
	1179	+	_c.Call.Run(func(args mock.Arguments) {
	1180	+	run()
	1181	+	})
	1182	+	return _c
	1183	+	}
	1184	+
	1185	+	func (_c MockClock_Now_Call) Return(time1 time.Time) MockClock_Now_Call {
	1186	+	_c.Call.Return(time1)
	1187	+	return _c
	1188	+	}
	1189	+
	1190	+	func (_c MockClock_Now_Call) RunAndReturn(run func() time.Time) MockClock_Now_Call {
	1191	+	_c.Call.Return(run)
	1192	+	return _c
	1193	+	}
	1194	+
	1195	+	// NewMockTimer creates a new instance of MockTimer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	1196	+	// The first argument is typically a *testing.T value.
	1197	+	func NewMockTimer(t interface {
	1198	+	mock.TestingT
	1199	+	Cleanup(func())
	1200	+	}) *MockTimer {
	1201	+	mock := &MockTimer{}
	1202	+	mock.Mock.Test(t)
	1203	+
	1204	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	1205	+
	1206	+	return mock
	1207	+	}
	1208	+
	1209	+	// MockTimer is an autogenerated mock type for the Timer type
	1210	+	type MockTimer struct {
	1211	+	mock.Mock
	1212	+	}
	1213	+
	1214	+	type MockTimer_Expecter struct {
	1215	+	mock *mock.Mock
	1216	+	}
	1217	+
	1218	+	func (_m MockTimer) EXPECT() MockTimer_Expecter {
	1219	+	return &MockTimer_Expecter{mock: &_m.Mock}
	1220	+	}
	1221	+
	1222	+	// C provides a mock function for the type MockTimer
	1223	+	func (_mock *MockTimer) C() <-chan time.Time {
	1224	+	ret := _mock.Called()
	1225	+
	1226	+	if len(ret) == 0 {
	1227	+	panic("no return value specified for C")
	1228	+	}
	1229	+
	1230	+	var r0 <-chan time.Time
	1231	+	if returnFunc, ok := ret.Get(0).(func() <-chan time.Time); ok {
	1232	+	r0 = returnFunc()
	1233	+	} else {
	1234	+	if ret.Get(0) != nil {
	1235	+	r0 = ret.Get(0).(<-chan time.Time)
	1236	+	}
	1237	+	}
	1238	+	return r0
	1239	+	}
	1240	+
	1241	+	// MockTimer_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C'
	1242	+	type MockTimer_C_Call struct {
	1243	+	*mock.Call
	1244	+	}
	1245	+
	1246	+	// C is a helper method to define mock.On call
	1247	+	func (_e MockTimer_Expecter) C() MockTimer_C_Call {
	1248	+	return &MockTimer_C_Call{Call: _e.mock.On("C")}
	1249	+	}
	1250	+
	1251	+	func (_c MockTimer_C_Call) Run(run func()) MockTimer_C_Call {
	1252	+	_c.Call.Run(func(args mock.Arguments) {
	1253	+	run()
	1254	+	})
	1255	+	return _c
	1256	+	}
	1257	+
	1258	+	func (_c MockTimer_C_Call) Return(timeCh <-chan time.Time) MockTimer_C_Call {
	1259	+	_c.Call.Return(timeCh)
	1260	+	return _c
	1261	+	}
	1262	+
	1263	+	func (_c MockTimer_C_Call) RunAndReturn(run func() <-chan time.Time) MockTimer_C_Call {
	1264	+	_c.Call.Return(run)
	1265	+	return _c
	1266	+	}
	1267	+
	1268	+	// Reset provides a mock function for the type MockTimer
	1269	+	func (_mock *MockTimer) Reset(d time.Duration) bool {
	1270	+	ret := _mock.Called(d)
	1271	+
	1272	+	if len(ret) == 0 {
	1273	+	panic("no return value specified for Reset")
	1274	+	}
	1275	+
	1276	+	var r0 bool
	1277	+	if returnFunc, ok := ret.Get(0).(func(time.Duration) bool); ok {
	1278	+	r0 = returnFunc(d)
	1279	+	} else {
	1280	+	r0 = ret.Get(0).(bool)
	1281	+	}
	1282	+	return r0
	1283	+	}
	1284	+
	1285	+	// MockTimer_Reset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reset'
	1286	+	type MockTimer_Reset_Call struct {
	1287	+	*mock.Call
	1288	+	}
	1289	+
	1290	+	// Reset is a helper method to define mock.On call
	1291	+	// - d time.Duration
	1292	+	func (_e MockTimer_Expecter) Reset(d any) MockTimer_Reset_Call {
	1293	+	return &MockTimer_Reset_Call{Call: _e.mock.On("Reset", d)}
	1294	+	}
	1295	+
	1296	+	func (_c MockTimer_Reset_Call) Run(run func(d time.Duration)) MockTimer_Reset_Call {
	1297	+	_c.Call.Run(func(args mock.Arguments) {
	1298	+	var arg0 time.Duration
	1299	+	if args[0] != nil {
	1300	+	arg0 = args[0].(time.Duration)
	1301	+	}
	1302	+	run(
	1303	+	arg0,
	1304	+	)
	1305	+	})
	1306	+	return _c
	1307	+	}
	1308	+
	1309	+	func (_c MockTimer_Reset_Call) Return(b bool) MockTimer_Reset_Call {
	1310	+	_c.Call.Return(b)
	1311	+	return _c
	1312	+	}
	1313	+
	1314	+	func (_c MockTimer_Reset_Call) RunAndReturn(run func(d time.Duration) bool) MockTimer_Reset_Call {
	1315	+	_c.Call.Return(run)
	1316	+	return _c
	1317	+	}
	1318	+
	1319	+	// Stop provides a mock function for the type MockTimer
	1320	+	func (_mock *MockTimer) Stop() bool {
	1321	+	ret := _mock.Called()
	1322	+
	1323	+	if len(ret) == 0 {
	1324	+	panic("no return value specified for Stop")
	1325	+	}
	1326	+
	1327	+	var r0 bool
	1328	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	1329	+	r0 = returnFunc()
	1330	+	} else {
	1331	+	r0 = ret.Get(0).(bool)
	1332	+	}
	1333	+	return r0
	1334	+	}
	1335	+
	1336	+	// MockTimer_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
	1337	+	type MockTimer_Stop_Call struct {
	1338	+	*mock.Call
	1339	+	}
	1340	+
	1341	+	// Stop is a helper method to define mock.On call
	1342	+	func (_e MockTimer_Expecter) Stop() MockTimer_Stop_Call {
	1343	+	return &MockTimer_Stop_Call{Call: _e.mock.On("Stop")}
	1344	+	}
	1345	+
	1346	+	func (_c MockTimer_Stop_Call) Run(run func()) MockTimer_Stop_Call {
	1347	+	_c.Call.Run(func(args mock.Arguments) {
	1348	+	run()
	1349	+	})
	1350	+	return _c
	1351	+	}
	1352	+
	1353	+	func (_c MockTimer_Stop_Call) Return(b bool) MockTimer_Stop_Call {
	1354	+	_c.Call.Return(b)
	1355	+	return _c
	1356	+	}
	1357	+
	1358	+	func (_c MockTimer_Stop_Call) RunAndReturn(run func() bool) MockTimer_Stop_Call {
	1359	+	_c.Call.Return(run)
	1360	+	return _c
	1361	+	}

@@ -0,0 +1,1361 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package portsmocks
	6	+
	7	+	import (
	8	+	"io"
	9	+	"time"
	10	+
	11	+	"github.com/bnema/vev/internal/domain"
	12	+	"github.com/bnema/vev/internal/ports"
	13	+	mock "github.com/stretchr/testify/mock"
	14	+	)
	15	+
	16	+	// NewMockPTY creates a new instance of MockPTY. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	17	+	// The first argument is typically a *testing.T value.
	18	+	func NewMockPTY(t interface {
	19	+	mock.TestingT
	20	+	Cleanup(func())
	21	+	}) *MockPTY {
	22	+	mock := &MockPTY{}
	23	+	mock.Mock.Test(t)
	24	+
	25	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	26	+
	27	+	return mock
	28	+	}
	29	+
	30	+	// MockPTY is an autogenerated mock type for the PTY type
	31	+	type MockPTY struct {
	32	+	mock.Mock
	33	+	}
	34	+
	35	+	type MockPTY_Expecter struct {
	36	+	mock *mock.Mock
	37	+	}
	38	+
	39	+	func (_m MockPTY) EXPECT() MockPTY_Expecter {
	40	+	return &MockPTY_Expecter{mock: &_m.Mock}
	41	+	}
	42	+
	43	+	// Close provides a mock function for the type MockPTY
	44	+	func (_mock *MockPTY) Close() error {
	45	+	ret := _mock.Called()
	46	+
	47	+	if len(ret) == 0 {
	48	+	panic("no return value specified for Close")
	49	+	}
	50	+
	51	+	var r0 error
	52	+	if returnFunc, ok := ret.Get(0).(func() error); ok {
	53	+	r0 = returnFunc()
	54	+	} else {
	55	+	r0 = ret.Error(0)
	56	+	}
	57	+	return r0
	58	+	}
	59	+
	60	+	// MockPTY_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
	61	+	type MockPTY_Close_Call struct {
	62	+	*mock.Call
	63	+	}
	64	+
	65	+	// Close is a helper method to define mock.On call
	66	+	func (_e MockPTY_Expecter) Close() MockPTY_Close_Call {
	67	+	return &MockPTY_Close_Call{Call: _e.mock.On("Close")}
	68	+	}
	69	+
	70	+	func (_c MockPTY_Close_Call) Run(run func()) MockPTY_Close_Call {
	71	+	_c.Call.Run(func(args mock.Arguments) {
	72	+	run()
	73	+	})
	74	+	return _c
	75	+	}
	76	+
	77	+	func (_c MockPTY_Close_Call) Return(err error) MockPTY_Close_Call {
	78	+	_c.Call.Return(err)
	79	+	return _c
	80	+	}
	81	+
	82	+	func (_c MockPTY_Close_Call) RunAndReturn(run func() error) MockPTY_Close_Call {
	83	+	_c.Call.Return(run)
	84	+	return _c
	85	+	}
	86	+
	87	+	// Pid provides a mock function for the type MockPTY
	88	+	func (_mock *MockPTY) Pid() int {
	89	+	ret := _mock.Called()
	90	+
	91	+	if len(ret) == 0 {
	92	+	panic("no return value specified for Pid")
	93	+	}
	94	+
	95	+	var r0 int
	96	+	if returnFunc, ok := ret.Get(0).(func() int); ok {
	97	+	r0 = returnFunc()
	98	+	} else {
	99	+	r0 = ret.Get(0).(int)
	100	+	}
	101	+	return r0
	102	+	}
	103	+
	104	+	// MockPTY_Pid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pid'
	105	+	type MockPTY_Pid_Call struct {
	106	+	*mock.Call
	107	+	}
	108	+
	109	+	// Pid is a helper method to define mock.On call
	110	+	func (_e MockPTY_Expecter) Pid() MockPTY_Pid_Call {
	111	+	return &MockPTY_Pid_Call{Call: _e.mock.On("Pid")}
	112	+	}
	113	+
	114	+	func (_c MockPTY_Pid_Call) Run(run func()) MockPTY_Pid_Call {
	115	+	_c.Call.Run(func(args mock.Arguments) {
	116	+	run()
	117	+	})
	118	+	return _c
	119	+	}
	120	+
	121	+	func (_c MockPTY_Pid_Call) Return(n int) MockPTY_Pid_Call {
	122	+	_c.Call.Return(n)
	123	+	return _c
	124	+	}
	125	+
	126	+	func (_c MockPTY_Pid_Call) RunAndReturn(run func() int) MockPTY_Pid_Call {
	127	+	_c.Call.Return(run)
	128	+	return _c
	129	+	}
	130	+
	131	+	// Read provides a mock function for the type MockPTY
	132	+	func (_mock *MockPTY) Read(p []byte) (int, error) {
	133	+	ret := _mock.Called(p)
	134	+
	135	+	if len(ret) == 0 {
	136	+	panic("no return value specified for Read")
	137	+	}
	138	+
	139	+	var r0 int
	140	+	var r1 error
	141	+	if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
	142	+	return returnFunc(p)
	143	+	}
	144	+	if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
	145	+	r0 = returnFunc(p)
	146	+	} else {
	147	+	r0 = ret.Get(0).(int)
	148	+	}
	149	+	if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
	150	+	r1 = returnFunc(p)
	151	+	} else {
	152	+	r1 = ret.Error(1)
	153	+	}
	154	+	return r0, r1
	155	+	}
	156	+
	157	+	// MockPTY_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
	158	+	type MockPTY_Read_Call struct {
	159	+	*mock.Call
	160	+	}
	161	+
	162	+	// Read is a helper method to define mock.On call
	163	+	// - p []byte
	164	+	func (_e MockPTY_Expecter) Read(p any) MockPTY_Read_Call {
	165	+	return &MockPTY_Read_Call{Call: _e.mock.On("Read", p)}
	166	+	}
	167	+
	168	+	func (_c MockPTY_Read_Call) Run(run func(p []byte)) MockPTY_Read_Call {
	169	+	_c.Call.Run(func(args mock.Arguments) {
	170	+	var arg0 []byte
	171	+	if args[0] != nil {
	172	+	arg0 = args[0].([]byte)
	173	+	}
	174	+	run(
	175	+	arg0,
	176	+	)
	177	+	})
	178	+	return _c
	179	+	}
	180	+
	181	+	func (_c MockPTY_Read_Call) Return(n int, err error) MockPTY_Read_Call {
	182	+	_c.Call.Return(n, err)
	183	+	return _c
	184	+	}
	185	+
	186	+	func (_c MockPTY_Read_Call) RunAndReturn(run func(p []byte) (int, error)) MockPTY_Read_Call {
	187	+	_c.Call.Return(run)
	188	+	return _c
	189	+	}
	190	+
	191	+	// Resize provides a mock function for the type MockPTY
	192	+	func (_mock *MockPTY) Resize(sz domain.Size) error {
	193	+	ret := _mock.Called(sz)
	194	+
	195	+	if len(ret) == 0 {
	196	+	panic("no return value specified for Resize")
	197	+	}
	198	+
	199	+	var r0 error
	200	+	if returnFunc, ok := ret.Get(0).(func(domain.Size) error); ok {
	201	+	r0 = returnFunc(sz)
	202	+	} else {
	203	+	r0 = ret.Error(0)
	204	+	}
	205	+	return r0
	206	+	}
	207	+
	208	+	// MockPTY_Resize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resize'
	209	+	type MockPTY_Resize_Call struct {
	210	+	*mock.Call
	211	+	}
	212	+
	213	+	// Resize is a helper method to define mock.On call
	214	+	// - sz domain.Size
	215	+	func (_e MockPTY_Expecter) Resize(sz any) MockPTY_Resize_Call {
	216	+	return &MockPTY_Resize_Call{Call: _e.mock.On("Resize", sz)}
	217	+	}
	218	+
	219	+	func (_c MockPTY_Resize_Call) Run(run func(sz domain.Size)) MockPTY_Resize_Call {
	220	+	_c.Call.Run(func(args mock.Arguments) {
	221	+	var arg0 domain.Size
	222	+	if args[0] != nil {
	223	+	arg0 = args[0].(domain.Size)
	224	+	}
	225	+	run(
	226	+	arg0,
	227	+	)
	228	+	})
	229	+	return _c
	230	+	}
	231	+
	232	+	func (_c MockPTY_Resize_Call) Return(err error) MockPTY_Resize_Call {
	233	+	_c.Call.Return(err)
	234	+	return _c
	235	+	}
	236	+
	237	+	func (_c MockPTY_Resize_Call) RunAndReturn(run func(sz domain.Size) error) MockPTY_Resize_Call {
	238	+	_c.Call.Return(run)
	239	+	return _c
	240	+	}
	241	+
	242	+	// Write provides a mock function for the type MockPTY
	243	+	func (_mock *MockPTY) Write(p []byte) (int, error) {
	244	+	ret := _mock.Called(p)
	245	+
	246	+	if len(ret) == 0 {
	247	+	panic("no return value specified for Write")
	248	+	}
	249	+
	250	+	var r0 int
	251	+	var r1 error
	252	+	if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
	253	+	return returnFunc(p)
	254	+	}
	255	+	if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
	256	+	r0 = returnFunc(p)
	257	+	} else {
	258	+	r0 = ret.Get(0).(int)
	259	+	}
	260	+	if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
	261	+	r1 = returnFunc(p)
	262	+	} else {
	263	+	r1 = ret.Error(1)
	264	+	}
	265	+	return r0, r1
	266	+	}
	267	+
	268	+	// MockPTY_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
	269	+	type MockPTY_Write_Call struct {
	270	+	*mock.Call
	271	+	}
	272	+
	273	+	// Write is a helper method to define mock.On call
	274	+	// - p []byte
	275	+	func (_e MockPTY_Expecter) Write(p any) MockPTY_Write_Call {
	276	+	return &MockPTY_Write_Call{Call: _e.mock.On("Write", p)}
	277	+	}
	278	+
	279	+	func (_c MockPTY_Write_Call) Run(run func(p []byte)) MockPTY_Write_Call {
	280	+	_c.Call.Run(func(args mock.Arguments) {
	281	+	var arg0 []byte
	282	+	if args[0] != nil {
	283	+	arg0 = args[0].([]byte)
	284	+	}
	285	+	run(
	286	+	arg0,
	287	+	)
	288	+	})
	289	+	return _c
	290	+	}
	291	+
	292	+	func (_c MockPTY_Write_Call) Return(n int, err error) MockPTY_Write_Call {
	293	+	_c.Call.Return(n, err)
	294	+	return _c
	295	+	}
	296	+
	297	+	func (_c MockPTY_Write_Call) RunAndReturn(run func(p []byte) (int, error)) MockPTY_Write_Call {
	298	+	_c.Call.Return(run)
	299	+	return _c
	300	+	}
	301	+
	302	+	// NewMockPTYFactory creates a new instance of MockPTYFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	303	+	// The first argument is typically a *testing.T value.
	304	+	func NewMockPTYFactory(t interface {
	305	+	mock.TestingT
	306	+	Cleanup(func())
	307	+	}) *MockPTYFactory {
	308	+	mock := &MockPTYFactory{}
	309	+	mock.Mock.Test(t)
	310	+
	311	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	312	+
	313	+	return mock
	314	+	}
	315	+
	316	+	// MockPTYFactory is an autogenerated mock type for the PTYFactory type
	317	+	type MockPTYFactory struct {
	318	+	mock.Mock
	319	+	}
	320	+
	321	+	type MockPTYFactory_Expecter struct {
	322	+	mock *mock.Mock
	323	+	}
	324	+
	325	+	func (_m MockPTYFactory) EXPECT() MockPTYFactory_Expecter {
	326	+	return &MockPTYFactory_Expecter{mock: &_m.Mock}
	327	+	}
	328	+
	329	+	// Open provides a mock function for the type MockPTYFactory
	330	+	func (_mock *MockPTYFactory) Open(cmd string, args []string, env []string, sz domain.Size) (ports.PTY, error) {
	331	+	ret := _mock.Called(cmd, args, env, sz)
	332	+
	333	+	if len(ret) == 0 {
	334	+	panic("no return value specified for Open")
	335	+	}
	336	+
	337	+	var r0 ports.PTY
	338	+	var r1 error
	339	+	if returnFunc, ok := ret.Get(0).(func(string, []string, []string, domain.Size) (ports.PTY, error)); ok {
	340	+	return returnFunc(cmd, args, env, sz)
	341	+	}
	342	+	if returnFunc, ok := ret.Get(0).(func(string, []string, []string, domain.Size) ports.PTY); ok {
	343	+	r0 = returnFunc(cmd, args, env, sz)
	344	+	} else {
	345	+	if ret.Get(0) != nil {
	346	+	r0 = ret.Get(0).(ports.PTY)
	347	+	}
	348	+	}
	349	+	if returnFunc, ok := ret.Get(1).(func(string, []string, []string, domain.Size) error); ok {
	350	+	r1 = returnFunc(cmd, args, env, sz)
	351	+	} else {
	352	+	r1 = ret.Error(1)
	353	+	}
	354	+	return r0, r1
	355	+	}
	356	+
	357	+	// MockPTYFactory_Open_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Open'
	358	+	type MockPTYFactory_Open_Call struct {
	359	+	*mock.Call
	360	+	}
	361	+
	362	+	// Open is a helper method to define mock.On call
	363	+	// - cmd string
	364	+	// - args []string
	365	+	// - env []string
	366	+	// - sz domain.Size
	367	+	func (_e MockPTYFactory_Expecter) Open(cmd any, args any, env any, sz any) MockPTYFactory_Open_Call {
	368	+	return &MockPTYFactory_Open_Call{Call: _e.mock.On("Open", cmd, args, env, sz)}
	369	+	}
	370	+
	371	+	func (_c MockPTYFactory_Open_Call) Run(run func(cmd string, args []string, env []string, sz domain.Size)) MockPTYFactory_Open_Call {
	372	+	_c.Call.Run(func(args mock.Arguments) {
	373	+	var arg0 string
	374	+	if args[0] != nil {
	375	+	arg0 = args[0].(string)
	376	+	}
	377	+	var arg1 []string
	378	+	if args[1] != nil {
	379	+	arg1 = args[1].([]string)
	380	+	}
	381	+	var arg2 []string
	382	+	if args[2] != nil {
	383	+	arg2 = args[2].([]string)
	384	+	}
	385	+	var arg3 domain.Size
	386	+	if args[3] != nil {
	387	+	arg3 = args[3].(domain.Size)
	388	+	}
	389	+	run(
	390	+	arg0,
	391	+	arg1,
	392	+	arg2,
	393	+	arg3,
	394	+	)
	395	+	})
	396	+	return _c
	397	+	}
	398	+
	399	+	func (_c MockPTYFactory_Open_Call) Return(pTY ports.PTY, err error) MockPTYFactory_Open_Call {
	400	+	_c.Call.Return(pTY, err)
	401	+	return _c
	402	+	}
	403	+
	404	+	func (_c MockPTYFactory_Open_Call) RunAndReturn(run func(cmd string, args []string, env []string, sz domain.Size) (ports.PTY, error)) MockPTYFactory_Open_Call {
	405	+	_c.Call.Return(run)
	406	+	return _c
	407	+	}
	408	+
	409	+	// NewMockTerminal creates a new instance of MockTerminal. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	410	+	// The first argument is typically a *testing.T value.
	411	+	func NewMockTerminal(t interface {
	412	+	mock.TestingT
	413	+	Cleanup(func())
	414	+	}) *MockTerminal {
	415	+	mock := &MockTerminal{}
	416	+	mock.Mock.Test(t)
	417	+
	418	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	419	+
	420	+	return mock
	421	+	}
	422	+
	423	+	// MockTerminal is an autogenerated mock type for the Terminal type
	424	+	type MockTerminal struct {
	425	+	mock.Mock
	426	+	}
	427	+
	428	+	type MockTerminal_Expecter struct {
	429	+	mock *mock.Mock
	430	+	}
	431	+
	432	+	func (_m MockTerminal) EXPECT() MockTerminal_Expecter {
	433	+	return &MockTerminal_Expecter{mock: &_m.Mock}
	434	+	}
	435	+
	436	+	// EnterRaw provides a mock function for the type MockTerminal
	437	+	func (_mock *MockTerminal) EnterRaw() (func() error, error) {
	438	+	ret := _mock.Called()
	439	+
	440	+	if len(ret) == 0 {
	441	+	panic("no return value specified for EnterRaw")
	442	+	}
	443	+
	444	+	var r0 func() error
	445	+	var r1 error
	446	+	if returnFunc, ok := ret.Get(0).(func() (func() error, error)); ok {
	447	+	return returnFunc()
	448	+	}
	449	+	if returnFunc, ok := ret.Get(0).(func() func() error); ok {
	450	+	r0 = returnFunc()
	451	+	} else {
	452	+	if ret.Get(0) != nil {
	453	+	r0 = ret.Get(0).(func() error)
	454	+	}
	455	+	}
	456	+	if returnFunc, ok := ret.Get(1).(func() error); ok {
	457	+	r1 = returnFunc()
	458	+	} else {
	459	+	r1 = ret.Error(1)
	460	+	}
	461	+	return r0, r1
	462	+	}
	463	+
	464	+	// MockTerminal_EnterRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnterRaw'
	465	+	type MockTerminal_EnterRaw_Call struct {
	466	+	*mock.Call
	467	+	}
	468	+
	469	+	// EnterRaw is a helper method to define mock.On call
	470	+	func (_e MockTerminal_Expecter) EnterRaw() MockTerminal_EnterRaw_Call {
	471	+	return &MockTerminal_EnterRaw_Call{Call: _e.mock.On("EnterRaw")}
	472	+	}
	473	+
	474	+	func (_c MockTerminal_EnterRaw_Call) Run(run func()) MockTerminal_EnterRaw_Call {
	475	+	_c.Call.Run(func(args mock.Arguments) {
	476	+	run()
	477	+	})
	478	+	return _c
	479	+	}
	480	+
	481	+	func (_c MockTerminal_EnterRaw_Call) Return(restore func() error, err error) MockTerminal_EnterRaw_Call {
	482	+	_c.Call.Return(restore, err)
	483	+	return _c
	484	+	}
	485	+
	486	+	func (_c MockTerminal_EnterRaw_Call) RunAndReturn(run func() (func() error, error)) MockTerminal_EnterRaw_Call {
	487	+	_c.Call.Return(run)
	488	+	return _c
	489	+	}
	490	+
	491	+	// Flush provides a mock function for the type MockTerminal
	492	+	func (_mock *MockTerminal) Flush() error {
	493	+	ret := _mock.Called()
	494	+
	495	+	if len(ret) == 0 {
	496	+	panic("no return value specified for Flush")
	497	+	}
	498	+
	499	+	var r0 error
	500	+	if returnFunc, ok := ret.Get(0).(func() error); ok {
	501	+	r0 = returnFunc()
	502	+	} else {
	503	+	r0 = ret.Error(0)
	504	+	}
	505	+	return r0
	506	+	}
	507	+
	508	+	// MockTerminal_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
	509	+	type MockTerminal_Flush_Call struct {
	510	+	*mock.Call
	511	+	}
	512	+
	513	+	// Flush is a helper method to define mock.On call
	514	+	func (_e MockTerminal_Expecter) Flush() MockTerminal_Flush_Call {
	515	+	return &MockTerminal_Flush_Call{Call: _e.mock.On("Flush")}
	516	+	}
	517	+
	518	+	func (_c MockTerminal_Flush_Call) Run(run func()) MockTerminal_Flush_Call {
	519	+	_c.Call.Run(func(args mock.Arguments) {
	520	+	run()
	521	+	})
	522	+	return _c
	523	+	}
	524	+
	525	+	func (_c MockTerminal_Flush_Call) Return(err error) MockTerminal_Flush_Call {
	526	+	_c.Call.Return(err)
	527	+	return _c
	528	+	}
	529	+
	530	+	func (_c MockTerminal_Flush_Call) RunAndReturn(run func() error) MockTerminal_Flush_Call {
	531	+	_c.Call.Return(run)
	532	+	return _c
	533	+	}
	534	+
	535	+	// In provides a mock function for the type MockTerminal
	536	+	func (_mock *MockTerminal) In() io.Reader {
	537	+	ret := _mock.Called()
	538	+
	539	+	if len(ret) == 0 {
	540	+	panic("no return value specified for In")
	541	+	}
	542	+
	543	+	var r0 io.Reader
	544	+	if returnFunc, ok := ret.Get(0).(func() io.Reader); ok {
	545	+	r0 = returnFunc()
	546	+	} else {
	547	+	if ret.Get(0) != nil {
	548	+	r0 = ret.Get(0).(io.Reader)
	549	+	}
	550	+	}
	551	+	return r0
	552	+	}
	553	+
	554	+	// MockTerminal_In_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'In'
	555	+	type MockTerminal_In_Call struct {
	556	+	*mock.Call
	557	+	}
	558	+
	559	+	// In is a helper method to define mock.On call
	560	+	func (_e MockTerminal_Expecter) In() MockTerminal_In_Call {
	561	+	return &MockTerminal_In_Call{Call: _e.mock.On("In")}
	562	+	}
	563	+
	564	+	func (_c MockTerminal_In_Call) Run(run func()) MockTerminal_In_Call {
	565	+	_c.Call.Run(func(args mock.Arguments) {
	566	+	run()
	567	+	})
	568	+	return _c
	569	+	}
	570	+
	571	+	func (_c MockTerminal_In_Call) Return(reader io.Reader) MockTerminal_In_Call {
	572	+	_c.Call.Return(reader)
	573	+	return _c
	574	+	}
	575	+
	576	+	func (_c MockTerminal_In_Call) RunAndReturn(run func() io.Reader) MockTerminal_In_Call {
	577	+	_c.Call.Return(run)
	578	+	return _c
	579	+	}
	580	+
	581	+	// Out provides a mock function for the type MockTerminal
	582	+	func (_mock *MockTerminal) Out() io.Writer {
	583	+	ret := _mock.Called()
	584	+
	585	+	if len(ret) == 0 {
	586	+	panic("no return value specified for Out")
	587	+	}
	588	+
	589	+	var r0 io.Writer
	590	+	if returnFunc, ok := ret.Get(0).(func() io.Writer); ok {
	591	+	r0 = returnFunc()
	592	+	} else {
	593	+	if ret.Get(0) != nil {
	594	+	r0 = ret.Get(0).(io.Writer)
	595	+	}
	596	+	}
	597	+	return r0
	598	+	}
	599	+
	600	+	// MockTerminal_Out_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Out'
	601	+	type MockTerminal_Out_Call struct {
	602	+	*mock.Call
	603	+	}
	604	+
	605	+	// Out is a helper method to define mock.On call
	606	+	func (_e MockTerminal_Expecter) Out() MockTerminal_Out_Call {
	607	+	return &MockTerminal_Out_Call{Call: _e.mock.On("Out")}
	608	+	}
	609	+
	610	+	func (_c MockTerminal_Out_Call) Run(run func()) MockTerminal_Out_Call {
	611	+	_c.Call.Run(func(args mock.Arguments) {
	612	+	run()
	613	+	})
	614	+	return _c
	615	+	}
	616	+
	617	+	func (_c MockTerminal_Out_Call) Return(writer io.Writer) MockTerminal_Out_Call {
	618	+	_c.Call.Return(writer)
	619	+	return _c
	620	+	}
	621	+
	622	+	func (_c MockTerminal_Out_Call) RunAndReturn(run func() io.Writer) MockTerminal_Out_Call {
	623	+	_c.Call.Return(run)
	624	+	return _c
	625	+	}
	626	+
	627	+	// ResizeEvents provides a mock function for the type MockTerminal
	628	+	func (_mock *MockTerminal) ResizeEvents() <-chan domain.Size {
	629	+	ret := _mock.Called()
	630	+
	631	+	if len(ret) == 0 {
	632	+	panic("no return value specified for ResizeEvents")
	633	+	}
	634	+
	635	+	var r0 <-chan domain.Size
	636	+	if returnFunc, ok := ret.Get(0).(func() <-chan domain.Size); ok {
	637	+	r0 = returnFunc()
	638	+	} else {
	639	+	if ret.Get(0) != nil {
	640	+	r0 = ret.Get(0).(<-chan domain.Size)
	641	+	}
	642	+	}
	643	+	return r0
	644	+	}
	645	+
	646	+	// MockTerminal_ResizeEvents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResizeEvents'
	647	+	type MockTerminal_ResizeEvents_Call struct {
	648	+	*mock.Call
	649	+	}
	650	+
	651	+	// ResizeEvents is a helper method to define mock.On call
	652	+	func (_e MockTerminal_Expecter) ResizeEvents() MockTerminal_ResizeEvents_Call {
	653	+	return &MockTerminal_ResizeEvents_Call{Call: _e.mock.On("ResizeEvents")}
	654	+	}
	655	+
	656	+	func (_c MockTerminal_ResizeEvents_Call) Run(run func()) MockTerminal_ResizeEvents_Call {
	657	+	_c.Call.Run(func(args mock.Arguments) {
	658	+	run()
	659	+	})
	660	+	return _c
	661	+	}
	662	+
	663	+	func (_c MockTerminal_ResizeEvents_Call) Return(sizeCh <-chan domain.Size) MockTerminal_ResizeEvents_Call {
	664	+	_c.Call.Return(sizeCh)
	665	+	return _c
	666	+	}
	667	+
	668	+	func (_c MockTerminal_ResizeEvents_Call) RunAndReturn(run func() <-chan domain.Size) MockTerminal_ResizeEvents_Call {
	669	+	_c.Call.Return(run)
	670	+	return _c
	671	+	}
	672	+
	673	+	// Size provides a mock function for the type MockTerminal
	674	+	func (_mock *MockTerminal) Size() (domain.Size, error) {
	675	+	ret := _mock.Called()
	676	+
	677	+	if len(ret) == 0 {
	678	+	panic("no return value specified for Size")
	679	+	}
	680	+
	681	+	var r0 domain.Size
	682	+	var r1 error
	683	+	if returnFunc, ok := ret.Get(0).(func() (domain.Size, error)); ok {
	684	+	return returnFunc()
	685	+	}
	686	+	if returnFunc, ok := ret.Get(0).(func() domain.Size); ok {
	687	+	r0 = returnFunc()
	688	+	} else {
	689	+	r0 = ret.Get(0).(domain.Size)
	690	+	}
	691	+	if returnFunc, ok := ret.Get(1).(func() error); ok {
	692	+	r1 = returnFunc()
	693	+	} else {
	694	+	r1 = ret.Error(1)
	695	+	}
	696	+	return r0, r1
	697	+	}
	698	+
	699	+	// MockTerminal_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
	700	+	type MockTerminal_Size_Call struct {
	701	+	*mock.Call
	702	+	}
	703	+
	704	+	// Size is a helper method to define mock.On call
	705	+	func (_e MockTerminal_Expecter) Size() MockTerminal_Size_Call {
	706	+	return &MockTerminal_Size_Call{Call: _e.mock.On("Size")}
	707	+	}
	708	+
	709	+	func (_c MockTerminal_Size_Call) Run(run func()) MockTerminal_Size_Call {
	710	+	_c.Call.Run(func(args mock.Arguments) {
	711	+	run()
	712	+	})
	713	+	return _c
	714	+	}
	715	+
	716	+	func (_c MockTerminal_Size_Call) Return(size domain.Size, err error) MockTerminal_Size_Call {
	717	+	_c.Call.Return(size, err)
	718	+	return _c
	719	+	}
	720	+
	721	+	func (_c MockTerminal_Size_Call) RunAndReturn(run func() (domain.Size, error)) MockTerminal_Size_Call {
	722	+	_c.Call.Return(run)
	723	+	return _c
	724	+	}
	725	+
	726	+	// NewMockTransport creates a new instance of MockTransport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	727	+	// The first argument is typically a *testing.T value.
	728	+	func NewMockTransport(t interface {
	729	+	mock.TestingT
	730	+	Cleanup(func())
	731	+	}) *MockTransport {
	732	+	mock := &MockTransport{}
	733	+	mock.Mock.Test(t)
	734	+
	735	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	736	+
	737	+	return mock
	738	+	}
	739	+
	740	+	// MockTransport is an autogenerated mock type for the Transport type
	741	+	type MockTransport struct {
	742	+	mock.Mock
	743	+	}
	744	+
	745	+	type MockTransport_Expecter struct {
	746	+	mock *mock.Mock
	747	+	}
	748	+
	749	+	func (_m MockTransport) EXPECT() MockTransport_Expecter {
	750	+	return &MockTransport_Expecter{mock: &_m.Mock}
	751	+	}
	752	+
	753	+	// Close provides a mock function for the type MockTransport
	754	+	func (_mock *MockTransport) Close() error {
	755	+	ret := _mock.Called()
	756	+
	757	+	if len(ret) == 0 {
	758	+	panic("no return value specified for Close")
	759	+	}
	760	+
	761	+	var r0 error
	762	+	if returnFunc, ok := ret.Get(0).(func() error); ok {
	763	+	r0 = returnFunc()
	764	+	} else {
	765	+	r0 = ret.Error(0)
	766	+	}
	767	+	return r0
	768	+	}
	769	+
	770	+	// MockTransport_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
	771	+	type MockTransport_Close_Call struct {
	772	+	*mock.Call
	773	+	}
	774	+
	775	+	// Close is a helper method to define mock.On call
	776	+	func (_e MockTransport_Expecter) Close() MockTransport_Close_Call {
	777	+	return &MockTransport_Close_Call{Call: _e.mock.On("Close")}
	778	+	}
	779	+
	780	+	func (_c MockTransport_Close_Call) Run(run func()) MockTransport_Close_Call {
	781	+	_c.Call.Run(func(args mock.Arguments) {
	782	+	run()
	783	+	})
	784	+	return _c
	785	+	}
	786	+
	787	+	func (_c MockTransport_Close_Call) Return(err error) MockTransport_Close_Call {
	788	+	_c.Call.Return(err)
	789	+	return _c
	790	+	}
	791	+
	792	+	func (_c MockTransport_Close_Call) RunAndReturn(run func() error) MockTransport_Close_Call {
	793	+	_c.Call.Return(run)
	794	+	return _c
	795	+	}
	796	+
	797	+	// Recv provides a mock function for the type MockTransport
	798	+	func (_mock *MockTransport) Recv() (ports.Frame, error) {
	799	+	ret := _mock.Called()
	800	+
	801	+	if len(ret) == 0 {
	802	+	panic("no return value specified for Recv")
	803	+	}
	804	+
	805	+	var r0 ports.Frame
	806	+	var r1 error
	807	+	if returnFunc, ok := ret.Get(0).(func() (ports.Frame, error)); ok {
	808	+	return returnFunc()
	809	+	}
	810	+	if returnFunc, ok := ret.Get(0).(func() ports.Frame); ok {
	811	+	r0 = returnFunc()
	812	+	} else {
	813	+	r0 = ret.Get(0).(ports.Frame)
	814	+	}
	815	+	if returnFunc, ok := ret.Get(1).(func() error); ok {
	816	+	r1 = returnFunc()
	817	+	} else {
	818	+	r1 = ret.Error(1)
	819	+	}
	820	+	return r0, r1
	821	+	}
	822	+
	823	+	// MockTransport_Recv_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Recv'
	824	+	type MockTransport_Recv_Call struct {
	825	+	*mock.Call
	826	+	}
	827	+
	828	+	// Recv is a helper method to define mock.On call
	829	+	func (_e MockTransport_Expecter) Recv() MockTransport_Recv_Call {
	830	+	return &MockTransport_Recv_Call{Call: _e.mock.On("Recv")}
	831	+	}
	832	+
	833	+	func (_c MockTransport_Recv_Call) Run(run func()) MockTransport_Recv_Call {
	834	+	_c.Call.Run(func(args mock.Arguments) {
	835	+	run()
	836	+	})
	837	+	return _c
	838	+	}
	839	+
	840	+	func (_c MockTransport_Recv_Call) Return(frame ports.Frame, err error) MockTransport_Recv_Call {
	841	+	_c.Call.Return(frame, err)
	842	+	return _c
	843	+	}
	844	+
	845	+	func (_c MockTransport_Recv_Call) RunAndReturn(run func() (ports.Frame, error)) MockTransport_Recv_Call {
	846	+	_c.Call.Return(run)
	847	+	return _c
	848	+	}
	849	+
	850	+	// Send provides a mock function for the type MockTransport
	851	+	func (_mock *MockTransport) Send(frame ports.Frame) error {
	852	+	ret := _mock.Called(frame)
	853	+
	854	+	if len(ret) == 0 {
	855	+	panic("no return value specified for Send")
	856	+	}
	857	+
	858	+	var r0 error
	859	+	if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
	860	+	r0 = returnFunc(frame)
	861	+	} else {
	862	+	r0 = ret.Error(0)
	863	+	}
	864	+	return r0
	865	+	}
	866	+
	867	+	// MockTransport_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'
	868	+	type MockTransport_Send_Call struct {
	869	+	*mock.Call
	870	+	}
	871	+
	872	+	// Send is a helper method to define mock.On call
	873	+	// - frame ports.Frame
	874	+	func (_e MockTransport_Expecter) Send(frame any) MockTransport_Send_Call {
	875	+	return &MockTransport_Send_Call{Call: _e.mock.On("Send", frame)}
	876	+	}
	877	+
	878	+	func (_c MockTransport_Send_Call) Run(run func(frame ports.Frame)) MockTransport_Send_Call {
	879	+	_c.Call.Run(func(args mock.Arguments) {
	880	+	var arg0 ports.Frame
	881	+	if args[0] != nil {
	882	+	arg0 = args[0].(ports.Frame)
	883	+	}
	884	+	run(
	885	+	arg0,
	886	+	)
	887	+	})
	888	+	return _c
	889	+	}
	890	+
	891	+	func (_c MockTransport_Send_Call) Return(err error) MockTransport_Send_Call {
	892	+	_c.Call.Return(err)
	893	+	return _c
	894	+	}
	895	+
	896	+	func (_c MockTransport_Send_Call) RunAndReturn(run func(frame ports.Frame) error) MockTransport_Send_Call {
	897	+	_c.Call.Return(run)
	898	+	return _c
	899	+	}
	900	+
	901	+	// NewMockListener creates a new instance of MockListener. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	902	+	// The first argument is typically a *testing.T value.
	903	+	func NewMockListener(t interface {
	904	+	mock.TestingT
	905	+	Cleanup(func())
	906	+	}) *MockListener {
	907	+	mock := &MockListener{}
	908	+	mock.Mock.Test(t)
	909	+
	910	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	911	+
	912	+	return mock
	913	+	}
	914	+
	915	+	// MockListener is an autogenerated mock type for the Listener type
	916	+	type MockListener struct {
	917	+	mock.Mock
	918	+	}
	919	+
	920	+	type MockListener_Expecter struct {
	921	+	mock *mock.Mock
	922	+	}
	923	+
	924	+	func (_m MockListener) EXPECT() MockListener_Expecter {
	925	+	return &MockListener_Expecter{mock: &_m.Mock}
	926	+	}
	927	+
	928	+	// Accept provides a mock function for the type MockListener
	929	+	func (_mock *MockListener) Accept() (ports.Transport, error) {
	930	+	ret := _mock.Called()
	931	+
	932	+	if len(ret) == 0 {
	933	+	panic("no return value specified for Accept")
	934	+	}
	935	+
	936	+	var r0 ports.Transport
	937	+	var r1 error
	938	+	if returnFunc, ok := ret.Get(0).(func() (ports.Transport, error)); ok {
	939	+	return returnFunc()
	940	+	}
	941	+	if returnFunc, ok := ret.Get(0).(func() ports.Transport); ok {
	942	+	r0 = returnFunc()
	943	+	} else {
	944	+	if ret.Get(0) != nil {
	945	+	r0 = ret.Get(0).(ports.Transport)
	946	+	}
	947	+	}
	948	+	if returnFunc, ok := ret.Get(1).(func() error); ok {
	949	+	r1 = returnFunc()
	950	+	} else {
	951	+	r1 = ret.Error(1)
	952	+	}
	953	+	return r0, r1
	954	+	}
	955	+
	956	+	// MockListener_Accept_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Accept'
	957	+	type MockListener_Accept_Call struct {
	958	+	*mock.Call
	959	+	}
	960	+
	961	+	// Accept is a helper method to define mock.On call
	962	+	func (_e MockListener_Expecter) Accept() MockListener_Accept_Call {
	963	+	return &MockListener_Accept_Call{Call: _e.mock.On("Accept")}
	964	+	}
	965	+
	966	+	func (_c MockListener_Accept_Call) Run(run func()) MockListener_Accept_Call {
	967	+	_c.Call.Run(func(args mock.Arguments) {
	968	+	run()
	969	+	})
	970	+	return _c
	971	+	}
	972	+
	973	+	func (_c MockListener_Accept_Call) Return(transport ports.Transport, err error) MockListener_Accept_Call {
	974	+	_c.Call.Return(transport, err)
	975	+	return _c
	976	+	}
	977	+
	978	+	func (_c MockListener_Accept_Call) RunAndReturn(run func() (ports.Transport, error)) MockListener_Accept_Call {
	979	+	_c.Call.Return(run)
	980	+	return _c
	981	+	}
	982	+
	983	+	// Addr provides a mock function for the type MockListener
	984	+	func (_mock *MockListener) Addr() string {
	985	+	ret := _mock.Called()
	986	+
	987	+	if len(ret) == 0 {
	988	+	panic("no return value specified for Addr")
	989	+	}
	990	+
	991	+	var r0 string
	992	+	if returnFunc, ok := ret.Get(0).(func() string); ok {
	993	+	r0 = returnFunc()
	994	+	} else {
	995	+	r0 = ret.Get(0).(string)
	996	+	}
	997	+	return r0
	998	+	}
	999	+
	1000	+	// MockListener_Addr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Addr'
	1001	+	type MockListener_Addr_Call struct {
	1002	+	*mock.Call
	1003	+	}
	1004	+
	1005	+	// Addr is a helper method to define mock.On call
	1006	+	func (_e MockListener_Expecter) Addr() MockListener_Addr_Call {
	1007	+	return &MockListener_Addr_Call{Call: _e.mock.On("Addr")}
	1008	+	}
	1009	+
	1010	+	func (_c MockListener_Addr_Call) Run(run func()) MockListener_Addr_Call {
	1011	+	_c.Call.Run(func(args mock.Arguments) {
	1012	+	run()
	1013	+	})
	1014	+	return _c
	1015	+	}
	1016	+
	1017	+	func (_c MockListener_Addr_Call) Return(s string) MockListener_Addr_Call {
	1018	+	_c.Call.Return(s)
	1019	+	return _c
	1020	+	}
	1021	+
	1022	+	func (_c MockListener_Addr_Call) RunAndReturn(run func() string) MockListener_Addr_Call {
	1023	+	_c.Call.Return(run)
	1024	+	return _c
	1025	+	}
	1026	+
	1027	+	// Close provides a mock function for the type MockListener
	1028	+	func (_mock *MockListener) Close() error {
	1029	+	ret := _mock.Called()
	1030	+
	1031	+	if len(ret) == 0 {
	1032	+	panic("no return value specified for Close")
	1033	+	}
	1034	+
	1035	+	var r0 error
	1036	+	if returnFunc, ok := ret.Get(0).(func() error); ok {
	1037	+	r0 = returnFunc()
	1038	+	} else {
	1039	+	r0 = ret.Error(0)
	1040	+	}
	1041	+	return r0
	1042	+	}
	1043	+
	1044	+	// MockListener_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
	1045	+	type MockListener_Close_Call struct {
	1046	+	*mock.Call
	1047	+	}
	1048	+
	1049	+	// Close is a helper method to define mock.On call
	1050	+	func (_e MockListener_Expecter) Close() MockListener_Close_Call {
	1051	+	return &MockListener_Close_Call{Call: _e.mock.On("Close")}
	1052	+	}
	1053	+
	1054	+	func (_c MockListener_Close_Call) Run(run func()) MockListener_Close_Call {
	1055	+	_c.Call.Run(func(args mock.Arguments) {
	1056	+	run()
	1057	+	})
	1058	+	return _c
	1059	+	}
	1060	+
	1061	+	func (_c MockListener_Close_Call) Return(err error) MockListener_Close_Call {
	1062	+	_c.Call.Return(err)
	1063	+	return _c
	1064	+	}
	1065	+
	1066	+	func (_c MockListener_Close_Call) RunAndReturn(run func() error) MockListener_Close_Call {
	1067	+	_c.Call.Return(run)
	1068	+	return _c
	1069	+	}
	1070	+
	1071	+	// NewMockClock creates a new instance of MockClock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	1072	+	// The first argument is typically a *testing.T value.
	1073	+	func NewMockClock(t interface {
	1074	+	mock.TestingT
	1075	+	Cleanup(func())
	1076	+	}) *MockClock {
	1077	+	mock := &MockClock{}
	1078	+	mock.Mock.Test(t)
	1079	+
	1080	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	1081	+
	1082	+	return mock
	1083	+	}
	1084	+
	1085	+	// MockClock is an autogenerated mock type for the Clock type
	1086	+	type MockClock struct {
	1087	+	mock.Mock
	1088	+	}
	1089	+
	1090	+	type MockClock_Expecter struct {
	1091	+	mock *mock.Mock
	1092	+	}
	1093	+
	1094	+	func (_m MockClock) EXPECT() MockClock_Expecter {
	1095	+	return &MockClock_Expecter{mock: &_m.Mock}
	1096	+	}
	1097	+
	1098	+	// NewTimer provides a mock function for the type MockClock
	1099	+	func (_mock *MockClock) NewTimer(d time.Duration) ports.Timer {
	1100	+	ret := _mock.Called(d)
	1101	+
	1102	+	if len(ret) == 0 {
	1103	+	panic("no return value specified for NewTimer")
	1104	+	}
	1105	+
	1106	+	var r0 ports.Timer
	1107	+	if returnFunc, ok := ret.Get(0).(func(time.Duration) ports.Timer); ok {
	1108	+	r0 = returnFunc(d)
	1109	+	} else {
	1110	+	if ret.Get(0) != nil {
	1111	+	r0 = ret.Get(0).(ports.Timer)
	1112	+	}
	1113	+	}
	1114	+	return r0
	1115	+	}
	1116	+
	1117	+	// MockClock_NewTimer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewTimer'
	1118	+	type MockClock_NewTimer_Call struct {
	1119	+	*mock.Call
	1120	+	}
	1121	+
	1122	+	// NewTimer is a helper method to define mock.On call
	1123	+	// - d time.Duration
	1124	+	func (_e MockClock_Expecter) NewTimer(d any) MockClock_NewTimer_Call {
	1125	+	return &MockClock_NewTimer_Call{Call: _e.mock.On("NewTimer", d)}
	1126	+	}
	1127	+
	1128	+	func (_c MockClock_NewTimer_Call) Run(run func(d time.Duration)) MockClock_NewTimer_Call {
	1129	+	_c.Call.Run(func(args mock.Arguments) {
	1130	+	var arg0 time.Duration
	1131	+	if args[0] != nil {
	1132	+	arg0 = args[0].(time.Duration)
	1133	+	}
	1134	+	run(
	1135	+	arg0,
	1136	+	)
	1137	+	})
	1138	+	return _c
	1139	+	}
	1140	+
	1141	+	func (_c MockClock_NewTimer_Call) Return(timer ports.Timer) MockClock_NewTimer_Call {
	1142	+	_c.Call.Return(timer)
	1143	+	return _c
	1144	+	}
	1145	+
	1146	+	func (_c MockClock_NewTimer_Call) RunAndReturn(run func(d time.Duration) ports.Timer) MockClock_NewTimer_Call {
	1147	+	_c.Call.Return(run)
	1148	+	return _c
	1149	+	}
	1150	+
	1151	+	// Now provides a mock function for the type MockClock
	1152	+	func (_mock *MockClock) Now() time.Time {
	1153	+	ret := _mock.Called()
	1154	+
	1155	+	if len(ret) == 0 {
	1156	+	panic("no return value specified for Now")
	1157	+	}
	1158	+
	1159	+	var r0 time.Time
	1160	+	if returnFunc, ok := ret.Get(0).(func() time.Time); ok {
	1161	+	r0 = returnFunc()
	1162	+	} else {
	1163	+	r0 = ret.Get(0).(time.Time)
	1164	+	}
	1165	+	return r0
	1166	+	}
	1167	+
	1168	+	// MockClock_Now_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Now'
	1169	+	type MockClock_Now_Call struct {
	1170	+	*mock.Call
	1171	+	}
	1172	+
	1173	+	// Now is a helper method to define mock.On call
	1174	+	func (_e MockClock_Expecter) Now() MockClock_Now_Call {
	1175	+	return &MockClock_Now_Call{Call: _e.mock.On("Now")}
	1176	+	}
	1177	+
	1178	+	func (_c MockClock_Now_Call) Run(run func()) MockClock_Now_Call {
	1179	+	_c.Call.Run(func(args mock.Arguments) {
	1180	+	run()
	1181	+	})
	1182	+	return _c
	1183	+	}
	1184	+
	1185	+	func (_c MockClock_Now_Call) Return(time1 time.Time) MockClock_Now_Call {
	1186	+	_c.Call.Return(time1)
	1187	+	return _c
	1188	+	}
	1189	+
	1190	+	func (_c MockClock_Now_Call) RunAndReturn(run func() time.Time) MockClock_Now_Call {
	1191	+	_c.Call.Return(run)
	1192	+	return _c
	1193	+	}
	1194	+
	1195	+	// NewMockTimer creates a new instance of MockTimer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	1196	+	// The first argument is typically a *testing.T value.
	1197	+	func NewMockTimer(t interface {
	1198	+	mock.TestingT
	1199	+	Cleanup(func())
	1200	+	}) *MockTimer {
	1201	+	mock := &MockTimer{}
	1202	+	mock.Mock.Test(t)
	1203	+
	1204	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	1205	+
	1206	+	return mock
	1207	+	}
	1208	+
	1209	+	// MockTimer is an autogenerated mock type for the Timer type
	1210	+	type MockTimer struct {
	1211	+	mock.Mock
	1212	+	}
	1213	+
	1214	+	type MockTimer_Expecter struct {
	1215	+	mock *mock.Mock
	1216	+	}
	1217	+
	1218	+	func (_m MockTimer) EXPECT() MockTimer_Expecter {
	1219	+	return &MockTimer_Expecter{mock: &_m.Mock}
	1220	+	}
	1221	+
	1222	+	// C provides a mock function for the type MockTimer
	1223	+	func (_mock *MockTimer) C() <-chan time.Time {
	1224	+	ret := _mock.Called()
	1225	+
	1226	+	if len(ret) == 0 {
	1227	+	panic("no return value specified for C")
	1228	+	}
	1229	+
	1230	+	var r0 <-chan time.Time
	1231	+	if returnFunc, ok := ret.Get(0).(func() <-chan time.Time); ok {
	1232	+	r0 = returnFunc()
	1233	+	} else {
	1234	+	if ret.Get(0) != nil {
	1235	+	r0 = ret.Get(0).(<-chan time.Time)
	1236	+	}
	1237	+	}
	1238	+	return r0
	1239	+	}
	1240	+
	1241	+	// MockTimer_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C'
	1242	+	type MockTimer_C_Call struct {
	1243	+	*mock.Call
	1244	+	}
	1245	+
	1246	+	// C is a helper method to define mock.On call
	1247	+	func (_e MockTimer_Expecter) C() MockTimer_C_Call {
	1248	+	return &MockTimer_C_Call{Call: _e.mock.On("C")}
	1249	+	}
	1250	+
	1251	+	func (_c MockTimer_C_Call) Run(run func()) MockTimer_C_Call {
	1252	+	_c.Call.Run(func(args mock.Arguments) {
	1253	+	run()
	1254	+	})
	1255	+	return _c
	1256	+	}
	1257	+
	1258	+	func (_c MockTimer_C_Call) Return(timeCh <-chan time.Time) MockTimer_C_Call {
	1259	+	_c.Call.Return(timeCh)
	1260	+	return _c
	1261	+	}
	1262	+
	1263	+	func (_c MockTimer_C_Call) RunAndReturn(run func() <-chan time.Time) MockTimer_C_Call {
	1264	+	_c.Call.Return(run)
	1265	+	return _c
	1266	+	}
	1267	+
	1268	+	// Reset provides a mock function for the type MockTimer
	1269	+	func (_mock *MockTimer) Reset(d time.Duration) bool {
	1270	+	ret := _mock.Called(d)
	1271	+
	1272	+	if len(ret) == 0 {
	1273	+	panic("no return value specified for Reset")
	1274	+	}
	1275	+
	1276	+	var r0 bool
	1277	+	if returnFunc, ok := ret.Get(0).(func(time.Duration) bool); ok {
	1278	+	r0 = returnFunc(d)
	1279	+	} else {
	1280	+	r0 = ret.Get(0).(bool)
	1281	+	}
	1282	+	return r0
	1283	+	}
	1284	+
	1285	+	// MockTimer_Reset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reset'
	1286	+	type MockTimer_Reset_Call struct {
	1287	+	*mock.Call
	1288	+	}
	1289	+
	1290	+	// Reset is a helper method to define mock.On call
	1291	+	// - d time.Duration
	1292	+	func (_e MockTimer_Expecter) Reset(d any) MockTimer_Reset_Call {
	1293	+	return &MockTimer_Reset_Call{Call: _e.mock.On("Reset", d)}
	1294	+	}
	1295	+
	1296	+	func (_c MockTimer_Reset_Call) Run(run func(d time.Duration)) MockTimer_Reset_Call {
	1297	+	_c.Call.Run(func(args mock.Arguments) {
	1298	+	var arg0 time.Duration
	1299	+	if args[0] != nil {
	1300	+	arg0 = args[0].(time.Duration)
	1301	+	}
	1302	+	run(
	1303	+	arg0,
	1304	+	)
	1305	+	})
	1306	+	return _c
	1307	+	}
	1308	+
	1309	+	func (_c MockTimer_Reset_Call) Return(b bool) MockTimer_Reset_Call {
	1310	+	_c.Call.Return(b)
	1311	+	return _c
	1312	+	}
	1313	+
	1314	+	func (_c MockTimer_Reset_Call) RunAndReturn(run func(d time.Duration) bool) MockTimer_Reset_Call {
	1315	+	_c.Call.Return(run)
	1316	+	return _c
	1317	+	}
	1318	+
	1319	+	// Stop provides a mock function for the type MockTimer
	1320	+	func (_mock *MockTimer) Stop() bool {
	1321	+	ret := _mock.Called()
	1322	+
	1323	+	if len(ret) == 0 {
	1324	+	panic("no return value specified for Stop")
	1325	+	}
	1326	+
	1327	+	var r0 bool
	1328	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	1329	+	r0 = returnFunc()
	1330	+	} else {
	1331	+	r0 = ret.Get(0).(bool)
	1332	+	}
	1333	+	return r0
	1334	+	}
	1335	+
	1336	+	// MockTimer_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
	1337	+	type MockTimer_Stop_Call struct {
	1338	+	*mock.Call
	1339	+	}
	1340	+
	1341	+	// Stop is a helper method to define mock.On call
	1342	+	func (_e MockTimer_Expecter) Stop() MockTimer_Stop_Call {
	1343	+	return &MockTimer_Stop_Call{Call: _e.mock.On("Stop")}
	1344	+	}
	1345	+
	1346	+	func (_c MockTimer_Stop_Call) Run(run func()) MockTimer_Stop_Call {
	1347	+	_c.Call.Run(func(args mock.Arguments) {
	1348	+	run()
	1349	+	})
	1350	+	return _c
	1351	+	}
	1352	+
	1353	+	func (_c MockTimer_Stop_Call) Return(b bool) MockTimer_Stop_Call {
	1354	+	_c.Call.Return(b)
	1355	+	return _c
	1356	+	}
	1357	+
	1358	+	func (_c MockTimer_Stop_Call) RunAndReturn(run func() bool) MockTimer_Stop_Call {
	1359	+	_c.Call.Return(run)
	1360	+	return _c
	1361	+	}