package mockclock

Import Path
	go.pact.im/x/clock/mockclock (on go.dev)

Dependency Relation
	imports 4 packages, and imported by 0 packages

Involved Source Files

	      clock.go
	   #d doc.go
		Package mockclock provides clock.Clock implementation that uses GoMock
		mocking framework.

	      gen.go
	      mockclock.go
	      ticker.go
	      timer.go
Package-Level Type Names (total 7, all are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Clock (interface)
		Clock is a union of all interfaces implemented by a full-featured clock
		implementation. It is satisfied by clock.Clock that provides shims for
		missing functionality.

		It is an input for mock types generator and must not be used outside of this
		package.

		Methods (total 5, in which 4 are exported)
			( Clock) Now() time.Time
				Now returns the current local time.

			( Clock) Schedule(d time.Duration, f func(now time.Time)) clock.Event
				Schedule schedules an event that calls f in its own goroutine when
				the given duration elapses. It returns an Event that can be canceled
				using the Stop method.

			( Clock) Ticker(d time.Duration) clock.Ticker
				Ticker returns a new Ticker containing a channel that will send the time
				on the channel after each tick. The period of the ticks is specified by the
				duration argument. The ticker will adjust the time interval or drop ticks to
				make up for slow receivers. The duration d must be greater than zero; if
				not, Ticker will panic. Stop the ticker to release associated resources.

			( Clock) Timer(d time.Duration) clock.Timer
				Timer creates a new Timer that will send the current time on
				its channel after at least duration d.

			/* one unexported ... *//* one unexported: */
			( Clock) private()
		Implemented By (at least one exported)
			*MockClock
		Implements (at least 4, all are exported)
			 Clock : go.pact.im/x/clock.NowScheduler
			 Clock : go.pact.im/x/clock.Scheduler
			 Clock : go.pact.im/x/clock.TickerScheduler
			 Clock : go.pact.im/x/clock.TimerScheduler

	 type MockClock (struct)
		MockClock is a mock of Clock interface.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			ctrl *gomock.Controller
			recorder *MockClockMockRecorder
		Methods (total 6, in which 5 are exported)
			(*MockClock) EXPECT() *MockClockMockRecorder
				EXPECT returns an object that allows the caller to indicate expected use.

			(*MockClock) Now() time.Time
				Now mocks base method.

			(*MockClock) Schedule(d time.Duration, f func(time.Time)) clock.Event
				Schedule mocks base method.

			(*MockClock) Ticker(d time.Duration) clock.Ticker
				Ticker mocks base method.

			(*MockClock) Timer(d time.Duration) clock.Timer
				Timer mocks base method.

			/* one unexported ... *//* one unexported: */
			(*MockClock) private()
				private mocks base method.

		Implements (at least 5, all are exported)
			*MockClock : Clock
			*MockClock : go.pact.im/x/clock.NowScheduler
			*MockClock : go.pact.im/x/clock.Scheduler
			*MockClock : go.pact.im/x/clock.TickerScheduler
			*MockClock : go.pact.im/x/clock.TimerScheduler
		As Outputs Of (at least one exported)
			func NewMockClock(ctrl *gomock.Controller) *MockClock

	 type MockClockMockRecorder (struct)
		MockClockMockRecorder is the mock recorder for MockClock.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			mock *MockClock
		Methods (total 5, in which 4 are exported)
			(*MockClockMockRecorder) Now() *gomock.Call
				Now indicates an expected call of Now.

			(*MockClockMockRecorder) Schedule(d, f interface{}) *gomock.Call
				Schedule indicates an expected call of Schedule.

			(*MockClockMockRecorder) Ticker(d interface{}) *gomock.Call
				Ticker indicates an expected call of Ticker.

			(*MockClockMockRecorder) Timer(d interface{}) *gomock.Call
				Timer indicates an expected call of Timer.

			/* one unexported ... *//* one unexported: */
			(*MockClockMockRecorder) private() *gomock.Call
				private indicates an expected call of private.

		As Outputs Of (at least one exported)
			func (*MockClock).EXPECT() *MockClockMockRecorder

	 type MockTicker (struct)
		MockTicker is a mock of Ticker interface.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			ctrl *gomock.Controller
			recorder *MockTickerMockRecorder
		Methods (total 4, all are exported)
			(*MockTicker) C() <-chan time.Time
				C mocks base method.

			(*MockTicker) EXPECT() *MockTickerMockRecorder
				EXPECT returns an object that allows the caller to indicate expected use.

			(*MockTicker) Reset(arg0 time.Duration)
				Reset mocks base method.

			(*MockTicker) Stop()
				Stop mocks base method.

		Implements (at least one exported)
			*MockTicker : go.pact.im/x/clock.Ticker
		As Outputs Of (at least one exported)
			func NewMockTicker(ctrl *gomock.Controller) *MockTicker

	 type MockTickerMockRecorder (struct)
		MockTickerMockRecorder is the mock recorder for MockTicker.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			mock *MockTicker
		Methods (total 3, all are exported)
			(*MockTickerMockRecorder) C() *gomock.Call
				C indicates an expected call of C.

			(*MockTickerMockRecorder) Reset(arg0 interface{}) *gomock.Call
				Reset indicates an expected call of Reset.

			(*MockTickerMockRecorder) Stop() *gomock.Call
				Stop indicates an expected call of Stop.

		As Outputs Of (at least one exported)
			func (*MockTicker).EXPECT() *MockTickerMockRecorder

	 type MockTimer (struct)
		MockTimer is a mock of Timer interface.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			ctrl *gomock.Controller
			recorder *MockTimerMockRecorder
		Methods (total 4, all are exported)
			(*MockTimer) C() <-chan time.Time
				C mocks base method.

			(*MockTimer) EXPECT() *MockTimerMockRecorder
				EXPECT returns an object that allows the caller to indicate expected use.

			(*MockTimer) Reset(arg0 time.Duration)
				Reset mocks base method.

			(*MockTimer) Stop() bool
				Stop mocks base method.

		Implements (at least one exported)
			*MockTimer : go.pact.im/x/clock.Timer
		As Outputs Of (at least one exported)
			func NewMockTimer(ctrl *gomock.Controller) *MockTimer

	 type MockTimerMockRecorder (struct)
		MockTimerMockRecorder is the mock recorder for MockTimer.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			mock *MockTimer
		Methods (total 3, all are exported)
			(*MockTimerMockRecorder) C() *gomock.Call
				C indicates an expected call of C.

			(*MockTimerMockRecorder) Reset(arg0 interface{}) *gomock.Call
				Reset indicates an expected call of Reset.

			(*MockTimerMockRecorder) Stop() *gomock.Call
				Stop indicates an expected call of Stop.

		As Outputs Of (at least one exported)
			func (*MockTimer).EXPECT() *MockTimerMockRecorder


Package-Level Functions (total 3, all are exported)

	 func NewMockClock(ctrl *gomock.Controller) *MockClock
		NewMockClock creates a new mock instance.

	 func NewMockTicker(ctrl *gomock.Controller) *MockTicker
		NewMockTicker creates a new mock instance.

	 func NewMockTimer(ctrl *gomock.Controller) *MockTimer
		NewMockTimer creates a new mock instance.

The pages are generated with Golds v0.4.9. (GOOS=linux GOARCH=amd64)