README

PkgGoDev

clock

This library has been forked from https://github.com/kubernetes/apimachinery/tree/v0.18.3/pkg/util/clock so that it can easily used in non-k8s related projects.

Expand ▾ Collapse ▴

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Clock

type Clock interface {
	PassiveClock
	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 {
    	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) HasWaiters

          func (f *FakeClock) HasWaiters() bool

            HasWaiters 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

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

                                                                  Source Files