mocks

Documentation

Overview

Package mocks is a generated GoMock package.

Package mocks is a generated GoMock package.

Index

• type MockClock
  • func NewMockClock(ctrl *gomock.Controller) *MockClock
  • func (m *MockClock) After(arg0 time.Duration) <-chan time.Time
  • func (m *MockClock) AfterFunc(arg0 time.Duration, arg1 func()) clock.Timer
  • func (m *MockClock) At(arg0 time.Time) <-chan time.Time
  • func (m *MockClock) AtFunc(arg0 time.Time, arg1 func()) clock.Alarm
  • func (m *MockClock) EXPECT() *MockClockMockRecorder
  • func (m *MockClock) NewAlarm(arg0 time.Time) clock.Alarm
  • func (m *MockClock) NewTimer(arg0 time.Duration) clock.Timer
  • func (m *MockClock) Now() time.Time
• type MockClockAfterCall
  • func (c *MockClockAfterCall) Do(f func(time.Duration) <-chan time.Time) *MockClockAfterCall
  • func (c *MockClockAfterCall) DoAndReturn(f func(time.Duration) <-chan time.Time) *MockClockAfterCall
  • func (c *MockClockAfterCall) Return(arg0 <-chan time.Time) *MockClockAfterCall
• type MockClockAfterFuncCall
  • func (c *MockClockAfterFuncCall) Do(f func(time.Duration, func()) clock.Timer) *MockClockAfterFuncCall
  • func (c *MockClockAfterFuncCall) DoAndReturn(f func(time.Duration, func()) clock.Timer) *MockClockAfterFuncCall
  • func (c *MockClockAfterFuncCall) Return(arg0 clock.Timer) *MockClockAfterFuncCall
• type MockClockAtCall
  • func (c *MockClockAtCall) Do(f func(time.Time) <-chan time.Time) *MockClockAtCall
  • func (c *MockClockAtCall) DoAndReturn(f func(time.Time) <-chan time.Time) *MockClockAtCall
  • func (c *MockClockAtCall) Return(arg0 <-chan time.Time) *MockClockAtCall
• type MockClockAtFuncCall
  • func (c *MockClockAtFuncCall) Do(f func(time.Time, func()) clock.Alarm) *MockClockAtFuncCall
  • func (c *MockClockAtFuncCall) DoAndReturn(f func(time.Time, func()) clock.Alarm) *MockClockAtFuncCall
  • func (c *MockClockAtFuncCall) Return(arg0 clock.Alarm) *MockClockAtFuncCall
• type MockClockMockRecorder
  • func (mr *MockClockMockRecorder) After(arg0 any) *MockClockAfterCall
  • func (mr *MockClockMockRecorder) AfterFunc(arg0, arg1 any) *MockClockAfterFuncCall
  • func (mr *MockClockMockRecorder) At(arg0 any) *MockClockAtCall
  • func (mr *MockClockMockRecorder) AtFunc(arg0, arg1 any) *MockClockAtFuncCall
  • func (mr *MockClockMockRecorder) NewAlarm(arg0 any) *MockClockNewAlarmCall
  • func (mr *MockClockMockRecorder) NewTimer(arg0 any) *MockClockNewTimerCall
  • func (mr *MockClockMockRecorder) Now() *MockClockNowCall
• type MockClockNewAlarmCall
  • func (c *MockClockNewAlarmCall) Do(f func(time.Time) clock.Alarm) *MockClockNewAlarmCall
  • func (c *MockClockNewAlarmCall) DoAndReturn(f func(time.Time) clock.Alarm) *MockClockNewAlarmCall
  • func (c *MockClockNewAlarmCall) Return(arg0 clock.Alarm) *MockClockNewAlarmCall
• type MockClockNewTimerCall
  • func (c *MockClockNewTimerCall) Do(f func(time.Duration) clock.Timer) *MockClockNewTimerCall
  • func (c *MockClockNewTimerCall) DoAndReturn(f func(time.Duration) clock.Timer) *MockClockNewTimerCall
  • func (c *MockClockNewTimerCall) Return(arg0 clock.Timer) *MockClockNewTimerCall
• type MockClockNowCall
  • func (c *MockClockNowCall) Do(f func() time.Time) *MockClockNowCall
  • func (c *MockClockNowCall) DoAndReturn(f func() time.Time) *MockClockNowCall
  • func (c *MockClockNowCall) Return(arg0 time.Time) *MockClockNowCall
• type MockTerminal
  • func NewMockTerminal(ctrl *gomock.Controller) *MockTerminal
  • func (m *MockTerminal) EXPECT() *MockTerminalMockRecorder
  • func (m *MockTerminal) Width() int
• type MockTerminalMockRecorder
  • func (mr *MockTerminalMockRecorder) Width() *MockTerminalWidthCall
• type MockTerminalWidthCall
  • func (c *MockTerminalWidthCall) Do(f func() int) *MockTerminalWidthCall
  • func (c *MockTerminalWidthCall) DoAndReturn(f func() int) *MockTerminalWidthCall
  • func (c *MockTerminalWidthCall) Return(arg0 int) *MockTerminalWidthCall

Types

type MockClock

type MockClock struct {
	// contains filtered or unexported fields
}

MockClock is a mock of Clock interface.

func NewMockClock

func NewMockClock(ctrl *gomock.Controller) *MockClock

NewMockClock creates a new mock instance.

func (*MockClock) After

func (m *MockClock) After(arg0 time.Duration) <-chan time.Time

After mocks base method.

func (*MockClock) AfterFunc

func (m *MockClock) AfterFunc(arg0 time.Duration, arg1 func()) clock.Timer

AfterFunc mocks base method.

func (*MockClock) At

func (m *MockClock) At(arg0 time.Time) <-chan time.Time

At mocks base method.

func (*MockClock) AtFunc

func (m *MockClock) AtFunc(arg0 time.Time, arg1 func()) clock.Alarm

AtFunc mocks base method.

func (*MockClock) EXPECT

func (m *MockClock) EXPECT() *MockClockMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockClock) NewAlarm

func (m *MockClock) NewAlarm(arg0 time.Time) clock.Alarm

NewAlarm mocks base method.

func (*MockClock) NewTimer

func (m *MockClock) NewTimer(arg0 time.Duration) clock.Timer

NewTimer mocks base method.

func (*MockClock) Now

func (m *MockClock) Now() time.Time

Now mocks base method.

type MockClockAfterCall

type MockClockAfterCall struct {
	*gomock.Call
}

MockClockAfterCall wrap *gomock.Call

func (*MockClockAfterCall) Do

func (c *MockClockAfterCall) Do(f func(time.Duration) <-chan time.Time) *MockClockAfterCall

Do rewrite *gomock.Call.Do

func (*MockClockAfterCall) DoAndReturn

func (c *MockClockAfterCall) DoAndReturn(f func(time.Duration) <-chan time.Time) *MockClockAfterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockAfterCall) Return

func (c *MockClockAfterCall) Return(arg0 <-chan time.Time) *MockClockAfterCall

Return rewrite *gomock.Call.Return

type MockClockAfterFuncCall

type MockClockAfterFuncCall struct {
	*gomock.Call
}

MockClockAfterFuncCall wrap *gomock.Call

func (*MockClockAfterFuncCall) Do

func (c *MockClockAfterFuncCall) Do(f func(time.Duration, func()) clock.Timer) *MockClockAfterFuncCall

Do rewrite *gomock.Call.Do

func (*MockClockAfterFuncCall) DoAndReturn

func (c *MockClockAfterFuncCall) DoAndReturn(f func(time.Duration, func()) clock.Timer) *MockClockAfterFuncCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockAfterFuncCall) Return

func (c *MockClockAfterFuncCall) Return(arg0 clock.Timer) *MockClockAfterFuncCall

Return rewrite *gomock.Call.Return

type MockClockAtCall

type MockClockAtCall struct {
	*gomock.Call
}

MockClockAtCall wrap *gomock.Call

func (*MockClockAtCall) Do

func (c *MockClockAtCall) Do(f func(time.Time) <-chan time.Time) *MockClockAtCall

Do rewrite *gomock.Call.Do

func (*MockClockAtCall) DoAndReturn

func (c *MockClockAtCall) DoAndReturn(f func(time.Time) <-chan time.Time) *MockClockAtCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockAtCall) Return

func (c *MockClockAtCall) Return(arg0 <-chan time.Time) *MockClockAtCall

Return rewrite *gomock.Call.Return

type MockClockAtFuncCall

type MockClockAtFuncCall struct {
	*gomock.Call
}

MockClockAtFuncCall wrap *gomock.Call

func (*MockClockAtFuncCall) Do

func (c *MockClockAtFuncCall) Do(f func(time.Time, func()) clock.Alarm) *MockClockAtFuncCall

Do rewrite *gomock.Call.Do

func (*MockClockAtFuncCall) DoAndReturn

func (c *MockClockAtFuncCall) DoAndReturn(f func(time.Time, func()) clock.Alarm) *MockClockAtFuncCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockAtFuncCall) Return

func (c *MockClockAtFuncCall) Return(arg0 clock.Alarm) *MockClockAtFuncCall

Return rewrite *gomock.Call.Return

type MockClockMockRecorder

type MockClockMockRecorder struct {
	// contains filtered or unexported fields
}

MockClockMockRecorder is the mock recorder for MockClock.

func (*MockClockMockRecorder) After

func (mr *MockClockMockRecorder) After(arg0 any) *MockClockAfterCall

After indicates an expected call of After.

func (*MockClockMockRecorder) AfterFunc

func (mr *MockClockMockRecorder) AfterFunc(arg0, arg1 any) *MockClockAfterFuncCall

AfterFunc indicates an expected call of AfterFunc.

func (*MockClockMockRecorder) At

func (mr *MockClockMockRecorder) At(arg0 any) *MockClockAtCall

At indicates an expected call of At.

func (*MockClockMockRecorder) AtFunc

func (mr *MockClockMockRecorder) AtFunc(arg0, arg1 any) *MockClockAtFuncCall

AtFunc indicates an expected call of AtFunc.

func (*MockClockMockRecorder) NewAlarm

func (mr *MockClockMockRecorder) NewAlarm(arg0 any) *MockClockNewAlarmCall

NewAlarm indicates an expected call of NewAlarm.

func (*MockClockMockRecorder) NewTimer

func (mr *MockClockMockRecorder) NewTimer(arg0 any) *MockClockNewTimerCall

NewTimer indicates an expected call of NewTimer.

func (*MockClockMockRecorder) Now

func (mr *MockClockMockRecorder) Now() *MockClockNowCall

Now indicates an expected call of Now.

type MockClockNewAlarmCall

type MockClockNewAlarmCall struct {
	*gomock.Call
}

MockClockNewAlarmCall wrap *gomock.Call

func (*MockClockNewAlarmCall) Do

func (c *MockClockNewAlarmCall) Do(f func(time.Time) clock.Alarm) *MockClockNewAlarmCall

Do rewrite *gomock.Call.Do

func (*MockClockNewAlarmCall) DoAndReturn

func (c *MockClockNewAlarmCall) DoAndReturn(f func(time.Time) clock.Alarm) *MockClockNewAlarmCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockNewAlarmCall) Return

func (c *MockClockNewAlarmCall) Return(arg0 clock.Alarm) *MockClockNewAlarmCall

Return rewrite *gomock.Call.Return

type MockClockNewTimerCall

type MockClockNewTimerCall struct {
	*gomock.Call
}

MockClockNewTimerCall wrap *gomock.Call

func (*MockClockNewTimerCall) Do

func (c *MockClockNewTimerCall) Do(f func(time.Duration) clock.Timer) *MockClockNewTimerCall

Do rewrite *gomock.Call.Do

func (*MockClockNewTimerCall) DoAndReturn

func (c *MockClockNewTimerCall) DoAndReturn(f func(time.Duration) clock.Timer) *MockClockNewTimerCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockNewTimerCall) Return

func (c *MockClockNewTimerCall) Return(arg0 clock.Timer) *MockClockNewTimerCall

Return rewrite *gomock.Call.Return

type MockClockNowCall

type MockClockNowCall struct {
	*gomock.Call
}

MockClockNowCall wrap *gomock.Call

func (*MockClockNowCall) Do

func (c *MockClockNowCall) Do(f func() time.Time) *MockClockNowCall

Do rewrite *gomock.Call.Do

func (*MockClockNowCall) DoAndReturn

func (c *MockClockNowCall) DoAndReturn(f func() time.Time) *MockClockNowCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockClockNowCall) Return

func (c *MockClockNowCall) Return(arg0 time.Time) *MockClockNowCall

Return rewrite *gomock.Call.Return

type MockTerminal

type MockTerminal struct {
	// contains filtered or unexported fields
}

MockTerminal is a mock of Terminal interface.

func NewMockTerminal

func NewMockTerminal(ctrl *gomock.Controller) *MockTerminal

NewMockTerminal creates a new mock instance.

func (*MockTerminal) EXPECT

func (m *MockTerminal) EXPECT() *MockTerminalMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockTerminal) Width

func (m *MockTerminal) Width() int

Width mocks base method.

type MockTerminalMockRecorder

type MockTerminalMockRecorder struct {
	// contains filtered or unexported fields
}

MockTerminalMockRecorder is the mock recorder for MockTerminal.

func (*MockTerminalMockRecorder) Width

func (mr *MockTerminalMockRecorder) Width() *MockTerminalWidthCall

Width indicates an expected call of Width.

type MockTerminalWidthCall

type MockTerminalWidthCall struct {
	*gomock.Call
}

MockTerminalWidthCall wrap *gomock.Call

func (*MockTerminalWidthCall) Do

func (c *MockTerminalWidthCall) Do(f func() int) *MockTerminalWidthCall

Do rewrite *gomock.Call.Do

func (*MockTerminalWidthCall) DoAndReturn

func (c *MockTerminalWidthCall) DoAndReturn(f func() int) *MockTerminalWidthCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTerminalWidthCall) Return

func (c *MockTerminalWidthCall) Return(arg0 int) *MockTerminalWidthCall

Return rewrite *gomock.Call.Return