1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package command
6
7import (
8 mock "github.com/stretchr/testify/mock"
9)
10
11// NewMockContext creates a new instance of MockContext. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
12// The first argument is typically a *testing.T value.
13func NewMockContext(t interface {
14 mock.TestingT
15 Cleanup(func())
16}) *MockContext {
17 if helper, ok := t.(interface{ Helper() }); ok {
18 helper.Helper()
19 }
20
21 mock := &MockContext{}
22 mock.Mock.Test(t)
23
24 t.Cleanup(func() {
25 if helper, ok := t.(interface{ Helper() }); ok {
26 helper.Helper()
27 }
28 mock.AssertExpectations(t)
29 })
30
31 return mock
32}
33
34// MockContext is an autogenerated mock type for the Context type
35type MockContext struct {
36 mock.Mock
37}
38
39type MockContext_Expecter struct {
40 mock *mock.Mock
41}
42
43func (_m *MockContext) EXPECT() *MockContext_Expecter {
44 return &MockContext_Expecter{mock: &_m.Mock}
45}
46
47// BackSession provides a mock function for the type MockContext
48func (_mock *MockContext) BackSession() error {
49 ret := _mock.Called()
50
51 if len(ret) == 0 {
52 panic("no return value specified for BackSession")
53 }
54
55 var r0 error
56 if returnFunc, ok := ret.Get(0).(func() error); ok {
57 r0 = returnFunc()
58 } else {
59 r0 = ret.Error(0)
60 }
61 return r0
62}
63
64// MockContext_BackSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BackSession'
65type MockContext_BackSession_Call struct {
66 *mock.Call
67}
68
69// BackSession is a helper method to define mock.On call
70func (_e *MockContext_Expecter) BackSession() *MockContext_BackSession_Call {
71 return &MockContext_BackSession_Call{Call: _e.mock.On("BackSession")}
72}
73
74func (_c *MockContext_BackSession_Call) Run(run func()) *MockContext_BackSession_Call {
75 _c.Call.Run(func(args mock.Arguments) {
76 run()
77 })
78 return _c
79}
80
81func (_c *MockContext_BackSession_Call) Return(err error) *MockContext_BackSession_Call {
82 _c.Call.Return(err)
83 return _c
84}
85
86func (_c *MockContext_BackSession_Call) RunAndReturn(run func() error) *MockContext_BackSession_Call {
87 _c.Call.Return(run)
88 return _c
89}
90
91// ClosePane provides a mock function for the type MockContext
92func (_mock *MockContext) ClosePane() error {
93 ret := _mock.Called()
94
95 if len(ret) == 0 {
96 panic("no return value specified for ClosePane")
97 }
98
99 var r0 error
100 if returnFunc, ok := ret.Get(0).(func() error); ok {
101 r0 = returnFunc()
102 } else {
103 r0 = ret.Error(0)
104 }
105 return r0
106}
107
108// MockContext_ClosePane_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClosePane'
109type MockContext_ClosePane_Call struct {
110 *mock.Call
111}
112
113// ClosePane is a helper method to define mock.On call
114func (_e *MockContext_Expecter) ClosePane() *MockContext_ClosePane_Call {
115 return &MockContext_ClosePane_Call{Call: _e.mock.On("ClosePane")}
116}
117
118func (_c *MockContext_ClosePane_Call) Run(run func()) *MockContext_ClosePane_Call {
119 _c.Call.Run(func(args mock.Arguments) {
120 run()
121 })
122 return _c
123}
124
125func (_c *MockContext_ClosePane_Call) Return(err error) *MockContext_ClosePane_Call {
126 _c.Call.Return(err)
127 return _c
128}
129
130func (_c *MockContext_ClosePane_Call) RunAndReturn(run func() error) *MockContext_ClosePane_Call {
131 _c.Call.Return(run)
132 return _c
133}
134
135// CloseTab provides a mock function for the type MockContext
136func (_mock *MockContext) CloseTab() error {
137 ret := _mock.Called()
138
139 if len(ret) == 0 {
140 panic("no return value specified for CloseTab")
141 }
142
143 var r0 error
144 if returnFunc, ok := ret.Get(0).(func() error); ok {
145 r0 = returnFunc()
146 } else {
147 r0 = ret.Error(0)
148 }
149 return r0
150}
151
152// MockContext_CloseTab_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseTab'
153type MockContext_CloseTab_Call struct {
154 *mock.Call
155}
156
157// CloseTab is a helper method to define mock.On call
158func (_e *MockContext_Expecter) CloseTab() *MockContext_CloseTab_Call {
159 return &MockContext_CloseTab_Call{Call: _e.mock.On("CloseTab")}
160}
161
162func (_c *MockContext_CloseTab_Call) Run(run func()) *MockContext_CloseTab_Call {
163 _c.Call.Run(func(args mock.Arguments) {
164 run()
165 })
166 return _c
167}
168
169func (_c *MockContext_CloseTab_Call) Return(err error) *MockContext_CloseTab_Call {
170 _c.Call.Return(err)
171 return _c
172}
173
174func (_c *MockContext_CloseTab_Call) RunAndReturn(run func() error) *MockContext_CloseTab_Call {
175 _c.Call.Return(run)
176 return _c
177}
178
179// ConsumeOrExpelPaneLeft provides a mock function for the type MockContext
180func (_mock *MockContext) ConsumeOrExpelPaneLeft() error {
181 ret := _mock.Called()
182
183 if len(ret) == 0 {
184 panic("no return value specified for ConsumeOrExpelPaneLeft")
185 }
186
187 var r0 error
188 if returnFunc, ok := ret.Get(0).(func() error); ok {
189 r0 = returnFunc()
190 } else {
191 r0 = ret.Error(0)
192 }
193 return r0
194}
195
196// MockContext_ConsumeOrExpelPaneLeft_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConsumeOrExpelPaneLeft'
197type MockContext_ConsumeOrExpelPaneLeft_Call struct {
198 *mock.Call
199}
200
201// ConsumeOrExpelPaneLeft is a helper method to define mock.On call
202func (_e *MockContext_Expecter) ConsumeOrExpelPaneLeft() *MockContext_ConsumeOrExpelPaneLeft_Call {
203 return &MockContext_ConsumeOrExpelPaneLeft_Call{Call: _e.mock.On("ConsumeOrExpelPaneLeft")}
204}
205
206func (_c *MockContext_ConsumeOrExpelPaneLeft_Call) Run(run func()) *MockContext_ConsumeOrExpelPaneLeft_Call {
207 _c.Call.Run(func(args mock.Arguments) {
208 run()
209 })
210 return _c
211}
212
213func (_c *MockContext_ConsumeOrExpelPaneLeft_Call) Return(err error) *MockContext_ConsumeOrExpelPaneLeft_Call {
214 _c.Call.Return(err)
215 return _c
216}
217
218func (_c *MockContext_ConsumeOrExpelPaneLeft_Call) RunAndReturn(run func() error) *MockContext_ConsumeOrExpelPaneLeft_Call {
219 _c.Call.Return(run)
220 return _c
221}
222
223// ConsumeOrExpelPaneRight provides a mock function for the type MockContext
224func (_mock *MockContext) ConsumeOrExpelPaneRight() error {
225 ret := _mock.Called()
226
227 if len(ret) == 0 {
228 panic("no return value specified for ConsumeOrExpelPaneRight")
229 }
230
231 var r0 error
232 if returnFunc, ok := ret.Get(0).(func() error); ok {
233 r0 = returnFunc()
234 } else {
235 r0 = ret.Error(0)
236 }
237 return r0
238}
239
240// MockContext_ConsumeOrExpelPaneRight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConsumeOrExpelPaneRight'
241type MockContext_ConsumeOrExpelPaneRight_Call struct {
242 *mock.Call
243}
244
245// ConsumeOrExpelPaneRight is a helper method to define mock.On call
246func (_e *MockContext_Expecter) ConsumeOrExpelPaneRight() *MockContext_ConsumeOrExpelPaneRight_Call {
247 return &MockContext_ConsumeOrExpelPaneRight_Call{Call: _e.mock.On("ConsumeOrExpelPaneRight")}
248}
249
250func (_c *MockContext_ConsumeOrExpelPaneRight_Call) Run(run func()) *MockContext_ConsumeOrExpelPaneRight_Call {
251 _c.Call.Run(func(args mock.Arguments) {
252 run()
253 })
254 return _c
255}
256
257func (_c *MockContext_ConsumeOrExpelPaneRight_Call) Return(err error) *MockContext_ConsumeOrExpelPaneRight_Call {
258 _c.Call.Return(err)
259 return _c
260}
261
262func (_c *MockContext_ConsumeOrExpelPaneRight_Call) RunAndReturn(run func() error) *MockContext_ConsumeOrExpelPaneRight_Call {
263 _c.Call.Return(run)
264 return _c
265}
266
267// CreateEphemeralSession provides a mock function for the type MockContext
268func (_mock *MockContext) CreateEphemeralSession() error {
269 ret := _mock.Called()
270
271 if len(ret) == 0 {
272 panic("no return value specified for CreateEphemeralSession")
273 }
274
275 var r0 error
276 if returnFunc, ok := ret.Get(0).(func() error); ok {
277 r0 = returnFunc()
278 } else {
279 r0 = ret.Error(0)
280 }
281 return r0
282}
283
284// MockContext_CreateEphemeralSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEphemeralSession'
285type MockContext_CreateEphemeralSession_Call struct {
286 *mock.Call
287}
288
289// CreateEphemeralSession is a helper method to define mock.On call
290func (_e *MockContext_Expecter) CreateEphemeralSession() *MockContext_CreateEphemeralSession_Call {
291 return &MockContext_CreateEphemeralSession_Call{Call: _e.mock.On("CreateEphemeralSession")}
292}
293
294func (_c *MockContext_CreateEphemeralSession_Call) Run(run func()) *MockContext_CreateEphemeralSession_Call {
295 _c.Call.Run(func(args mock.Arguments) {
296 run()
297 })
298 return _c
299}
300
301func (_c *MockContext_CreateEphemeralSession_Call) Return(err error) *MockContext_CreateEphemeralSession_Call {
302 _c.Call.Return(err)
303 return _c
304}
305
306func (_c *MockContext_CreateEphemeralSession_Call) RunAndReturn(run func() error) *MockContext_CreateEphemeralSession_Call {
307 _c.Call.Return(run)
308 return _c
309}
310
311// CreateSession provides a mock function for the type MockContext
312func (_mock *MockContext) CreateSession() error {
313 ret := _mock.Called()
314
315 if len(ret) == 0 {
316 panic("no return value specified for CreateSession")
317 }
318
319 var r0 error
320 if returnFunc, ok := ret.Get(0).(func() error); ok {
321 r0 = returnFunc()
322 } else {
323 r0 = ret.Error(0)
324 }
325 return r0
326}
327
328// MockContext_CreateSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSession'
329type MockContext_CreateSession_Call struct {
330 *mock.Call
331}
332
333// CreateSession is a helper method to define mock.On call
334func (_e *MockContext_Expecter) CreateSession() *MockContext_CreateSession_Call {
335 return &MockContext_CreateSession_Call{Call: _e.mock.On("CreateSession")}
336}
337
338func (_c *MockContext_CreateSession_Call) Run(run func()) *MockContext_CreateSession_Call {
339 _c.Call.Run(func(args mock.Arguments) {
340 run()
341 })
342 return _c
343}
344
345func (_c *MockContext_CreateSession_Call) Return(err error) *MockContext_CreateSession_Call {
346 _c.Call.Return(err)
347 return _c
348}
349
350func (_c *MockContext_CreateSession_Call) RunAndReturn(run func() error) *MockContext_CreateSession_Call {
351 _c.Call.Return(run)
352 return _c
353}
354
355// CreateSessionNamed provides a mock function for the type MockContext
356func (_mock *MockContext) CreateSessionNamed(name string) error {
357 ret := _mock.Called(name)
358
359 if len(ret) == 0 {
360 panic("no return value specified for CreateSessionNamed")
361 }
362
363 var r0 error
364 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
365 r0 = returnFunc(name)
366 } else {
367 r0 = ret.Error(0)
368 }
369 return r0
370}
371
372// MockContext_CreateSessionNamed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSessionNamed'
373type MockContext_CreateSessionNamed_Call struct {
374 *mock.Call
375}
376
377// CreateSessionNamed is a helper method to define mock.On call
378// - name string
379func (_e *MockContext_Expecter) CreateSessionNamed(name any) *MockContext_CreateSessionNamed_Call {
380 return &MockContext_CreateSessionNamed_Call{Call: _e.mock.On("CreateSessionNamed", name)}
381}
382
383func (_c *MockContext_CreateSessionNamed_Call) Run(run func(name string)) *MockContext_CreateSessionNamed_Call {
384 _c.Call.Run(func(args mock.Arguments) {
385 var arg0 string
386 if args[0] != nil {
387 arg0 = args[0].(string)
388 }
389 run(
390 arg0,
391 )
392 })
393 return _c
394}
395
396func (_c *MockContext_CreateSessionNamed_Call) Return(err error) *MockContext_CreateSessionNamed_Call {
397 _c.Call.Return(err)
398 return _c
399}
400
401func (_c *MockContext_CreateSessionNamed_Call) RunAndReturn(run func(name string) error) *MockContext_CreateSessionNamed_Call {
402 _c.Call.Return(run)
403 return _c
404}
405
406// CreateTab provides a mock function for the type MockContext
407func (_mock *MockContext) CreateTab() error {
408 ret := _mock.Called()
409
410 if len(ret) == 0 {
411 panic("no return value specified for CreateTab")
412 }
413
414 var r0 error
415 if returnFunc, ok := ret.Get(0).(func() error); ok {
416 r0 = returnFunc()
417 } else {
418 r0 = ret.Error(0)
419 }
420 return r0
421}
422
423// MockContext_CreateTab_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTab'
424type MockContext_CreateTab_Call struct {
425 *mock.Call
426}
427
428// CreateTab is a helper method to define mock.On call
429func (_e *MockContext_Expecter) CreateTab() *MockContext_CreateTab_Call {
430 return &MockContext_CreateTab_Call{Call: _e.mock.On("CreateTab")}
431}
432
433func (_c *MockContext_CreateTab_Call) Run(run func()) *MockContext_CreateTab_Call {
434 _c.Call.Run(func(args mock.Arguments) {
435 run()
436 })
437 return _c
438}
439
440func (_c *MockContext_CreateTab_Call) Return(err error) *MockContext_CreateTab_Call {
441 _c.Call.Return(err)
442 return _c
443}
444
445func (_c *MockContext_CreateTab_Call) RunAndReturn(run func() error) *MockContext_CreateTab_Call {
446 _c.Call.Return(run)
447 return _c
448}
449
450// Detach provides a mock function for the type MockContext
451func (_mock *MockContext) Detach() error {
452 ret := _mock.Called()
453
454 if len(ret) == 0 {
455 panic("no return value specified for Detach")
456 }
457
458 var r0 error
459 if returnFunc, ok := ret.Get(0).(func() error); ok {
460 r0 = returnFunc()
461 } else {
462 r0 = ret.Error(0)
463 }
464 return r0
465}
466
467// MockContext_Detach_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Detach'
468type MockContext_Detach_Call struct {
469 *mock.Call
470}
471
472// Detach is a helper method to define mock.On call
473func (_e *MockContext_Expecter) Detach() *MockContext_Detach_Call {
474 return &MockContext_Detach_Call{Call: _e.mock.On("Detach")}
475}
476
477func (_c *MockContext_Detach_Call) Run(run func()) *MockContext_Detach_Call {
478 _c.Call.Run(func(args mock.Arguments) {
479 run()
480 })
481 return _c
482}
483
484func (_c *MockContext_Detach_Call) Return(err error) *MockContext_Detach_Call {
485 _c.Call.Return(err)
486 return _c
487}
488
489func (_c *MockContext_Detach_Call) RunAndReturn(run func() error) *MockContext_Detach_Call {
490 _c.Call.Return(run)
491 return _c
492}
493
494// EnterResizeMode provides a mock function for the type MockContext
495func (_mock *MockContext) EnterResizeMode() error {
496 ret := _mock.Called()
497
498 if len(ret) == 0 {
499 panic("no return value specified for EnterResizeMode")
500 }
501
502 var r0 error
503 if returnFunc, ok := ret.Get(0).(func() error); ok {
504 r0 = returnFunc()
505 } else {
506 r0 = ret.Error(0)
507 }
508 return r0
509}
510
511// MockContext_EnterResizeMode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnterResizeMode'
512type MockContext_EnterResizeMode_Call struct {
513 *mock.Call
514}
515
516// EnterResizeMode is a helper method to define mock.On call
517func (_e *MockContext_Expecter) EnterResizeMode() *MockContext_EnterResizeMode_Call {
518 return &MockContext_EnterResizeMode_Call{Call: _e.mock.On("EnterResizeMode")}
519}
520
521func (_c *MockContext_EnterResizeMode_Call) Run(run func()) *MockContext_EnterResizeMode_Call {
522 _c.Call.Run(func(args mock.Arguments) {
523 run()
524 })
525 return _c
526}
527
528func (_c *MockContext_EnterResizeMode_Call) Return(err error) *MockContext_EnterResizeMode_Call {
529 _c.Call.Return(err)
530 return _c
531}
532
533func (_c *MockContext_EnterResizeMode_Call) RunAndReturn(run func() error) *MockContext_EnterResizeMode_Call {
534 _c.Call.Return(run)
535 return _c
536}
537
538// EnterVisualMode provides a mock function for the type MockContext
539func (_mock *MockContext) EnterVisualMode() error {
540 ret := _mock.Called()
541
542 if len(ret) == 0 {
543 panic("no return value specified for EnterVisualMode")
544 }
545
546 var r0 error
547 if returnFunc, ok := ret.Get(0).(func() error); ok {
548 r0 = returnFunc()
549 } else {
550 r0 = ret.Error(0)
551 }
552 return r0
553}
554
555// MockContext_EnterVisualMode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnterVisualMode'
556type MockContext_EnterVisualMode_Call struct {
557 *mock.Call
558}
559
560// EnterVisualMode is a helper method to define mock.On call
561func (_e *MockContext_Expecter) EnterVisualMode() *MockContext_EnterVisualMode_Call {
562 return &MockContext_EnterVisualMode_Call{Call: _e.mock.On("EnterVisualMode")}
563}
564
565func (_c *MockContext_EnterVisualMode_Call) Run(run func()) *MockContext_EnterVisualMode_Call {
566 _c.Call.Run(func(args mock.Arguments) {
567 run()
568 })
569 return _c
570}
571
572func (_c *MockContext_EnterVisualMode_Call) Return(err error) *MockContext_EnterVisualMode_Call {
573 _c.Call.Return(err)
574 return _c
575}
576
577func (_c *MockContext_EnterVisualMode_Call) RunAndReturn(run func() error) *MockContext_EnterVisualMode_Call {
578 _c.Call.Return(run)
579 return _c
580}
581
582// EqualizePanes provides a mock function for the type MockContext
583func (_mock *MockContext) EqualizePanes() error {
584 ret := _mock.Called()
585
586 if len(ret) == 0 {
587 panic("no return value specified for EqualizePanes")
588 }
589
590 var r0 error
591 if returnFunc, ok := ret.Get(0).(func() error); ok {
592 r0 = returnFunc()
593 } else {
594 r0 = ret.Error(0)
595 }
596 return r0
597}
598
599// MockContext_EqualizePanes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EqualizePanes'
600type MockContext_EqualizePanes_Call struct {
601 *mock.Call
602}
603
604// EqualizePanes is a helper method to define mock.On call
605func (_e *MockContext_Expecter) EqualizePanes() *MockContext_EqualizePanes_Call {
606 return &MockContext_EqualizePanes_Call{Call: _e.mock.On("EqualizePanes")}
607}
608
609func (_c *MockContext_EqualizePanes_Call) Run(run func()) *MockContext_EqualizePanes_Call {
610 _c.Call.Run(func(args mock.Arguments) {
611 run()
612 })
613 return _c
614}
615
616func (_c *MockContext_EqualizePanes_Call) Return(err error) *MockContext_EqualizePanes_Call {
617 _c.Call.Return(err)
618 return _c
619}
620
621func (_c *MockContext_EqualizePanes_Call) RunAndReturn(run func() error) *MockContext_EqualizePanes_Call {
622 _c.Call.Return(run)
623 return _c
624}
625
626// FocusPaneDown provides a mock function for the type MockContext
627func (_mock *MockContext) FocusPaneDown() error {
628 ret := _mock.Called()
629
630 if len(ret) == 0 {
631 panic("no return value specified for FocusPaneDown")
632 }
633
634 var r0 error
635 if returnFunc, ok := ret.Get(0).(func() error); ok {
636 r0 = returnFunc()
637 } else {
638 r0 = ret.Error(0)
639 }
640 return r0
641}
642
643// MockContext_FocusPaneDown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FocusPaneDown'
644type MockContext_FocusPaneDown_Call struct {
645 *mock.Call
646}
647
648// FocusPaneDown is a helper method to define mock.On call
649func (_e *MockContext_Expecter) FocusPaneDown() *MockContext_FocusPaneDown_Call {
650 return &MockContext_FocusPaneDown_Call{Call: _e.mock.On("FocusPaneDown")}
651}
652
653func (_c *MockContext_FocusPaneDown_Call) Run(run func()) *MockContext_FocusPaneDown_Call {
654 _c.Call.Run(func(args mock.Arguments) {
655 run()
656 })
657 return _c
658}
659
660func (_c *MockContext_FocusPaneDown_Call) Return(err error) *MockContext_FocusPaneDown_Call {
661 _c.Call.Return(err)
662 return _c
663}
664
665func (_c *MockContext_FocusPaneDown_Call) RunAndReturn(run func() error) *MockContext_FocusPaneDown_Call {
666 _c.Call.Return(run)
667 return _c
668}
669
670// FocusPaneLeft provides a mock function for the type MockContext
671func (_mock *MockContext) FocusPaneLeft() error {
672 ret := _mock.Called()
673
674 if len(ret) == 0 {
675 panic("no return value specified for FocusPaneLeft")
676 }
677
678 var r0 error
679 if returnFunc, ok := ret.Get(0).(func() error); ok {
680 r0 = returnFunc()
681 } else {
682 r0 = ret.Error(0)
683 }
684 return r0
685}
686
687// MockContext_FocusPaneLeft_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FocusPaneLeft'
688type MockContext_FocusPaneLeft_Call struct {
689 *mock.Call
690}
691
692// FocusPaneLeft is a helper method to define mock.On call
693func (_e *MockContext_Expecter) FocusPaneLeft() *MockContext_FocusPaneLeft_Call {
694 return &MockContext_FocusPaneLeft_Call{Call: _e.mock.On("FocusPaneLeft")}
695}
696
697func (_c *MockContext_FocusPaneLeft_Call) Run(run func()) *MockContext_FocusPaneLeft_Call {
698 _c.Call.Run(func(args mock.Arguments) {
699 run()
700 })
701 return _c
702}
703
704func (_c *MockContext_FocusPaneLeft_Call) Return(err error) *MockContext_FocusPaneLeft_Call {
705 _c.Call.Return(err)
706 return _c
707}
708
709func (_c *MockContext_FocusPaneLeft_Call) RunAndReturn(run func() error) *MockContext_FocusPaneLeft_Call {
710 _c.Call.Return(run)
711 return _c
712}
713
714// FocusPaneRight provides a mock function for the type MockContext
715func (_mock *MockContext) FocusPaneRight() error {
716 ret := _mock.Called()
717
718 if len(ret) == 0 {
719 panic("no return value specified for FocusPaneRight")
720 }
721
722 var r0 error
723 if returnFunc, ok := ret.Get(0).(func() error); ok {
724 r0 = returnFunc()
725 } else {
726 r0 = ret.Error(0)
727 }
728 return r0
729}
730
731// MockContext_FocusPaneRight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FocusPaneRight'
732type MockContext_FocusPaneRight_Call struct {
733 *mock.Call
734}
735
736// FocusPaneRight is a helper method to define mock.On call
737func (_e *MockContext_Expecter) FocusPaneRight() *MockContext_FocusPaneRight_Call {
738 return &MockContext_FocusPaneRight_Call{Call: _e.mock.On("FocusPaneRight")}
739}
740
741func (_c *MockContext_FocusPaneRight_Call) Run(run func()) *MockContext_FocusPaneRight_Call {
742 _c.Call.Run(func(args mock.Arguments) {
743 run()
744 })
745 return _c
746}
747
748func (_c *MockContext_FocusPaneRight_Call) Return(err error) *MockContext_FocusPaneRight_Call {
749 _c.Call.Return(err)
750 return _c
751}
752
753func (_c *MockContext_FocusPaneRight_Call) RunAndReturn(run func() error) *MockContext_FocusPaneRight_Call {
754 _c.Call.Return(run)
755 return _c
756}
757
758// FocusPaneUp provides a mock function for the type MockContext
759func (_mock *MockContext) FocusPaneUp() error {
760 ret := _mock.Called()
761
762 if len(ret) == 0 {
763 panic("no return value specified for FocusPaneUp")
764 }
765
766 var r0 error
767 if returnFunc, ok := ret.Get(0).(func() error); ok {
768 r0 = returnFunc()
769 } else {
770 r0 = ret.Error(0)
771 }
772 return r0
773}
774
775// MockContext_FocusPaneUp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FocusPaneUp'
776type MockContext_FocusPaneUp_Call struct {
777 *mock.Call
778}
779
780// FocusPaneUp is a helper method to define mock.On call
781func (_e *MockContext_Expecter) FocusPaneUp() *MockContext_FocusPaneUp_Call {
782 return &MockContext_FocusPaneUp_Call{Call: _e.mock.On("FocusPaneUp")}
783}
784
785func (_c *MockContext_FocusPaneUp_Call) Run(run func()) *MockContext_FocusPaneUp_Call {
786 _c.Call.Run(func(args mock.Arguments) {
787 run()
788 })
789 return _c
790}
791
792func (_c *MockContext_FocusPaneUp_Call) Return(err error) *MockContext_FocusPaneUp_Call {
793 _c.Call.Return(err)
794 return _c
795}
796
797func (_c *MockContext_FocusPaneUp_Call) RunAndReturn(run func() error) *MockContext_FocusPaneUp_Call {
798 _c.Call.Return(run)
799 return _c
800}
801
802// GrowPaneHeight provides a mock function for the type MockContext
803func (_mock *MockContext) GrowPaneHeight() error {
804 ret := _mock.Called()
805
806 if len(ret) == 0 {
807 panic("no return value specified for GrowPaneHeight")
808 }
809
810 var r0 error
811 if returnFunc, ok := ret.Get(0).(func() error); ok {
812 r0 = returnFunc()
813 } else {
814 r0 = ret.Error(0)
815 }
816 return r0
817}
818
819// MockContext_GrowPaneHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrowPaneHeight'
820type MockContext_GrowPaneHeight_Call struct {
821 *mock.Call
822}
823
824// GrowPaneHeight is a helper method to define mock.On call
825func (_e *MockContext_Expecter) GrowPaneHeight() *MockContext_GrowPaneHeight_Call {
826 return &MockContext_GrowPaneHeight_Call{Call: _e.mock.On("GrowPaneHeight")}
827}
828
829func (_c *MockContext_GrowPaneHeight_Call) Run(run func()) *MockContext_GrowPaneHeight_Call {
830 _c.Call.Run(func(args mock.Arguments) {
831 run()
832 })
833 return _c
834}
835
836func (_c *MockContext_GrowPaneHeight_Call) Return(err error) *MockContext_GrowPaneHeight_Call {
837 _c.Call.Return(err)
838 return _c
839}
840
841func (_c *MockContext_GrowPaneHeight_Call) RunAndReturn(run func() error) *MockContext_GrowPaneHeight_Call {
842 _c.Call.Return(run)
843 return _c
844}
845
846// GrowPaneWidth provides a mock function for the type MockContext
847func (_mock *MockContext) GrowPaneWidth() error {
848 ret := _mock.Called()
849
850 if len(ret) == 0 {
851 panic("no return value specified for GrowPaneWidth")
852 }
853
854 var r0 error
855 if returnFunc, ok := ret.Get(0).(func() error); ok {
856 r0 = returnFunc()
857 } else {
858 r0 = ret.Error(0)
859 }
860 return r0
861}
862
863// MockContext_GrowPaneWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrowPaneWidth'
864type MockContext_GrowPaneWidth_Call struct {
865 *mock.Call
866}
867
868// GrowPaneWidth is a helper method to define mock.On call
869func (_e *MockContext_Expecter) GrowPaneWidth() *MockContext_GrowPaneWidth_Call {
870 return &MockContext_GrowPaneWidth_Call{Call: _e.mock.On("GrowPaneWidth")}
871}
872
873func (_c *MockContext_GrowPaneWidth_Call) Run(run func()) *MockContext_GrowPaneWidth_Call {
874 _c.Call.Run(func(args mock.Arguments) {
875 run()
876 })
877 return _c
878}
879
880func (_c *MockContext_GrowPaneWidth_Call) Return(err error) *MockContext_GrowPaneWidth_Call {
881 _c.Call.Return(err)
882 return _c
883}
884
885func (_c *MockContext_GrowPaneWidth_Call) RunAndReturn(run func() error) *MockContext_GrowPaneWidth_Call {
886 _c.Call.Return(run)
887 return _c
888}
889
890// JumpRecentSession provides a mock function for the type MockContext
891func (_mock *MockContext) JumpRecentSession(rank int) error {
892 ret := _mock.Called(rank)
893
894 if len(ret) == 0 {
895 panic("no return value specified for JumpRecentSession")
896 }
897
898 var r0 error
899 if returnFunc, ok := ret.Get(0).(func(int) error); ok {
900 r0 = returnFunc(rank)
901 } else {
902 r0 = ret.Error(0)
903 }
904 return r0
905}
906
907// MockContext_JumpRecentSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JumpRecentSession'
908type MockContext_JumpRecentSession_Call struct {
909 *mock.Call
910}
911
912// JumpRecentSession is a helper method to define mock.On call
913// - rank int
914func (_e *MockContext_Expecter) JumpRecentSession(rank any) *MockContext_JumpRecentSession_Call {
915 return &MockContext_JumpRecentSession_Call{Call: _e.mock.On("JumpRecentSession", rank)}
916}
917
918func (_c *MockContext_JumpRecentSession_Call) Run(run func(rank int)) *MockContext_JumpRecentSession_Call {
919 _c.Call.Run(func(args mock.Arguments) {
920 var arg0 int
921 if args[0] != nil {
922 arg0 = args[0].(int)
923 }
924 run(
925 arg0,
926 )
927 })
928 return _c
929}
930
931func (_c *MockContext_JumpRecentSession_Call) Return(err error) *MockContext_JumpRecentSession_Call {
932 _c.Call.Return(err)
933 return _c
934}
935
936func (_c *MockContext_JumpRecentSession_Call) RunAndReturn(run func(rank int) error) *MockContext_JumpRecentSession_Call {
937 _c.Call.Return(run)
938 return _c
939}
940
941// NextTab provides a mock function for the type MockContext
942func (_mock *MockContext) NextTab() error {
943 ret := _mock.Called()
944
945 if len(ret) == 0 {
946 panic("no return value specified for NextTab")
947 }
948
949 var r0 error
950 if returnFunc, ok := ret.Get(0).(func() error); ok {
951 r0 = returnFunc()
952 } else {
953 r0 = ret.Error(0)
954 }
955 return r0
956}
957
958// MockContext_NextTab_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NextTab'
959type MockContext_NextTab_Call struct {
960 *mock.Call
961}
962
963// NextTab is a helper method to define mock.On call
964func (_e *MockContext_Expecter) NextTab() *MockContext_NextTab_Call {
965 return &MockContext_NextTab_Call{Call: _e.mock.On("NextTab")}
966}
967
968func (_c *MockContext_NextTab_Call) Run(run func()) *MockContext_NextTab_Call {
969 _c.Call.Run(func(args mock.Arguments) {
970 run()
971 })
972 return _c
973}
974
975func (_c *MockContext_NextTab_Call) Return(err error) *MockContext_NextTab_Call {
976 _c.Call.Return(err)
977 return _c
978}
979
980func (_c *MockContext_NextTab_Call) RunAndReturn(run func() error) *MockContext_NextTab_Call {
981 _c.Call.Return(run)
982 return _c
983}
984
985// OpenMovePanePicker provides a mock function for the type MockContext
986func (_mock *MockContext) OpenMovePanePicker() error {
987 ret := _mock.Called()
988
989 if len(ret) == 0 {
990 panic("no return value specified for OpenMovePanePicker")
991 }
992
993 var r0 error
994 if returnFunc, ok := ret.Get(0).(func() error); ok {
995 r0 = returnFunc()
996 } else {
997 r0 = ret.Error(0)
998 }
999 return r0
1000}
1001
1002// MockContext_OpenMovePanePicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenMovePanePicker'
1003type MockContext_OpenMovePanePicker_Call struct {
1004 *mock.Call
1005}
1006
1007// OpenMovePanePicker is a helper method to define mock.On call
1008func (_e *MockContext_Expecter) OpenMovePanePicker() *MockContext_OpenMovePanePicker_Call {
1009 return &MockContext_OpenMovePanePicker_Call{Call: _e.mock.On("OpenMovePanePicker")}
1010}
1011
1012func (_c *MockContext_OpenMovePanePicker_Call) Run(run func()) *MockContext_OpenMovePanePicker_Call {
1013 _c.Call.Run(func(args mock.Arguments) {
1014 run()
1015 })
1016 return _c
1017}
1018
1019func (_c *MockContext_OpenMovePanePicker_Call) Return(err error) *MockContext_OpenMovePanePicker_Call {
1020 _c.Call.Return(err)
1021 return _c
1022}
1023
1024func (_c *MockContext_OpenMovePanePicker_Call) RunAndReturn(run func() error) *MockContext_OpenMovePanePicker_Call {
1025 _c.Call.Return(run)
1026 return _c
1027}
1028
1029// OpenMoveTabPicker provides a mock function for the type MockContext
1030func (_mock *MockContext) OpenMoveTabPicker() error {
1031 ret := _mock.Called()
1032
1033 if len(ret) == 0 {
1034 panic("no return value specified for OpenMoveTabPicker")
1035 }
1036
1037 var r0 error
1038 if returnFunc, ok := ret.Get(0).(func() error); ok {
1039 r0 = returnFunc()
1040 } else {
1041 r0 = ret.Error(0)
1042 }
1043 return r0
1044}
1045
1046// MockContext_OpenMoveTabPicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenMoveTabPicker'
1047type MockContext_OpenMoveTabPicker_Call struct {
1048 *mock.Call
1049}
1050
1051// OpenMoveTabPicker is a helper method to define mock.On call
1052func (_e *MockContext_Expecter) OpenMoveTabPicker() *MockContext_OpenMoveTabPicker_Call {
1053 return &MockContext_OpenMoveTabPicker_Call{Call: _e.mock.On("OpenMoveTabPicker")}
1054}
1055
1056func (_c *MockContext_OpenMoveTabPicker_Call) Run(run func()) *MockContext_OpenMoveTabPicker_Call {
1057 _c.Call.Run(func(args mock.Arguments) {
1058 run()
1059 })
1060 return _c
1061}
1062
1063func (_c *MockContext_OpenMoveTabPicker_Call) Return(err error) *MockContext_OpenMoveTabPicker_Call {
1064 _c.Call.Return(err)
1065 return _c
1066}
1067
1068func (_c *MockContext_OpenMoveTabPicker_Call) RunAndReturn(run func() error) *MockContext_OpenMoveTabPicker_Call {
1069 _c.Call.Return(run)
1070 return _c
1071}
1072
1073// OpenNotifications provides a mock function for the type MockContext
1074func (_mock *MockContext) OpenNotifications() error {
1075 ret := _mock.Called()
1076
1077 if len(ret) == 0 {
1078 panic("no return value specified for OpenNotifications")
1079 }
1080
1081 var r0 error
1082 if returnFunc, ok := ret.Get(0).(func() error); ok {
1083 r0 = returnFunc()
1084 } else {
1085 r0 = ret.Error(0)
1086 }
1087 return r0
1088}
1089
1090// MockContext_OpenNotifications_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenNotifications'
1091type MockContext_OpenNotifications_Call struct {
1092 *mock.Call
1093}
1094
1095// OpenNotifications is a helper method to define mock.On call
1096func (_e *MockContext_Expecter) OpenNotifications() *MockContext_OpenNotifications_Call {
1097 return &MockContext_OpenNotifications_Call{Call: _e.mock.On("OpenNotifications")}
1098}
1099
1100func (_c *MockContext_OpenNotifications_Call) Run(run func()) *MockContext_OpenNotifications_Call {
1101 _c.Call.Run(func(args mock.Arguments) {
1102 run()
1103 })
1104 return _c
1105}
1106
1107func (_c *MockContext_OpenNotifications_Call) Return(err error) *MockContext_OpenNotifications_Call {
1108 _c.Call.Return(err)
1109 return _c
1110}
1111
1112func (_c *MockContext_OpenNotifications_Call) RunAndReturn(run func() error) *MockContext_OpenNotifications_Call {
1113 _c.Call.Return(run)
1114 return _c
1115}
1116
1117// OpenSessionPicker provides a mock function for the type MockContext
1118func (_mock *MockContext) OpenSessionPicker() error {
1119 ret := _mock.Called()
1120
1121 if len(ret) == 0 {
1122 panic("no return value specified for OpenSessionPicker")
1123 }
1124
1125 var r0 error
1126 if returnFunc, ok := ret.Get(0).(func() error); ok {
1127 r0 = returnFunc()
1128 } else {
1129 r0 = ret.Error(0)
1130 }
1131 return r0
1132}
1133
1134// MockContext_OpenSessionPicker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenSessionPicker'
1135type MockContext_OpenSessionPicker_Call struct {
1136 *mock.Call
1137}
1138
1139// OpenSessionPicker is a helper method to define mock.On call
1140func (_e *MockContext_Expecter) OpenSessionPicker() *MockContext_OpenSessionPicker_Call {
1141 return &MockContext_OpenSessionPicker_Call{Call: _e.mock.On("OpenSessionPicker")}
1142}
1143
1144func (_c *MockContext_OpenSessionPicker_Call) Run(run func()) *MockContext_OpenSessionPicker_Call {
1145 _c.Call.Run(func(args mock.Arguments) {
1146 run()
1147 })
1148 return _c
1149}
1150
1151func (_c *MockContext_OpenSessionPicker_Call) Return(err error) *MockContext_OpenSessionPicker_Call {
1152 _c.Call.Return(err)
1153 return _c
1154}
1155
1156func (_c *MockContext_OpenSessionPicker_Call) RunAndReturn(run func() error) *MockContext_OpenSessionPicker_Call {
1157 _c.Call.Return(run)
1158 return _c
1159}
1160
1161// PrevTab provides a mock function for the type MockContext
1162func (_mock *MockContext) PrevTab() error {
1163 ret := _mock.Called()
1164
1165 if len(ret) == 0 {
1166 panic("no return value specified for PrevTab")
1167 }
1168
1169 var r0 error
1170 if returnFunc, ok := ret.Get(0).(func() error); ok {
1171 r0 = returnFunc()
1172 } else {
1173 r0 = ret.Error(0)
1174 }
1175 return r0
1176}
1177
1178// MockContext_PrevTab_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PrevTab'
1179type MockContext_PrevTab_Call struct {
1180 *mock.Call
1181}
1182
1183// PrevTab is a helper method to define mock.On call
1184func (_e *MockContext_Expecter) PrevTab() *MockContext_PrevTab_Call {
1185 return &MockContext_PrevTab_Call{Call: _e.mock.On("PrevTab")}
1186}
1187
1188func (_c *MockContext_PrevTab_Call) Run(run func()) *MockContext_PrevTab_Call {
1189 _c.Call.Run(func(args mock.Arguments) {
1190 run()
1191 })
1192 return _c
1193}
1194
1195func (_c *MockContext_PrevTab_Call) Return(err error) *MockContext_PrevTab_Call {
1196 _c.Call.Return(err)
1197 return _c
1198}
1199
1200func (_c *MockContext_PrevTab_Call) RunAndReturn(run func() error) *MockContext_PrevTab_Call {
1201 _c.Call.Return(run)
1202 return _c
1203}
1204
1205// RenameSession provides a mock function for the type MockContext
1206func (_mock *MockContext) RenameSession() error {
1207 ret := _mock.Called()
1208
1209 if len(ret) == 0 {
1210 panic("no return value specified for RenameSession")
1211 }
1212
1213 var r0 error
1214 if returnFunc, ok := ret.Get(0).(func() error); ok {
1215 r0 = returnFunc()
1216 } else {
1217 r0 = ret.Error(0)
1218 }
1219 return r0
1220}
1221
1222// MockContext_RenameSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameSession'
1223type MockContext_RenameSession_Call struct {
1224 *mock.Call
1225}
1226
1227// RenameSession is a helper method to define mock.On call
1228func (_e *MockContext_Expecter) RenameSession() *MockContext_RenameSession_Call {
1229 return &MockContext_RenameSession_Call{Call: _e.mock.On("RenameSession")}
1230}
1231
1232func (_c *MockContext_RenameSession_Call) Run(run func()) *MockContext_RenameSession_Call {
1233 _c.Call.Run(func(args mock.Arguments) {
1234 run()
1235 })
1236 return _c
1237}
1238
1239func (_c *MockContext_RenameSession_Call) Return(err error) *MockContext_RenameSession_Call {
1240 _c.Call.Return(err)
1241 return _c
1242}
1243
1244func (_c *MockContext_RenameSession_Call) RunAndReturn(run func() error) *MockContext_RenameSession_Call {
1245 _c.Call.Return(run)
1246 return _c
1247}
1248
1249// RenameSessionTo provides a mock function for the type MockContext
1250func (_mock *MockContext) RenameSessionTo(name string) error {
1251 ret := _mock.Called(name)
1252
1253 if len(ret) == 0 {
1254 panic("no return value specified for RenameSessionTo")
1255 }
1256
1257 var r0 error
1258 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
1259 r0 = returnFunc(name)
1260 } else {
1261 r0 = ret.Error(0)
1262 }
1263 return r0
1264}
1265
1266// MockContext_RenameSessionTo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameSessionTo'
1267type MockContext_RenameSessionTo_Call struct {
1268 *mock.Call
1269}
1270
1271// RenameSessionTo is a helper method to define mock.On call
1272// - name string
1273func (_e *MockContext_Expecter) RenameSessionTo(name any) *MockContext_RenameSessionTo_Call {
1274 return &MockContext_RenameSessionTo_Call{Call: _e.mock.On("RenameSessionTo", name)}
1275}
1276
1277func (_c *MockContext_RenameSessionTo_Call) Run(run func(name string)) *MockContext_RenameSessionTo_Call {
1278 _c.Call.Run(func(args mock.Arguments) {
1279 var arg0 string
1280 if args[0] != nil {
1281 arg0 = args[0].(string)
1282 }
1283 run(
1284 arg0,
1285 )
1286 })
1287 return _c
1288}
1289
1290func (_c *MockContext_RenameSessionTo_Call) Return(err error) *MockContext_RenameSessionTo_Call {
1291 _c.Call.Return(err)
1292 return _c
1293}
1294
1295func (_c *MockContext_RenameSessionTo_Call) RunAndReturn(run func(name string) error) *MockContext_RenameSessionTo_Call {
1296 _c.Call.Return(run)
1297 return _c
1298}
1299
1300// RenameTab provides a mock function for the type MockContext
1301func (_mock *MockContext) RenameTab() error {
1302 ret := _mock.Called()
1303
1304 if len(ret) == 0 {
1305 panic("no return value specified for RenameTab")
1306 }
1307
1308 var r0 error
1309 if returnFunc, ok := ret.Get(0).(func() error); ok {
1310 r0 = returnFunc()
1311 } else {
1312 r0 = ret.Error(0)
1313 }
1314 return r0
1315}
1316
1317// MockContext_RenameTab_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameTab'
1318type MockContext_RenameTab_Call struct {
1319 *mock.Call
1320}
1321
1322// RenameTab is a helper method to define mock.On call
1323func (_e *MockContext_Expecter) RenameTab() *MockContext_RenameTab_Call {
1324 return &MockContext_RenameTab_Call{Call: _e.mock.On("RenameTab")}
1325}
1326
1327func (_c *MockContext_RenameTab_Call) Run(run func()) *MockContext_RenameTab_Call {
1328 _c.Call.Run(func(args mock.Arguments) {
1329 run()
1330 })
1331 return _c
1332}
1333
1334func (_c *MockContext_RenameTab_Call) Return(err error) *MockContext_RenameTab_Call {
1335 _c.Call.Return(err)
1336 return _c
1337}
1338
1339func (_c *MockContext_RenameTab_Call) RunAndReturn(run func() error) *MockContext_RenameTab_Call {
1340 _c.Call.Return(run)
1341 return _c
1342}
1343
1344// RenameTabTo provides a mock function for the type MockContext
1345func (_mock *MockContext) RenameTabTo(name string) error {
1346 ret := _mock.Called(name)
1347
1348 if len(ret) == 0 {
1349 panic("no return value specified for RenameTabTo")
1350 }
1351
1352 var r0 error
1353 if returnFunc, ok := ret.Get(0).(func(string) error); ok {
1354 r0 = returnFunc(name)
1355 } else {
1356 r0 = ret.Error(0)
1357 }
1358 return r0
1359}
1360
1361// MockContext_RenameTabTo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenameTabTo'
1362type MockContext_RenameTabTo_Call struct {
1363 *mock.Call
1364}
1365
1366// RenameTabTo is a helper method to define mock.On call
1367// - name string
1368func (_e *MockContext_Expecter) RenameTabTo(name any) *MockContext_RenameTabTo_Call {
1369 return &MockContext_RenameTabTo_Call{Call: _e.mock.On("RenameTabTo", name)}
1370}
1371
1372func (_c *MockContext_RenameTabTo_Call) Run(run func(name string)) *MockContext_RenameTabTo_Call {
1373 _c.Call.Run(func(args mock.Arguments) {
1374 var arg0 string
1375 if args[0] != nil {
1376 arg0 = args[0].(string)
1377 }
1378 run(
1379 arg0,
1380 )
1381 })
1382 return _c
1383}
1384
1385func (_c *MockContext_RenameTabTo_Call) Return(err error) *MockContext_RenameTabTo_Call {
1386 _c.Call.Return(err)
1387 return _c
1388}
1389
1390func (_c *MockContext_RenameTabTo_Call) RunAndReturn(run func(name string) error) *MockContext_RenameTabTo_Call {
1391 _c.Call.Return(run)
1392 return _c
1393}
1394
1395// ShrinkPaneHeight provides a mock function for the type MockContext
1396func (_mock *MockContext) ShrinkPaneHeight() error {
1397 ret := _mock.Called()
1398
1399 if len(ret) == 0 {
1400 panic("no return value specified for ShrinkPaneHeight")
1401 }
1402
1403 var r0 error
1404 if returnFunc, ok := ret.Get(0).(func() error); ok {
1405 r0 = returnFunc()
1406 } else {
1407 r0 = ret.Error(0)
1408 }
1409 return r0
1410}
1411
1412// MockContext_ShrinkPaneHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShrinkPaneHeight'
1413type MockContext_ShrinkPaneHeight_Call struct {
1414 *mock.Call
1415}
1416
1417// ShrinkPaneHeight is a helper method to define mock.On call
1418func (_e *MockContext_Expecter) ShrinkPaneHeight() *MockContext_ShrinkPaneHeight_Call {
1419 return &MockContext_ShrinkPaneHeight_Call{Call: _e.mock.On("ShrinkPaneHeight")}
1420}
1421
1422func (_c *MockContext_ShrinkPaneHeight_Call) Run(run func()) *MockContext_ShrinkPaneHeight_Call {
1423 _c.Call.Run(func(args mock.Arguments) {
1424 run()
1425 })
1426 return _c
1427}
1428
1429func (_c *MockContext_ShrinkPaneHeight_Call) Return(err error) *MockContext_ShrinkPaneHeight_Call {
1430 _c.Call.Return(err)
1431 return _c
1432}
1433
1434func (_c *MockContext_ShrinkPaneHeight_Call) RunAndReturn(run func() error) *MockContext_ShrinkPaneHeight_Call {
1435 _c.Call.Return(run)
1436 return _c
1437}
1438
1439// ShrinkPaneWidth provides a mock function for the type MockContext
1440func (_mock *MockContext) ShrinkPaneWidth() error {
1441 ret := _mock.Called()
1442
1443 if len(ret) == 0 {
1444 panic("no return value specified for ShrinkPaneWidth")
1445 }
1446
1447 var r0 error
1448 if returnFunc, ok := ret.Get(0).(func() error); ok {
1449 r0 = returnFunc()
1450 } else {
1451 r0 = ret.Error(0)
1452 }
1453 return r0
1454}
1455
1456// MockContext_ShrinkPaneWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShrinkPaneWidth'
1457type MockContext_ShrinkPaneWidth_Call struct {
1458 *mock.Call
1459}
1460
1461// ShrinkPaneWidth is a helper method to define mock.On call
1462func (_e *MockContext_Expecter) ShrinkPaneWidth() *MockContext_ShrinkPaneWidth_Call {
1463 return &MockContext_ShrinkPaneWidth_Call{Call: _e.mock.On("ShrinkPaneWidth")}
1464}
1465
1466func (_c *MockContext_ShrinkPaneWidth_Call) Run(run func()) *MockContext_ShrinkPaneWidth_Call {
1467 _c.Call.Run(func(args mock.Arguments) {
1468 run()
1469 })
1470 return _c
1471}
1472
1473func (_c *MockContext_ShrinkPaneWidth_Call) Return(err error) *MockContext_ShrinkPaneWidth_Call {
1474 _c.Call.Return(err)
1475 return _c
1476}
1477
1478func (_c *MockContext_ShrinkPaneWidth_Call) RunAndReturn(run func() error) *MockContext_ShrinkPaneWidth_Call {
1479 _c.Call.Return(run)
1480 return _c
1481}
1482
1483// SplitDown provides a mock function for the type MockContext
1484func (_mock *MockContext) SplitDown() error {
1485 ret := _mock.Called()
1486
1487 if len(ret) == 0 {
1488 panic("no return value specified for SplitDown")
1489 }
1490
1491 var r0 error
1492 if returnFunc, ok := ret.Get(0).(func() error); ok {
1493 r0 = returnFunc()
1494 } else {
1495 r0 = ret.Error(0)
1496 }
1497 return r0
1498}
1499
1500// MockContext_SplitDown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SplitDown'
1501type MockContext_SplitDown_Call struct {
1502 *mock.Call
1503}
1504
1505// SplitDown is a helper method to define mock.On call
1506func (_e *MockContext_Expecter) SplitDown() *MockContext_SplitDown_Call {
1507 return &MockContext_SplitDown_Call{Call: _e.mock.On("SplitDown")}
1508}
1509
1510func (_c *MockContext_SplitDown_Call) Run(run func()) *MockContext_SplitDown_Call {
1511 _c.Call.Run(func(args mock.Arguments) {
1512 run()
1513 })
1514 return _c
1515}
1516
1517func (_c *MockContext_SplitDown_Call) Return(err error) *MockContext_SplitDown_Call {
1518 _c.Call.Return(err)
1519 return _c
1520}
1521
1522func (_c *MockContext_SplitDown_Call) RunAndReturn(run func() error) *MockContext_SplitDown_Call {
1523 _c.Call.Return(run)
1524 return _c
1525}
1526
1527// SplitLeft provides a mock function for the type MockContext
1528func (_mock *MockContext) SplitLeft() error {
1529 ret := _mock.Called()
1530
1531 if len(ret) == 0 {
1532 panic("no return value specified for SplitLeft")
1533 }
1534
1535 var r0 error
1536 if returnFunc, ok := ret.Get(0).(func() error); ok {
1537 r0 = returnFunc()
1538 } else {
1539 r0 = ret.Error(0)
1540 }
1541 return r0
1542}
1543
1544// MockContext_SplitLeft_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SplitLeft'
1545type MockContext_SplitLeft_Call struct {
1546 *mock.Call
1547}
1548
1549// SplitLeft is a helper method to define mock.On call
1550func (_e *MockContext_Expecter) SplitLeft() *MockContext_SplitLeft_Call {
1551 return &MockContext_SplitLeft_Call{Call: _e.mock.On("SplitLeft")}
1552}
1553
1554func (_c *MockContext_SplitLeft_Call) Run(run func()) *MockContext_SplitLeft_Call {
1555 _c.Call.Run(func(args mock.Arguments) {
1556 run()
1557 })
1558 return _c
1559}
1560
1561func (_c *MockContext_SplitLeft_Call) Return(err error) *MockContext_SplitLeft_Call {
1562 _c.Call.Return(err)
1563 return _c
1564}
1565
1566func (_c *MockContext_SplitLeft_Call) RunAndReturn(run func() error) *MockContext_SplitLeft_Call {
1567 _c.Call.Return(run)
1568 return _c
1569}
1570
1571// SplitRight provides a mock function for the type MockContext
1572func (_mock *MockContext) SplitRight() error {
1573 ret := _mock.Called()
1574
1575 if len(ret) == 0 {
1576 panic("no return value specified for SplitRight")
1577 }
1578
1579 var r0 error
1580 if returnFunc, ok := ret.Get(0).(func() error); ok {
1581 r0 = returnFunc()
1582 } else {
1583 r0 = ret.Error(0)
1584 }
1585 return r0
1586}
1587
1588// MockContext_SplitRight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SplitRight'
1589type MockContext_SplitRight_Call struct {
1590 *mock.Call
1591}
1592
1593// SplitRight is a helper method to define mock.On call
1594func (_e *MockContext_Expecter) SplitRight() *MockContext_SplitRight_Call {
1595 return &MockContext_SplitRight_Call{Call: _e.mock.On("SplitRight")}
1596}
1597
1598func (_c *MockContext_SplitRight_Call) Run(run func()) *MockContext_SplitRight_Call {
1599 _c.Call.Run(func(args mock.Arguments) {
1600 run()
1601 })
1602 return _c
1603}
1604
1605func (_c *MockContext_SplitRight_Call) Return(err error) *MockContext_SplitRight_Call {
1606 _c.Call.Return(err)
1607 return _c
1608}
1609
1610func (_c *MockContext_SplitRight_Call) RunAndReturn(run func() error) *MockContext_SplitRight_Call {
1611 _c.Call.Return(run)
1612 return _c
1613}
1614
1615// SplitUp provides a mock function for the type MockContext
1616func (_mock *MockContext) SplitUp() error {
1617 ret := _mock.Called()
1618
1619 if len(ret) == 0 {
1620 panic("no return value specified for SplitUp")
1621 }
1622
1623 var r0 error
1624 if returnFunc, ok := ret.Get(0).(func() error); ok {
1625 r0 = returnFunc()
1626 } else {
1627 r0 = ret.Error(0)
1628 }
1629 return r0
1630}
1631
1632// MockContext_SplitUp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SplitUp'
1633type MockContext_SplitUp_Call struct {
1634 *mock.Call
1635}
1636
1637// SplitUp is a helper method to define mock.On call
1638func (_e *MockContext_Expecter) SplitUp() *MockContext_SplitUp_Call {
1639 return &MockContext_SplitUp_Call{Call: _e.mock.On("SplitUp")}
1640}
1641
1642func (_c *MockContext_SplitUp_Call) Run(run func()) *MockContext_SplitUp_Call {
1643 _c.Call.Run(func(args mock.Arguments) {
1644 run()
1645 })
1646 return _c
1647}
1648
1649func (_c *MockContext_SplitUp_Call) Return(err error) *MockContext_SplitUp_Call {
1650 _c.Call.Return(err)
1651 return _c
1652}
1653
1654func (_c *MockContext_SplitUp_Call) RunAndReturn(run func() error) *MockContext_SplitUp_Call {
1655 _c.Call.Return(run)
1656 return _c
1657}
1658
1659// StackPane provides a mock function for the type MockContext
1660func (_mock *MockContext) StackPane() error {
1661 ret := _mock.Called()
1662
1663 if len(ret) == 0 {
1664 panic("no return value specified for StackPane")
1665 }
1666
1667 var r0 error
1668 if returnFunc, ok := ret.Get(0).(func() error); ok {
1669 r0 = returnFunc()
1670 } else {
1671 r0 = ret.Error(0)
1672 }
1673 return r0
1674}
1675
1676// MockContext_StackPane_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StackPane'
1677type MockContext_StackPane_Call struct {
1678 *mock.Call
1679}
1680
1681// StackPane is a helper method to define mock.On call
1682func (_e *MockContext_Expecter) StackPane() *MockContext_StackPane_Call {
1683 return &MockContext_StackPane_Call{Call: _e.mock.On("StackPane")}
1684}
1685
1686func (_c *MockContext_StackPane_Call) Run(run func()) *MockContext_StackPane_Call {
1687 _c.Call.Run(func(args mock.Arguments) {
1688 run()
1689 })
1690 return _c
1691}
1692
1693func (_c *MockContext_StackPane_Call) Return(err error) *MockContext_StackPane_Call {
1694 _c.Call.Return(err)
1695 return _c
1696}
1697
1698func (_c *MockContext_StackPane_Call) RunAndReturn(run func() error) *MockContext_StackPane_Call {
1699 _c.Call.Return(run)
1700 return _c
1701}
1702
1703// ToggleFloatingPane provides a mock function for the type MockContext
1704func (_mock *MockContext) ToggleFloatingPane() error {
1705 ret := _mock.Called()
1706
1707 if len(ret) == 0 {
1708 panic("no return value specified for ToggleFloatingPane")
1709 }
1710
1711 var r0 error
1712 if returnFunc, ok := ret.Get(0).(func() error); ok {
1713 r0 = returnFunc()
1714 } else {
1715 r0 = ret.Error(0)
1716 }
1717 return r0
1718}
1719
1720// MockContext_ToggleFloatingPane_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleFloatingPane'
1721type MockContext_ToggleFloatingPane_Call struct {
1722 *mock.Call
1723}
1724
1725// ToggleFloatingPane is a helper method to define mock.On call
1726func (_e *MockContext_Expecter) ToggleFloatingPane() *MockContext_ToggleFloatingPane_Call {
1727 return &MockContext_ToggleFloatingPane_Call{Call: _e.mock.On("ToggleFloatingPane")}
1728}
1729
1730func (_c *MockContext_ToggleFloatingPane_Call) Run(run func()) *MockContext_ToggleFloatingPane_Call {
1731 _c.Call.Run(func(args mock.Arguments) {
1732 run()
1733 })
1734 return _c
1735}
1736
1737func (_c *MockContext_ToggleFloatingPane_Call) Return(err error) *MockContext_ToggleFloatingPane_Call {
1738 _c.Call.Return(err)
1739 return _c
1740}
1741
1742func (_c *MockContext_ToggleFloatingPane_Call) RunAndReturn(run func() error) *MockContext_ToggleFloatingPane_Call {
1743 _c.Call.Return(run)
1744 return _c
1745}
1746
1747// ToggleStack provides a mock function for the type MockContext
1748func (_mock *MockContext) ToggleStack() error {
1749 ret := _mock.Called()
1750
1751 if len(ret) == 0 {
1752 panic("no return value specified for ToggleStack")
1753 }
1754
1755 var r0 error
1756 if returnFunc, ok := ret.Get(0).(func() error); ok {
1757 r0 = returnFunc()
1758 } else {
1759 r0 = ret.Error(0)
1760 }
1761 return r0
1762}
1763
1764// MockContext_ToggleStack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToggleStack'
1765type MockContext_ToggleStack_Call struct {
1766 *mock.Call
1767}
1768
1769// ToggleStack is a helper method to define mock.On call
1770func (_e *MockContext_Expecter) ToggleStack() *MockContext_ToggleStack_Call {
1771 return &MockContext_ToggleStack_Call{Call: _e.mock.On("ToggleStack")}
1772}
1773
1774func (_c *MockContext_ToggleStack_Call) Run(run func()) *MockContext_ToggleStack_Call {
1775 _c.Call.Run(func(args mock.Arguments) {
1776 run()
1777 })
1778 return _c
1779}
1780
1781func (_c *MockContext_ToggleStack_Call) Return(err error) *MockContext_ToggleStack_Call {
1782 _c.Call.Return(err)
1783 return _c
1784}
1785
1786func (_c *MockContext_ToggleStack_Call) RunAndReturn(run func() error) *MockContext_ToggleStack_Call {
1787 _c.Call.Return(run)
1788 return _c
1789}
1790
1791// YankLastNotification provides a mock function for the type MockContext
1792func (_mock *MockContext) YankLastNotification() error {
1793 ret := _mock.Called()
1794
1795 if len(ret) == 0 {
1796 panic("no return value specified for YankLastNotification")
1797 }
1798
1799 var r0 error
1800 if returnFunc, ok := ret.Get(0).(func() error); ok {
1801 r0 = returnFunc()
1802 } else {
1803 r0 = ret.Error(0)
1804 }
1805 return r0
1806}
1807
1808// MockContext_YankLastNotification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'YankLastNotification'
1809type MockContext_YankLastNotification_Call struct {
1810 *mock.Call
1811}
1812
1813// YankLastNotification is a helper method to define mock.On call
1814func (_e *MockContext_Expecter) YankLastNotification() *MockContext_YankLastNotification_Call {
1815 return &MockContext_YankLastNotification_Call{Call: _e.mock.On("YankLastNotification")}
1816}
1817
1818func (_c *MockContext_YankLastNotification_Call) Run(run func()) *MockContext_YankLastNotification_Call {
1819 _c.Call.Run(func(args mock.Arguments) {
1820 run()
1821 })
1822 return _c
1823}
1824
1825func (_c *MockContext_YankLastNotification_Call) Return(err error) *MockContext_YankLastNotification_Call {
1826 _c.Call.Return(err)
1827 return _c
1828}
1829
1830func (_c *MockContext_YankLastNotification_Call) RunAndReturn(run func() error) *MockContext_YankLastNotification_Call {
1831 _c.Call.Return(run)
1832 return _c
1833}