tick_test.go

Documentation: time

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package time_test
     6  
     7  import (
     8  	"fmt"
     9  	"runtime"
    10  	"testing"
    11  	. "time"
    12  )
    13  
    14  func TestTicker(t *testing.T) {
    15  	// We want to test that a ticker takes as much time as expected.
    16  	// Since we don't want the test to run for too long, we don't
    17  	// want to use lengthy times. This makes the test inherently flaky.
    18  	// So only report an error if it fails five times in a row.
    19  
    20  	count := 10
    21  	delta := 20 * Millisecond
    22  
    23  	// On Darwin ARM64 the tick frequency seems limited. Issue 35692.
    24  	if (runtime.GOOS == "darwin" || runtime.GOOS == "ios") && runtime.GOARCH == "arm64" {
    25  		// The following test will run ticker count/2 times then reset
    26  		// the ticker to double the duration for the rest of count/2.
    27  		// Since tick frequency is limited on Darwin ARM64, use even
    28  		// number to give the ticks more time to let the test pass.
    29  		// See CL 220638.
    30  		count = 6
    31  		delta = 100 * Millisecond
    32  	}
    33  
    34  	var errs []string
    35  	logErrs := func() {
    36  		for _, e := range errs {
    37  			t.Log(e)
    38  		}
    39  	}
    40  
    41  	for i := 0; i < 5; i++ {
    42  		ticker := NewTicker(delta)
    43  		t0 := Now()
    44  		for i := 0; i < count/2; i++ {
    45  			<-ticker.C
    46  		}
    47  		ticker.Reset(delta * 2)
    48  		for i := count / 2; i < count; i++ {
    49  			<-ticker.C
    50  		}
    51  		ticker.Stop()
    52  		t1 := Now()
    53  		dt := t1.Sub(t0)
    54  		target := 3 * delta * Duration(count/2)
    55  		slop := target * 3 / 10
    56  		if dt < target-slop || dt > target+slop {
    57  			errs = append(errs, fmt.Sprintf("%d %s ticks then %d %s ticks took %s, expected [%s,%s]", count/2, delta, count/2, delta*2, dt, target-slop, target+slop))
    58  			if dt > target+slop {
    59  				// System may be overloaded; sleep a bit
    60  				// in the hopes it will recover.
    61  				Sleep(Second / 2)
    62  			}
    63  			continue
    64  		}
    65  		// Now test that the ticker stopped.
    66  		Sleep(2 * delta)
    67  		select {
    68  		case <-ticker.C:
    69  			errs = append(errs, "Ticker did not shut down")
    70  			continue
    71  		default:
    72  			// ok
    73  		}
    74  
    75  		// Test passed, so all done.
    76  		if len(errs) > 0 {
    77  			t.Logf("saw %d errors, ignoring to avoid flakiness", len(errs))
    78  			logErrs()
    79  		}
    80  
    81  		return
    82  	}
    83  
    84  	t.Errorf("saw %d errors", len(errs))
    85  	logErrs()
    86  }
    87  
    88  // Issue 21874
    89  func TestTickerStopWithDirectInitialization(t *testing.T) {
    90  	c := make(chan Time)
    91  	tk := &Ticker{C: c}
    92  	tk.Stop()
    93  }
    94  
    95  // Test that a bug tearing down a ticker has been fixed. This routine should not deadlock.
    96  func TestTeardown(t *testing.T) {
    97  	Delta := 100 * Millisecond
    98  	if testing.Short() {
    99  		Delta = 20 * Millisecond
   100  	}
   101  	for i := 0; i < 3; i++ {
   102  		ticker := NewTicker(Delta)
   103  		<-ticker.C
   104  		ticker.Stop()
   105  	}
   106  }
   107  
   108  // Test the Tick convenience wrapper.
   109  func TestTick(t *testing.T) {
   110  	// Test that giving a negative duration returns nil.
   111  	if got := Tick(-1); got != nil {
   112  		t.Errorf("Tick(-1) = %v; want nil", got)
   113  	}
   114  }
   115  
   116  // Test that NewTicker panics when given a duration less than zero.
   117  func TestNewTickerLtZeroDuration(t *testing.T) {
   118  	defer func() {
   119  		if err := recover(); err == nil {
   120  			t.Errorf("NewTicker(-1) should have panicked")
   121  		}
   122  	}()
   123  	NewTicker(-1)
   124  }
   125  
   126  func BenchmarkTicker(b *testing.B) {
   127  	benchmark(b, func(n int) {
   128  		ticker := NewTicker(Nanosecond)
   129  		for i := 0; i < n; i++ {
   130  			<-ticker.C
   131  		}
   132  		ticker.Stop()
   133  	})
   134  }
   135  
   136  func BenchmarkTickerReset(b *testing.B) {
   137  	benchmark(b, func(n int) {
   138  		ticker := NewTicker(Nanosecond)
   139  		for i := 0; i < n; i++ {
   140  			ticker.Reset(Nanosecond * 2)
   141  		}
   142  		ticker.Stop()
   143  	})
   144  }
   145  
   146  func BenchmarkTickerResetNaive(b *testing.B) {
   147  	benchmark(b, func(n int) {
   148  		ticker := NewTicker(Nanosecond)
   149  		for i := 0; i < n; i++ {
   150  			ticker.Stop()
   151  			ticker = NewTicker(Nanosecond * 2)
   152  		}
   153  		ticker.Stop()
   154  	})
   155  }
   156
View as plain text