mirror of
https://github.com/ergochat/ergo.git
synced 2024-11-30 07:59:24 +01:00
276 lines
7.7 KiB
Go
276 lines
7.7 KiB
Go
// Copyright (c) 2018 Shivaram Lingamneni <slingamn@cs.stanford.edu>
|
|
// released under the MIT license
|
|
|
|
package history
|
|
|
|
import (
|
|
"reflect"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
timeFormat = "2006-01-02 15:04:05Z"
|
|
)
|
|
|
|
func betweenTimestamps(buf *Buffer, start, end time.Time, limit int) (result []Item, complete bool) {
|
|
result, complete, _ = buf.betweenHelper(Selector{Time: start}, Selector{Time: end}, time.Time{}, nil, limit)
|
|
return
|
|
}
|
|
|
|
func TestEmptyBuffer(t *testing.T) {
|
|
pastTime := easyParse(timeFormat)
|
|
|
|
buf := NewHistoryBuffer(0, 0)
|
|
|
|
buf.Add(Item{
|
|
Nick: "testnick",
|
|
})
|
|
|
|
since, complete := betweenTimestamps(buf, pastTime, time.Now(), 0)
|
|
if len(since) != 0 {
|
|
t.Error("shouldn't be able to add to disabled buf")
|
|
}
|
|
if complete {
|
|
t.Error("the empty/disabled buffer should report results as incomplete")
|
|
}
|
|
|
|
buf.Resize(1, 0)
|
|
since, complete = betweenTimestamps(buf, pastTime, time.Now(), 0)
|
|
assertEqual(complete, true, t)
|
|
assertEqual(len(since), 0, t)
|
|
buf.Add(Item{
|
|
Nick: "testnick",
|
|
})
|
|
since, complete = betweenTimestamps(buf, pastTime, time.Now(), 0)
|
|
if len(since) != 1 {
|
|
t.Error("should be able to store items in a nonempty buffer")
|
|
}
|
|
if !complete {
|
|
t.Error("results should be complete")
|
|
}
|
|
if since[0].Nick != "testnick" {
|
|
t.Error("retrived junk data")
|
|
}
|
|
|
|
buf.Add(Item{
|
|
Nick: "testnick2",
|
|
})
|
|
since, complete = betweenTimestamps(buf, pastTime, time.Now(), 0)
|
|
if len(since) != 1 {
|
|
t.Error("expect exactly 1 item")
|
|
}
|
|
if complete {
|
|
t.Error("results must be marked incomplete")
|
|
}
|
|
if since[0].Nick != "testnick2" {
|
|
t.Error("retrieved junk data")
|
|
}
|
|
assertEqual(toNicks(buf.latest(0)), []string{"testnick2"}, t)
|
|
}
|
|
|
|
func toNicks(items []Item) (result []string) {
|
|
result = make([]string, len(items))
|
|
for i, item := range items {
|
|
result[i] = item.Nick
|
|
}
|
|
return
|
|
}
|
|
|
|
func easyParse(timestamp string) time.Time {
|
|
result, err := time.Parse(timeFormat, timestamp)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func easyItem(nick string, timestamp string) (result Item) {
|
|
result.Message.Time = easyParse(timestamp)
|
|
result.Nick = nick
|
|
return
|
|
}
|
|
|
|
func assertEqual(supplied, expected interface{}, t *testing.T) {
|
|
if !reflect.DeepEqual(supplied, expected) {
|
|
t.Errorf("expected %v but got %v", expected, supplied)
|
|
}
|
|
}
|
|
|
|
func TestBuffer(t *testing.T) {
|
|
start := easyParse("2006-01-01 00:00:00Z")
|
|
|
|
buf := NewHistoryBuffer(3, 0)
|
|
buf.Add(easyItem("testnick0", "2006-01-01 15:04:05Z"))
|
|
|
|
buf.Add(easyItem("testnick1", "2006-01-02 15:04:05Z"))
|
|
|
|
buf.Add(easyItem("testnick2", "2006-01-03 15:04:05Z"))
|
|
|
|
since, complete := betweenTimestamps(buf, start, time.Now(), 0)
|
|
assertEqual(complete, true, t)
|
|
assertEqual(toNicks(since), []string{"testnick0", "testnick1", "testnick2"}, t)
|
|
|
|
// add another item, evicting the first
|
|
buf.Add(easyItem("testnick3", "2006-01-04 15:04:05Z"))
|
|
|
|
since, complete = betweenTimestamps(buf, start, time.Now(), 0)
|
|
assertEqual(complete, false, t)
|
|
assertEqual(toNicks(since), []string{"testnick1", "testnick2", "testnick3"}, t)
|
|
// now exclude the time of the discarded entry; results should be complete again
|
|
since, complete = betweenTimestamps(buf, easyParse("2006-01-02 00:00:00Z"), time.Now(), 0)
|
|
assertEqual(complete, true, t)
|
|
assertEqual(toNicks(since), []string{"testnick1", "testnick2", "testnick3"}, t)
|
|
since, complete = betweenTimestamps(buf, easyParse("2006-01-02 00:00:00Z"), easyParse("2006-01-03 00:00:00Z"), 0)
|
|
assertEqual(complete, true, t)
|
|
assertEqual(toNicks(since), []string{"testnick1"}, t)
|
|
|
|
// shrink the buffer, cutting off testnick1
|
|
buf.Resize(2, 0)
|
|
since, complete = betweenTimestamps(buf, easyParse("2006-01-02 00:00:00Z"), time.Now(), 0)
|
|
assertEqual(complete, false, t)
|
|
assertEqual(toNicks(since), []string{"testnick2", "testnick3"}, t)
|
|
|
|
buf.Resize(5, 0)
|
|
buf.Add(easyItem("testnick4", "2006-01-05 15:04:05Z"))
|
|
buf.Add(easyItem("testnick5", "2006-01-06 15:04:05Z"))
|
|
buf.Add(easyItem("testnick6", "2006-01-07 15:04:05Z"))
|
|
since, complete = betweenTimestamps(buf, easyParse("2006-01-03 00:00:00Z"), time.Now(), 0)
|
|
assertEqual(complete, true, t)
|
|
assertEqual(toNicks(since), []string{"testnick2", "testnick3", "testnick4", "testnick5", "testnick6"}, t)
|
|
|
|
// test ascending order
|
|
since, _ = betweenTimestamps(buf, easyParse("2006-01-03 00:00:00Z"), time.Time{}, 2)
|
|
assertEqual(toNicks(since), []string{"testnick2", "testnick3"}, t)
|
|
}
|
|
|
|
func autoItem(id int, t time.Time) (result Item) {
|
|
result.Message.Time = t
|
|
result.Nick = strconv.Itoa(id)
|
|
result.Message.Msgid = result.Nick
|
|
return
|
|
}
|
|
|
|
func atoi(s string) int {
|
|
result, err := strconv.Atoi(s)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func TestAutoresize(t *testing.T) {
|
|
now := easyParse("2006-01-01 00:00:00Z")
|
|
nowFunc := func() time.Time {
|
|
return now
|
|
}
|
|
|
|
buf := NewHistoryBuffer(128, time.Hour)
|
|
buf.nowFunc = nowFunc
|
|
|
|
// add items slowly (one every 10 minutes): the buffer should not expand
|
|
// beyond initialAutoSize
|
|
id := 0
|
|
for i := 0; i < 72; i += 1 {
|
|
buf.Add(autoItem(id, now))
|
|
if initialAutoSize < buf.length() {
|
|
t.Errorf("buffer incorrectly resized above %d to %d", initialAutoSize, buf.length())
|
|
}
|
|
now = now.Add(time.Minute * 10)
|
|
id += 1
|
|
}
|
|
items := buf.latest(0)
|
|
assertEqual(len(items), initialAutoSize, t)
|
|
assertEqual(atoi(items[0].Nick), 40, t)
|
|
assertEqual(atoi(items[len(items)-1].Nick), 71, t)
|
|
|
|
// dump 100 items in very fast:
|
|
for i := 0; i < 100; i += 1 {
|
|
buf.Add(autoItem(id, now))
|
|
now = now.Add(time.Second)
|
|
id += 1
|
|
}
|
|
// ok, 5 items from the first batch are still in the 1-hour window;
|
|
// we should overwrite until only those 5 are left, then start expanding
|
|
// the buffer so that it retains those 5 and the 100 new items
|
|
items = buf.latest(0)
|
|
assertEqual(len(items), 105, t)
|
|
assertEqual(atoi(items[0].Nick), 67, t)
|
|
assertEqual(atoi(items[len(items)-1].Nick), 171, t)
|
|
|
|
// another 100 items very fast:
|
|
for i := 0; i < 100; i += 1 {
|
|
buf.Add(autoItem(id, now))
|
|
now = now.Add(time.Second)
|
|
id += 1
|
|
}
|
|
// should fill up to the maximum size of 128 and start overwriting
|
|
items = buf.latest(0)
|
|
assertEqual(len(items), 128, t)
|
|
assertEqual(atoi(items[0].Nick), 144, t)
|
|
assertEqual(atoi(items[len(items)-1].Nick), 271, t)
|
|
}
|
|
|
|
// regression test for #702
|
|
func TestEnabledByResize(t *testing.T) {
|
|
now := easyParse("2006-01-01 00:00:00Z")
|
|
// empty/disabled autoresizing buffer
|
|
buf := NewHistoryBuffer(0, time.Hour)
|
|
// enable the buffer as during a rehash
|
|
buf.Resize(128, time.Hour)
|
|
// add an item and test that it is stored and retrievable
|
|
buf.Add(autoItem(0, now))
|
|
items := buf.latest(0)
|
|
assertEqual(len(items), 1, t)
|
|
assertEqual(atoi(items[0].Nick), 0, t)
|
|
}
|
|
|
|
func TestDisabledByResize(t *testing.T) {
|
|
now := easyParse("2006-01-01 00:00:00Z")
|
|
// enabled autoresizing buffer
|
|
buf := NewHistoryBuffer(128, time.Hour)
|
|
buf.Add(autoItem(0, now))
|
|
items := buf.latest(0)
|
|
assertEqual(len(items), 1, t)
|
|
assertEqual(atoi(items[0].Nick), 0, t)
|
|
|
|
// disable as during a rehash, confirm that nothing can be retrieved
|
|
buf.Resize(0, time.Hour)
|
|
items = buf.latest(0)
|
|
assertEqual(len(items), 0, t)
|
|
}
|
|
|
|
func TestRoundUp(t *testing.T) {
|
|
assertEqual(roundUpToPowerOfTwo(2), 2, t)
|
|
assertEqual(roundUpToPowerOfTwo(3), 4, t)
|
|
assertEqual(roundUpToPowerOfTwo(64), 64, t)
|
|
assertEqual(roundUpToPowerOfTwo(65), 128, t)
|
|
assertEqual(roundUpToPowerOfTwo(100), 128, t)
|
|
assertEqual(roundUpToPowerOfTwo(1000), 1024, t)
|
|
assertEqual(roundUpToPowerOfTwo(1025), 2048, t)
|
|
assertEqual(roundUpToPowerOfTwo(269435457), 536870912, t)
|
|
}
|
|
|
|
func BenchmarkInsert(b *testing.B) {
|
|
buf := NewHistoryBuffer(1024, 0)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
buf.Add(Item{})
|
|
}
|
|
}
|
|
|
|
func BenchmarkMatch(b *testing.B) {
|
|
buf := NewHistoryBuffer(1024, 0)
|
|
var now time.Time
|
|
for i := 0; i < 1024; i += 1 {
|
|
buf.Add(autoItem(i, now))
|
|
now = now.Add(time.Second)
|
|
}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
buf.lookup("512")
|
|
}
|
|
}
|