times/lib_test.go

package times_test

import (
	"testing"
	"code.squareroundforest.org/arpio/times"
	"time"
	"sort"
)

func TestSys(t *testing.T) {
	t.Run("now", func(t *testing.T) {
		c := times.Sys()
		t0 := time.Now()
		tt := c.Now()
		t1 := time.Now()
		if tt.Before(t0) || tt.After(t1) {
			t.Fatal(tt)
		}
	})

	t.Run("after", func(t *testing.T) {
		c := times.Sys()
		t0 := time.Now()
		ct := c.After(time.Millisecond)
		tt := <-ct
		if tt.Before(t0.Add(time.Millisecond)) {
			t.Fatal(tt)
		}
	})
}

func TestTest(t *testing.T) {
	t.Run("now default", func(t *testing.T) {
		c := times.Test()
		t0 := c.Now()
		t1 := c.Now()
		t2 := c.Now()
		if t0.After(t1) || t1.After(t2) {
			t.Fatal(t0, t1, t2)
		}
	})

	t.Run("now custom initial", func(t *testing.T) {
		now := time.Now()
		c := times.TestFrom(now)
		t0 := c.Now()
		t1 := c.Now()
		t2 := c.Now()
		if t0.Before(now) || t0.After(t1) || t1.After(t2) {
			t.Fatal(now, t0, t1, t2)
		}
	})

	t.Run("now after pass", func(t *testing.T) {
		c := times.Test()
		t0 := c.Now()
		c.Pass(time.Millisecond)
		t1 := c.Now()
		if t1.Before(t0.Add(time.Millisecond)) {
			t.Fatal(t0, t1)
		}
	})

	t.Run("now after zero pass", func(t *testing.T) {
		c := times.Test()
		t0 := c.Now()
		c.Pass(0)
		t1 := c.Now()
		if t1.Before(t0) {
			t.Fatal(t0, t1)
		}
	})

	t.Run("now after negative pass", func(t *testing.T) {
		c := times.Test()
		t0 := c.Now()
		c.Pass(-1000)
		t1 := c.Now()
		if t1.Before(t0) {
			t.Fatal(t0, t1)
		}
	})

	t.Run("now after jump", func(t *testing.T) {
		c := times.Test()
		t0 := c.Now()
		c.Jump(t0.Add(time.Millisecond))
		t1 := c.Now()
		if t1.Before(t0.Add(time.Millisecond)) {
			t.Fatal(t0, t1)
		}
	})

	t.Run("now after jump present", func(t *testing.T) {
		c := times.Test()
		t0 := c.Now()
		c.Jump(t0)
		t1 := c.Now()
		if t1.Before(t0) {
			t.Fatal(t0, t1)
		}
	})

	t.Run("now after jump to past", func(t *testing.T) {
		c := times.Test()
		t0 := c.Now()
		c.Jump(t0.Add(-1000))
		t1 := c.Now()
		if t1.Before(t0) {
			t.Fatal(t0, t1)
		}
	})

	t.Run("after 0 default", func(t *testing.T) {
		c := times.Test()
		a := c.After(0)
		t0 := c.Now()
		tt := <-a
		t1 := c.Now()
		if t0.After(tt) || t1.Before(tt) {
			t.Fatal(t0, tt, t1)
		}
	})

	t.Run("after 0 custom initial", func(t *testing.T) {
		c := times.TestFrom(time.Now())
		a := c.After(0)
		t0 := c.Now()
		tt := <-a
		t1 := c.Now()
		if t0.After(tt) || t1.Before(tt) {
			t.Fatal(t0, tt, t1)
		}
	})

	t.Run("after negative default", func(t *testing.T) {
		c := times.Test()
		a := c.After(-1000)
		t0 := c.Now()
		tt := <-a
		t1 := c.Now()
		if t0.After(tt) || t1.Before(tt) {
			t.Fatal(t0, tt, t1)
		}
	})

	t.Run("after negative custom initial", func(t *testing.T) {
		c := times.TestFrom(time.Now())
		a := c.After(-1000)
		t0 := c.Now()
		tt := <-a
		t1 := c.Now()
		if t0.After(tt) || t1.Before(tt) {
			t.Fatal(t0, tt, t1)
		}
	})

	t.Run("after on pass", func(t *testing.T) {
		c := times.Test()
		a := c.After(2 * time.Millisecond)
		select {
		case <-a:
			t.Fatal()
		default:
		}

		c.Pass(time.Millisecond)
		select {
		case <-a:
			t.Fatal()
		default:
		}

		c.Pass(time.Millisecond)
		t0 := c.Now()
		tt := <-a
		t1 := c.Now()
		if t0.After(tt) || t1.Before(tt) {
			t.Fatal(t0, tt, t1)
		}
	})

	t.Run("after on jump", func(t *testing.T) {
		start := time.Now()
		c := times.TestFrom(start)
		a := c.After(2 * time.Millisecond)
		select {
		case <-a:
			t.Fatal()
		default:
		}

		c.Jump(start.Add(time.Millisecond))
		select {
		case <-a:
			t.Fatal()
		default:
		}

		c.Jump(start.Add(2 * time.Millisecond))
		t0 := c.Now()
		tt := <-a
		t1 := c.Now()
		if t0.After(tt) || t1.Before(tt) {
			t.Fatal(t0, tt, t1)
		}
	})

	t.Run("multiple afters set in varying order and only part trigger", func(t *testing.T) {
		initOrder := []time.Duration{2, 1, 2, 3, 2, 3}
		c := times.Test()

		var a []<-chan time.Time
		for _, d := range initOrder {
			a = append(a, c.After(d * time.Millisecond))
		}

		sort.Slice(a, func(i, j int) bool { return initOrder[i] < initOrder[j] })
		sort.Slice(initOrder, func(i, j int) bool { return initOrder[i] < initOrder[j] })

		var last time.Duration
		for len(initOrder) > 0 {
			if initOrder[0] > last {
				c.Pass((initOrder[0] - last) * time.Millisecond)
				last = initOrder[0]
			}

			<-a[0]
			a, initOrder = a[1:], initOrder[1:]
		}
	})
}