diff options
Diffstat (limited to 'vm')
| -rw-r--r-- | vm/proxyapp/mocks/ProxyAppInterface.go | 298 | ||||
| -rw-r--r-- | vm/proxyapp/mocks/subProcessCmd.go | 143 |
2 files changed, 441 insertions, 0 deletions
diff --git a/vm/proxyapp/mocks/ProxyAppInterface.go b/vm/proxyapp/mocks/ProxyAppInterface.go index 78bf08fbc..a79afbb0e 100644 --- a/vm/proxyapp/mocks/ProxyAppInterface.go +++ b/vm/proxyapp/mocks/ProxyAppInterface.go @@ -12,6 +12,14 @@ type ProxyAppInterface struct { mock.Mock } +type ProxyAppInterface_Expecter struct { + mock *mock.Mock +} + +func (_m *ProxyAppInterface) EXPECT() *ProxyAppInterface_Expecter { + return &ProxyAppInterface_Expecter{mock: &_m.Mock} +} + // Close provides a mock function with given fields: in, out func (_m *ProxyAppInterface) Close(in proxyrpc.CloseParams, out *proxyrpc.CloseReply) error { ret := _m.Called(in, out) @@ -30,6 +38,35 @@ func (_m *ProxyAppInterface) Close(in proxyrpc.CloseParams, out *proxyrpc.CloseR return r0 } +// ProxyAppInterface_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type ProxyAppInterface_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +// - in proxyrpc.CloseParams +// - out *proxyrpc.CloseReply +func (_e *ProxyAppInterface_Expecter) Close(in interface{}, out interface{}) *ProxyAppInterface_Close_Call { + return &ProxyAppInterface_Close_Call{Call: _e.mock.On("Close", in, out)} +} + +func (_c *ProxyAppInterface_Close_Call) Run(run func(in proxyrpc.CloseParams, out *proxyrpc.CloseReply)) *ProxyAppInterface_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(proxyrpc.CloseParams), args[1].(*proxyrpc.CloseReply)) + }) + return _c +} + +func (_c *ProxyAppInterface_Close_Call) Return(_a0 error) *ProxyAppInterface_Close_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProxyAppInterface_Close_Call) RunAndReturn(run func(proxyrpc.CloseParams, *proxyrpc.CloseReply) error) *ProxyAppInterface_Close_Call { + _c.Call.Return(run) + return _c +} + // Copy provides a mock function with given fields: in, out func (_m *ProxyAppInterface) Copy(in proxyrpc.CopyParams, out *proxyrpc.CopyResult) error { ret := _m.Called(in, out) @@ -48,6 +85,35 @@ func (_m *ProxyAppInterface) Copy(in proxyrpc.CopyParams, out *proxyrpc.CopyResu return r0 } +// ProxyAppInterface_Copy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Copy' +type ProxyAppInterface_Copy_Call struct { + *mock.Call +} + +// Copy is a helper method to define mock.On call +// - in proxyrpc.CopyParams +// - out *proxyrpc.CopyResult +func (_e *ProxyAppInterface_Expecter) Copy(in interface{}, out interface{}) *ProxyAppInterface_Copy_Call { + return &ProxyAppInterface_Copy_Call{Call: _e.mock.On("Copy", in, out)} +} + +func (_c *ProxyAppInterface_Copy_Call) Run(run func(in proxyrpc.CopyParams, out *proxyrpc.CopyResult)) *ProxyAppInterface_Copy_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(proxyrpc.CopyParams), args[1].(*proxyrpc.CopyResult)) + }) + return _c +} + +func (_c *ProxyAppInterface_Copy_Call) Return(_a0 error) *ProxyAppInterface_Copy_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProxyAppInterface_Copy_Call) RunAndReturn(run func(proxyrpc.CopyParams, *proxyrpc.CopyResult) error) *ProxyAppInterface_Copy_Call { + _c.Call.Return(run) + return _c +} + // CreateInstance provides a mock function with given fields: in, out func (_m *ProxyAppInterface) CreateInstance(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult) error { ret := _m.Called(in, out) @@ -66,6 +132,35 @@ func (_m *ProxyAppInterface) CreateInstance(in proxyrpc.CreateInstanceParams, ou return r0 } +// ProxyAppInterface_CreateInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInstance' +type ProxyAppInterface_CreateInstance_Call struct { + *mock.Call +} + +// CreateInstance is a helper method to define mock.On call +// - in proxyrpc.CreateInstanceParams +// - out *proxyrpc.CreateInstanceResult +func (_e *ProxyAppInterface_Expecter) CreateInstance(in interface{}, out interface{}) *ProxyAppInterface_CreateInstance_Call { + return &ProxyAppInterface_CreateInstance_Call{Call: _e.mock.On("CreateInstance", in, out)} +} + +func (_c *ProxyAppInterface_CreateInstance_Call) Run(run func(in proxyrpc.CreateInstanceParams, out *proxyrpc.CreateInstanceResult)) *ProxyAppInterface_CreateInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(proxyrpc.CreateInstanceParams), args[1].(*proxyrpc.CreateInstanceResult)) + }) + return _c +} + +func (_c *ProxyAppInterface_CreateInstance_Call) Return(_a0 error) *ProxyAppInterface_CreateInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProxyAppInterface_CreateInstance_Call) RunAndReturn(run func(proxyrpc.CreateInstanceParams, *proxyrpc.CreateInstanceResult) error) *ProxyAppInterface_CreateInstance_Call { + _c.Call.Return(run) + return _c +} + // CreatePool provides a mock function with given fields: in, out func (_m *ProxyAppInterface) CreatePool(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult) error { ret := _m.Called(in, out) @@ -84,6 +179,35 @@ func (_m *ProxyAppInterface) CreatePool(in proxyrpc.CreatePoolParams, out *proxy return r0 } +// ProxyAppInterface_CreatePool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePool' +type ProxyAppInterface_CreatePool_Call struct { + *mock.Call +} + +// CreatePool is a helper method to define mock.On call +// - in proxyrpc.CreatePoolParams +// - out *proxyrpc.CreatePoolResult +func (_e *ProxyAppInterface_Expecter) CreatePool(in interface{}, out interface{}) *ProxyAppInterface_CreatePool_Call { + return &ProxyAppInterface_CreatePool_Call{Call: _e.mock.On("CreatePool", in, out)} +} + +func (_c *ProxyAppInterface_CreatePool_Call) Run(run func(in proxyrpc.CreatePoolParams, out *proxyrpc.CreatePoolResult)) *ProxyAppInterface_CreatePool_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(proxyrpc.CreatePoolParams), args[1].(*proxyrpc.CreatePoolResult)) + }) + return _c +} + +func (_c *ProxyAppInterface_CreatePool_Call) Return(_a0 error) *ProxyAppInterface_CreatePool_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProxyAppInterface_CreatePool_Call) RunAndReturn(run func(proxyrpc.CreatePoolParams, *proxyrpc.CreatePoolResult) error) *ProxyAppInterface_CreatePool_Call { + _c.Call.Return(run) + return _c +} + // Diagnose provides a mock function with given fields: in, out func (_m *ProxyAppInterface) Diagnose(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply) error { ret := _m.Called(in, out) @@ -102,6 +226,35 @@ func (_m *ProxyAppInterface) Diagnose(in proxyrpc.DiagnoseParams, out *proxyrpc. return r0 } +// ProxyAppInterface_Diagnose_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Diagnose' +type ProxyAppInterface_Diagnose_Call struct { + *mock.Call +} + +// Diagnose is a helper method to define mock.On call +// - in proxyrpc.DiagnoseParams +// - out *proxyrpc.DiagnoseReply +func (_e *ProxyAppInterface_Expecter) Diagnose(in interface{}, out interface{}) *ProxyAppInterface_Diagnose_Call { + return &ProxyAppInterface_Diagnose_Call{Call: _e.mock.On("Diagnose", in, out)} +} + +func (_c *ProxyAppInterface_Diagnose_Call) Run(run func(in proxyrpc.DiagnoseParams, out *proxyrpc.DiagnoseReply)) *ProxyAppInterface_Diagnose_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(proxyrpc.DiagnoseParams), args[1].(*proxyrpc.DiagnoseReply)) + }) + return _c +} + +func (_c *ProxyAppInterface_Diagnose_Call) Return(_a0 error) *ProxyAppInterface_Diagnose_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProxyAppInterface_Diagnose_Call) RunAndReturn(run func(proxyrpc.DiagnoseParams, *proxyrpc.DiagnoseReply) error) *ProxyAppInterface_Diagnose_Call { + _c.Call.Return(run) + return _c +} + // Forward provides a mock function with given fields: in, out func (_m *ProxyAppInterface) Forward(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult) error { ret := _m.Called(in, out) @@ -120,6 +273,35 @@ func (_m *ProxyAppInterface) Forward(in proxyrpc.ForwardParams, out *proxyrpc.Fo return r0 } +// ProxyAppInterface_Forward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Forward' +type ProxyAppInterface_Forward_Call struct { + *mock.Call +} + +// Forward is a helper method to define mock.On call +// - in proxyrpc.ForwardParams +// - out *proxyrpc.ForwardResult +func (_e *ProxyAppInterface_Expecter) Forward(in interface{}, out interface{}) *ProxyAppInterface_Forward_Call { + return &ProxyAppInterface_Forward_Call{Call: _e.mock.On("Forward", in, out)} +} + +func (_c *ProxyAppInterface_Forward_Call) Run(run func(in proxyrpc.ForwardParams, out *proxyrpc.ForwardResult)) *ProxyAppInterface_Forward_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(proxyrpc.ForwardParams), args[1].(*proxyrpc.ForwardResult)) + }) + return _c +} + +func (_c *ProxyAppInterface_Forward_Call) Return(_a0 error) *ProxyAppInterface_Forward_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProxyAppInterface_Forward_Call) RunAndReturn(run func(proxyrpc.ForwardParams, *proxyrpc.ForwardResult) error) *ProxyAppInterface_Forward_Call { + _c.Call.Return(run) + return _c +} + // PoolLogs provides a mock function with given fields: in, out func (_m *ProxyAppInterface) PoolLogs(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply) error { ret := _m.Called(in, out) @@ -138,6 +320,35 @@ func (_m *ProxyAppInterface) PoolLogs(in proxyrpc.PoolLogsParam, out *proxyrpc.P return r0 } +// ProxyAppInterface_PoolLogs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PoolLogs' +type ProxyAppInterface_PoolLogs_Call struct { + *mock.Call +} + +// PoolLogs is a helper method to define mock.On call +// - in proxyrpc.PoolLogsParam +// - out *proxyrpc.PoolLogsReply +func (_e *ProxyAppInterface_Expecter) PoolLogs(in interface{}, out interface{}) *ProxyAppInterface_PoolLogs_Call { + return &ProxyAppInterface_PoolLogs_Call{Call: _e.mock.On("PoolLogs", in, out)} +} + +func (_c *ProxyAppInterface_PoolLogs_Call) Run(run func(in proxyrpc.PoolLogsParam, out *proxyrpc.PoolLogsReply)) *ProxyAppInterface_PoolLogs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(proxyrpc.PoolLogsParam), args[1].(*proxyrpc.PoolLogsReply)) + }) + return _c +} + +func (_c *ProxyAppInterface_PoolLogs_Call) Return(_a0 error) *ProxyAppInterface_PoolLogs_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProxyAppInterface_PoolLogs_Call) RunAndReturn(run func(proxyrpc.PoolLogsParam, *proxyrpc.PoolLogsReply) error) *ProxyAppInterface_PoolLogs_Call { + _c.Call.Return(run) + return _c +} + // RunReadProgress provides a mock function with given fields: in, out func (_m *ProxyAppInterface) RunReadProgress(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply) error { ret := _m.Called(in, out) @@ -156,6 +367,35 @@ func (_m *ProxyAppInterface) RunReadProgress(in proxyrpc.RunReadProgressParams, return r0 } +// ProxyAppInterface_RunReadProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunReadProgress' +type ProxyAppInterface_RunReadProgress_Call struct { + *mock.Call +} + +// RunReadProgress is a helper method to define mock.On call +// - in proxyrpc.RunReadProgressParams +// - out *proxyrpc.RunReadProgressReply +func (_e *ProxyAppInterface_Expecter) RunReadProgress(in interface{}, out interface{}) *ProxyAppInterface_RunReadProgress_Call { + return &ProxyAppInterface_RunReadProgress_Call{Call: _e.mock.On("RunReadProgress", in, out)} +} + +func (_c *ProxyAppInterface_RunReadProgress_Call) Run(run func(in proxyrpc.RunReadProgressParams, out *proxyrpc.RunReadProgressReply)) *ProxyAppInterface_RunReadProgress_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(proxyrpc.RunReadProgressParams), args[1].(*proxyrpc.RunReadProgressReply)) + }) + return _c +} + +func (_c *ProxyAppInterface_RunReadProgress_Call) Return(_a0 error) *ProxyAppInterface_RunReadProgress_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProxyAppInterface_RunReadProgress_Call) RunAndReturn(run func(proxyrpc.RunReadProgressParams, *proxyrpc.RunReadProgressReply) error) *ProxyAppInterface_RunReadProgress_Call { + _c.Call.Return(run) + return _c +} + // RunStart provides a mock function with given fields: in, out func (_m *ProxyAppInterface) RunStart(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply) error { ret := _m.Called(in, out) @@ -174,6 +414,35 @@ func (_m *ProxyAppInterface) RunStart(in proxyrpc.RunStartParams, out *proxyrpc. return r0 } +// ProxyAppInterface_RunStart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunStart' +type ProxyAppInterface_RunStart_Call struct { + *mock.Call +} + +// RunStart is a helper method to define mock.On call +// - in proxyrpc.RunStartParams +// - out *proxyrpc.RunStartReply +func (_e *ProxyAppInterface_Expecter) RunStart(in interface{}, out interface{}) *ProxyAppInterface_RunStart_Call { + return &ProxyAppInterface_RunStart_Call{Call: _e.mock.On("RunStart", in, out)} +} + +func (_c *ProxyAppInterface_RunStart_Call) Run(run func(in proxyrpc.RunStartParams, out *proxyrpc.RunStartReply)) *ProxyAppInterface_RunStart_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(proxyrpc.RunStartParams), args[1].(*proxyrpc.RunStartReply)) + }) + return _c +} + +func (_c *ProxyAppInterface_RunStart_Call) Return(_a0 error) *ProxyAppInterface_RunStart_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProxyAppInterface_RunStart_Call) RunAndReturn(run func(proxyrpc.RunStartParams, *proxyrpc.RunStartReply) error) *ProxyAppInterface_RunStart_Call { + _c.Call.Return(run) + return _c +} + // RunStop provides a mock function with given fields: in, out func (_m *ProxyAppInterface) RunStop(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply) error { ret := _m.Called(in, out) @@ -192,6 +461,35 @@ func (_m *ProxyAppInterface) RunStop(in proxyrpc.RunStopParams, out *proxyrpc.Ru return r0 } +// ProxyAppInterface_RunStop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunStop' +type ProxyAppInterface_RunStop_Call struct { + *mock.Call +} + +// RunStop is a helper method to define mock.On call +// - in proxyrpc.RunStopParams +// - out *proxyrpc.RunStopReply +func (_e *ProxyAppInterface_Expecter) RunStop(in interface{}, out interface{}) *ProxyAppInterface_RunStop_Call { + return &ProxyAppInterface_RunStop_Call{Call: _e.mock.On("RunStop", in, out)} +} + +func (_c *ProxyAppInterface_RunStop_Call) Run(run func(in proxyrpc.RunStopParams, out *proxyrpc.RunStopReply)) *ProxyAppInterface_RunStop_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(proxyrpc.RunStopParams), args[1].(*proxyrpc.RunStopReply)) + }) + return _c +} + +func (_c *ProxyAppInterface_RunStop_Call) Return(_a0 error) *ProxyAppInterface_RunStop_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *ProxyAppInterface_RunStop_Call) RunAndReturn(run func(proxyrpc.RunStopParams, *proxyrpc.RunStopReply) error) *ProxyAppInterface_RunStop_Call { + _c.Call.Return(run) + return _c +} + // NewProxyAppInterface creates a new instance of ProxyAppInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. // The first argument is typically a *testing.T value. func NewProxyAppInterface(t interface { diff --git a/vm/proxyapp/mocks/subProcessCmd.go b/vm/proxyapp/mocks/subProcessCmd.go index 7402ee1a6..50961fe0d 100644 --- a/vm/proxyapp/mocks/subProcessCmd.go +++ b/vm/proxyapp/mocks/subProcessCmd.go @@ -13,6 +13,14 @@ type SubProcessCmd struct { mock.Mock } +type SubProcessCmd_Expecter struct { + mock *mock.Mock +} + +func (_m *SubProcessCmd) EXPECT() *SubProcessCmd_Expecter { + return &SubProcessCmd_Expecter{mock: &_m.Mock} +} + // Start provides a mock function with no fields func (_m *SubProcessCmd) Start() error { ret := _m.Called() @@ -31,6 +39,33 @@ func (_m *SubProcessCmd) Start() error { return r0 } +// SubProcessCmd_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type SubProcessCmd_Start_Call struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +func (_e *SubProcessCmd_Expecter) Start() *SubProcessCmd_Start_Call { + return &SubProcessCmd_Start_Call{Call: _e.mock.On("Start")} +} + +func (_c *SubProcessCmd_Start_Call) Run(run func()) *SubProcessCmd_Start_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SubProcessCmd_Start_Call) Return(_a0 error) *SubProcessCmd_Start_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SubProcessCmd_Start_Call) RunAndReturn(run func() error) *SubProcessCmd_Start_Call { + _c.Call.Return(run) + return _c +} + // StderrPipe provides a mock function with no fields func (_m *SubProcessCmd) StderrPipe() (io.ReadCloser, error) { ret := _m.Called() @@ -61,6 +96,33 @@ func (_m *SubProcessCmd) StderrPipe() (io.ReadCloser, error) { return r0, r1 } +// SubProcessCmd_StderrPipe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StderrPipe' +type SubProcessCmd_StderrPipe_Call struct { + *mock.Call +} + +// StderrPipe is a helper method to define mock.On call +func (_e *SubProcessCmd_Expecter) StderrPipe() *SubProcessCmd_StderrPipe_Call { + return &SubProcessCmd_StderrPipe_Call{Call: _e.mock.On("StderrPipe")} +} + +func (_c *SubProcessCmd_StderrPipe_Call) Run(run func()) *SubProcessCmd_StderrPipe_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SubProcessCmd_StderrPipe_Call) Return(_a0 io.ReadCloser, _a1 error) *SubProcessCmd_StderrPipe_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SubProcessCmd_StderrPipe_Call) RunAndReturn(run func() (io.ReadCloser, error)) *SubProcessCmd_StderrPipe_Call { + _c.Call.Return(run) + return _c +} + // StdinPipe provides a mock function with no fields func (_m *SubProcessCmd) StdinPipe() (io.WriteCloser, error) { ret := _m.Called() @@ -91,6 +153,33 @@ func (_m *SubProcessCmd) StdinPipe() (io.WriteCloser, error) { return r0, r1 } +// SubProcessCmd_StdinPipe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StdinPipe' +type SubProcessCmd_StdinPipe_Call struct { + *mock.Call +} + +// StdinPipe is a helper method to define mock.On call +func (_e *SubProcessCmd_Expecter) StdinPipe() *SubProcessCmd_StdinPipe_Call { + return &SubProcessCmd_StdinPipe_Call{Call: _e.mock.On("StdinPipe")} +} + +func (_c *SubProcessCmd_StdinPipe_Call) Run(run func()) *SubProcessCmd_StdinPipe_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SubProcessCmd_StdinPipe_Call) Return(_a0 io.WriteCloser, _a1 error) *SubProcessCmd_StdinPipe_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SubProcessCmd_StdinPipe_Call) RunAndReturn(run func() (io.WriteCloser, error)) *SubProcessCmd_StdinPipe_Call { + _c.Call.Return(run) + return _c +} + // StdoutPipe provides a mock function with no fields func (_m *SubProcessCmd) StdoutPipe() (io.ReadCloser, error) { ret := _m.Called() @@ -121,6 +210,33 @@ func (_m *SubProcessCmd) StdoutPipe() (io.ReadCloser, error) { return r0, r1 } +// SubProcessCmd_StdoutPipe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StdoutPipe' +type SubProcessCmd_StdoutPipe_Call struct { + *mock.Call +} + +// StdoutPipe is a helper method to define mock.On call +func (_e *SubProcessCmd_Expecter) StdoutPipe() *SubProcessCmd_StdoutPipe_Call { + return &SubProcessCmd_StdoutPipe_Call{Call: _e.mock.On("StdoutPipe")} +} + +func (_c *SubProcessCmd_StdoutPipe_Call) Run(run func()) *SubProcessCmd_StdoutPipe_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SubProcessCmd_StdoutPipe_Call) Return(_a0 io.ReadCloser, _a1 error) *SubProcessCmd_StdoutPipe_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SubProcessCmd_StdoutPipe_Call) RunAndReturn(run func() (io.ReadCloser, error)) *SubProcessCmd_StdoutPipe_Call { + _c.Call.Return(run) + return _c +} + // Wait provides a mock function with no fields func (_m *SubProcessCmd) Wait() error { ret := _m.Called() @@ -139,6 +255,33 @@ func (_m *SubProcessCmd) Wait() error { return r0 } +// SubProcessCmd_Wait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Wait' +type SubProcessCmd_Wait_Call struct { + *mock.Call +} + +// Wait is a helper method to define mock.On call +func (_e *SubProcessCmd_Expecter) Wait() *SubProcessCmd_Wait_Call { + return &SubProcessCmd_Wait_Call{Call: _e.mock.On("Wait")} +} + +func (_c *SubProcessCmd_Wait_Call) Run(run func()) *SubProcessCmd_Wait_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SubProcessCmd_Wait_Call) Return(_a0 error) *SubProcessCmd_Wait_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SubProcessCmd_Wait_Call) RunAndReturn(run func() error) *SubProcessCmd_Wait_Call { + _c.Call.Return(run) + return _c +} + // NewSubProcessCmd creates a new instance of SubProcessCmd. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. // The first argument is typically a *testing.T value. func NewSubProcessCmd(t interface { |