github.com/insionng/yougam@v0.0.0-20170714101924-2bc18d833463/libraries/syndtr/goleveldb/leveldb/testutil/kvtest.go (about) 1 // Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com> 2 // All rights reserved. 3 // 4 // Use of this source code is governed by a BSD-style license that can be 5 // found in the LICENSE file. 6 7 package testutil 8 9 import ( 10 "fmt" 11 "math/rand" 12 13 . "github.com/insionng/yougam/libraries/onsi/ginkgo" 14 . "github.com/insionng/yougam/libraries/onsi/gomega" 15 16 "github.com/insionng/yougam/libraries/syndtr/goleveldb/leveldb/errors" 17 "github.com/insionng/yougam/libraries/syndtr/goleveldb/leveldb/util" 18 ) 19 20 func TestFind(db Find, kv KeyValue) { 21 ShuffledIndex(nil, kv.Len(), 1, func(i int) { 22 key_, key, value := kv.IndexInexact(i) 23 24 // Using exact key. 25 rkey, rvalue, err := db.TestFind(key) 26 Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key) 27 Expect(rkey).Should(Equal(key), "Key") 28 Expect(rvalue).Should(Equal(value), "Value for key %q", key) 29 30 // Using inexact key. 31 rkey, rvalue, err = db.TestFind(key_) 32 Expect(err).ShouldNot(HaveOccurred(), "Error for key %q (%q)", key_, key) 33 Expect(rkey).Should(Equal(key)) 34 Expect(rvalue).Should(Equal(value), "Value for key %q (%q)", key_, key) 35 }) 36 } 37 38 func TestFindAfterLast(db Find, kv KeyValue) { 39 var key []byte 40 if kv.Len() > 0 { 41 key_, _ := kv.Index(kv.Len() - 1) 42 key = BytesAfter(key_) 43 } 44 rkey, _, err := db.TestFind(key) 45 Expect(err).Should(HaveOccurred(), "Find for key %q yield key %q", key, rkey) 46 Expect(err).Should(Equal(errors.ErrNotFound)) 47 } 48 49 func TestGet(db Get, kv KeyValue) { 50 ShuffledIndex(nil, kv.Len(), 1, func(i int) { 51 key_, key, value := kv.IndexInexact(i) 52 53 // Using exact key. 54 rvalue, err := db.TestGet(key) 55 Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key) 56 Expect(rvalue).Should(Equal(value), "Value for key %q", key) 57 58 // Using inexact key. 59 if len(key_) > 0 { 60 _, err = db.TestGet(key_) 61 Expect(err).Should(HaveOccurred(), "Error for key %q", key_) 62 Expect(err).Should(Equal(errors.ErrNotFound)) 63 } 64 }) 65 } 66 67 func TestHas(db Has, kv KeyValue) { 68 ShuffledIndex(nil, kv.Len(), 1, func(i int) { 69 key_, key, _ := kv.IndexInexact(i) 70 71 // Using exact key. 72 ret, err := db.TestHas(key) 73 Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key) 74 Expect(ret).Should(BeTrue(), "False for key %q", key) 75 76 // Using inexact key. 77 if len(key_) > 0 { 78 ret, err = db.TestHas(key_) 79 Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key_) 80 Expect(ret).ShouldNot(BeTrue(), "True for key %q", key) 81 } 82 }) 83 } 84 85 func TestIter(db NewIterator, r *util.Range, kv KeyValue) { 86 iter := db.TestNewIterator(r) 87 Expect(iter.Error()).ShouldNot(HaveOccurred()) 88 89 t := IteratorTesting{ 90 KeyValue: kv, 91 Iter: iter, 92 } 93 94 DoIteratorTesting(&t) 95 iter.Release() 96 } 97 98 func KeyValueTesting(rnd *rand.Rand, kv KeyValue, p DB, setup func(KeyValue) DB, teardown func(DB)) { 99 if rnd == nil { 100 rnd = NewRand() 101 } 102 103 if p == nil { 104 BeforeEach(func() { 105 p = setup(kv) 106 }) 107 if teardown != nil { 108 AfterEach(func() { 109 teardown(p) 110 }) 111 } 112 } 113 114 It("Should find all keys with Find", func() { 115 if db, ok := p.(Find); ok { 116 TestFind(db, kv) 117 } 118 }) 119 120 It("Should return error if Find on key after the last", func() { 121 if db, ok := p.(Find); ok { 122 TestFindAfterLast(db, kv) 123 } 124 }) 125 126 It("Should only find exact key with Get", func() { 127 if db, ok := p.(Get); ok { 128 TestGet(db, kv) 129 } 130 }) 131 132 It("Should only find present key with Has", func() { 133 if db, ok := p.(Has); ok { 134 TestHas(db, kv) 135 } 136 }) 137 138 It("Should iterates and seeks correctly", func(done Done) { 139 if db, ok := p.(NewIterator); ok { 140 TestIter(db, nil, kv.Clone()) 141 } 142 done <- true 143 }, 3.0) 144 145 It("Should iterates and seeks slice correctly", func(done Done) { 146 if db, ok := p.(NewIterator); ok { 147 RandomIndex(rnd, kv.Len(), Min(kv.Len(), 50), func(i int) { 148 type slice struct { 149 r *util.Range 150 start, limit int 151 } 152 153 key_, _, _ := kv.IndexInexact(i) 154 for _, x := range []slice{ 155 {&util.Range{Start: key_, Limit: nil}, i, kv.Len()}, 156 {&util.Range{Start: nil, Limit: key_}, 0, i}, 157 } { 158 By(fmt.Sprintf("Random index of %d .. %d", x.start, x.limit), func() { 159 TestIter(db, x.r, kv.Slice(x.start, x.limit)) 160 }) 161 } 162 }) 163 } 164 done <- true 165 }, 50.0) 166 167 It("Should iterates and seeks slice correctly", func(done Done) { 168 if db, ok := p.(NewIterator); ok { 169 RandomRange(rnd, kv.Len(), Min(kv.Len(), 50), func(start, limit int) { 170 By(fmt.Sprintf("Random range of %d .. %d", start, limit), func() { 171 r := kv.Range(start, limit) 172 TestIter(db, &r, kv.Slice(start, limit)) 173 }) 174 }) 175 } 176 done <- true 177 }, 50.0) 178 } 179 180 func AllKeyValueTesting(rnd *rand.Rand, body, setup func(KeyValue) DB, teardown func(DB)) { 181 Test := func(kv *KeyValue) func() { 182 return func() { 183 var p DB 184 if setup != nil { 185 Defer("setup", func() { 186 p = setup(*kv) 187 }) 188 } 189 if teardown != nil { 190 Defer("teardown", func() { 191 teardown(p) 192 }) 193 } 194 if body != nil { 195 p = body(*kv) 196 } 197 KeyValueTesting(rnd, *kv, p, func(KeyValue) DB { 198 return p 199 }, nil) 200 } 201 } 202 203 Describe("with no key/value (empty)", Test(&KeyValue{})) 204 Describe("with empty key", Test(KeyValue_EmptyKey())) 205 Describe("with empty value", Test(KeyValue_EmptyValue())) 206 Describe("with one key/value", Test(KeyValue_OneKeyValue())) 207 Describe("with big value", Test(KeyValue_BigValue())) 208 Describe("with special key", Test(KeyValue_SpecialKey())) 209 Describe("with multiple key/value", Test(KeyValue_MultipleKeyValue())) 210 Describe("with generated key/value", Test(KeyValue_Generate(nil, 120, 1, 50, 10, 120))) 211 }