initial import

core/timex/relativetime.go

@@ -0,0 +1,18 @@
+package timex
+
+import "time"
+
+// Use the long enough past time as start time, in case timex.Now() - lastTime equals 0.
+var initTime = time.Now().AddDate(-1, -1, -1)
+
+func Now() time.Duration {
+	return time.Since(initTime)
+}
+
+func Since(d time.Duration) time.Duration {
+	return time.Since(initTime) - d
+}
+
+func Time() time.Time {
+	return initTime.Add(Now())
+}

core/timex/relativetime_test.go

@@ -0,0 +1,25 @@
+package timex
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRelativeTime(t *testing.T) {
+	time.Sleep(time.Millisecond)
+	now := Now()
+	assert.True(t, now > 0)
+	time.Sleep(time.Millisecond)
+	assert.True(t, Since(now) > 0)
+}
+
+func TestRelativeTime_Time(t *testing.T) {
+	diff := Time().Sub(time.Now())
+	if diff > 0 {
+		assert.True(t, diff < time.Second)
+	} else {
+		assert.True(t, -diff < time.Second)
+	}
+}

core/timex/repr.go

@@ -0,0 +1,10 @@
+package timex
+
+import (
+	"fmt"
+	"time"
+)
+
+func ReprOfDuration(duration time.Duration) string {
+	return fmt.Sprintf("%.1fms", float32(duration)/float32(time.Millisecond))
+}

core/timex/repr_test.go

@@ -0,0 +1,14 @@
+package timex
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestReprOfDuration(t *testing.T) {
+	assert.Equal(t, "1000.0ms", ReprOfDuration(time.Second))
+	assert.Equal(t, "1111.6ms", ReprOfDuration(
+		time.Second+time.Millisecond*111+time.Microsecond*555))
+}

core/timex/ticker.go

@@ -0,0 +1,73 @@
+package timex
+
+import (
+	"errors"
+	"time"
+
+	"zero/core/lang"
+)
+
+type (
+	Ticker interface {
+		Chan() <-chan time.Time
+		Stop()
+	}
+
+	FakeTicker interface {
+		Ticker
+		Done()
+		Tick()
+		Wait(d time.Duration) error
+	}
+
+	fakeTicker struct {
+		c    chan time.Time
+		done chan lang.PlaceholderType
+	}
+
+	realTicker struct {
+		*time.Ticker
+	}
+)
+
+func NewTicker(d time.Duration) Ticker {
+	return &realTicker{
+		Ticker: time.NewTicker(d),
+	}
+}
+
+func (rt *realTicker) Chan() <-chan time.Time {
+	return rt.C
+}
+
+func NewFakeTicker() FakeTicker {
+	return &fakeTicker{
+		c:    make(chan time.Time, 1),
+		done: make(chan lang.PlaceholderType, 1),
+	}
+}
+
+func (ft *fakeTicker) Chan() <-chan time.Time {
+	return ft.c
+}
+
+func (ft *fakeTicker) Done() {
+	ft.done <- lang.Placeholder
+}
+
+func (ft *fakeTicker) Stop() {
+	close(ft.c)
+}
+
+func (ft *fakeTicker) Tick() {
+	ft.c <- Time()
+}
+
+func (ft *fakeTicker) Wait(d time.Duration) error {
+	select {
+	case <-time.After(d):
+		return errors.New("timeout")
+	case <-ft.done:
+		return nil
+	}
+}

core/timex/ticker_test.go

@@ -0,0 +1,46 @@
+package timex
+
+import (
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRealTickerDoTick(t *testing.T) {
+	ticker := NewTicker(time.Millisecond * 10)
+	defer ticker.Stop()
+	var count int
+	for range ticker.Chan() {
+		count++
+		if count > 5 {
+			break
+		}
+	}
+}
+
+func TestFakeTicker(t *testing.T) {
+	const total = 5
+	ticker := NewFakeTicker()
+	defer ticker.Stop()
+
+	var count int32
+	go func() {
+		for {
+			select {
+			case <-ticker.Chan():
+				if atomic.AddInt32(&count, 1) == total {
+					ticker.Done()
+				}
+			}
+		}
+	}()
+
+	for i := 0; i < 5; i++ {
+		ticker.Tick()
+	}
+
+	assert.Nil(t, ticker.Wait(time.Second))
+	assert.Equal(t, int32(total), atomic.LoadInt32(&count))
+}