clock

Documentation

Index

• type Clock
• type FakeClock
  • func NewFakeClock(t time.Time) *FakeClock
  • func (f *FakeClock) After(d time.Duration) <-chan time.Time
  • func (f *FakeClock) AfterFunc(d time.Duration, cb func()) Timer
  • func (f *FakeClock) HasWaiters() bool
  • func (f *FakeClock) NewTicker(d time.Duration) Ticker
  • func (f *FakeClock) NewTimer(d time.Duration) Timer
  • func (f *FakeClock) SetTime(t time.Time)
  • func (f *FakeClock) Sleep(d time.Duration)
  • func (f *FakeClock) Step(d time.Duration)
• type FakePassiveClock
  • func NewFakePassiveClock(t time.Time) *FakePassiveClock
  • func (f *FakePassiveClock) Now() time.Time
  • func (f *FakePassiveClock) SetTime(t time.Time)
  • func (f *FakePassiveClock) Since(ts time.Time) time.Duration
• type IntervalClock
  • func (*IntervalClock) After(d time.Duration) <-chan time.Time
  • func (*IntervalClock) AfterFunc(d time.Duration, cb func()) Timer
  • func (*IntervalClock) NewTicker(d time.Duration) Ticker
  • func (*IntervalClock) NewTimer(d time.Duration) Timer
  • func (i *IntervalClock) Now() time.Time
  • func (i *IntervalClock) Since(ts time.Time) time.Duration
  • func (*IntervalClock) Sleep(d time.Duration)
• type PassiveClock
• type RealClock
  • func (RealClock) After(d time.Duration) <-chan time.Time
  • func (RealClock) AfterFunc(d time.Duration, f func()) Timer
  • func (RealClock) NewTicker(d time.Duration) Ticker
  • func (RealClock) NewTimer(d time.Duration) Timer
  • func (RealClock) Now() time.Time
  • func (RealClock) Since(ts time.Time) time.Duration
  • func (RealClock) Sleep(d time.Duration)
• type Ticker
• type Timer

Types

type Clock

type Clock interface {
	PassiveClock
	After(time.Duration) <-chan time.Time
	AfterFunc(time.Duration, func()) Timer
	NewTimer(time.Duration) Timer
	Sleep(time.Duration)
	NewTicker(time.Duration) Ticker
}

Clock allows for injecting fake or real clocks into code that needs to do arbitrary things based on time.

type FakeClock

type FakeClock struct {
	FakePassiveClock
	// contains filtered or unexported fields
}

FakeClock implements Clock, but returns an arbitrary time.

func NewFakeClock

func NewFakeClock(t time.Time) *FakeClock

NewFakeClock returns a new FakeClock

func (*FakeClock) After

func (f *FakeClock) After(d time.Duration) <-chan time.Time

After is the Fake version of time.After(d).

func (*FakeClock) AfterFunc

func (f *FakeClock) AfterFunc(d time.Duration, cb func()) Timer

AfterFunc is the Fake version of time.AfterFunc(d, callback).

func (*FakeClock) HasWaiters

func (f *FakeClock) HasWaiters() bool

HasWaiters returns true if After or AfterFunc has been called on f but not yet satisfied (so you can write race-free tests).

func (*FakeClock) NewTicker

func (f *FakeClock) NewTicker(d time.Duration) Ticker

NewTicker returns a new Ticker.

func (*FakeClock) NewTimer

func (f *FakeClock) NewTimer(d time.Duration) Timer

NewTimer is the Fake version of time.NewTimer(d).

func (*FakeClock) SetTime

func (f *FakeClock) SetTime(t time.Time)

SetTime sets the time on a FakeClock.

func (*FakeClock) Sleep

func (f *FakeClock) Sleep(d time.Duration)

Sleep pauses the FakeClock for duration d.

func (*FakeClock) Step

func (f *FakeClock) Step(d time.Duration)

Step moves clock by Duration, notifies anyone that's called After, Tick, or NewTimer

type FakePassiveClock

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

FakePassiveClock implements PassiveClock, but returns an arbitrary time.

func NewFakePassiveClock

func NewFakePassiveClock(t time.Time) *FakePassiveClock

NewFakePassiveClock returns a new FakePassiveClock.

func (*FakePassiveClock) Now

func (f *FakePassiveClock) Now() time.Time

Now returns f's time.

func (*FakePassiveClock) SetTime

func (f *FakePassiveClock) SetTime(t time.Time)

SetTime sets the time on the FakePassiveClock.

func (*FakePassiveClock) Since

func (f *FakePassiveClock) Since(ts time.Time) time.Duration

Since returns time since the time in f.

type IntervalClock

type IntervalClock struct {
	Time     time.Time
	Duration time.Duration
}

IntervalClock implements Clock, but each invocation of Now steps the clock forward the specified duration

func (*IntervalClock) After

func (*IntervalClock) After(d time.Duration) <-chan time.Time

After is currently unimplemented, will panic. TODO: make interval clock use FakeClock so this can be implemented.

func (*IntervalClock) AfterFunc

func (*IntervalClock) AfterFunc(d time.Duration, cb func()) Timer

AfterFunc is currently unimplemented, will panic. TODO: make interval clock use FakeClock so this can be implemented.

func (*IntervalClock) NewTicker

func (*IntervalClock) NewTicker(d time.Duration) Ticker

NewTicker is currently unimplemented, will panic. TODO: make interval clock use FakeClock so this can be implemented.

func (*IntervalClock) NewTimer

func (*IntervalClock) NewTimer(d time.Duration) Timer

NewTimer is currently unimplemented, will panic. TODO: make interval clock use FakeClock so this can be implemented.

func (*IntervalClock) Now

func (i *IntervalClock) Now() time.Time

Now returns i's time.

func (*IntervalClock) Since

func (i *IntervalClock) Since(ts time.Time) time.Duration

Since returns time since the time in i.

func (*IntervalClock) Sleep

func (*IntervalClock) Sleep(d time.Duration)

Sleep is currently unimplemented; will panic.

type PassiveClock

type PassiveClock interface {
	Now() time.Time
	Since(time.Time) time.Duration
}

PassiveClock allows for injecting fake or real clocks into code that needs to read the current time but does not support scheduling activity in the future.

type RealClock

type RealClock struct{}

RealClock really calls time.Now()

func (RealClock) After

func (RealClock) After(d time.Duration) <-chan time.Time

After is the same as time.After(d).

func (RealClock) AfterFunc

func (RealClock) AfterFunc(d time.Duration, f func()) Timer

AfterFunc is the same as time.AfterFunc(d, f).

func (RealClock) NewTicker

func (RealClock) NewTicker(d time.Duration) Ticker

NewTicker returns a new Ticker.

func (RealClock) NewTimer

func (RealClock) NewTimer(d time.Duration) Timer

NewTimer returns a new Timer.

func (RealClock) Now

func (RealClock) Now() time.Time

Now returns the current time.

func (RealClock) Since

func (RealClock) Since(ts time.Time) time.Duration

Since returns time since the specified timestamp.

func (RealClock) Sleep

func (RealClock) Sleep(d time.Duration)

Sleep pauses the RealClock for duration d.

type Ticker

type Ticker interface {
	C() <-chan time.Time
	Stop()
}

Ticker defines the Ticker interface

type Timer

type Timer interface {
	C() <-chan time.Time
	Stop() bool
	Reset(d time.Duration) bool
}

Timer allows for injecting fake or real timers into code that needs to do arbitrary things based on time.