// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package timing

import (
	"bytes"
	"fmt"
	"math/rand"
	"reflect"
	"strings"
	"testing"
	"time"
)

func sec(d int) time.Duration {
	return time.Second * time.Duration(d)
}

func tsec(d int) time.Time {
	return time.Time{}.Add(sec(d))
}

// fakeNow is a simulated clock where now is set manually.
type fakeNow struct{ now int }

func (f *fakeNow) Now() time.Time { return tsec(f.now) }

// stepNow is a simulated clock where now increments in 1 second steps.
type stepNow struct{ now int }

func (s *stepNow) Now() time.Time {
	s.now++
	return tsec(s.now)
}

type (
	// op represents the operations that can be performed on a Timer, with a fake
	// clock.  This makes it easy to construct test cases.
	op interface {
		run(f *fakeNow, t *Timer)
	}
	push struct {
		now  int
		name string
	}
	pop struct {
		now int
	}
	finish struct {
		now int
	}
)

func (x push) run(f *fakeNow, t *Timer) {
	f.now = x.now
	t.Push(x.name)
}
func (x pop) run(f *fakeNow, t *Timer) {
	f.now = x.now
	t.Pop()
}
func (x finish) run(f *fakeNow, t *Timer) {
	f.now = x.now
	t.Finish()
}

// stripGaps strips out leading newlines, and also strips any line with an
// asterisk (*).  Asterisks appear in lines with gaps, as shown here:
//    00:00:01.000 root   98.000s    00:01:39.000
//    00:00:01.000    *       9.000s 00:00:10.000
//    00:00:10.000    abc    89.000s 00:01:39.000
func stripGaps(out string) string {
	out = strings.TrimLeft(out, "\n")
	var lines []string
	for _, line := range strings.Split(out, "\n") {
		if !strings.ContainsRune(line, '*') {
			lines = append(lines, line)
		}
	}
	return strings.Join(lines, "\n")
}

func TestTimer(t *testing.T) {
	tests := []struct {
		ops       []op
		intervals []Interval
		str       string
	}{
		{
			nil,
			[]Interval{{"root", 0, sec(0), InvalidDuration}},
			`
00:00:01.000 root 999.000s ---------now
`,
		},
		{
			[]op{pop{123}},
			[]Interval{{"root", 0, sec(0), InvalidDuration}},
			`
00:00:01.000 root 999.000s ---------now
`,
		},
		{
			[]op{finish{99}},
			[]Interval{{"root", 0, sec(0), sec(98)}},
			`
00:00:01.000 root 98.000s 00:01:39.000
`,
		},
		{
			[]op{finish{99}, pop{123}},
			[]Interval{{"root", 0, sec(0), sec(98)}},
			`
00:00:01.000 root 98.000s 00:01:39.000
`,
		},
		{
			[]op{push{10, "abc"}},
			[]Interval{
				{"root", 0, sec(0), InvalidDuration},
				{"abc", 1, sec(9), InvalidDuration},
			},
			`
00:00:01.000 root   999.000s    ---------now
00:00:01.000    *        9.000s 00:00:10.000
00:00:10.000    abc    990.000s ---------now
`,
		},
		{
			[]op{push{10, "abc"}, finish{99}},
			[]Interval{
				{"root", 0, sec(0), sec(98)},
				{"abc", 1, sec(9), sec(98)},
			},
			`
00:00:01.000 root   98.000s    00:01:39.000
00:00:01.000    *       9.000s 00:00:10.000
00:00:10.000    abc    89.000s 00:01:39.000
`,
		},
		{
			[]op{push{10, "abc"}, pop{20}, finish{99}},
			[]Interval{
				{"root", 0, sec(0), sec(98)},
				{"abc", 1, sec(9), sec(19)},
			},
			`
00:00:01.000 root   98.000s    00:01:39.000
00:00:01.000    *       9.000s 00:00:10.000
00:00:10.000    abc    10.000s 00:00:20.000
00:00:20.000    *      79.000s 00:01:39.000
`,
		},
		{
			[]op{push{10, "A1"}, push{20, "A1_1"}},
			[]Interval{
				{"root", 0, sec(0), InvalidDuration},
				{"A1", 1, sec(9), InvalidDuration},
				{"A1_1", 2, sec(19), InvalidDuration},
			},
			`
00:00:01.000 root       999.000s       ---------now
00:00:01.000    *            9.000s    00:00:10.000
00:00:10.000    A1         990.000s    ---------now
00:00:10.000       *           10.000s 00:00:20.000
00:00:20.000       A1_1       980.000s ---------now
`,
		},
		{
			[]op{push{10, "A1"}, push{20, "A1_1"}, finish{99}},
			[]Interval{
				{"root", 0, sec(0), sec(98)},
				{"A1", 1, sec(9), sec(98)},
				{"A1_1", 2, sec(19), sec(98)},
			},
			`
00:00:01.000 root       98.000s       00:01:39.000
00:00:01.000    *           9.000s    00:00:10.000
00:00:10.000    A1         89.000s    00:01:39.000
00:00:10.000       *          10.000s 00:00:20.000
00:00:20.000       A1_1       79.000s 00:01:39.000
`,
		},
		{
			[]op{push{10, "A1"}, push{20, "A1_1"}, pop{30}, finish{99}},
			[]Interval{
				{"root", 0, sec(0), sec(98)},
				{"A1", 1, sec(9), sec(98)},
				{"A1_1", 2, sec(19), sec(29)},
			},
			`
00:00:01.000 root       98.000s       00:01:39.000
00:00:01.000    *           9.000s    00:00:10.000
00:00:10.000    A1         89.000s    00:01:39.000
00:00:10.000       *          10.000s 00:00:20.000
00:00:20.000       A1_1       10.000s 00:00:30.000
00:00:30.000       *          69.000s 00:01:39.000
`,
		},
		{
			[]op{push{10, "A1"}, push{20, "A1_1"}, pop{30}, pop{40}, finish{99}},
			[]Interval{
				{"root", 0, sec(0), sec(98)},
				{"A1", 1, sec(9), sec(39)},
				{"A1_1", 2, sec(19), sec(29)},
			},
			`
00:00:01.000 root       98.000s       00:01:39.000
00:00:01.000    *           9.000s    00:00:10.000
00:00:10.000    A1         30.000s    00:00:40.000
00:00:10.000       *          10.000s 00:00:20.000
00:00:20.000       A1_1       10.000s 00:00:30.000
00:00:30.000       *          10.000s 00:00:40.000
00:00:40.000    *          59.000s    00:01:39.000
`,
		},
		{
			[]op{push{10, "A1"}, push{20, "A1_1"}, push{30, "A1_1_1"}},
			[]Interval{
				{"root", 0, sec(0), InvalidDuration},
				{"A1", 1, sec(9), InvalidDuration},
				{"A1_1", 2, sec(19), InvalidDuration},
				{"A1_1_1", 3, sec(29), InvalidDuration},
			},
			`
00:00:01.000 root            999.000s          ---------now
00:00:01.000    *                 9.000s       00:00:10.000
00:00:10.000    A1              990.000s       ---------now
00:00:10.000       *                10.000s    00:00:20.000
00:00:20.000       A1_1            980.000s    ---------now
00:00:20.000          *                10.000s 00:00:30.000
00:00:30.000          A1_1_1          970.000s ---------now
`,
		},
		{
			[]op{push{10, "A1"}, push{20, "A1_1"}, push{30, "A1_1_1"}, finish{99}},
			[]Interval{
				{"root", 0, sec(0), sec(98)},
				{"A1", 1, sec(9), sec(98)},
				{"A1_1", 2, sec(19), sec(98)},
				{"A1_1_1", 3, sec(29), sec(98)},
			},
			`
00:00:01.000 root            98.000s          00:01:39.000
00:00:01.000    *                9.000s       00:00:10.000
00:00:10.000    A1              89.000s       00:01:39.000
00:00:10.000       *               10.000s    00:00:20.000
00:00:20.000       A1_1            79.000s    00:01:39.000
00:00:20.000          *               10.000s 00:00:30.000
00:00:30.000          A1_1_1          69.000s 00:01:39.000
`,
		},
		{
			[]op{push{10, "A1"}, push{20, "A1_1"}, push{30, "A1_1_1"}, pop{40}, finish{99}},
			[]Interval{
				{"root", 0, sec(0), sec(98)},
				{"A1", 1, sec(9), sec(98)},
				{"A1_1", 2, sec(19), sec(98)},
				{"A1_1_1", 3, sec(29), sec(39)},
			},
			`
00:00:01.000 root            98.000s          00:01:39.000
00:00:01.000    *                9.000s       00:00:10.000
00:00:10.000    A1              89.000s       00:01:39.000
00:00:10.000       *               10.000s    00:00:20.000
00:00:20.000       A1_1            79.000s    00:01:39.000
00:00:20.000          *               10.000s 00:00:30.000
00:00:30.000          A1_1_1          10.000s 00:00:40.000
00:00:40.000          *               59.000s 00:01:39.000
`,
		},
		{
			[]op{push{10, "A1"}, push{20, "A1_1"}, push{30, "A1_1_1"}, pop{40}, pop{55}, finish{99}},
			[]Interval{
				{"root", 0, sec(0), sec(98)},
				{"A1", 1, sec(9), sec(98)},
				{"A1_1", 2, sec(19), sec(54)},
				{"A1_1_1", 3, sec(29), sec(39)},
			},
			`
00:00:01.000 root            98.000s          00:01:39.000
00:00:01.000    *                9.000s       00:00:10.000
00:00:10.000    A1              89.000s       00:01:39.000
00:00:10.000       *               10.000s    00:00:20.000
00:00:20.000       A1_1            35.000s    00:00:55.000
00:00:20.000          *               10.000s 00:00:30.000
00:00:30.000          A1_1_1          10.000s 00:00:40.000
00:00:40.000          *               15.000s 00:00:55.000
00:00:55.000       *               44.000s    00:01:39.000
`,
		},
		{
			[]op{push{10, "A1"}, push{20, "A1_1"}, push{30, "A1_1_1"}, pop{40}, pop{55}, pop{75}, finish{99}},
			[]Interval{
				{"root", 0, sec(0), sec(98)},
				{"A1", 1, sec(9), sec(74)},
				{"A1_1", 2, sec(19), sec(54)},
				{"A1_1_1", 3, sec(29), sec(39)},
			},
			`
00:00:01.000 root            98.000s          00:01:39.000
00:00:01.000    *                9.000s       00:00:10.000
00:00:10.000    A1              65.000s       00:01:15.000
00:00:10.000       *               10.000s    00:00:20.000
00:00:20.000       A1_1            35.000s    00:00:55.000
00:00:20.000          *               10.000s 00:00:30.000
00:00:30.000          A1_1_1          10.000s 00:00:40.000
00:00:40.000          *               15.000s 00:00:55.000
00:00:55.000       *               20.000s    00:01:15.000
00:01:15.000    *               24.000s       00:01:39.000
`,
		},
		{
			[]op{push{10, "A1"}, push{20, "A1_1"}, finish{30}, push{40, "B1"}},
			[]Interval{
				{"root", 0, sec(0), InvalidDuration},
				{"A1", 1, sec(9), sec(29)},
				{"A1_1", 2, sec(19), sec(29)},
				{"B1", 1, sec(39), InvalidDuration},
			},
			`
00:00:01.000 root       999.000s       ---------now
00:00:01.000    *            9.000s    00:00:10.000
00:00:10.000    A1          20.000s    00:00:30.000
00:00:10.000       *           10.000s 00:00:20.000
00:00:20.000       A1_1        10.000s 00:00:30.000
00:00:30.000    *           10.000s    00:00:40.000
00:00:40.000    B1         960.000s    ---------now
`,
		},
		{
			[]op{push{10, "A1"}, push{20, "A1_1"}, finish{30}, push{40, "B1"}, finish{99}},
			[]Interval{
				{"root", 0, sec(0), sec(98)},
				{"A1", 1, sec(9), sec(29)},
				{"A1_1", 2, sec(19), sec(29)},
				{"B1", 1, sec(39), sec(98)},
			},
			`
00:00:01.000 root       98.000s       00:01:39.000
00:00:01.000    *           9.000s    00:00:10.000
00:00:10.000    A1         20.000s    00:00:30.000
00:00:10.000       *          10.000s 00:00:20.000
00:00:20.000       A1_1       10.000s 00:00:30.000
00:00:30.000    *          10.000s    00:00:40.000
00:00:40.000    B1         59.000s    00:01:39.000
`,
		},
		{
			[]op{push{10, "foo"}, push{15, "foo1"}, pop{37}, push{37, "foo2"}, pop{55}, pop{55}, push{55, "bar"}, pop{80}, push{80, "baz"}, pop{99}, finish{99}},
			[]Interval{
				{"root", 0, sec(0), sec(98)},
				{"foo", 1, sec(9), sec(54)},
				{"foo1", 2, sec(14), sec(36)},
				{"foo2", 2, sec(36), sec(54)},
				{"bar", 1, sec(54), sec(79)},
				{"baz", 1, sec(79), sec(98)},
			},
			`
00:00:01.000 root       98.000s       00:01:39.000
00:00:01.000    *           9.000s    00:00:10.000
00:00:10.000    foo        45.000s    00:00:55.000
00:00:10.000       *           5.000s 00:00:15.000
00:00:15.000       foo1       22.000s 00:00:37.000
00:00:37.000       foo2       18.000s 00:00:55.000
00:00:55.000    bar        25.000s    00:01:20.000
00:01:20.000    baz        19.000s    00:01:39.000
`,
		},
		{
			[]op{push{10, "foo"}, push{15, "foo1"}, pop{30}, push{37, "foo2"}, pop{50}, pop{53}, push{55, "bar"}, pop{75}, push{80, "baz"}, pop{90}, finish{99}},
			[]Interval{
				{"root", 0, sec(0), sec(98)},
				{"foo", 1, sec(9), sec(52)},
				{"foo1", 2, sec(14), sec(29)},
				{"foo2", 2, sec(36), sec(49)},
				{"bar", 1, sec(54), sec(74)},
				{"baz", 1, sec(79), sec(89)},
			},
			`
00:00:01.000 root       98.000s       00:01:39.000
00:00:01.000    *           9.000s    00:00:10.000
00:00:10.000    foo        43.000s    00:00:53.000
00:00:10.000       *           5.000s 00:00:15.000
00:00:15.000       foo1       15.000s 00:00:30.000
00:00:30.000       *           7.000s 00:00:37.000
00:00:37.000       foo2       13.000s 00:00:50.000
00:00:50.000       *           3.000s 00:00:53.000
00:00:53.000    *           2.000s    00:00:55.000
00:00:55.000    bar        20.000s    00:01:15.000
00:01:15.000    *           5.000s    00:01:20.000
00:01:20.000    baz        10.000s    00:01:30.000
00:01:30.000    *           9.000s    00:01:39.000
`,
		},
	}
	for _, test := range tests {
		// Run all ops.
		now := &fakeNow{1}
		nowFunc = now.Now
		timer := NewTimer("root")
		for _, op := range test.ops {
			op.run(now, timer)
		}
		name := fmt.Sprintf("%#v", test.ops)
		// Check all intervals.
		if got, want := timer.Intervals, test.intervals; !reflect.DeepEqual(got, want) {
			t.Errorf("%s got intervals %v, want %v", name, got, want)
		}
		// Check string output.
		now.now = 1000
		if got, want := timer.String(), strings.TrimLeft(test.str, "\n"); got != want {
			t.Errorf("%s GOT STRING\n%sWANT\n%s", name, got, want)
		}
		// Check print output hiding all gaps.
		var buf bytes.Buffer
		printer := IntervalPrinter{Zero: timer.Zero, MinGap: time.Hour}
		if err := printer.Print(&buf, timer.Intervals, nowFunc().Sub(timer.Zero)); err != nil {
			t.Errorf("%s got printer error: %v", name, err)
		}
		if got, want := buf.String(), stripGaps(test.str); got != want {
			t.Errorf("%s GOT PRINT\n%sWANT\n%s", name, got, want)
		}
	}
	nowFunc = time.Now
}

// TestIntervalPrinterCornerCases tests corner cases for the printer.  These are
// all cases where only a subset of the full Timer intervals is printed.
func TestIntervalPrinterCornerCases(t *testing.T) {
	tests := []struct {
		intervals []Interval
		str       string
	}{
		{
			[]Interval{{"abc", 1, sec(9), InvalidDuration}},
			`
00:00:01.000 *     9.000s 00:00:10.000
00:00:10.000 abc 990.000s ---------now
`,
		},
		{
			[]Interval{{"abc", 1, sec(9), sec(98)}},
			`
00:00:01.000 *    9.000s 00:00:10.000
00:00:10.000 abc 89.000s 00:01:39.000
`,
		},
		{
			[]Interval{
				{"A1", 1, sec(9), InvalidDuration},
				{"A1_1", 2, sec(19), InvalidDuration},
			},
			`
00:00:01.000 *         9.000s    00:00:10.000
00:00:10.000 A1      990.000s    ---------now
00:00:10.000    *        10.000s 00:00:20.000
00:00:20.000    A1_1    980.000s ---------now
`,
		},
		{
			[]Interval{
				{"A1", 1, sec(9), InvalidDuration},
				{"A1_1", 2, sec(19), sec(49)},
			},
			`
00:00:01.000 *         9.000s    00:00:10.000
00:00:10.000 A1      990.000s    ---------now
00:00:10.000    *        10.000s 00:00:20.000
00:00:20.000    A1_1     30.000s 00:00:50.000
00:00:50.000    *       950.000s ---------now
`,
		},
		{
			[]Interval{
				{"A1", 1, sec(9), sec(98)},
				{"A1_1", 2, sec(19), sec(49)},
			},
			`
00:00:01.000 *        9.000s    00:00:10.000
00:00:10.000 A1      89.000s    00:01:39.000
00:00:10.000    *       10.000s 00:00:20.000
00:00:20.000    A1_1    30.000s 00:00:50.000
00:00:50.000    *       49.000s 00:01:39.000
`,
		},
		{
			[]Interval{
				{"A1_1", 2, sec(9), sec(19)},
				{"B1", 1, sec(39), InvalidDuration},
			},
			`
00:00:01.000    *         9.000s 00:00:10.000
00:00:10.000    A1_1     10.000s 00:00:20.000
00:00:20.000    *        20.000s 00:00:40.000
00:00:40.000 B1      960.000s    ---------now
`,
		},
		{
			[]Interval{
				{"A1_1", 2, sec(9), sec(19)},
				{"B1", 1, sec(39), sec(64)},
			},
			`
00:00:01.000    *        9.000s 00:00:10.000
00:00:10.000    A1_1    10.000s 00:00:20.000
00:00:20.000    *       20.000s 00:00:40.000
00:00:40.000 B1      25.000s    00:01:05.000
`,
		},
		{
			[]Interval{
				{"A1_1", 2, sec(9), sec(19)},
				{"B1", 1, sec(39), sec(64)},
				{"C1", 1, sec(69), sec(84)},
			},
			`
00:00:01.000    *        9.000s 00:00:10.000
00:00:10.000    A1_1    10.000s 00:00:20.000
00:00:20.000    *       20.000s 00:00:40.000
00:00:40.000 B1      25.000s    00:01:05.000
00:01:05.000 *        5.000s    00:01:10.000
00:01:10.000 C1      15.000s    00:01:25.000
`,
		},
		{
			[]Interval{
				{"A1_1", 2, sec(9), sec(19)},
				{"B1", 1, sec(39), sec(84)},
				{"B1_1", 2, sec(64), sec(69)},
			},
			`
00:00:01.000    *        9.000s 00:00:10.000
00:00:10.000    A1_1    10.000s 00:00:20.000
00:00:20.000    *       20.000s 00:00:40.000
00:00:40.000 B1      45.000s    00:01:25.000
00:00:40.000    *       25.000s 00:01:05.000
00:01:05.000    B1_1     5.000s 00:01:10.000
00:01:10.000    *       15.000s 00:01:25.000
`,
		},
		{
			[]Interval{
				{"A1_1", 2, sec(9), sec(19)},
				{"B1", 1, sec(39), sec(89)},
				{"B1_1", 2, sec(64), sec(69)},
				{"B1_2", 2, sec(79), sec(87)},
			},
			`
00:00:01.000    *        9.000s 00:00:10.000
00:00:10.000    A1_1    10.000s 00:00:20.000
00:00:20.000    *       20.000s 00:00:40.000
00:00:40.000 B1      50.000s    00:01:30.000
00:00:40.000    *       25.000s 00:01:05.000
00:01:05.000    B1_1     5.000s 00:01:10.000
00:01:10.000    *       10.000s 00:01:20.000
00:01:20.000    B1_2     8.000s 00:01:28.000
00:01:28.000    *        2.000s 00:01:30.000
`,
		},
		{
			[]Interval{
				{"A1_1_1", 3, sec(9), sec(19)},
				{"B1", 1, sec(39), InvalidDuration},
			},
			`
00:00:01.000       *              9.000s 00:00:10.000
00:00:10.000       A1_1_1        10.000s 00:00:20.000
00:00:20.000       *             20.000s 00:00:40.000
00:00:40.000 B1           960.000s       ---------now
`,
		},
		{
			[]Interval{
				{"A1_1_1", 3, sec(9), sec(19)},
				{"B1", 1, sec(39), sec(64)},
			},
			`
00:00:01.000       *             9.000s 00:00:10.000
00:00:10.000       A1_1_1       10.000s 00:00:20.000
00:00:20.000       *            20.000s 00:00:40.000
00:00:40.000 B1           25.000s       00:01:05.000
`,
		},
		{
			[]Interval{
				{"A1_1_1", 3, sec(9), sec(19)},
				{"B1", 1, sec(39), sec(64)},
				{"C1", 1, sec(69), sec(84)},
			},
			`
00:00:01.000       *             9.000s 00:00:10.000
00:00:10.000       A1_1_1       10.000s 00:00:20.000
00:00:20.000       *            20.000s 00:00:40.000
00:00:40.000 B1           25.000s       00:01:05.000
00:01:05.000 *             5.000s       00:01:10.000
00:01:10.000 C1           15.000s       00:01:25.000
`,
		},
		{
			[]Interval{
				{"A1_1_1", 3, sec(9), sec(19)},
				{"B1", 1, sec(39), sec(84)},
				{"B1_1", 2, sec(59), sec(69)},
			},
			`
00:00:01.000       *             9.000s 00:00:10.000
00:00:10.000       A1_1_1       10.000s 00:00:20.000
00:00:20.000       *            20.000s 00:00:40.000
00:00:40.000 B1           45.000s       00:01:25.000
00:00:40.000    *            20.000s    00:01:00.000
00:01:00.000    B1_1         10.000s    00:01:10.000
00:01:10.000    *            15.000s    00:01:25.000
`,
		},
		{
			[]Interval{
				{"A1_1", 2, sec(9), sec(84)},
				{"A1_1_1", 3, sec(39), sec(79)},
				{"A1_1_1_1", 4, sec(54), sec(69)},
				{"B1", 1, sec(89), sec(99)},
			},
			`
00:00:01.000    *                  9.000s       00:00:10.000
00:00:10.000    A1_1              75.000s       00:01:25.000
00:00:10.000       *                 30.000s    00:00:40.000
00:00:40.000       A1_1_1            40.000s    00:01:20.000
00:00:40.000          *                 15.000s 00:00:55.000
00:00:55.000          A1_1_1_1          15.000s 00:01:10.000
00:01:10.000          *                 10.000s 00:01:20.000
00:01:20.000       *                  5.000s    00:01:25.000
00:01:25.000    *                  5.000s       00:01:30.000
00:01:30.000 B1                10.000s          00:01:40.000
`,
		},
	}
	for _, test := range tests {
		name := fmt.Sprintf("%#v", test.intervals)
		// Check print output with gaps.
		var buf bytes.Buffer
		printer := IntervalPrinter{Zero: tsec(1)}
		if err := printer.Print(&buf, test.intervals, sec(999)); err != nil {
			t.Errorf("%s got printer error: %v", name, err)
		}
		if got, want := buf.String(), strings.TrimLeft(test.str, "\n"); got != want {
			t.Errorf("%s GOT STRING\n%sWANT\n%s", name, got, want)
		}
	}
}

func BenchmarkTimerPush(b *testing.B) {
	t := NewTimer("root")
	for i := 0; i < b.N; i++ {
		t.Push("child")
	}
}

func BenchmarkTimerPushPop(b *testing.B) {
	t := NewTimer("root")
	for i := 0; i < b.N; i++ {
		timerPushPop(t)
	}
}
func timerPushPop(t *Timer) {
	t.Push("child1")
	t.Pop()
	t.Push("child2")
	t.Push("child2_1")
	t.Pop()
	t.Push("child2_2")
	t.Pop()
	t.Pop()
	t.Push("child3")
	t.Pop()
}

var randSource = rand.NewSource(123)

func BenchmarkTimerRandom(b *testing.B) {
	t, rng := NewTimer("root"), rand.New(randSource)
	for i := 0; i < b.N; i++ {
		timerRandom(rng, t)
	}
}
func timerRandom(rng *rand.Rand, t *Timer) {
	switch pct := rng.Intn(100); {
	case pct < 60:
		timerPushPop(t)
	case pct < 90:
		t.Push("foo")
	case pct < 99:
		t.Pop()
	default:
		t.Finish()
	}
}

func BenchmarkTimerString(b *testing.B) {
	t, rng, now := NewTimer("root"), rand.New(randSource), &stepNow{0}
	nowFunc = now.Now
	for i := 0; i < 1000; i++ {
		timerRandom(rng, t)
	}
	t.Finish() // Make sure all intervals are closed.
	want := t.String()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		if got := t.String(); got != want {
			b.Fatalf("GOT\n%sWANT\n%s\nTIMER\n%#v", got, want, t)
		}
	}
	nowFunc = time.Now
}