Documentation

Overview

    Package mclock is a wrapper for a monotonic clock source

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type AbsTime

    type AbsTime time.Duration

      AbsTime represents absolute monotonic time.

      func Now

      func Now() AbsTime

        Now returns the current absolute monotonic time.

        func (AbsTime) Add

        func (t AbsTime) Add(d time.Duration) AbsTime

          Add returns t + d as absolute time.

          func (AbsTime) Sub

          func (t AbsTime) Sub(t2 AbsTime) time.Duration

            Sub returns t - t2 as a duration.

            type ChanTimer

            type ChanTimer interface {
            	Timer
            
            	// The channel returned by C receives a value when the timer expires.
            	C() <-chan AbsTime
            	// Reset reschedules the timer with a new timeout.
            	// It should be invoked only on stopped or expired timers with drained channels.
            	Reset(time.Duration)
            }

              ChanTimer is a cancellable event created by NewTimer.

              type Clock

              type Clock interface {
              	Now() AbsTime
              	Sleep(time.Duration)
              	NewTimer(time.Duration) ChanTimer
              	After(time.Duration) <-chan AbsTime
              	AfterFunc(d time.Duration, f func()) Timer
              }

                The Clock interface makes it possible to replace the monotonic system clock with a simulated clock.

                type Simulated

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

                  Simulated implements a virtual Clock for reproducible time-sensitive tests. It simulates a scheduler on a virtual timescale where actual processing takes zero time.

                  The virtual clock doesn't advance on its own, call Run to advance it and execute timers. Since there is no way to influence the Go scheduler, testing timeout behaviour involving goroutines needs special care. A good way to test such timeouts is as follows: First perform the action that is supposed to time out. Ensure that the timer you want to test is created. Then run the clock until after the timeout. Finally observe the effect of the timeout using a channel or semaphore.

                  func (*Simulated) ActiveTimers

                  func (s *Simulated) ActiveTimers() int

                    ActiveTimers returns the number of timers that haven't fired.

                    func (*Simulated) After

                    func (s *Simulated) After(d time.Duration) <-chan AbsTime

                      After returns a channel which receives the current time after the clock has advanced by d.

                      func (*Simulated) AfterFunc

                      func (s *Simulated) AfterFunc(d time.Duration, fn func()) Timer

                        AfterFunc runs fn after the clock has advanced by d. Unlike with the system clock, fn runs on the goroutine that calls Run.

                        func (*Simulated) NewTimer

                        func (s *Simulated) NewTimer(d time.Duration) ChanTimer

                          NewTimer creates a timer which fires when the clock has advanced by d.

                          func (*Simulated) Now

                          func (s *Simulated) Now() AbsTime

                            Now returns the current virtual time.

                            func (*Simulated) Run

                            func (s *Simulated) Run(d time.Duration)

                              Run moves the clock by the given duration, executing all timers before that duration.

                              func (*Simulated) Sleep

                              func (s *Simulated) Sleep(d time.Duration)

                                Sleep blocks until the clock has advanced by d.

                                func (*Simulated) WaitForTimers

                                func (s *Simulated) WaitForTimers(n int)

                                  WaitForTimers waits until the clock has at least n scheduled timers.

                                  type System

                                  type System struct{}

                                    System implements Clock using the system clock.

                                    func (System) After

                                    func (c System) After(d time.Duration) <-chan AbsTime

                                      After returns a channel which receives the current time after d has elapsed.

                                      func (System) AfterFunc

                                      func (c System) AfterFunc(d time.Duration, f func()) Timer

                                        AfterFunc runs f on a new goroutine after the duration has elapsed.

                                        func (System) NewTimer

                                        func (c System) NewTimer(d time.Duration) ChanTimer

                                          NewTimer creates a timer which can be rescheduled.

                                          func (System) Now

                                          func (c System) Now() AbsTime

                                            Now returns the current monotonic time.

                                            func (System) Sleep

                                            func (c System) Sleep(d time.Duration)

                                              Sleep blocks for the given duration.

                                              type Timer

                                              type Timer interface {
                                              	// Stop cancels the timer. It returns false if the timer has already
                                              	// expired or been stopped.
                                              	Stop() bool
                                              }

                                                Timer is a cancellable event created by AfterFunc.