add package

[bytom/vapor.git] / vendor / github.com / hashicorp / golang-lru / simplelru / lru_test.go

diff --git a/vendor/github.com/hashicorp/golang-lru/simplelru/lru_test.go b/vendor/github.com/hashicorp/golang-lru/simplelru/lru_test.go
new file mode 100644 (file)
index 0000000..ca5676e
--- /dev/null
+++ b/vendor/github.com/hashicorp/golang-lru/simplelru/lru_test.go
@@ -0,0 +1,167 @@
+package simplelru
+
+import "testing"
+
+func TestLRU(t *testing.T) {
+       evictCounter := 0
+       onEvicted := func(k interface{}, v interface{}) {
+               if k != v {
+                       t.Fatalf("Evict values not equal (%v!=%v)", k, v)
+               }
+               evictCounter++
+       }
+       l, err := NewLRU(128, onEvicted)
+       if err != nil {
+               t.Fatalf("err: %v", err)
+       }
+
+       for i := 0; i < 256; i++ {
+               l.Add(i, i)
+       }
+       if l.Len() != 128 {
+               t.Fatalf("bad len: %v", l.Len())
+       }
+
+       if evictCounter != 128 {
+               t.Fatalf("bad evict count: %v", evictCounter)
+       }
+
+       for i, k := range l.Keys() {
+               if v, ok := l.Get(k); !ok || v != k || v != i+128 {
+                       t.Fatalf("bad key: %v", k)
+               }
+       }
+       for i := 0; i < 128; i++ {
+               _, ok := l.Get(i)
+               if ok {
+                       t.Fatalf("should be evicted")
+               }
+       }
+       for i := 128; i < 256; i++ {
+               _, ok := l.Get(i)
+               if !ok {
+                       t.Fatalf("should not be evicted")
+               }
+       }
+       for i := 128; i < 192; i++ {
+               ok := l.Remove(i)
+               if !ok {
+                       t.Fatalf("should be contained")
+               }
+               ok = l.Remove(i)
+               if ok {
+                       t.Fatalf("should not be contained")
+               }
+               _, ok = l.Get(i)
+               if ok {
+                       t.Fatalf("should be deleted")
+               }
+       }
+
+       l.Get(192) // expect 192 to be last key in l.Keys()
+
+       for i, k := range l.Keys() {
+               if (i < 63 && k != i+193) || (i == 63 && k != 192) {
+                       t.Fatalf("out of order key: %v", k)
+               }
+       }
+
+       l.Purge()
+       if l.Len() != 0 {
+               t.Fatalf("bad len: %v", l.Len())
+       }
+       if _, ok := l.Get(200); ok {
+               t.Fatalf("should contain nothing")
+       }
+}
+
+func TestLRU_GetOldest_RemoveOldest(t *testing.T) {
+       l, err := NewLRU(128, nil)
+       if err != nil {
+               t.Fatalf("err: %v", err)
+       }
+       for i := 0; i < 256; i++ {
+               l.Add(i, i)
+       }
+       k, _, ok := l.GetOldest()
+       if !ok {
+               t.Fatalf("missing")
+       }
+       if k.(int) != 128 {
+               t.Fatalf("bad: %v", k)
+       }
+
+       k, _, ok = l.RemoveOldest()
+       if !ok {
+               t.Fatalf("missing")
+       }
+       if k.(int) != 128 {
+               t.Fatalf("bad: %v", k)
+       }
+
+       k, _, ok = l.RemoveOldest()
+       if !ok {
+               t.Fatalf("missing")
+       }
+       if k.(int) != 129 {
+               t.Fatalf("bad: %v", k)
+       }
+}
+
+// Test that Add returns true/false if an eviction occurred
+func TestLRU_Add(t *testing.T) {
+       evictCounter := 0
+       onEvicted := func(k interface{}, v interface{}) {
+               evictCounter++
+       }
+
+       l, err := NewLRU(1, onEvicted)
+       if err != nil {
+               t.Fatalf("err: %v", err)
+       }
+
+       if l.Add(1, 1) == true || evictCounter != 0 {
+               t.Errorf("should not have an eviction")
+       }
+       if l.Add(2, 2) == false || evictCounter != 1 {
+               t.Errorf("should have an eviction")
+       }
+}
+
+// Test that Contains doesn't update recent-ness
+func TestLRU_Contains(t *testing.T) {
+       l, err := NewLRU(2, nil)
+       if err != nil {
+               t.Fatalf("err: %v", err)
+       }
+
+       l.Add(1, 1)
+       l.Add(2, 2)
+       if !l.Contains(1) {
+               t.Errorf("1 should be contained")
+       }
+
+       l.Add(3, 3)
+       if l.Contains(1) {
+               t.Errorf("Contains should not have updated recent-ness of 1")
+       }
+}
+
+// Test that Peek doesn't update recent-ness
+func TestLRU_Peek(t *testing.T) {
+       l, err := NewLRU(2, nil)
+       if err != nil {
+               t.Fatalf("err: %v", err)
+       }
+
+       l.Add(1, 1)
+       l.Add(2, 2)
+       if v, ok := l.Peek(1); !ok || v != 1 {
+               t.Errorf("1 should be set to 1: %v, %v", v, ok)
+       }
+
+       l.Add(3, 3)
+       if l.Contains(1) {
+               t.Errorf("should not have updated recent-ness of 1")
+       }
+}