Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Clock

type Clock interface {
	Now() time.Time
	Since(time.Time) time.Duration
	After(time.Duration) <-chan time.Time
	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 {
    	// 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) NewTicker

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

          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

                    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) NewTicker

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

                          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)

                                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) NewTicker

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

                                    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)

                                        type Ticker

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

                                        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.

                                          Source Files