2015-09-29 23:29:49 -07:00
|
|
|
package bps
|
2014-03-02 22:44:09 -08:00
|
|
|
|
|
|
|
import (
|
2015-09-29 23:29:49 -07:00
|
|
|
"bytes"
|
|
|
|
"io"
|
2014-03-02 22:44:09 -08:00
|
|
|
"log"
|
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
|
|
|
|
}
|
|
|
|
|
|
|
|
func validate(t *testing.T, actual, expected []float64) {
|
|
|
|
if len(actual) != len(expected) {
|
|
|
|
t.Errorf("len is not same: %d expected %d", len(actual), len(expected))
|
|
|
|
}
|
|
|
|
for i, _ := range actual {
|
|
|
|
if actual[i] != expected[i] {
|
|
|
|
t.Errorf("%dth: got %f expected %f", i, actual[i], expected[i])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestEmpty(t *testing.T) {
|
2015-09-29 23:29:49 -07:00
|
|
|
bw, err := New([]int{1, 10, 60}, 100*time.Second)
|
2014-03-02 22:44:09 -08:00
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
2015-09-29 23:29:49 -07:00
|
|
|
bw.timeBuckets = []int64{1, 10, 60}
|
|
|
|
validate(t, bw.Cur(), []float64{0, 0, 0})
|
|
|
|
bw.Close()
|
2014-03-02 22:44:09 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestEmptySeconds(t *testing.T) {
|
2015-09-29 23:29:49 -07:00
|
|
|
_, err := New([]int{}, 100*time.Second)
|
2014-03-02 22:44:09 -08:00
|
|
|
if err == nil {
|
2015-09-29 23:29:49 -07:00
|
|
|
t.Errorf("got no error wanted one: %v")
|
2014-03-02 22:44:09 -08:00
|
|
|
}
|
|
|
|
}
|
2014-03-08 00:45:55 -08:00
|
|
|
|
2015-09-29 23:29:49 -07:00
|
|
|
func TestTimeBucketsSize(t *testing.T) {
|
|
|
|
bw, _ := New([]int{1, 2, 5}, 1*time.Second)
|
|
|
|
if len(bw.timeBuckets) != 5 {
|
|
|
|
t.Errorf("buckets slice wrong length: %d, expected %d", len(bw.timeBuckets), 5)
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
2015-09-29 23:29:49 -07:00
|
|
|
bw.Close()
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestOnes(t *testing.T) {
|
2015-09-29 23:29:49 -07:00
|
|
|
bw, _ := New([]int{1, 2, 5}, 1*time.Second)
|
|
|
|
var i int64
|
|
|
|
for i = 0; i < bw.max; i++ {
|
|
|
|
bw.timeBuckets[i] = 1.0
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
2015-09-29 23:29:49 -07:00
|
|
|
avgs := bw.averages(bw.timeBuckets)
|
2014-03-08 18:07:43 -08:00
|
|
|
// try a large range of starting points:
|
|
|
|
for i := 0; i < 10; i++ {
|
|
|
|
bw.timeI = i
|
|
|
|
validate(t, avgs, []float64{1.0, 1.0, 1.0})
|
|
|
|
}
|
2015-09-29 23:29:49 -07:00
|
|
|
bw.Close()
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestManyOnes(t *testing.T) {
|
2015-09-29 23:29:49 -07:00
|
|
|
bw, _ := New([]int{1, 10, 60}, 1*time.Second)
|
|
|
|
var i int64
|
|
|
|
for i = 0; i < bw.max; i++ {
|
|
|
|
bw.timeBuckets[i] = 1.0
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
2015-09-29 23:29:49 -07:00
|
|
|
avgs := bw.averages(bw.timeBuckets)
|
2014-03-08 18:07:43 -08:00
|
|
|
// try a large range of starting points:
|
|
|
|
for i := -70; i < 70; i++ {
|
|
|
|
bw.timeI = i
|
|
|
|
validate(t, avgs, []float64{1.0, 1.0, 1.0})
|
|
|
|
}
|
2015-09-29 23:29:49 -07:00
|
|
|
bw.Close()
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestLinear(t *testing.T) {
|
2015-09-29 23:29:49 -07:00
|
|
|
bw, _ := New([]int{1, 10, 60}, 1*time.Second)
|
|
|
|
var i int64
|
|
|
|
for i = 0; i < bw.max; i++ {
|
|
|
|
bw.timeBuckets[i] = i
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
2015-09-29 23:29:49 -07:00
|
|
|
avgs := bw.averages(bw.timeBuckets)
|
2014-03-08 18:07:43 -08:00
|
|
|
validate(t, avgs, []float64{0.0, 4.5, 29.5})
|
2015-09-29 23:29:49 -07:00
|
|
|
bw.Close()
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestInverseLinear(t *testing.T) {
|
2015-09-29 23:29:49 -07:00
|
|
|
bw, _ := New([]int{1, 10, 60}, 1*time.Second)
|
|
|
|
var i int64
|
|
|
|
for i = 0; i < bw.max; i++ {
|
|
|
|
bw.timeBuckets[i] = bw.max - i
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
2015-09-29 23:29:49 -07:00
|
|
|
avgs := bw.averages(bw.timeBuckets)
|
2014-03-08 18:07:43 -08:00
|
|
|
validate(t, avgs, []float64{60.0, 55.5, 30.5})
|
2015-09-29 23:29:49 -07:00
|
|
|
bw.Close()
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestSpecific(t *testing.T) {
|
2015-09-29 23:29:49 -07:00
|
|
|
bw, _ := New([]int{1, 2, 10}, 1*time.Second)
|
|
|
|
bw.timeBuckets[8] = 1.0
|
2014-03-08 18:07:43 -08:00
|
|
|
var avgs []float64
|
|
|
|
|
|
|
|
bw.timeI = 8
|
2015-09-29 23:29:49 -07:00
|
|
|
avgs = bw.averages(bw.timeBuckets)
|
2014-03-08 18:07:43 -08:00
|
|
|
validate(t, avgs, []float64{1.0, 0.5, 0.1})
|
|
|
|
|
|
|
|
bw.timeI = 7
|
2015-09-29 23:29:49 -07:00
|
|
|
avgs = bw.averages(bw.timeBuckets)
|
2014-03-08 18:07:43 -08:00
|
|
|
validate(t, avgs, []float64{0.0, 0.5, 0.1})
|
|
|
|
|
|
|
|
bw.timeI = 9
|
2015-09-29 23:29:49 -07:00
|
|
|
avgs = bw.averages(bw.timeBuckets)
|
2014-03-08 18:07:43 -08:00
|
|
|
validate(t, avgs, []float64{0.0, 0.0, 0.1})
|
2015-09-29 23:29:49 -07:00
|
|
|
bw.Close()
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestWriter(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
bw, _ := New([]int{1, 10, 100}, 1*time.Second)
|
|
|
|
defer bw.Close()
|
|
|
|
b := &bytes.Buffer{}
|
|
|
|
b.Write([]byte("helloooooooooooooooooooooooooooooooooooooooooooooo"))
|
|
|
|
io.Copy(bw, b)
|
|
|
|
validate(t, bw.Cur(), []float64{50, 5, 0.5})
|
|
|
|
time.Sleep(3 * time.Second)
|
|
|
|
validate(t, bw.Cur(), []float64{0, 5, 0.5})
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestAdd(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
bw, _ := New([]int{1, 10, 100}, 1*time.Second)
|
|
|
|
bw.Add(314)
|
|
|
|
validate(t, bw.Cur(), []float64{314, 31.4, 3.14})
|
|
|
|
time.Sleep(3 * time.Second)
|
|
|
|
validate(t, bw.Cur(), []float64{0, 31.4, 3.14})
|
|
|
|
bw.Close()
|
2014-03-08 00:45:55 -08:00
|
|
|
}
|