You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
141 lines
3.2 KiB
141 lines
3.2 KiB
package cursor_test
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/tendermint/tendermint/internal/eventlog/cursor"
|
|
)
|
|
|
|
func mustParse(t *testing.T, s string) cursor.Cursor {
|
|
t.Helper()
|
|
var c cursor.Cursor
|
|
if err := c.UnmarshalText([]byte(s)); err != nil {
|
|
t.Fatalf("Unmarshal %q: unexpected error: %v", s, err)
|
|
}
|
|
return c
|
|
}
|
|
|
|
func TestSource_counter(t *testing.T) {
|
|
src := &cursor.Source{
|
|
TimeIndex: func() int64 { return 255 },
|
|
}
|
|
for i := 1; i <= 5; i++ {
|
|
want := fmt.Sprintf("00000000000000ff-%04x", i)
|
|
got := src.Cursor().String()
|
|
if got != want {
|
|
t.Errorf("Cursor %d: got %q, want %q", i, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSource_timeIndex(t *testing.T) {
|
|
times := []int64{0, 1, 100, 65535, 0x76543210fecdba98}
|
|
src := &cursor.Source{
|
|
TimeIndex: func() int64 {
|
|
out := times[0]
|
|
times = append(times[1:], out)
|
|
return out
|
|
},
|
|
Counter: 160,
|
|
}
|
|
results := []string{
|
|
"0000000000000000-00a1",
|
|
"0000000000000001-00a2",
|
|
"0000000000000064-00a3",
|
|
"000000000000ffff-00a4",
|
|
"76543210fecdba98-00a5",
|
|
}
|
|
for i, want := range results {
|
|
if got := src.Cursor().String(); got != want {
|
|
t.Errorf("Cursor %d: got %q, want %q", i+1, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCursor_roundTrip(t *testing.T) {
|
|
const text = `0123456789abcdef-fce9`
|
|
|
|
c := mustParse(t, text)
|
|
if got := c.String(); got != text {
|
|
t.Errorf("Wrong string format: got %q, want %q", got, text)
|
|
}
|
|
cmp, err := c.MarshalText()
|
|
if err != nil {
|
|
t.Fatalf("Marshal %+v failed: %v", c, err)
|
|
}
|
|
if got := string(cmp); got != text {
|
|
t.Errorf("Wrong text format: got %q, want %q", got, text)
|
|
}
|
|
}
|
|
|
|
func TestCursor_ordering(t *testing.T) {
|
|
// Condition: text1 precedes text2 in time order.
|
|
// Condition: text2 has an earlier sequence than text1.
|
|
const zero = ""
|
|
const text1 = "0000000012345678-0005"
|
|
const text2 = "00000000fecdeba9-0002"
|
|
|
|
zc := mustParse(t, zero)
|
|
c1 := mustParse(t, text1)
|
|
c2 := mustParse(t, text2)
|
|
|
|
// Confirm for all pairs that string order respects time order.
|
|
pairs := []struct {
|
|
t1, t2 string
|
|
c1, c2 cursor.Cursor
|
|
}{
|
|
{zero, zero, zc, zc},
|
|
{zero, text1, zc, c1},
|
|
{zero, text2, zc, c2},
|
|
{text1, zero, c1, zc},
|
|
{text1, text1, c1, c1},
|
|
{text1, text2, c1, c2},
|
|
{text2, zero, c2, zc},
|
|
{text2, text1, c2, c1},
|
|
{text2, text2, c2, c2},
|
|
}
|
|
for _, pair := range pairs {
|
|
want := pair.t1 < pair.t2
|
|
if got := pair.c1.Before(pair.c2); got != want {
|
|
t.Errorf("(%s).Before(%s): got %v, want %v", pair.t1, pair.t2, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCursor_IsZero(t *testing.T) {
|
|
tests := []struct {
|
|
text string
|
|
want bool
|
|
}{
|
|
{"", true},
|
|
{"0000000000000000-0000", true},
|
|
{"0000000000000001-0000", false},
|
|
{"0000000000000000-0001", false},
|
|
{"0000000000000001-0001", false},
|
|
}
|
|
for _, test := range tests {
|
|
c := mustParse(t, test.text)
|
|
if got := c.IsZero(); got != test.want {
|
|
t.Errorf("IsZero(%q): got %v, want %v", test.text, got, test.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCursor_Diff(t *testing.T) {
|
|
const time1 = 0x1ac0193001
|
|
const time2 = 0x0ac0193001
|
|
|
|
text1 := fmt.Sprintf("%016x-0001", time1)
|
|
text2 := fmt.Sprintf("%016x-0005", time2)
|
|
want := time.Duration(time1 - time2)
|
|
|
|
c1 := mustParse(t, text1)
|
|
c2 := mustParse(t, text2)
|
|
|
|
got := c1.Diff(c2)
|
|
if got != want {
|
|
t.Fatalf("Diff %q - %q: got %v, want %v", text1, text2, got, want)
|
|
}
|
|
}
|