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)
|
|
|
|
}
|
|
|
|
|
2015-09-30 22:57:14 -07:00
|
|
|
func TestSimple(t *testing.T) {
|
2015-10-04 15:47:24 -07:00
|
|
|
bw, err := New(1 * time.Second)
|
2014-03-02 22:44:09 -08:00
|
|
|
if err != nil {
|
2015-09-30 22:57:14 -07:00
|
|
|
t.Fatalf("failure to make reasonable BPS: %v", err)
|
2014-03-02 22:44:09 -08:00
|
|
|
}
|
2015-09-29 23:29:49 -07:00
|
|
|
bw.Close()
|
2014-03-02 22:44:09 -08:00
|
|
|
}
|
|
|
|
|
2015-09-30 22:57:14 -07:00
|
|
|
func TestBadResolution(t *testing.T) {
|
2015-10-19 22:51:17 -07:00
|
|
|
var i uint
|
|
|
|
for i = 0; i < minResolution; i++ {
|
|
|
|
_, err := NewPrecise(1*time.Second, i)
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("expected an error, got nil for %d", i)
|
|
|
|
}
|
2014-03-02 22:44:09 -08:00
|
|
|
}
|
|
|
|
}
|
2014-03-08 00:45:55 -08:00
|
|
|
|
2015-09-30 22:57:14 -07:00
|
|
|
func TestWriter(t *testing.T) {
|
|
|
|
t.Parallel()
|
2015-10-04 15:47:24 -07:00
|
|
|
bw, err := New(1 * time.Second)
|
2015-09-30 22:57:14 -07:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failure to make reasonable BPS: %v", err)
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
2015-09-30 22:57:14 -07:00
|
|
|
b := &bytes.Buffer{}
|
|
|
|
b.Write([]byte("helloooooooooooooooooooooooooooooooooooooooooooooo"))
|
|
|
|
for i := 0; i < 90; i++ {
|
|
|
|
io.Copy(bw, b)
|
|
|
|
last := bw.Rate()
|
|
|
|
time.Sleep(10 * time.Millisecond)
|
|
|
|
if last > bw.Rate() {
|
|
|
|
t.Errorf("rate should be increasing, it isn't: last: %f > current: %f", last, bw.Rate())
|
|
|
|
}
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
2015-09-30 22:57:14 -07:00
|
|
|
time.Sleep(2 * time.Second)
|
|
|
|
for i := 0; i < 100; i++ {
|
|
|
|
if bw.Rate() > 0 {
|
|
|
|
t.Errorf("got high rate: got, want 0.0000", bw.Rate())
|
|
|
|
}
|
|
|
|
time.Sleep(9 * time.Millisecond)
|
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
|
|
|
}
|
|
|
|
|
2015-09-30 22:57:14 -07:00
|
|
|
func TestAdd(t *testing.T) {
|
|
|
|
t.Parallel()
|
2015-10-04 15:47:24 -07:00
|
|
|
bw, err := New(1 * time.Second)
|
2015-09-30 22:57:14 -07:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failure to make reasonable BPS: %v", err)
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
2015-09-30 22:57:14 -07:00
|
|
|
for i := 0; i < 90; i++ {
|
|
|
|
bw.Add(1024)
|
|
|
|
last := bw.Rate()
|
|
|
|
time.Sleep(10 * time.Millisecond)
|
|
|
|
if last > bw.Rate() {
|
|
|
|
t.Errorf("rate should be increasing, it isn't: last: %f > current: %f", last, bw.Rate())
|
|
|
|
}
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
2015-09-30 22:57:14 -07:00
|
|
|
time.Sleep(2 * time.Second)
|
|
|
|
for i := 0; i < 100; i++ {
|
|
|
|
if bw.Rate() > 0 {
|
|
|
|
t.Errorf("got high rate: got, want 0.0000", bw.Rate())
|
|
|
|
}
|
|
|
|
time.Sleep(9 * time.Millisecond)
|
2014-03-08 18:07:43 -08:00
|
|
|
}
|
2015-09-29 23:29:49 -07:00
|
|
|
bw.Close()
|
2014-03-08 00:45:55 -08:00
|
|
|
}
|
2015-09-30 23:07:41 -07:00
|
|
|
|
|
|
|
func TestHumanBytes(t *testing.T) {
|
|
|
|
t.Parallel()
|
2015-10-04 15:47:24 -07:00
|
|
|
bw, err := NewPrecise(100*time.Second, 10)
|
2015-09-30 23:07:41 -07:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failure to make reasonable BPS: %v", err)
|
|
|
|
}
|
|
|
|
bw.Add(1000)
|
|
|
|
got := bw.HumanRate()
|
|
|
|
want := "10B/s"
|
|
|
|
if got != want {
|
|
|
|
t.Fatalf("did not get right human rate; got %v, want %v", got, want)
|
|
|
|
}
|
|
|
|
}
|
2015-10-28 21:46:20 -07:00
|
|
|
|
2015-10-31 16:16:27 -07:00
|
|
|
// TestSparkBadBucketCounts just makes sure that bad inputs are reported
|
|
|
|
func TestSparkBadBucketCounts(t *testing.T) {
|
2015-10-28 21:46:20 -07:00
|
|
|
bw := BPS{
|
|
|
|
buckets: make([]int64, 10),
|
|
|
|
}
|
2015-10-31 16:16:27 -07:00
|
|
|
sizes := []int{-10, -1, 0, 11, 12, 100, 1000}
|
|
|
|
for _, size := range sizes {
|
|
|
|
got := bw.Sparkline(size)
|
|
|
|
want := "bucket count inappropriate"
|
|
|
|
if got != want {
|
|
|
|
t.Fatalf("got: %v, want: %v", got, want)
|
|
|
|
}
|
2015-10-28 21:46:20 -07:00
|
|
|
}
|
2015-10-31 16:16:27 -07:00
|
|
|
}
|
2015-10-28 21:46:20 -07:00
|
|
|
|
2015-10-31 16:16:27 -07:00
|
|
|
// TestSparkline just creates a simple BPS and traverses all reasonable count
|
|
|
|
// sizes. It's primarily a test for panics which plagued us early on.
|
|
|
|
func TestSparkline(t *testing.T) {
|
|
|
|
buckets := 20
|
|
|
|
bw := BPS{
|
|
|
|
buckets: make([]int64, buckets),
|
2015-10-28 21:46:20 -07:00
|
|
|
}
|
2015-10-31 16:16:27 -07:00
|
|
|
|
|
|
|
t.Logf("all 0")
|
|
|
|
for i := 0; i < buckets; i++ {
|
2015-10-28 21:46:20 -07:00
|
|
|
bw.buckets[i] = 0
|
|
|
|
}
|
2015-10-31 16:16:27 -07:00
|
|
|
for i := 1; i < buckets; i++ {
|
|
|
|
line := bw.Sparkline(i)
|
|
|
|
t.Logf("count: %d, len %d: %+v", i, len([]rune(line)), line)
|
|
|
|
}
|
2015-10-28 21:46:20 -07:00
|
|
|
|
2015-10-31 16:16:27 -07:00
|
|
|
t.Logf("increasing")
|
|
|
|
for i := 0; i < buckets; i++ {
|
|
|
|
bw.buckets[i] = int64(i * buckets)
|
2015-10-28 21:46:20 -07:00
|
|
|
}
|
2015-10-31 16:16:27 -07:00
|
|
|
for i := 1; i < buckets; i++ {
|
|
|
|
line := bw.Sparkline(i)
|
|
|
|
t.Logf("count: %d, len %d: %+v", i, len([]rune(line)), line)
|
|
|
|
}
|
|
|
|
|
|
|
|
t.Logf("decreasing")
|
|
|
|
for i := 0; i < buckets; i++ {
|
|
|
|
bw.buckets[i] = int64((buckets - i) * buckets)
|
|
|
|
}
|
|
|
|
for i := 1; i < buckets; i++ {
|
|
|
|
line := bw.Sparkline(i)
|
|
|
|
t.Logf("count: %d, len %d: %+v", i, len([]rune(line)), line)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestSparkRandom(t *testing.T) {
|
|
|
|
buckets := 20
|
|
|
|
bw := BPS{
|
|
|
|
buckets: make([]int64, buckets),
|
|
|
|
}
|
|
|
|
bw.buckets[3] = 100
|
2015-10-28 21:46:20 -07:00
|
|
|
t.Logf("%+v", bw.Sparkline(10))
|
2015-10-31 16:16:27 -07:00
|
|
|
bw.buckets[7] = 300
|
|
|
|
for i := 1; i < buckets; i++ {
|
|
|
|
line := bw.Sparkline(i)
|
|
|
|
t.Logf("count: %d, len: %d: %+v", i, len([]rune(line)), line)
|
|
|
|
}
|
2015-10-28 21:46:20 -07:00
|
|
|
}
|