process

package

Go to main page

Versions in this module

v1

v1.18.1

Nov 12, 2026

v1.18.0

Jul 4, 2026

v1.17.4

Nov 1, 2026

v1.17.3

Jul 4, 2026

v1.17.2

Mar 13, 2026

v1.17.1

Feb 10, 2026

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