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) HasWaiters() bool
  • func (f *FakeClock) NewTimer(d time.Duration) Timer
  • func (f *FakeClock) Now() time.Time
  • func (f *FakeClock) SetTime(t time.Time)
  • func (f *FakeClock) Since(ts time.Time) time.Duration
  • func (f *FakeClock) Sleep(d time.Duration)
  • func (f *FakeClock) Step(d time.Duration)
  • func (f *FakeClock) Tick(d time.Duration) <-chan time.Time
• type IntervalClock
  • func (*IntervalClock) After(d time.Duration) <-chan time.Time
  • 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)
  • func (*IntervalClock) Tick(d time.Duration) <-chan time.Time
• type RealClock
  • func (RealClock) After(d time.Duration) <-chan time.Time
  • 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)
  • func (RealClock) Tick(d time.Duration) <-chan time.Time
• type Timer

Types

type Clock

type Clock interface {
	Now() time.Time
	Since(time.Time) time.Duration
	After(d time.Duration) <-chan time.Time
	NewTimer(d time.Duration) Timer
	Sleep(d time.Duration)
	Tick(d time.Duration) <-chan time.Time
}

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

type FakeClock

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

FakeClock implements Clock, but returns an arbitrary time.

func NewFakeClock

func NewFakeClock(t time.Time) *FakeClock

func (*FakeClock) After

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

Fake version of time.After(d).

func (*FakeClock) HasWaiters

func (f *FakeClock) HasWaiters() bool

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

func (*FakeClock) NewTimer

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

Fake version of time.NewTimer(d).

func (*FakeClock) Now

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

Now returns f's time.

func (*FakeClock) SetTime

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

Sets the time.

func (*FakeClock) Since

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

Since returns time since the time in f.

func (*FakeClock) Sleep

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

func (*FakeClock) Step

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

Move clock by Duration, notify anyone that's called After, Tick, or NewTimer

func (*FakeClock) Tick

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

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

Unimplemented, will panic. TODO: make interval clock use FakeClock so this can be implemented.

func (*IntervalClock) NewTimer

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

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)

func (*IntervalClock) Tick

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

Unimplemented, will panic. TODO: make interval clock use FakeClock so this can be implemented.

type RealClock

type RealClock struct{}

RealClock really calls time.Now()

func (RealClock) After

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

Same as time.After(d).

func (RealClock) NewTimer

func (RealClock) NewTimer(d time.Duration) 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)

func (RealClock) Tick

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

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.