process

package

Go to main page

Versions in this module

v1

v1.17.0

Feb 2, 2026

Changes in this version

+ type OnPipeOutputFunc struct

+ func NewOnPipeOutputFunc(t interface{ ... }) *OnPipeOutputFunc

+ func (_m *OnPipeOutputFunc) EXPECT() *OnPipeOutputFunc_Expecter

+ func (_m *OnPipeOutputFunc) Execute(typ process.OutputType, line []byte, key string)

+ type OnPipeOutputFunc_Execute_Call struct

+ func (_c *OnPipeOutputFunc_Execute_Call) Return() *OnPipeOutputFunc_Execute_Call

+ func (_c *OnPipeOutputFunc_Execute_Call) Run(run func(typ process.OutputType, line []byte, key string)) *OnPipeOutputFunc_Execute_Call

+ func (_c *OnPipeOutputFunc_Execute_Call) RunAndReturn(run func(process.OutputType, []byte, string)) *OnPipeOutputFunc_Execute_Call

+ type OnPipeOutputFunc_Expecter struct

+ func (_e *OnPipeOutputFunc_Expecter) Execute(typ interface{}, line interface{}, key interface{}) *OnPipeOutputFunc_Execute_Call

+ type OnPoolOutputFunc struct

+ func NewOnPoolOutputFunc(t interface{ ... }) *OnPoolOutputFunc

+ func (_m *OnPoolOutputFunc) EXPECT() *OnPoolOutputFunc_Expecter

+ func (_m *OnPoolOutputFunc) Execute(typ process.OutputType, line []byte, key string)

+ type OnPoolOutputFunc_Execute_Call struct

+ func (_c *OnPoolOutputFunc_Execute_Call) Return() *OnPoolOutputFunc_Execute_Call

+ func (_c *OnPoolOutputFunc_Execute_Call) Run(run func(typ process.OutputType, line []byte, key string)) *OnPoolOutputFunc_Execute_Call

+ func (_c *OnPoolOutputFunc_Execute_Call) RunAndReturn(run func(process.OutputType, []byte, string)) *OnPoolOutputFunc_Execute_Call

+ type OnPoolOutputFunc_Expecter struct

+ func (_e *OnPoolOutputFunc_Expecter) Execute(typ interface{}, line interface{}, key interface{}) *OnPoolOutputFunc_Execute_Call

+ type Pipe struct

+ func NewPipe(t interface{ ... }) *Pipe

+ func (_m *Pipe) Command(name string, arg ...string) process.PipeCommand

+ func (_m *Pipe) EXPECT() *Pipe_Expecter

+ type PipeBuilder struct

+ func NewPipeBuilder(t interface{ ... }) *PipeBuilder

+ func (_m *PipeBuilder) Command(name string, arg ...string) *process.PipeCommand

+ func (_m *PipeBuilder) EXPECT() *PipeBuilder_Expecter

+ type PipeBuilder_Command_Call struct

+ func (_c *PipeBuilder_Command_Call) Return(_a0 *process.PipeCommand) *PipeBuilder_Command_Call

+ func (_c *PipeBuilder_Command_Call) Run(run func(name string, arg ...string)) *PipeBuilder_Command_Call

+ func (_c *PipeBuilder_Command_Call) RunAndReturn(run func(string, ...string) *process.PipeCommand) *PipeBuilder_Command_Call

+ type PipeBuilder_Expecter struct

+ func (_e *PipeBuilder_Expecter) Command(name interface{}, arg ...interface{}) *PipeBuilder_Command_Call

+ type PipeCommand struct

+ func NewPipeCommand(t interface{ ... }) *PipeCommand

+ func (_m *PipeCommand) As(key string) process.PipeCommand

+ func (_m *PipeCommand) EXPECT() *PipeCommand_Expecter

+ func (_m *PipeCommand) WithSpinner(message ...string) process.PipeCommand

+ type PipeCommand_As_Call struct

+ func (_c *PipeCommand_As_Call) Return(_a0 process.PipeCommand) *PipeCommand_As_Call

+ func (_c *PipeCommand_As_Call) Run(run func(key string)) *PipeCommand_As_Call

+ func (_c *PipeCommand_As_Call) RunAndReturn(run func(string) process.PipeCommand) *PipeCommand_As_Call

+ type PipeCommand_Expecter struct

+ func (_e *PipeCommand_Expecter) As(key interface{}) *PipeCommand_As_Call

+ func (_e *PipeCommand_Expecter) WithSpinner(message ...interface{}) *PipeCommand_WithSpinner_Call

+ type PipeCommand_WithSpinner_Call struct

+ func (_c *PipeCommand_WithSpinner_Call) Return(_a0 process.PipeCommand) *PipeCommand_WithSpinner_Call

+ func (_c *PipeCommand_WithSpinner_Call) Run(run func(message ...string)) *PipeCommand_WithSpinner_Call

+ func (_c *PipeCommand_WithSpinner_Call) RunAndReturn(run func(...string) process.PipeCommand) *PipeCommand_WithSpinner_Call

+ type Pipe_Command_Call struct

+ func (_c *Pipe_Command_Call) Return(_a0 process.PipeCommand) *Pipe_Command_Call

+ func (_c *Pipe_Command_Call) Run(run func(name string, arg ...string)) *Pipe_Command_Call

+ func (_c *Pipe_Command_Call) RunAndReturn(run func(string, ...string) process.PipeCommand) *Pipe_Command_Call

+ type Pipe_Expecter struct

+ func (_e *Pipe_Expecter) Command(name interface{}, arg ...interface{}) *Pipe_Command_Call

+ type Pipeline struct

+ func NewPipeline(t interface{ ... }) *Pipeline

+ func (_m *Pipeline) DisableBuffering() process.Pipeline

+ func (_m *Pipeline) EXPECT() *Pipeline_Expecter

+ func (_m *Pipeline) Env(vars map[string]string) process.Pipeline

+ func (_m *Pipeline) Input(in io.Reader) process.Pipeline

+ func (_m *Pipeline) OnOutput(handler process.OnPipeOutputFunc) process.Pipeline

+ func (_m *Pipeline) Path(path string) process.Pipeline

+ func (_m *Pipeline) Pipe(configurer func(process.Pipe)) process.Pipeline

+ func (_m *Pipeline) Quietly() process.Pipeline

+ func (_m *Pipeline) Run() process.Result

+ func (_m *Pipeline) Start() (process.RunningPipe, error)

+ func (_m *Pipeline) Timeout(timeout time.Duration) process.Pipeline

+ func (_m *Pipeline) WithContext(ctx context.Context) process.Pipeline

+ func (_m *Pipeline) WithSpinner(message ...string) process.Pipeline

+ type Pipeline_DisableBuffering_Call struct

+ func (_c *Pipeline_DisableBuffering_Call) Return(_a0 process.Pipeline) *Pipeline_DisableBuffering_Call

+ func (_c *Pipeline_DisableBuffering_Call) Run(run func()) *Pipeline_DisableBuffering_Call

+ func (_c *Pipeline_DisableBuffering_Call) RunAndReturn(run func() process.Pipeline) *Pipeline_DisableBuffering_Call

+ type Pipeline_Env_Call struct

+ func (_c *Pipeline_Env_Call) Return(_a0 process.Pipeline) *Pipeline_Env_Call

+ func (_c *Pipeline_Env_Call) Run(run func(vars map[string]string)) *Pipeline_Env_Call

+ func (_c *Pipeline_Env_Call) RunAndReturn(run func(map[string]string) process.Pipeline) *Pipeline_Env_Call

+ type Pipeline_Expecter struct

+ func (_e *Pipeline_Expecter) DisableBuffering() *Pipeline_DisableBuffering_Call

+ func (_e *Pipeline_Expecter) Env(vars interface{}) *Pipeline_Env_Call

+ func (_e *Pipeline_Expecter) Input(in interface{}) *Pipeline_Input_Call

+ func (_e *Pipeline_Expecter) OnOutput(handler interface{}) *Pipeline_OnOutput_Call

+ func (_e *Pipeline_Expecter) Path(path interface{}) *Pipeline_Path_Call

+ func (_e *Pipeline_Expecter) Pipe(configurer interface{}) *Pipeline_Pipe_Call

+ func (_e *Pipeline_Expecter) Quietly() *Pipeline_Quietly_Call

+ func (_e *Pipeline_Expecter) Run() *Pipeline_Run_Call

+ func (_e *Pipeline_Expecter) Start() *Pipeline_Start_Call

+ func (_e *Pipeline_Expecter) Timeout(timeout interface{}) *Pipeline_Timeout_Call

+ func (_e *Pipeline_Expecter) WithContext(ctx interface{}) *Pipeline_WithContext_Call

+ func (_e *Pipeline_Expecter) WithSpinner(message ...interface{}) *Pipeline_WithSpinner_Call

+ type Pipeline_Input_Call struct

+ func (_c *Pipeline_Input_Call) Return(_a0 process.Pipeline) *Pipeline_Input_Call

+ func (_c *Pipeline_Input_Call) Run(run func(in io.Reader)) *Pipeline_Input_Call

+ func (_c *Pipeline_Input_Call) RunAndReturn(run func(io.Reader) process.Pipeline) *Pipeline_Input_Call

+ type Pipeline_OnOutput_Call struct

+ func (_c *Pipeline_OnOutput_Call) Return(_a0 process.Pipeline) *Pipeline_OnOutput_Call

+ func (_c *Pipeline_OnOutput_Call) Run(run func(handler process.OnPipeOutputFunc)) *Pipeline_OnOutput_Call

+ func (_c *Pipeline_OnOutput_Call) RunAndReturn(run func(process.OnPipeOutputFunc) process.Pipeline) *Pipeline_OnOutput_Call

+ type Pipeline_Path_Call struct

+ func (_c *Pipeline_Path_Call) Return(_a0 process.Pipeline) *Pipeline_Path_Call

+ func (_c *Pipeline_Path_Call) Run(run func(path string)) *Pipeline_Path_Call

+ func (_c *Pipeline_Path_Call) RunAndReturn(run func(string) process.Pipeline) *Pipeline_Path_Call

+ type Pipeline_Pipe_Call struct

+ func (_c *Pipeline_Pipe_Call) Return(_a0 process.Pipeline) *Pipeline_Pipe_Call

+ func (_c *Pipeline_Pipe_Call) Run(run func(configurer func(process.Pipe))) *Pipeline_Pipe_Call

+ func (_c *Pipeline_Pipe_Call) RunAndReturn(run func(func(process.Pipe)) process.Pipeline) *Pipeline_Pipe_Call

+ type Pipeline_Quietly_Call struct

+ func (_c *Pipeline_Quietly_Call) Return(_a0 process.Pipeline) *Pipeline_Quietly_Call

+ func (_c *Pipeline_Quietly_Call) Run(run func()) *Pipeline_Quietly_Call

+ func (_c *Pipeline_Quietly_Call) RunAndReturn(run func() process.Pipeline) *Pipeline_Quietly_Call

+ type Pipeline_Run_Call struct

+ func (_c *Pipeline_Run_Call) Return(_a0 process.Result) *Pipeline_Run_Call

+ func (_c *Pipeline_Run_Call) Run(run func()) *Pipeline_Run_Call

+ func (_c *Pipeline_Run_Call) RunAndReturn(run func() process.Result) *Pipeline_Run_Call

+ type Pipeline_Start_Call struct

+ func (_c *Pipeline_Start_Call) Return(_a0 process.RunningPipe, _a1 error) *Pipeline_Start_Call

+ func (_c *Pipeline_Start_Call) Run(run func()) *Pipeline_Start_Call

+ func (_c *Pipeline_Start_Call) RunAndReturn(run func() (process.RunningPipe, error)) *Pipeline_Start_Call

+ type Pipeline_Timeout_Call struct

+ func (_c *Pipeline_Timeout_Call) Return(_a0 process.Pipeline) *Pipeline_Timeout_Call

+ func (_c *Pipeline_Timeout_Call) Run(run func(timeout time.Duration)) *Pipeline_Timeout_Call

+ func (_c *Pipeline_Timeout_Call) RunAndReturn(run func(time.Duration) process.Pipeline) *Pipeline_Timeout_Call

+ type Pipeline_WithContext_Call struct

+ func (_c *Pipeline_WithContext_Call) Return(_a0 process.Pipeline) *Pipeline_WithContext_Call

+ func (_c *Pipeline_WithContext_Call) Run(run func(ctx context.Context)) *Pipeline_WithContext_Call

+ func (_c *Pipeline_WithContext_Call) RunAndReturn(run func(context.Context) process.Pipeline) *Pipeline_WithContext_Call

+ type Pipeline_WithSpinner_Call struct

+ func (_c *Pipeline_WithSpinner_Call) Return(_a0 process.Pipeline) *Pipeline_WithSpinner_Call

+ func (_c *Pipeline_WithSpinner_Call) Run(run func(message ...string)) *Pipeline_WithSpinner_Call

+ func (_c *Pipeline_WithSpinner_Call) RunAndReturn(run func(...string) process.Pipeline) *Pipeline_WithSpinner_Call

+ type Pool struct

+ func NewPool(t interface{ ... }) *Pool

+ func (_m *Pool) Command(name string, arg ...string) process.PoolCommand

+ func (_m *Pool) EXPECT() *Pool_Expecter

+ type PoolBuilder struct

+ func NewPoolBuilder(t interface{ ... }) *PoolBuilder

+ func (_m *PoolBuilder) Concurrency(n int) process.PoolBuilder

+ func (_m *PoolBuilder) EXPECT() *PoolBuilder_Expecter

+ func (_m *PoolBuilder) OnOutput(handler process.OnPoolOutputFunc) process.PoolBuilder

+ func (_m *PoolBuilder) Pool(configurer func(process.Pool)) process.PoolBuilder

+ func (_m *PoolBuilder) Run() (map[string]process.Result, error)

+ func (_m *PoolBuilder) Start() (process.RunningPool, error)

+ func (_m *PoolBuilder) Timeout(timeout time.Duration) process.PoolBuilder

+ func (_m *PoolBuilder) WithContext(ctx context.Context) process.PoolBuilder

+ func (_m *PoolBuilder) WithSpinner(message ...string) process.PoolBuilder

+ type PoolBuilder_Concurrency_Call struct

+ func (_c *PoolBuilder_Concurrency_Call) Return(_a0 process.PoolBuilder) *PoolBuilder_Concurrency_Call

+ func (_c *PoolBuilder_Concurrency_Call) Run(run func(n int)) *PoolBuilder_Concurrency_Call

+ func (_c *PoolBuilder_Concurrency_Call) RunAndReturn(run func(int) process.PoolBuilder) *PoolBuilder_Concurrency_Call

+ type PoolBuilder_Expecter struct

+ func (_e *PoolBuilder_Expecter) Concurrency(n interface{}) *PoolBuilder_Concurrency_Call

+ func (_e *PoolBuilder_Expecter) OnOutput(handler interface{}) *PoolBuilder_OnOutput_Call

+ func (_e *PoolBuilder_Expecter) Pool(configurer interface{}) *PoolBuilder_Pool_Call

+ func (_e *PoolBuilder_Expecter) Run() *PoolBuilder_Run_Call

+ func (_e *PoolBuilder_Expecter) Start() *PoolBuilder_Start_Call

+ func (_e *PoolBuilder_Expecter) Timeout(timeout interface{}) *PoolBuilder_Timeout_Call

+ func (_e *PoolBuilder_Expecter) WithContext(ctx interface{}) *PoolBuilder_WithContext_Call

+ func (_e *PoolBuilder_Expecter) WithSpinner(message ...interface{}) *PoolBuilder_WithSpinner_Call

+ type PoolBuilder_OnOutput_Call struct

+ func (_c *PoolBuilder_OnOutput_Call) Return(_a0 process.PoolBuilder) *PoolBuilder_OnOutput_Call

+ func (_c *PoolBuilder_OnOutput_Call) Run(run func(handler process.OnPoolOutputFunc)) *PoolBuilder_OnOutput_Call

+ func (_c *PoolBuilder_OnOutput_Call) RunAndReturn(run func(process.OnPoolOutputFunc) process.PoolBuilder) *PoolBuilder_OnOutput_Call

+ type PoolBuilder_Pool_Call struct

+ func (_c *PoolBuilder_Pool_Call) Return(_a0 process.PoolBuilder) *PoolBuilder_Pool_Call

+ func (_c *PoolBuilder_Pool_Call) Run(run func(configurer func(process.Pool))) *PoolBuilder_Pool_Call

+ func (_c *PoolBuilder_Pool_Call) RunAndReturn(run func(func(process.Pool)) process.PoolBuilder) *PoolBuilder_Pool_Call

+ type PoolBuilder_Run_Call struct

+ func (_c *PoolBuilder_Run_Call) Return(_a0 map[string]process.Result, _a1 error) *PoolBuilder_Run_Call

+ func (_c *PoolBuilder_Run_Call) Run(run func()) *PoolBuilder_Run_Call

+ func (_c *PoolBuilder_Run_Call) RunAndReturn(run func() (map[string]process.Result, error)) *PoolBuilder_Run_Call

+ type PoolBuilder_Start_Call struct

+ func (_c *PoolBuilder_Start_Call) Return(_a0 process.RunningPool, _a1 error) *PoolBuilder_Start_Call

+ func (_c *PoolBuilder_Start_Call) Run(run func()) *PoolBuilder_Start_Call

+ func (_c *PoolBuilder_Start_Call) RunAndReturn(run func() (process.RunningPool, error)) *PoolBuilder_Start_Call

+ type PoolBuilder_Timeout_Call struct

+ func (_c *PoolBuilder_Timeout_Call) Return(_a0 process.PoolBuilder) *PoolBuilder_Timeout_Call

+ func (_c *PoolBuilder_Timeout_Call) Run(run func(timeout time.Duration)) *PoolBuilder_Timeout_Call

+ func (_c *PoolBuilder_Timeout_Call) RunAndReturn(run func(time.Duration) process.PoolBuilder) *PoolBuilder_Timeout_Call

+ type PoolBuilder_WithContext_Call struct

+ func (_c *PoolBuilder_WithContext_Call) Return(_a0 process.PoolBuilder) *PoolBuilder_WithContext_Call

+ func (_c *PoolBuilder_WithContext_Call) Run(run func(ctx context.Context)) *PoolBuilder_WithContext_Call

+ func (_c *PoolBuilder_WithContext_Call) RunAndReturn(run func(context.Context) process.PoolBuilder) *PoolBuilder_WithContext_Call

+ type PoolBuilder_WithSpinner_Call struct

+ func (_c *PoolBuilder_WithSpinner_Call) Return(_a0 process.PoolBuilder) *PoolBuilder_WithSpinner_Call

+ func (_c *PoolBuilder_WithSpinner_Call) Run(run func(message ...string)) *PoolBuilder_WithSpinner_Call

+ func (_c *PoolBuilder_WithSpinner_Call) RunAndReturn(run func(...string) process.PoolBuilder) *PoolBuilder_WithSpinner_Call

+ type PoolCommand struct

+ func NewPoolCommand(t interface{ ... }) *PoolCommand

+ func (_m *PoolCommand) As(key string) process.PoolCommand

+ func (_m *PoolCommand) DisableBuffering() process.PoolCommand

+ func (_m *PoolCommand) EXPECT() *PoolCommand_Expecter

+ func (_m *PoolCommand) Env(vars map[string]string) process.PoolCommand

+ func (_m *PoolCommand) Input(in io.Reader) process.PoolCommand

+ func (_m *PoolCommand) Path(path string) process.PoolCommand

+ func (_m *PoolCommand) Quietly() process.PoolCommand

+ func (_m *PoolCommand) Timeout(timeout time.Duration) process.PoolCommand

+ func (_m *PoolCommand) WithContext(ctx context.Context) process.PoolCommand

+ type PoolCommand_As_Call struct

+ func (_c *PoolCommand_As_Call) Return(_a0 process.PoolCommand) *PoolCommand_As_Call

+ func (_c *PoolCommand_As_Call) Run(run func(key string)) *PoolCommand_As_Call

+ func (_c *PoolCommand_As_Call) RunAndReturn(run func(string) process.PoolCommand) *PoolCommand_As_Call

+ type PoolCommand_DisableBuffering_Call struct

+ func (_c *PoolCommand_DisableBuffering_Call) Return(_a0 process.PoolCommand) *PoolCommand_DisableBuffering_Call

+ func (_c *PoolCommand_DisableBuffering_Call) Run(run func()) *PoolCommand_DisableBuffering_Call

+ func (_c *PoolCommand_DisableBuffering_Call) RunAndReturn(run func() process.PoolCommand) *PoolCommand_DisableBuffering_Call

+ type PoolCommand_Env_Call struct

+ func (_c *PoolCommand_Env_Call) Return(_a0 process.PoolCommand) *PoolCommand_Env_Call

+ func (_c *PoolCommand_Env_Call) Run(run func(vars map[string]string)) *PoolCommand_Env_Call

+ func (_c *PoolCommand_Env_Call) RunAndReturn(run func(map[string]string) process.PoolCommand) *PoolCommand_Env_Call

+ type PoolCommand_Expecter struct

+ func (_e *PoolCommand_Expecter) As(key interface{}) *PoolCommand_As_Call

+ func (_e *PoolCommand_Expecter) DisableBuffering() *PoolCommand_DisableBuffering_Call

+ func (_e *PoolCommand_Expecter) Env(vars interface{}) *PoolCommand_Env_Call

+ func (_e *PoolCommand_Expecter) Input(in interface{}) *PoolCommand_Input_Call

+ func (_e *PoolCommand_Expecter) Path(path interface{}) *PoolCommand_Path_Call

+ func (_e *PoolCommand_Expecter) Quietly() *PoolCommand_Quietly_Call

+ func (_e *PoolCommand_Expecter) Timeout(timeout interface{}) *PoolCommand_Timeout_Call

+ func (_e *PoolCommand_Expecter) WithContext(ctx interface{}) *PoolCommand_WithContext_Call

+ type PoolCommand_Input_Call struct

+ func (_c *PoolCommand_Input_Call) Return(_a0 process.PoolCommand) *PoolCommand_Input_Call

+ func (_c *PoolCommand_Input_Call) Run(run func(in io.Reader)) *PoolCommand_Input_Call

+ func (_c *PoolCommand_Input_Call) RunAndReturn(run func(io.Reader) process.PoolCommand) *PoolCommand_Input_Call

+ type PoolCommand_Path_Call struct

+ func (_c *PoolCommand_Path_Call) Return(_a0 process.PoolCommand) *PoolCommand_Path_Call

+ func (_c *PoolCommand_Path_Call) Run(run func(path string)) *PoolCommand_Path_Call

+ func (_c *PoolCommand_Path_Call) RunAndReturn(run func(string) process.PoolCommand) *PoolCommand_Path_Call

+ type PoolCommand_Quietly_Call struct

+ func (_c *PoolCommand_Quietly_Call) Return(_a0 process.PoolCommand) *PoolCommand_Quietly_Call

+ func (_c *PoolCommand_Quietly_Call) Run(run func()) *PoolCommand_Quietly_Call

+ func (_c *PoolCommand_Quietly_Call) RunAndReturn(run func() process.PoolCommand) *PoolCommand_Quietly_Call

+ type PoolCommand_Timeout_Call struct

+ func (_c *PoolCommand_Timeout_Call) Return(_a0 process.PoolCommand) *PoolCommand_Timeout_Call

+ func (_c *PoolCommand_Timeout_Call) Run(run func(timeout time.Duration)) *PoolCommand_Timeout_Call

+ func (_c *PoolCommand_Timeout_Call) RunAndReturn(run func(time.Duration) process.PoolCommand) *PoolCommand_Timeout_Call

+ type PoolCommand_WithContext_Call struct

+ func (_c *PoolCommand_WithContext_Call) Return(_a0 process.PoolCommand) *PoolCommand_WithContext_Call

+ func (_c *PoolCommand_WithContext_Call) Run(run func(ctx context.Context)) *PoolCommand_WithContext_Call

+ func (_c *PoolCommand_WithContext_Call) RunAndReturn(run func(context.Context) process.PoolCommand) *PoolCommand_WithContext_Call

+ type Pool_Command_Call struct

+ func (_c *Pool_Command_Call) Return(_a0 process.PoolCommand) *Pool_Command_Call

+ func (_c *Pool_Command_Call) Run(run func(name string, arg ...string)) *Pool_Command_Call

+ func (_c *Pool_Command_Call) RunAndReturn(run func(string, ...string) process.PoolCommand) *Pool_Command_Call

+ type Pool_Expecter struct

+ func (_e *Pool_Expecter) Command(name interface{}, arg ...interface{}) *Pool_Command_Call

type Process

+ func (_m *Process) DisableBuffering() process.Process

+ func (_m *Process) Pipe(configurer func(process.Pipe)) process.Pipeline

+ func (_m *Process) Pool(configurer func(process.Pool)) process.PoolBuilder

+ func (_m *Process) WithSpinner(message ...string) process.Process

+ type Process_DisableBuffering_Call struct

+ func (_c *Process_DisableBuffering_Call) Return(_a0 process.Process) *Process_DisableBuffering_Call

+ func (_c *Process_DisableBuffering_Call) Run(run func()) *Process_DisableBuffering_Call

+ func (_c *Process_DisableBuffering_Call) RunAndReturn(run func() process.Process) *Process_DisableBuffering_Call

type Process_Expecter

+ func (_e *Process_Expecter) DisableBuffering() *Process_DisableBuffering_Call

+ func (_e *Process_Expecter) Pipe(configurer interface{}) *Process_Pipe_Call

+ func (_e *Process_Expecter) Pool(configurer interface{}) *Process_Pool_Call

+ func (_e *Process_Expecter) WithSpinner(message ...interface{}) *Process_WithSpinner_Call

+ type Process_Pipe_Call struct

+ func (_c *Process_Pipe_Call) Return(_a0 process.Pipeline) *Process_Pipe_Call

+ func (_c *Process_Pipe_Call) Run(run func(configurer func(process.Pipe))) *Process_Pipe_Call

+ func (_c *Process_Pipe_Call) RunAndReturn(run func(func(process.Pipe)) process.Pipeline) *Process_Pipe_Call

+ type Process_Pool_Call struct

+ func (_c *Process_Pool_Call) Return(_a0 process.PoolBuilder) *Process_Pool_Call

+ func (_c *Process_Pool_Call) Run(run func(configurer func(process.Pool))) *Process_Pool_Call

+ func (_c *Process_Pool_Call) RunAndReturn(run func(func(process.Pool)) process.PoolBuilder) *Process_Pool_Call

+ type Process_WithSpinner_Call struct

+ func (_c *Process_WithSpinner_Call) Return(_a0 process.Process) *Process_WithSpinner_Call

+ func (_c *Process_WithSpinner_Call) Run(run func(message ...string)) *Process_WithSpinner_Call

+ func (_c *Process_WithSpinner_Call) RunAndReturn(run func(...string) process.Process) *Process_WithSpinner_Call

type Result

+ func (_m *Result) Error() error

+ type Result_Error_Call struct

+ func (_c *Result_Error_Call) Return(_a0 error) *Result_Error_Call

+ func (_c *Result_Error_Call) Run(run func()) *Result_Error_Call

+ func (_c *Result_Error_Call) RunAndReturn(run func() error) *Result_Error_Call

type Result_Expecter

+ func (_e *Result_Expecter) Error() *Result_Error_Call

type Running

+ func (_m *Running) Done() <-chan struct{}

+ type RunningPipe struct

+ func NewRunningPipe(t interface{ ... }) *RunningPipe

+ func (_m *RunningPipe) Done() <-chan struct{}

+ func (_m *RunningPipe) EXPECT() *RunningPipe_Expecter

+ func (_m *RunningPipe) PIDs() map[string]int

+ func (_m *RunningPipe) Running() bool

+ func (_m *RunningPipe) Signal(sig os.Signal) error

+ func (_m *RunningPipe) Stop(timeout time.Duration, sig ...os.Signal) error

+ func (_m *RunningPipe) Wait() process.Result

+ type RunningPipe_Done_Call struct

+ func (_c *RunningPipe_Done_Call) Return(_a0 <-chan struct{}) *RunningPipe_Done_Call

+ func (_c *RunningPipe_Done_Call) Run(run func()) *RunningPipe_Done_Call

+ func (_c *RunningPipe_Done_Call) RunAndReturn(run func() <-chan struct{}) *RunningPipe_Done_Call

+ type RunningPipe_Expecter struct

+ func (_e *RunningPipe_Expecter) Done() *RunningPipe_Done_Call

+ func (_e *RunningPipe_Expecter) PIDs() *RunningPipe_PIDs_Call

+ func (_e *RunningPipe_Expecter) Running() *RunningPipe_Running_Call

+ func (_e *RunningPipe_Expecter) Signal(sig interface{}) *RunningPipe_Signal_Call

+ func (_e *RunningPipe_Expecter) Stop(timeout interface{}, sig ...interface{}) *RunningPipe_Stop_Call

+ func (_e *RunningPipe_Expecter) Wait() *RunningPipe_Wait_Call

+ type RunningPipe_PIDs_Call struct

+ func (_c *RunningPipe_PIDs_Call) Return(_a0 map[string]int) *RunningPipe_PIDs_Call

+ func (_c *RunningPipe_PIDs_Call) Run(run func()) *RunningPipe_PIDs_Call

+ func (_c *RunningPipe_PIDs_Call) RunAndReturn(run func() map[string]int) *RunningPipe_PIDs_Call

+ type RunningPipe_Running_Call struct

+ func (_c *RunningPipe_Running_Call) Return(_a0 bool) *RunningPipe_Running_Call

+ func (_c *RunningPipe_Running_Call) Run(run func()) *RunningPipe_Running_Call

+ func (_c *RunningPipe_Running_Call) RunAndReturn(run func() bool) *RunningPipe_Running_Call

+ type RunningPipe_Signal_Call struct

+ func (_c *RunningPipe_Signal_Call) Return(_a0 error) *RunningPipe_Signal_Call

+ func (_c *RunningPipe_Signal_Call) Run(run func(sig os.Signal)) *RunningPipe_Signal_Call

+ func (_c *RunningPipe_Signal_Call) RunAndReturn(run func(os.Signal) error) *RunningPipe_Signal_Call

+ type RunningPipe_Stop_Call struct

+ func (_c *RunningPipe_Stop_Call) Return(_a0 error) *RunningPipe_Stop_Call

+ func (_c *RunningPipe_Stop_Call) Run(run func(timeout time.Duration, sig ...os.Signal)) *RunningPipe_Stop_Call

+ func (_c *RunningPipe_Stop_Call) RunAndReturn(run func(time.Duration, ...os.Signal) error) *RunningPipe_Stop_Call

+ type RunningPipe_Wait_Call struct

+ func (_c *RunningPipe_Wait_Call) Return(_a0 process.Result) *RunningPipe_Wait_Call

+ func (_c *RunningPipe_Wait_Call) Run(run func()) *RunningPipe_Wait_Call

+ func (_c *RunningPipe_Wait_Call) RunAndReturn(run func() process.Result) *RunningPipe_Wait_Call

+ type RunningPool struct

+ func NewRunningPool(t interface{ ... }) *RunningPool

+ func (_m *RunningPool) Done() <-chan struct{}

+ func (_m *RunningPool) EXPECT() *RunningPool_Expecter

+ func (_m *RunningPool) PIDs() map[string]int

+ func (_m *RunningPool) Running() bool

+ func (_m *RunningPool) Signal(sig os.Signal) error

+ func (_m *RunningPool) Stop(timeout time.Duration, sig ...os.Signal) error

+ func (_m *RunningPool) Wait() map[string]process.Result

+ type RunningPool_Done_Call struct

+ func (_c *RunningPool_Done_Call) Return(_a0 <-chan struct{}) *RunningPool_Done_Call

+ func (_c *RunningPool_Done_Call) Run(run func()) *RunningPool_Done_Call

+ func (_c *RunningPool_Done_Call) RunAndReturn(run func() <-chan struct{}) *RunningPool_Done_Call

+ type RunningPool_Expecter struct

+ func (_e *RunningPool_Expecter) Done() *RunningPool_Done_Call

+ func (_e *RunningPool_Expecter) PIDs() *RunningPool_PIDs_Call

+ func (_e *RunningPool_Expecter) Running() *RunningPool_Running_Call

+ func (_e *RunningPool_Expecter) Signal(sig interface{}) *RunningPool_Signal_Call

+ func (_e *RunningPool_Expecter) Stop(timeout interface{}, sig ...interface{}) *RunningPool_Stop_Call

+ func (_e *RunningPool_Expecter) Wait() *RunningPool_Wait_Call

+ type RunningPool_PIDs_Call struct

+ func (_c *RunningPool_PIDs_Call) Return(_a0 map[string]int) *RunningPool_PIDs_Call

+ func (_c *RunningPool_PIDs_Call) Run(run func()) *RunningPool_PIDs_Call

+ func (_c *RunningPool_PIDs_Call) RunAndReturn(run func() map[string]int) *RunningPool_PIDs_Call

+ type RunningPool_Running_Call struct

+ func (_c *RunningPool_Running_Call) Return(_a0 bool) *RunningPool_Running_Call

+ func (_c *RunningPool_Running_Call) Run(run func()) *RunningPool_Running_Call

+ func (_c *RunningPool_Running_Call) RunAndReturn(run func() bool) *RunningPool_Running_Call

+ type RunningPool_Signal_Call struct

+ func (_c *RunningPool_Signal_Call) Return(_a0 error) *RunningPool_Signal_Call

+ func (_c *RunningPool_Signal_Call) Run(run func(sig os.Signal)) *RunningPool_Signal_Call

+ func (_c *RunningPool_Signal_Call) RunAndReturn(run func(os.Signal) error) *RunningPool_Signal_Call

+ type RunningPool_Stop_Call struct

+ func (_c *RunningPool_Stop_Call) Return(_a0 error) *RunningPool_Stop_Call

+ func (_c *RunningPool_Stop_Call) Run(run func(timeout time.Duration, sig ...os.Signal)) *RunningPool_Stop_Call

+ func (_c *RunningPool_Stop_Call) RunAndReturn(run func(time.Duration, ...os.Signal) error) *RunningPool_Stop_Call

+ type RunningPool_Wait_Call struct

+ func (_c *RunningPool_Wait_Call) Return(_a0 map[string]process.Result) *RunningPool_Wait_Call

+ func (_c *RunningPool_Wait_Call) Run(run func()) *RunningPool_Wait_Call

+ func (_c *RunningPool_Wait_Call) RunAndReturn(run func() map[string]process.Result) *RunningPool_Wait_Call

+ type Running_Done_Call struct

+ func (_c *Running_Done_Call) Return(_a0 <-chan struct{}) *Running_Done_Call

+ func (_c *Running_Done_Call) Run(run func()) *Running_Done_Call

+ func (_c *Running_Done_Call) RunAndReturn(run func() <-chan struct{}) *Running_Done_Call

type Running_Expecter

+ func (_e *Running_Expecter) Done() *Running_Done_Call

+ type Step struct

+ func NewStep(t interface{ ... }) *Step

+ func (_m *Step) As(key string) process.PipeCommand

+ func (_m *Step) EXPECT() *Step_Expecter

+ type Step_As_Call struct

+ func (_c *Step_As_Call) Return(_a0 process.PipeCommand) *Step_As_Call

+ func (_c *Step_As_Call) Run(run func(key string)) *Step_As_Call

+ func (_c *Step_As_Call) RunAndReturn(run func(string) process.PipeCommand) *Step_As_Call

+ type Step_Expecter struct

+ func (_e *Step_Expecter) As(key interface{}) *Step_As_Call

v1.16.2

Sep 9, 2025

v1.15.12

Sep 9, 2025

Changes in this version

+ type OnOutputFunc struct

+ func NewOnOutputFunc(t interface{ ... }) *OnOutputFunc

+ func (_m *OnOutputFunc) EXPECT() *OnOutputFunc_Expecter

+ func (_m *OnOutputFunc) Execute(typ process.OutputType, line []byte)

+ type OnOutputFunc_Execute_Call struct

+ func (_c *OnOutputFunc_Execute_Call) Return() *OnOutputFunc_Execute_Call

+ func (_c *OnOutputFunc_Execute_Call) Run(run func(typ process.OutputType, line []byte)) *OnOutputFunc_Execute_Call

+ func (_c *OnOutputFunc_Execute_Call) RunAndReturn(run func(process.OutputType, []byte)) *OnOutputFunc_Execute_Call

+ type OnOutputFunc_Expecter struct

+ func (_e *OnOutputFunc_Expecter) Execute(typ interface{}, line interface{}) *OnOutputFunc_Execute_Call

+ type Process struct

+ func NewProcess(t interface{ ... }) *Process

+ func (_m *Process) EXPECT() *Process_Expecter

+ func (_m *Process) Env(vars map[string]string) process.Process

+ func (_m *Process) Input(in io.Reader) process.Process

+ func (_m *Process) OnOutput(handler process.OnOutputFunc) process.Process

+ func (_m *Process) Path(path string) process.Process

+ func (_m *Process) Quietly() process.Process

+ func (_m *Process) Run(name string, arg ...string) (process.Result, error)

+ func (_m *Process) Start(name string, arg ...string) (process.Running, error)

+ func (_m *Process) TTY() process.Process

+ func (_m *Process) Timeout(timeout time.Duration) process.Process

+ func (_m *Process) WithContext(ctx context.Context) process.Process

+ type Process_Env_Call struct

+ func (_c *Process_Env_Call) Return(_a0 process.Process) *Process_Env_Call

+ func (_c *Process_Env_Call) Run(run func(vars map[string]string)) *Process_Env_Call

+ func (_c *Process_Env_Call) RunAndReturn(run func(map[string]string) process.Process) *Process_Env_Call

+ type Process_Expecter struct

+ func (_e *Process_Expecter) Env(vars interface{}) *Process_Env_Call

+ func (_e *Process_Expecter) Input(in interface{}) *Process_Input_Call

+ func (_e *Process_Expecter) OnOutput(handler interface{}) *Process_OnOutput_Call

+ func (_e *Process_Expecter) Path(path interface{}) *Process_Path_Call

+ func (_e *Process_Expecter) Quietly() *Process_Quietly_Call

+ func (_e *Process_Expecter) Run(name interface{}, arg ...interface{}) *Process_Run_Call

+ func (_e *Process_Expecter) Start(name interface{}, arg ...interface{}) *Process_Start_Call

+ func (_e *Process_Expecter) TTY() *Process_TTY_Call

+ func (_e *Process_Expecter) Timeout(timeout interface{}) *Process_Timeout_Call

+ func (_e *Process_Expecter) WithContext(ctx interface{}) *Process_WithContext_Call

+ type Process_Input_Call struct

+ func (_c *Process_Input_Call) Return(_a0 process.Process) *Process_Input_Call

+ func (_c *Process_Input_Call) Run(run func(in io.Reader)) *Process_Input_Call

+ func (_c *Process_Input_Call) RunAndReturn(run func(io.Reader) process.Process) *Process_Input_Call

+ type Process_OnOutput_Call struct

+ func (_c *Process_OnOutput_Call) Return(_a0 process.Process) *Process_OnOutput_Call

+ func (_c *Process_OnOutput_Call) Run(run func(handler process.OnOutputFunc)) *Process_OnOutput_Call

+ func (_c *Process_OnOutput_Call) RunAndReturn(run func(process.OnOutputFunc) process.Process) *Process_OnOutput_Call

+ type Process_Path_Call struct

+ func (_c *Process_Path_Call) Return(_a0 process.Process) *Process_Path_Call

+ func (_c *Process_Path_Call) Run(run func(path string)) *Process_Path_Call

+ func (_c *Process_Path_Call) RunAndReturn(run func(string) process.Process) *Process_Path_Call

+ type Process_Quietly_Call struct

+ func (_c *Process_Quietly_Call) Return(_a0 process.Process) *Process_Quietly_Call

+ func (_c *Process_Quietly_Call) Run(run func()) *Process_Quietly_Call

+ func (_c *Process_Quietly_Call) RunAndReturn(run func() process.Process) *Process_Quietly_Call

+ type Process_Run_Call struct

+ func (_c *Process_Run_Call) Return(_a0 process.Result, _a1 error) *Process_Run_Call

+ func (_c *Process_Run_Call) Run(run func(name string, arg ...string)) *Process_Run_Call

+ func (_c *Process_Run_Call) RunAndReturn(run func(string, ...string) (process.Result, error)) *Process_Run_Call

+ type Process_Start_Call struct

+ func (_c *Process_Start_Call) Return(_a0 process.Running, _a1 error) *Process_Start_Call

+ func (_c *Process_Start_Call) Run(run func(name string, arg ...string)) *Process_Start_Call

+ func (_c *Process_Start_Call) RunAndReturn(run func(string, ...string) (process.Running, error)) *Process_Start_Call

+ type Process_TTY_Call struct

+ func (_c *Process_TTY_Call) Return(_a0 process.Process) *Process_TTY_Call

+ func (_c *Process_TTY_Call) Run(run func()) *Process_TTY_Call

+ func (_c *Process_TTY_Call) RunAndReturn(run func() process.Process) *Process_TTY_Call

+ type Process_Timeout_Call struct

+ func (_c *Process_Timeout_Call) Return(_a0 process.Process) *Process_Timeout_Call

+ func (_c *Process_Timeout_Call) Run(run func(timeout time.Duration)) *Process_Timeout_Call

+ func (_c *Process_Timeout_Call) RunAndReturn(run func(time.Duration) process.Process) *Process_Timeout_Call

+ type Process_WithContext_Call struct

+ func (_c *Process_WithContext_Call) Return(_a0 process.Process) *Process_WithContext_Call

+ func (_c *Process_WithContext_Call) Run(run func(ctx context.Context)) *Process_WithContext_Call

+ func (_c *Process_WithContext_Call) RunAndReturn(run func(context.Context) process.Process) *Process_WithContext_Call

+ type Result struct

+ func NewResult(t interface{ ... }) *Result

+ func (_m *Result) Command() string

+ func (_m *Result) EXPECT() *Result_Expecter

+ func (_m *Result) ErrorOutput() string

+ func (_m *Result) ExitCode() int

+ func (_m *Result) Failed() bool

+ func (_m *Result) Output() string

+ func (_m *Result) SeeInErrorOutput(needle string) bool

+ func (_m *Result) SeeInOutput(needle string) bool

+ func (_m *Result) Successful() bool

+ type Result_Command_Call struct

+ func (_c *Result_Command_Call) Return(_a0 string) *Result_Command_Call

+ func (_c *Result_Command_Call) Run(run func()) *Result_Command_Call

+ func (_c *Result_Command_Call) RunAndReturn(run func() string) *Result_Command_Call

+ type Result_ErrorOutput_Call struct

+ func (_c *Result_ErrorOutput_Call) Return(_a0 string) *Result_ErrorOutput_Call

+ func (_c *Result_ErrorOutput_Call) Run(run func()) *Result_ErrorOutput_Call

+ func (_c *Result_ErrorOutput_Call) RunAndReturn(run func() string) *Result_ErrorOutput_Call

+ type Result_ExitCode_Call struct

+ func (_c *Result_ExitCode_Call) Return(_a0 int) *Result_ExitCode_Call

+ func (_c *Result_ExitCode_Call) Run(run func()) *Result_ExitCode_Call

+ func (_c *Result_ExitCode_Call) RunAndReturn(run func() int) *Result_ExitCode_Call

+ type Result_Expecter struct

+ func (_e *Result_Expecter) Command() *Result_Command_Call

+ func (_e *Result_Expecter) ErrorOutput() *Result_ErrorOutput_Call

+ func (_e *Result_Expecter) ExitCode() *Result_ExitCode_Call

+ func (_e *Result_Expecter) Failed() *Result_Failed_Call

+ func (_e *Result_Expecter) Output() *Result_Output_Call

+ func (_e *Result_Expecter) SeeInErrorOutput(needle interface{}) *Result_SeeInErrorOutput_Call

+ func (_e *Result_Expecter) SeeInOutput(needle interface{}) *Result_SeeInOutput_Call

+ func (_e *Result_Expecter) Successful() *Result_Successful_Call

+ type Result_Failed_Call struct

+ func (_c *Result_Failed_Call) Return(_a0 bool) *Result_Failed_Call

+ func (_c *Result_Failed_Call) Run(run func()) *Result_Failed_Call

+ func (_c *Result_Failed_Call) RunAndReturn(run func() bool) *Result_Failed_Call

+ type Result_Output_Call struct

+ func (_c *Result_Output_Call) Return(_a0 string) *Result_Output_Call

+ func (_c *Result_Output_Call) Run(run func()) *Result_Output_Call

+ func (_c *Result_Output_Call) RunAndReturn(run func() string) *Result_Output_Call

+ type Result_SeeInErrorOutput_Call struct

+ func (_c *Result_SeeInErrorOutput_Call) Return(_a0 bool) *Result_SeeInErrorOutput_Call

+ func (_c *Result_SeeInErrorOutput_Call) Run(run func(needle string)) *Result_SeeInErrorOutput_Call

+ func (_c *Result_SeeInErrorOutput_Call) RunAndReturn(run func(string) bool) *Result_SeeInErrorOutput_Call

+ type Result_SeeInOutput_Call struct

+ func (_c *Result_SeeInOutput_Call) Return(_a0 bool) *Result_SeeInOutput_Call

+ func (_c *Result_SeeInOutput_Call) Run(run func(needle string)) *Result_SeeInOutput_Call

+ func (_c *Result_SeeInOutput_Call) RunAndReturn(run func(string) bool) *Result_SeeInOutput_Call

+ type Result_Successful_Call struct

+ func (_c *Result_Successful_Call) Return(_a0 bool) *Result_Successful_Call

+ func (_c *Result_Successful_Call) Run(run func()) *Result_Successful_Call

+ func (_c *Result_Successful_Call) RunAndReturn(run func() bool) *Result_Successful_Call

+ type Running struct

+ func NewRunning(t interface{ ... }) *Running

+ func (_m *Running) EXPECT() *Running_Expecter

+ func (_m *Running) ErrorOutput() string

+ func (_m *Running) LatestErrorOutput() string

+ func (_m *Running) LatestOutput() string

+ func (_m *Running) Output() string

+ func (_m *Running) PID() int

+ func (_m *Running) Running() bool

+ func (_m *Running) Signal(sig os.Signal) error

+ func (_m *Running) Stop(timeout time.Duration, sig ...os.Signal) error

+ func (_m *Running) Wait() process.Result

+ type Running_ErrorOutput_Call struct

+ func (_c *Running_ErrorOutput_Call) Return(_a0 string) *Running_ErrorOutput_Call

+ func (_c *Running_ErrorOutput_Call) Run(run func()) *Running_ErrorOutput_Call

+ func (_c *Running_ErrorOutput_Call) RunAndReturn(run func() string) *Running_ErrorOutput_Call

+ type Running_Expecter struct

+ func (_e *Running_Expecter) ErrorOutput() *Running_ErrorOutput_Call

+ func (_e *Running_Expecter) LatestErrorOutput() *Running_LatestErrorOutput_Call

+ func (_e *Running_Expecter) LatestOutput() *Running_LatestOutput_Call

+ func (_e *Running_Expecter) Output() *Running_Output_Call

+ func (_e *Running_Expecter) PID() *Running_PID_Call

+ func (_e *Running_Expecter) Running() *Running_Running_Call

+ func (_e *Running_Expecter) Signal(sig interface{}) *Running_Signal_Call

+ func (_e *Running_Expecter) Stop(timeout interface{}, sig ...interface{}) *Running_Stop_Call

+ func (_e *Running_Expecter) Wait() *Running_Wait_Call

+ type Running_LatestErrorOutput_Call struct

+ func (_c *Running_LatestErrorOutput_Call) Return(_a0 string) *Running_LatestErrorOutput_Call

+ func (_c *Running_LatestErrorOutput_Call) Run(run func()) *Running_LatestErrorOutput_Call

+ func (_c *Running_LatestErrorOutput_Call) RunAndReturn(run func() string) *Running_LatestErrorOutput_Call

+ type Running_LatestOutput_Call struct

+ func (_c *Running_LatestOutput_Call) Return(_a0 string) *Running_LatestOutput_Call

+ func (_c *Running_LatestOutput_Call) Run(run func()) *Running_LatestOutput_Call

+ func (_c *Running_LatestOutput_Call) RunAndReturn(run func() string) *Running_LatestOutput_Call

+ type Running_Output_Call struct

+ func (_c *Running_Output_Call) Return(_a0 string) *Running_Output_Call

+ func (_c *Running_Output_Call) Run(run func()) *Running_Output_Call

+ func (_c *Running_Output_Call) RunAndReturn(run func() string) *Running_Output_Call

+ type Running_PID_Call struct

+ func (_c *Running_PID_Call) Return(_a0 int) *Running_PID_Call

+ func (_c *Running_PID_Call) Run(run func()) *Running_PID_Call

+ func (_c *Running_PID_Call) RunAndReturn(run func() int) *Running_PID_Call

+ type Running_Running_Call struct

+ func (_c *Running_Running_Call) Return(_a0 bool) *Running_Running_Call

+ func (_c *Running_Running_Call) Run(run func()) *Running_Running_Call

+ func (_c *Running_Running_Call) RunAndReturn(run func() bool) *Running_Running_Call

+ type Running_Signal_Call struct

+ func (_c *Running_Signal_Call) Return(_a0 error) *Running_Signal_Call

+ func (_c *Running_Signal_Call) Run(run func(sig os.Signal)) *Running_Signal_Call

+ func (_c *Running_Signal_Call) RunAndReturn(run func(os.Signal) error) *Running_Signal_Call

+ type Running_Stop_Call struct

+ func (_c *Running_Stop_Call) Return(_a0 error) *Running_Stop_Call

+ func (_c *Running_Stop_Call) Run(run func(timeout time.Duration, sig ...os.Signal)) *Running_Stop_Call

+ func (_c *Running_Stop_Call) RunAndReturn(run func(time.Duration, ...os.Signal) error) *Running_Stop_Call

+ type Running_Wait_Call struct

+ func (_c *Running_Wait_Call) Return(_a0 process.Result) *Running_Wait_Call

+ func (_c *Running_Wait_Call) Run(run func()) *Running_Wait_Call

+ func (_c *Running_Wait_Call) RunAndReturn(run func() process.Result) *Running_Wait_Call

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL