aboutsummaryrefslogtreecommitdiffstats
path: root/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go
diff options
context:
space:
mode:
Diffstat (limited to 'Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go')
-rw-r--r--Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go206
1 files changed, 115 insertions, 91 deletions
diff --git a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go
index a0b58f0e7..19d29dfc4 100644
--- a/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go
+++ b/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go
@@ -17,6 +17,84 @@ import (
"github.com/syndtr/goleveldb/leveldb/util"
)
+func TestFind(db Find, kv KeyValue) {
+ ShuffledIndex(nil, kv.Len(), 1, func(i int) {
+ key_, key, value := kv.IndexInexact(i)
+
+ // Using exact key.
+ rkey, rvalue, err := db.TestFind(key)
+ Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
+ Expect(rkey).Should(Equal(key), "Key")
+ Expect(rvalue).Should(Equal(value), "Value for key %q", key)
+
+ // Using inexact key.
+ rkey, rvalue, err = db.TestFind(key_)
+ Expect(err).ShouldNot(HaveOccurred(), "Error for key %q (%q)", key_, key)
+ Expect(rkey).Should(Equal(key))
+ Expect(rvalue).Should(Equal(value), "Value for key %q (%q)", key_, key)
+ })
+}
+
+func TestFindAfterLast(db Find, kv KeyValue) {
+ var key []byte
+ if kv.Len() > 0 {
+ key_, _ := kv.Index(kv.Len() - 1)
+ key = BytesAfter(key_)
+ }
+ rkey, _, err := db.TestFind(key)
+ Expect(err).Should(HaveOccurred(), "Find for key %q yield key %q", key, rkey)
+ Expect(err).Should(Equal(errors.ErrNotFound))
+}
+
+func TestGet(db Get, kv KeyValue) {
+ ShuffledIndex(nil, kv.Len(), 1, func(i int) {
+ key_, key, value := kv.IndexInexact(i)
+
+ // Using exact key.
+ rvalue, err := db.TestGet(key)
+ Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
+ Expect(rvalue).Should(Equal(value), "Value for key %q", key)
+
+ // Using inexact key.
+ if len(key_) > 0 {
+ _, err = db.TestGet(key_)
+ Expect(err).Should(HaveOccurred(), "Error for key %q", key_)
+ Expect(err).Should(Equal(errors.ErrNotFound))
+ }
+ })
+}
+
+func TestHas(db Has, kv KeyValue) {
+ ShuffledIndex(nil, kv.Len(), 1, func(i int) {
+ key_, key, _ := kv.IndexInexact(i)
+
+ // Using exact key.
+ ret, err := db.TestHas(key)
+ Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
+ Expect(ret).Should(BeTrue(), "False for key %q", key)
+
+ // Using inexact key.
+ if len(key_) > 0 {
+ ret, err = db.TestHas(key_)
+ Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key_)
+ Expect(ret).ShouldNot(BeTrue(), "True for key %q", key)
+ }
+ })
+}
+
+func TestIter(db NewIterator, r *util.Range, kv KeyValue) {
+ iter := db.TestNewIterator(r)
+ Expect(iter.Error()).ShouldNot(HaveOccurred())
+
+ t := IteratorTesting{
+ KeyValue: kv,
+ Iter: iter,
+ }
+
+ DoIteratorTesting(&t)
+ iter.Release()
+}
+
func KeyValueTesting(rnd *rand.Rand, kv KeyValue, p DB, setup func(KeyValue) DB, teardown func(DB)) {
if rnd == nil {
rnd = NewRand()
@@ -35,122 +113,68 @@ func KeyValueTesting(rnd *rand.Rand, kv KeyValue, p DB, setup func(KeyValue) DB,
It("Should find all keys with Find", func() {
if db, ok := p.(Find); ok {
- ShuffledIndex(nil, kv.Len(), 1, func(i int) {
- key_, key, value := kv.IndexInexact(i)
-
- // Using exact key.
- rkey, rvalue, err := db.TestFind(key)
- Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
- Expect(rkey).Should(Equal(key), "Key")
- Expect(rvalue).Should(Equal(value), "Value for key %q", key)
-
- // Using inexact key.
- rkey, rvalue, err = db.TestFind(key_)
- Expect(err).ShouldNot(HaveOccurred(), "Error for key %q (%q)", key_, key)
- Expect(rkey).Should(Equal(key))
- Expect(rvalue).Should(Equal(value), "Value for key %q (%q)", key_, key)
- })
+ TestFind(db, kv)
}
})
- It("Should return error if the key is not present", func() {
+ It("Should return error if Find on key after the last", func() {
if db, ok := p.(Find); ok {
- var key []byte
- if kv.Len() > 0 {
- key_, _ := kv.Index(kv.Len() - 1)
- key = BytesAfter(key_)
- }
- rkey, _, err := db.TestFind(key)
- Expect(err).Should(HaveOccurred(), "Find for key %q yield key %q", key, rkey)
- Expect(err).Should(Equal(errors.ErrNotFound))
+ TestFindAfterLast(db, kv)
}
})
It("Should only find exact key with Get", func() {
if db, ok := p.(Get); ok {
- ShuffledIndex(nil, kv.Len(), 1, func(i int) {
- key_, key, value := kv.IndexInexact(i)
-
- // Using exact key.
- rvalue, err := db.TestGet(key)
- Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
- Expect(rvalue).Should(Equal(value), "Value for key %q", key)
-
- // Using inexact key.
- if len(key_) > 0 {
- _, err = db.TestGet(key_)
- Expect(err).Should(HaveOccurred(), "Error for key %q", key_)
- Expect(err).Should(Equal(errors.ErrNotFound))
- }
- })
+ TestGet(db, kv)
}
})
It("Should only find present key with Has", func() {
if db, ok := p.(Has); ok {
- ShuffledIndex(nil, kv.Len(), 1, func(i int) {
- key_, key, _ := kv.IndexInexact(i)
-
- // Using exact key.
- ret, err := db.TestHas(key)
- Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
- Expect(ret).Should(BeTrue(), "False for key %q", key)
-
- // Using inexact key.
- if len(key_) > 0 {
- ret, err = db.TestHas(key_)
- Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key_)
- Expect(ret).ShouldNot(BeTrue(), "True for key %q", key)
- }
- })
+ TestHas(db, kv)
}
})
- TestIter := func(r *util.Range, _kv KeyValue) {
+ It("Should iterates and seeks correctly", func(done Done) {
if db, ok := p.(NewIterator); ok {
- iter := db.TestNewIterator(r)
- Expect(iter.Error()).ShouldNot(HaveOccurred())
-
- t := IteratorTesting{
- KeyValue: _kv,
- Iter: iter,
- }
-
- DoIteratorTesting(&t)
- iter.Release()
+ TestIter(db, nil, kv.Clone())
}
- }
-
- It("Should iterates and seeks correctly", func(done Done) {
- TestIter(nil, kv.Clone())
done <- true
}, 3.0)
- RandomIndex(rnd, kv.Len(), Min(kv.Len(), 50), func(i int) {
- type slice struct {
- r *util.Range
- start, limit int
- }
+ It("Should iterates and seeks slice correctly", func(done Done) {
+ if db, ok := p.(NewIterator); ok {
+ RandomIndex(rnd, kv.Len(), Min(kv.Len(), 50), func(i int) {
+ type slice struct {
+ r *util.Range
+ start, limit int
+ }
- key_, _, _ := kv.IndexInexact(i)
- for _, x := range []slice{
- {&util.Range{Start: key_, Limit: nil}, i, kv.Len()},
- {&util.Range{Start: nil, Limit: key_}, 0, i},
- } {
- It(fmt.Sprintf("Should iterates and seeks correctly of a slice %d .. %d", x.start, x.limit), func(done Done) {
- TestIter(x.r, kv.Slice(x.start, x.limit))
- done <- true
- }, 3.0)
+ key_, _, _ := kv.IndexInexact(i)
+ for _, x := range []slice{
+ {&util.Range{Start: key_, Limit: nil}, i, kv.Len()},
+ {&util.Range{Start: nil, Limit: key_}, 0, i},
+ } {
+ By(fmt.Sprintf("Random index of %d .. %d", x.start, x.limit), func() {
+ TestIter(db, x.r, kv.Slice(x.start, x.limit))
+ })
+ }
+ })
}
- })
+ done <- true
+ }, 50.0)
- RandomRange(rnd, kv.Len(), Min(kv.Len(), 50), func(start, limit int) {
- It(fmt.Sprintf("Should iterates and seeks correctly of a slice %d .. %d", start, limit), func(done Done) {
- r := kv.Range(start, limit)
- TestIter(&r, kv.Slice(start, limit))
- done <- true
- }, 3.0)
- })
+ It("Should iterates and seeks slice correctly", func(done Done) {
+ if db, ok := p.(NewIterator); ok {
+ RandomRange(rnd, kv.Len(), Min(kv.Len(), 50), func(start, limit int) {
+ By(fmt.Sprintf("Random range of %d .. %d", start, limit), func() {
+ r := kv.Range(start, limit)
+ TestIter(db, &r, kv.Slice(start, limit))
+ })
+ })
+ }
+ done <- true
+ }, 50.0)
}
func AllKeyValueTesting(rnd *rand.Rand, body, setup func(KeyValue) DB, teardown func(DB)) {
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-26 23:11:47 +0800