mv tmlibs files to libs dir

libs/common/repeat_timer_test.go

@@ -0,0 +1,137 @@
+package common
+
+import (
+	"math/rand"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/fortytw2/leaktest"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDefaultTicker(t *testing.T) {
+	ticker := defaultTickerMaker(time.Millisecond * 10)
+	<-ticker.Chan()
+	ticker.Stop()
+}
+
+func TestRepeatTimer(t *testing.T) {
+
+	ch := make(chan time.Time, 100)
+	mtx := new(sync.Mutex)
+
+	// tick() fires from start to end
+	// (exclusive) in milliseconds with incr.
+	// It locks on mtx, so subsequent calls
+	// run in series.
+	tick := func(startMs, endMs, incrMs time.Duration) {
+		mtx.Lock()
+		go func() {
+			for tMs := startMs; tMs < endMs; tMs += incrMs {
+				lt := time.Time{}
+				lt = lt.Add(tMs * time.Millisecond)
+				ch <- lt
+			}
+			mtx.Unlock()
+		}()
+	}
+
+	// tock consumes Ticker.Chan() events and checks them against the ms in "timesMs".
+	tock := func(t *testing.T, rt *RepeatTimer, timesMs []int64) {
+
+		// Check against timesMs.
+		for _, timeMs := range timesMs {
+			tyme := <-rt.Chan()
+			sinceMs := tyme.Sub(time.Time{}) / time.Millisecond
+			assert.Equal(t, timeMs, int64(sinceMs))
+		}
+
+		// TODO detect number of running
+		// goroutines to ensure that
+		// no other times will fire.
+		// See https://github.com/tendermint/tmlibs/issues/120.
+		time.Sleep(time.Millisecond * 100)
+		done := true
+		select {
+		case <-rt.Chan():
+			done = false
+		default:
+		}
+		assert.True(t, done)
+	}
+
+	tm := NewLogicalTickerMaker(ch)
+	rt := NewRepeatTimerWithTickerMaker("bar", time.Second, tm)
+
+	/* NOTE: Useful for debugging deadlocks...
+	go func() {
+		time.Sleep(time.Second * 3)
+		trace := make([]byte, 102400)
+		count := runtime.Stack(trace, true)
+		fmt.Printf("Stack of %d bytes: %s\n", count, trace)
+	}()
+	*/
+
+	tick(0, 1000, 10)
+	tock(t, rt, []int64{})
+	tick(1000, 2000, 10)
+	tock(t, rt, []int64{1000})
+	tick(2005, 5000, 10)
+	tock(t, rt, []int64{2005, 3005, 4005})
+	tick(5001, 5999, 1)
+	// Read 5005 instead of 5001 because
+	// it's 1 second greater than 4005.
+	tock(t, rt, []int64{5005})
+	tick(6000, 7005, 1)
+	tock(t, rt, []int64{6005})
+	tick(7033, 8032, 1)
+	tock(t, rt, []int64{7033})
+
+	// After a reset, nothing happens
+	// until two ticks are received.
+	rt.Reset()
+	tock(t, rt, []int64{})
+	tick(8040, 8041, 1)
+	tock(t, rt, []int64{})
+	tick(9555, 9556, 1)
+	tock(t, rt, []int64{9555})
+
+	// After a stop, nothing more is sent.
+	rt.Stop()
+	tock(t, rt, []int64{})
+
+	// Another stop panics.
+	assert.Panics(t, func() { rt.Stop() })
+}
+
+func TestRepeatTimerReset(t *testing.T) {
+	// check that we are not leaking any go-routines
+	defer leaktest.Check(t)()
+
+	timer := NewRepeatTimer("test", 20*time.Millisecond)
+	defer timer.Stop()
+
+	// test we don't receive tick before duration ms.
+	select {
+	case <-timer.Chan():
+		t.Fatal("did not expect to receive tick")
+	default:
+	}
+
+	timer.Reset()
+
+	// test we receive tick after Reset is called
+	select {
+	case <-timer.Chan():
+		// all good
+	case <-time.After(40 * time.Millisecond):
+		t.Fatal("expected to receive tick after reset")
+	}
+
+	// just random calls
+	for i := 0; i < 100; i++ {
+		time.Sleep(time.Duration(rand.Intn(40)) * time.Millisecond)
+		timer.Reset()
+	}
+}