1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package portsmocks
6
7import (
8 "context"
9
10 "github.com/bnema/vev/internal/domain"
11 "github.com/bnema/vev/internal/ports"
12 mock "github.com/stretchr/testify/mock"
13)
14
15// 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.
16// The first argument is typically a *testing.T value.
17func NewMockPTY(t interface {
18 mock.TestingT
19 Cleanup(func())
20}) *MockPTY {
21 if helper, ok := t.(interface{ Helper() }); ok {
22 helper.Helper()
23 }
24
25 mock := &MockPTY{}
26 mock.Mock.Test(t)
27
28 t.Cleanup(func() {
29 if helper, ok := t.(interface{ Helper() }); ok {
30 helper.Helper()
31 }
32 mock.AssertExpectations(t)
33 })
34
35 return mock
36}
37
38// MockPTY is an autogenerated mock type for the PTY type
39type MockPTY struct {
40 mock.Mock
41}
42
43type MockPTY_Expecter struct {
44 mock *mock.Mock
45}
46
47func (_m *MockPTY) EXPECT() *MockPTY_Expecter {
48 return &MockPTY_Expecter{mock: &_m.Mock}
49}
50
51// Close provides a mock function for the type MockPTY
52func (_mock *MockPTY) Close() error {
53 ret := _mock.Called()
54
55 if len(ret) == 0 {
56 panic("no return value specified for Close")
57 }
58
59 var r0 error
60 if returnFunc, ok := ret.Get(0).(func() error); ok {
61 r0 = returnFunc()
62 } else {
63 r0 = ret.Error(0)
64 }
65 return r0
66}
67
68// MockPTY_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
69type MockPTY_Close_Call struct {
70 *mock.Call
71}
72
73// Close is a helper method to define mock.On call
74func (_e *MockPTY_Expecter) Close() *MockPTY_Close_Call {
75 return &MockPTY_Close_Call{Call: _e.mock.On("Close")}
76}
77
78func (_c *MockPTY_Close_Call) Run(run func()) *MockPTY_Close_Call {
79 _c.Call.Run(func(args mock.Arguments) {
80 run()
81 })
82 return _c
83}
84
85func (_c *MockPTY_Close_Call) Return(err error) *MockPTY_Close_Call {
86 _c.Call.Return(err)
87 return _c
88}
89
90func (_c *MockPTY_Close_Call) RunAndReturn(run func() error) *MockPTY_Close_Call {
91 _c.Call.Return(run)
92 return _c
93}
94
95// ForegroundPgid provides a mock function for the type MockPTY
96func (_mock *MockPTY) ForegroundPgid() (int, error) {
97 ret := _mock.Called()
98
99 if len(ret) == 0 {
100 panic("no return value specified for ForegroundPgid")
101 }
102
103 var r0 int
104 var r1 error
105 if returnFunc, ok := ret.Get(0).(func() (int, error)); ok {
106 return returnFunc()
107 }
108 if returnFunc, ok := ret.Get(0).(func() int); ok {
109 r0 = returnFunc()
110 } else {
111 r0 = ret.Get(0).(int)
112 }
113 if returnFunc, ok := ret.Get(1).(func() error); ok {
114 r1 = returnFunc()
115 } else {
116 r1 = ret.Error(1)
117 }
118 return r0, r1
119}
120
121// MockPTY_ForegroundPgid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ForegroundPgid'
122type MockPTY_ForegroundPgid_Call struct {
123 *mock.Call
124}
125
126// ForegroundPgid is a helper method to define mock.On call
127func (_e *MockPTY_Expecter) ForegroundPgid() *MockPTY_ForegroundPgid_Call {
128 return &MockPTY_ForegroundPgid_Call{Call: _e.mock.On("ForegroundPgid")}
129}
130
131func (_c *MockPTY_ForegroundPgid_Call) Run(run func()) *MockPTY_ForegroundPgid_Call {
132 _c.Call.Run(func(args mock.Arguments) {
133 run()
134 })
135 return _c
136}
137
138func (_c *MockPTY_ForegroundPgid_Call) Return(n int, err error) *MockPTY_ForegroundPgid_Call {
139 _c.Call.Return(n, err)
140 return _c
141}
142
143func (_c *MockPTY_ForegroundPgid_Call) RunAndReturn(run func() (int, error)) *MockPTY_ForegroundPgid_Call {
144 _c.Call.Return(run)
145 return _c
146}
147
148// Pid provides a mock function for the type MockPTY
149func (_mock *MockPTY) Pid() int {
150 ret := _mock.Called()
151
152 if len(ret) == 0 {
153 panic("no return value specified for Pid")
154 }
155
156 var r0 int
157 if returnFunc, ok := ret.Get(0).(func() int); ok {
158 r0 = returnFunc()
159 } else {
160 r0 = ret.Get(0).(int)
161 }
162 return r0
163}
164
165// MockPTY_Pid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pid'
166type MockPTY_Pid_Call struct {
167 *mock.Call
168}
169
170// Pid is a helper method to define mock.On call
171func (_e *MockPTY_Expecter) Pid() *MockPTY_Pid_Call {
172 return &MockPTY_Pid_Call{Call: _e.mock.On("Pid")}
173}
174
175func (_c *MockPTY_Pid_Call) Run(run func()) *MockPTY_Pid_Call {
176 _c.Call.Run(func(args mock.Arguments) {
177 run()
178 })
179 return _c
180}
181
182func (_c *MockPTY_Pid_Call) Return(n int) *MockPTY_Pid_Call {
183 _c.Call.Return(n)
184 return _c
185}
186
187func (_c *MockPTY_Pid_Call) RunAndReturn(run func() int) *MockPTY_Pid_Call {
188 _c.Call.Return(run)
189 return _c
190}
191
192// Read provides a mock function for the type MockPTY
193func (_mock *MockPTY) Read(p []byte) (int, error) {
194 ret := _mock.Called(p)
195
196 if len(ret) == 0 {
197 panic("no return value specified for Read")
198 }
199
200 var r0 int
201 var r1 error
202 if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
203 return returnFunc(p)
204 }
205 if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
206 r0 = returnFunc(p)
207 } else {
208 r0 = ret.Get(0).(int)
209 }
210 if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
211 r1 = returnFunc(p)
212 } else {
213 r1 = ret.Error(1)
214 }
215 return r0, r1
216}
217
218// MockPTY_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
219type MockPTY_Read_Call struct {
220 *mock.Call
221}
222
223// Read is a helper method to define mock.On call
224// - p []byte
225func (_e *MockPTY_Expecter) Read(p any) *MockPTY_Read_Call {
226 return &MockPTY_Read_Call{Call: _e.mock.On("Read", p)}
227}
228
229func (_c *MockPTY_Read_Call) Run(run func(p []byte)) *MockPTY_Read_Call {
230 _c.Call.Run(func(args mock.Arguments) {
231 var arg0 []byte
232 if args[0] != nil {
233 arg0 = args[0].([]byte)
234 }
235 run(
236 arg0,
237 )
238 })
239 return _c
240}
241
242func (_c *MockPTY_Read_Call) Return(n int, err error) *MockPTY_Read_Call {
243 _c.Call.Return(n, err)
244 return _c
245}
246
247func (_c *MockPTY_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockPTY_Read_Call {
248 _c.Call.Return(run)
249 return _c
250}
251
252// Resize provides a mock function for the type MockPTY
253func (_mock *MockPTY) Resize(geometry domain.Geometry) error {
254 ret := _mock.Called(geometry)
255
256 if len(ret) == 0 {
257 panic("no return value specified for Resize")
258 }
259
260 var r0 error
261 if returnFunc, ok := ret.Get(0).(func(domain.Geometry) error); ok {
262 r0 = returnFunc(geometry)
263 } else {
264 r0 = ret.Error(0)
265 }
266 return r0
267}
268
269// MockPTY_Resize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resize'
270type MockPTY_Resize_Call struct {
271 *mock.Call
272}
273
274// Resize is a helper method to define mock.On call
275// - geometry domain.Geometry
276func (_e *MockPTY_Expecter) Resize(geometry any) *MockPTY_Resize_Call {
277 return &MockPTY_Resize_Call{Call: _e.mock.On("Resize", geometry)}
278}
279
280func (_c *MockPTY_Resize_Call) Run(run func(geometry domain.Geometry)) *MockPTY_Resize_Call {
281 _c.Call.Run(func(args mock.Arguments) {
282 var arg0 domain.Geometry
283 if args[0] != nil {
284 arg0 = args[0].(domain.Geometry)
285 }
286 run(
287 arg0,
288 )
289 })
290 return _c
291}
292
293func (_c *MockPTY_Resize_Call) Return(err error) *MockPTY_Resize_Call {
294 _c.Call.Return(err)
295 return _c
296}
297
298func (_c *MockPTY_Resize_Call) RunAndReturn(run func(geometry domain.Geometry) error) *MockPTY_Resize_Call {
299 _c.Call.Return(run)
300 return _c
301}
302
303// Write provides a mock function for the type MockPTY
304func (_mock *MockPTY) Write(p []byte) (int, error) {
305 ret := _mock.Called(p)
306
307 if len(ret) == 0 {
308 panic("no return value specified for Write")
309 }
310
311 var r0 int
312 var r1 error
313 if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok {
314 return returnFunc(p)
315 }
316 if returnFunc, ok := ret.Get(0).(func([]byte) int); ok {
317 r0 = returnFunc(p)
318 } else {
319 r0 = ret.Get(0).(int)
320 }
321 if returnFunc, ok := ret.Get(1).(func([]byte) error); ok {
322 r1 = returnFunc(p)
323 } else {
324 r1 = ret.Error(1)
325 }
326 return r0, r1
327}
328
329// MockPTY_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write'
330type MockPTY_Write_Call struct {
331 *mock.Call
332}
333
334// Write is a helper method to define mock.On call
335// - p []byte
336func (_e *MockPTY_Expecter) Write(p any) *MockPTY_Write_Call {
337 return &MockPTY_Write_Call{Call: _e.mock.On("Write", p)}
338}
339
340func (_c *MockPTY_Write_Call) Run(run func(p []byte)) *MockPTY_Write_Call {
341 _c.Call.Run(func(args mock.Arguments) {
342 var arg0 []byte
343 if args[0] != nil {
344 arg0 = args[0].([]byte)
345 }
346 run(
347 arg0,
348 )
349 })
350 return _c
351}
352
353func (_c *MockPTY_Write_Call) Return(n int, err error) *MockPTY_Write_Call {
354 _c.Call.Return(n, err)
355 return _c
356}
357
358func (_c *MockPTY_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *MockPTY_Write_Call {
359 _c.Call.Return(run)
360 return _c
361}
362
363// 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.
364// The first argument is typically a *testing.T value.
365func NewMockPTYFactory(t interface {
366 mock.TestingT
367 Cleanup(func())
368}) *MockPTYFactory {
369 if helper, ok := t.(interface{ Helper() }); ok {
370 helper.Helper()
371 }
372
373 mock := &MockPTYFactory{}
374 mock.Mock.Test(t)
375
376 t.Cleanup(func() {
377 if helper, ok := t.(interface{ Helper() }); ok {
378 helper.Helper()
379 }
380 mock.AssertExpectations(t)
381 })
382
383 return mock
384}
385
386// MockPTYFactory is an autogenerated mock type for the PTYFactory type
387type MockPTYFactory struct {
388 mock.Mock
389}
390
391type MockPTYFactory_Expecter struct {
392 mock *mock.Mock
393}
394
395func (_m *MockPTYFactory) EXPECT() *MockPTYFactory_Expecter {
396 return &MockPTYFactory_Expecter{mock: &_m.Mock}
397}
398
399// Open provides a mock function for the type MockPTYFactory
400func (_mock *MockPTYFactory) Open(ctx context.Context, cmd string, args []string, env []string, dir string, geometry domain.Geometry) (ports.PTY, error) {
401 ret := _mock.Called(ctx, cmd, args, env, dir, geometry)
402
403 if len(ret) == 0 {
404 panic("no return value specified for Open")
405 }
406
407 var r0 ports.PTY
408 var r1 error
409 if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, []string, string, domain.Geometry) (ports.PTY, error)); ok {
410 return returnFunc(ctx, cmd, args, env, dir, geometry)
411 }
412 if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, []string, string, domain.Geometry) ports.PTY); ok {
413 r0 = returnFunc(ctx, cmd, args, env, dir, geometry)
414 } else {
415 if ret.Get(0) != nil {
416 r0 = ret.Get(0).(ports.PTY)
417 }
418 }
419 if returnFunc, ok := ret.Get(1).(func(context.Context, string, []string, []string, string, domain.Geometry) error); ok {
420 r1 = returnFunc(ctx, cmd, args, env, dir, geometry)
421 } else {
422 r1 = ret.Error(1)
423 }
424 return r0, r1
425}
426
427// MockPTYFactory_Open_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Open'
428type MockPTYFactory_Open_Call struct {
429 *mock.Call
430}
431
432// Open is a helper method to define mock.On call
433// - ctx context.Context
434// - cmd string
435// - args []string
436// - env []string
437// - dir string
438// - geometry domain.Geometry
439func (_e *MockPTYFactory_Expecter) Open(ctx any, cmd any, args any, env any, dir any, geometry any) *MockPTYFactory_Open_Call {
440 return &MockPTYFactory_Open_Call{Call: _e.mock.On("Open", ctx, cmd, args, env, dir, geometry)}
441}
442
443func (_c *MockPTYFactory_Open_Call) Run(run func(ctx context.Context, cmd string, args []string, env []string, dir string, geometry domain.Geometry)) *MockPTYFactory_Open_Call {
444 _c.Call.Run(func(args mock.Arguments) {
445 var arg0 context.Context
446 if args[0] != nil {
447 arg0 = args[0].(context.Context)
448 }
449 var arg1 string
450 if args[1] != nil {
451 arg1 = args[1].(string)
452 }
453 var arg2 []string
454 if args[2] != nil {
455 arg2 = args[2].([]string)
456 }
457 var arg3 []string
458 if args[3] != nil {
459 arg3 = args[3].([]string)
460 }
461 var arg4 string
462 if args[4] != nil {
463 arg4 = args[4].(string)
464 }
465 var arg5 domain.Geometry
466 if args[5] != nil {
467 arg5 = args[5].(domain.Geometry)
468 }
469 run(
470 arg0,
471 arg1,
472 arg2,
473 arg3,
474 arg4,
475 arg5,
476 )
477 })
478 return _c
479}
480
481func (_c *MockPTYFactory_Open_Call) Return(pTY ports.PTY, err error) *MockPTYFactory_Open_Call {
482 _c.Call.Return(pTY, err)
483 return _c
484}
485
486func (_c *MockPTYFactory_Open_Call) RunAndReturn(run func(ctx context.Context, cmd string, args []string, env []string, dir string, geometry domain.Geometry) (ports.PTY, error)) *MockPTYFactory_Open_Call {
487 _c.Call.Return(run)
488 return _c
489}