mirror of https://github.com/tikv/client-go.git
unionstore: replace pingcap/check with testify (#141)
Signed-off-by: disksing <i@disksing.com>
This commit is contained in:
disksing
GitHub
parent
425df82fdb
commit
d63c289bcc
|
|
@ -37,15 +37,17 @@ package unionstore
|
|||
import (
|
||||
"encoding/binary"
|
||||
"math/rand"
|
||||
"testing"
|
||||
|
||||
. "github.com/pingcap/check"
|
||||
"github.com/pingcap/goleveldb/leveldb/comparer"
|
||||
leveldb "github.com/pingcap/goleveldb/leveldb/memdb"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
// The test takes too long under the race detector.
|
||||
func (s testMemDBSuite) TestRandom(c *C) {
|
||||
c.Parallel()
|
||||
func TestRandom(t *testing.T) {
|
||||
require := require.New(t)
|
||||
|
||||
const cnt = 500000
|
||||
keys := make([][]byte, cnt)
|
||||
for i := range keys {
|
||||
|
|
@ -60,8 +62,8 @@ func (s testMemDBSuite) TestRandom(c *C) {
|
|||
_ = p2.Put(k, k)
|
||||
}
|
||||
|
||||
c.Check(p1.Len(), Equals, p2.Len())
|
||||
c.Check(p1.Size(), Equals, p2.Size())
|
||||
require.Equal(p1.Len(), p2.Len())
|
||||
require.Equal(p1.Size(), p2.Size())
|
||||
|
||||
rand.Shuffle(cnt, func(i, j int) { keys[i], keys[j] = keys[j], keys[i] })
|
||||
|
||||
|
|
@ -77,18 +79,17 @@ func (s testMemDBSuite) TestRandom(c *C) {
|
|||
_ = p2.Put(k, newValue)
|
||||
}
|
||||
}
|
||||
s.checkConsist(c, p1, p2)
|
||||
checkConsist(t, p1, p2)
|
||||
}
|
||||
|
||||
// The test takes too long under the race detector.
|
||||
func (s testMemDBSuite) TestRandomDerive(c *C) {
|
||||
c.Parallel()
|
||||
func TestRandomDerive(t *testing.T) {
|
||||
db := newMemDB()
|
||||
golden := leveldb.New(comparer.DefaultComparer, 4*1024)
|
||||
s.testRandomDeriveRecur(c, db, golden, 0)
|
||||
testRandomDeriveRecur(t, db, golden, 0)
|
||||
}
|
||||
|
||||
func (s testMemDBSuite) testRandomDeriveRecur(c *C, db *MemDB, golden *leveldb.DB, depth int) [][2][]byte {
|
||||
func testRandomDeriveRecur(t *testing.T, db *MemDB, golden *leveldb.DB, depth int) [][2][]byte {
|
||||
var keys [][]byte
|
||||
if op := rand.Float64(); op < 0.33 {
|
||||
start, end := rand.Intn(512), rand.Intn(512)+512
|
||||
|
|
@ -132,7 +133,7 @@ func (s testMemDBSuite) testRandomDeriveRecur(c *C, db *MemDB, golden *leveldb.D
|
|||
}
|
||||
|
||||
if depth < 2000 {
|
||||
childOps := s.testRandomDeriveRecur(c, db, golden, depth+1)
|
||||
childOps := testRandomDeriveRecur(t, db, golden, depth+1)
|
||||
opLog = append(opLog, childOps...)
|
||||
}
|
||||
|
||||
|
|
@ -151,7 +152,7 @@ func (s testMemDBSuite) testRandomDeriveRecur(c *C, db *MemDB, golden *leveldb.D
|
|||
}
|
||||
|
||||
if depth%200 == 0 {
|
||||
s.checkConsist(c, db, golden)
|
||||
checkConsist(t, db, golden)
|
||||
}
|
||||
|
||||
return opLog
|
||||
|
|
|
|||
|
|
@ -39,8 +39,9 @@ import (
|
|||
"fmt"
|
||||
"testing"
|
||||
|
||||
. "github.com/pingcap/check"
|
||||
leveldb "github.com/pingcap/goleveldb/leveldb/memdb"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
"github.com/tikv/client-go/v2/kv"
|
||||
"github.com/tikv/client-go/v2/util/testleak"
|
||||
)
|
||||
|
|
@ -51,18 +52,6 @@ func init() {
|
|||
testMode = true
|
||||
}
|
||||
|
||||
func TestT(t *testing.T) {
|
||||
CustomVerboseFlag = true
|
||||
TestingT(t)
|
||||
}
|
||||
|
||||
var (
|
||||
_ = Suite(&testKVSuite{})
|
||||
_ = Suite(&testMemDBSuite{})
|
||||
)
|
||||
|
||||
type testMemDBSuite struct{}
|
||||
|
||||
// DeleteKey is used in test to verify the `deleteNode` used in `vlog.revertToCheckpoint`.
|
||||
func (db *MemDB) DeleteKey(key []byte) {
|
||||
x := db.traverse(key, false)
|
||||
|
|
@ -73,120 +62,128 @@ func (db *MemDB) DeleteKey(key []byte) {
|
|||
db.deleteNode(x)
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestGetSet(c *C) {
|
||||
func TestGetSet(t *testing.T) {
|
||||
require := require.New(t)
|
||||
|
||||
const cnt = 10000
|
||||
p := s.fillDB(cnt)
|
||||
p := fillDB(cnt)
|
||||
|
||||
var buf [4]byte
|
||||
for i := 0; i < cnt; i++ {
|
||||
binary.BigEndian.PutUint32(buf[:], uint32(i))
|
||||
v, err := p.Get(buf[:])
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(v, BytesEquals, buf[:])
|
||||
require.Nil(err)
|
||||
require.Equal(v, buf[:])
|
||||
}
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestBigKV(c *C) {
|
||||
func TestBigKV(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
db := newMemDB()
|
||||
db.Set([]byte{1}, make([]byte, 80<<20))
|
||||
c.Assert(db.vlog.blockSize, Equals, maxBlockSize)
|
||||
c.Assert(len(db.vlog.blocks), Equals, 1)
|
||||
assert.Equal(db.vlog.blockSize, maxBlockSize)
|
||||
assert.Equal(len(db.vlog.blocks), 1)
|
||||
h := db.Staging()
|
||||
db.Set([]byte{2}, make([]byte, 127<<20))
|
||||
db.Release(h)
|
||||
c.Assert(db.vlog.blockSize, Equals, maxBlockSize)
|
||||
c.Assert(len(db.vlog.blocks), Equals, 2)
|
||||
c.Assert(func() { db.Set([]byte{3}, make([]byte, maxBlockSize+1)) }, Panics, "alloc size is larger than max block size")
|
||||
assert.Equal(db.vlog.blockSize, maxBlockSize)
|
||||
assert.Equal(len(db.vlog.blocks), 2)
|
||||
assert.PanicsWithValue("alloc size is larger than max block size", func() { db.Set([]byte{3}, make([]byte, maxBlockSize+1)) })
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestIterator(c *C) {
|
||||
func TestIterator(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
const cnt = 10000
|
||||
db := s.fillDB(cnt)
|
||||
db := fillDB(cnt)
|
||||
|
||||
var buf [4]byte
|
||||
var i int
|
||||
|
||||
for it, _ := db.Iter(nil, nil); it.Valid(); it.Next() {
|
||||
binary.BigEndian.PutUint32(buf[:], uint32(i))
|
||||
c.Assert(it.Key(), BytesEquals, buf[:])
|
||||
c.Assert(it.Value(), BytesEquals, buf[:])
|
||||
assert.Equal(it.Key(), buf[:])
|
||||
assert.Equal(it.Value(), buf[:])
|
||||
i++
|
||||
}
|
||||
c.Assert(i, Equals, cnt)
|
||||
assert.Equal(i, cnt)
|
||||
|
||||
i--
|
||||
for it, _ := db.IterReverse(nil); it.Valid(); it.Next() {
|
||||
binary.BigEndian.PutUint32(buf[:], uint32(i))
|
||||
c.Assert(it.Key(), BytesEquals, buf[:])
|
||||
c.Assert(it.Value(), BytesEquals, buf[:])
|
||||
assert.Equal(it.Key(), buf[:])
|
||||
assert.Equal(it.Value(), buf[:])
|
||||
i--
|
||||
}
|
||||
c.Assert(i, Equals, -1)
|
||||
assert.Equal(i, -1)
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestDiscard(c *C) {
|
||||
func TestDiscard(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
const cnt = 10000
|
||||
db := newMemDB()
|
||||
base := s.deriveAndFill(0, cnt, 0, db)
|
||||
base := deriveAndFill(0, cnt, 0, db)
|
||||
sz := db.Size()
|
||||
|
||||
db.Cleanup(s.deriveAndFill(0, cnt, 1, db))
|
||||
c.Assert(db.Len(), Equals, cnt)
|
||||
c.Assert(db.Size(), Equals, sz)
|
||||
db.Cleanup(deriveAndFill(0, cnt, 1, db))
|
||||
assert.Equal(db.Len(), cnt)
|
||||
assert.Equal(db.Size(), sz)
|
||||
|
||||
var buf [4]byte
|
||||
|
||||
for i := 0; i < cnt; i++ {
|
||||
binary.BigEndian.PutUint32(buf[:], uint32(i))
|
||||
v, err := db.Get(buf[:])
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(v, BytesEquals, buf[:])
|
||||
assert.Nil(err)
|
||||
assert.Equal(v, buf[:])
|
||||
}
|
||||
|
||||
var i int
|
||||
for it, _ := db.Iter(nil, nil); it.Valid(); it.Next() {
|
||||
binary.BigEndian.PutUint32(buf[:], uint32(i))
|
||||
c.Assert(it.Key(), BytesEquals, buf[:])
|
||||
c.Assert(it.Value(), BytesEquals, buf[:])
|
||||
assert.Equal(it.Key(), buf[:])
|
||||
assert.Equal(it.Value(), buf[:])
|
||||
i++
|
||||
}
|
||||
c.Assert(i, Equals, cnt)
|
||||
assert.Equal(i, cnt)
|
||||
|
||||
i--
|
||||
for it, _ := db.IterReverse(nil); it.Valid(); it.Next() {
|
||||
binary.BigEndian.PutUint32(buf[:], uint32(i))
|
||||
c.Assert(it.Key(), BytesEquals, buf[:])
|
||||
c.Assert(it.Value(), BytesEquals, buf[:])
|
||||
assert.Equal(it.Key(), buf[:])
|
||||
assert.Equal(it.Value(), buf[:])
|
||||
i--
|
||||
}
|
||||
c.Assert(i, Equals, -1)
|
||||
assert.Equal(i, -1)
|
||||
|
||||
db.Cleanup(base)
|
||||
for i := 0; i < cnt; i++ {
|
||||
binary.BigEndian.PutUint32(buf[:], uint32(i))
|
||||
_, err := db.Get(buf[:])
|
||||
c.Assert(err, NotNil)
|
||||
assert.NotNil(err)
|
||||
}
|
||||
it1, _ := db.Iter(nil, nil)
|
||||
it := it1.(*MemdbIterator)
|
||||
it.seekToFirst()
|
||||
c.Assert(it.Valid(), IsFalse)
|
||||
assert.False(it.Valid())
|
||||
it.seekToLast()
|
||||
c.Assert(it.Valid(), IsFalse)
|
||||
assert.False(it.Valid())
|
||||
it.seek([]byte{0xff})
|
||||
c.Assert(it.Valid(), IsFalse)
|
||||
assert.False(it.Valid())
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestFlushOverwrite(c *C) {
|
||||
func TestFlushOverwrite(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
const cnt = 10000
|
||||
db := newMemDB()
|
||||
db.Release(s.deriveAndFill(0, cnt, 0, db))
|
||||
db.Release(deriveAndFill(0, cnt, 0, db))
|
||||
sz := db.Size()
|
||||
|
||||
db.Release(s.deriveAndFill(0, cnt, 1, db))
|
||||
db.Release(deriveAndFill(0, cnt, 1, db))
|
||||
|
||||
c.Assert(db.Len(), Equals, cnt)
|
||||
c.Assert(db.Size(), Equals, sz)
|
||||
assert.Equal(db.Len(), cnt)
|
||||
assert.Equal(db.Size(), sz)
|
||||
|
||||
var kbuf, vbuf [4]byte
|
||||
|
||||
|
|
@ -194,32 +191,34 @@ func (s *testMemDBSuite) TestFlushOverwrite(c *C) {
|
|||
binary.BigEndian.PutUint32(kbuf[:], uint32(i))
|
||||
binary.BigEndian.PutUint32(vbuf[:], uint32(i+1))
|
||||
v, err := db.Get(kbuf[:])
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(v, DeepEquals, vbuf[:])
|
||||
assert.Nil(err)
|
||||
assert.Equal(v, vbuf[:])
|
||||
}
|
||||
|
||||
var i int
|
||||
for it, _ := db.Iter(nil, nil); it.Valid(); it.Next() {
|
||||
binary.BigEndian.PutUint32(kbuf[:], uint32(i))
|
||||
binary.BigEndian.PutUint32(vbuf[:], uint32(i+1))
|
||||
c.Assert(it.Key(), BytesEquals, kbuf[:])
|
||||
c.Assert(it.Value(), BytesEquals, vbuf[:])
|
||||
assert.Equal(it.Key(), kbuf[:])
|
||||
assert.Equal(it.Value(), vbuf[:])
|
||||
i++
|
||||
}
|
||||
c.Assert(i, Equals, cnt)
|
||||
assert.Equal(i, cnt)
|
||||
|
||||
i--
|
||||
for it, _ := db.IterReverse(nil); it.Valid(); it.Next() {
|
||||
binary.BigEndian.PutUint32(kbuf[:], uint32(i))
|
||||
binary.BigEndian.PutUint32(vbuf[:], uint32(i+1))
|
||||
c.Assert(it.Key(), BytesEquals, kbuf[:])
|
||||
c.Assert(it.Value(), BytesEquals, vbuf[:])
|
||||
assert.Equal(it.Key(), kbuf[:])
|
||||
assert.Equal(it.Value(), vbuf[:])
|
||||
i--
|
||||
}
|
||||
c.Assert(i, Equals, -1)
|
||||
assert.Equal(i, -1)
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestComplexUpdate(c *C) {
|
||||
func TestComplexUpdate(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
const (
|
||||
keep = 3000
|
||||
overwrite = 6000
|
||||
|
|
@ -227,10 +226,10 @@ func (s *testMemDBSuite) TestComplexUpdate(c *C) {
|
|||
)
|
||||
|
||||
db := newMemDB()
|
||||
db.Release(s.deriveAndFill(0, overwrite, 0, db))
|
||||
c.Assert(db.Len(), Equals, overwrite)
|
||||
db.Release(s.deriveAndFill(keep, insert, 1, db))
|
||||
c.Assert(db.Len(), Equals, insert)
|
||||
db.Release(deriveAndFill(0, overwrite, 0, db))
|
||||
assert.Equal(db.Len(), overwrite)
|
||||
db.Release(deriveAndFill(keep, insert, 1, db))
|
||||
assert.Equal(db.Len(), insert)
|
||||
|
||||
var kbuf, vbuf [4]byte
|
||||
|
||||
|
|
@ -241,18 +240,19 @@ func (s *testMemDBSuite) TestComplexUpdate(c *C) {
|
|||
binary.BigEndian.PutUint32(vbuf[:], uint32(i+1))
|
||||
}
|
||||
v, err := db.Get(kbuf[:])
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(v, BytesEquals, vbuf[:])
|
||||
assert.Nil(err)
|
||||
assert.Equal(v, vbuf[:])
|
||||
}
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestNestedSandbox(c *C) {
|
||||
func TestNestedSandbox(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
db := newMemDB()
|
||||
h0 := s.deriveAndFill(0, 200, 0, db)
|
||||
h1 := s.deriveAndFill(0, 100, 1, db)
|
||||
h2 := s.deriveAndFill(50, 150, 2, db)
|
||||
h3 := s.deriveAndFill(100, 120, 3, db)
|
||||
h4 := s.deriveAndFill(0, 150, 4, db)
|
||||
h0 := deriveAndFill(0, 200, 0, db)
|
||||
h1 := deriveAndFill(0, 100, 1, db)
|
||||
h2 := deriveAndFill(50, 150, 2, db)
|
||||
h3 := deriveAndFill(100, 120, 3, db)
|
||||
h4 := deriveAndFill(0, 150, 4, db)
|
||||
db.Cleanup(h4) // Discard (0..150 -> 4)
|
||||
db.Release(h3) // Flush (100..120 -> 3)
|
||||
db.Cleanup(h2) // Discard (100..120 -> 3) & (50..150 -> 2)
|
||||
|
|
@ -269,8 +269,8 @@ func (s *testMemDBSuite) TestNestedSandbox(c *C) {
|
|||
binary.BigEndian.PutUint32(vbuf[:], uint32(i+1))
|
||||
}
|
||||
v, err := db.Get(kbuf[:])
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(v, BytesEquals, vbuf[:])
|
||||
assert.Nil(err)
|
||||
assert.Equal(v, vbuf[:])
|
||||
}
|
||||
|
||||
var i int
|
||||
|
|
@ -281,11 +281,11 @@ func (s *testMemDBSuite) TestNestedSandbox(c *C) {
|
|||
if i < 100 {
|
||||
binary.BigEndian.PutUint32(vbuf[:], uint32(i+1))
|
||||
}
|
||||
c.Assert(it.Key(), BytesEquals, kbuf[:])
|
||||
c.Assert(it.Value(), BytesEquals, vbuf[:])
|
||||
assert.Equal(it.Key(), kbuf[:])
|
||||
assert.Equal(it.Value(), vbuf[:])
|
||||
i++
|
||||
}
|
||||
c.Assert(i, Equals, 200)
|
||||
assert.Equal(i, 200)
|
||||
|
||||
i--
|
||||
for it, _ := db.IterReverse(nil); it.Valid(); it.Next() {
|
||||
|
|
@ -294,16 +294,18 @@ func (s *testMemDBSuite) TestNestedSandbox(c *C) {
|
|||
if i < 100 {
|
||||
binary.BigEndian.PutUint32(vbuf[:], uint32(i+1))
|
||||
}
|
||||
c.Assert(it.Key(), BytesEquals, kbuf[:])
|
||||
c.Assert(it.Value(), BytesEquals, vbuf[:])
|
||||
assert.Equal(it.Key(), kbuf[:])
|
||||
assert.Equal(it.Value(), vbuf[:])
|
||||
i--
|
||||
}
|
||||
c.Assert(i, Equals, -1)
|
||||
assert.Equal(i, -1)
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestOverwrite(c *C) {
|
||||
func TestOverwrite(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
const cnt = 10000
|
||||
db := s.fillDB(cnt)
|
||||
db := fillDB(cnt)
|
||||
var buf [4]byte
|
||||
|
||||
sz := db.Size()
|
||||
|
|
@ -313,17 +315,17 @@ func (s *testMemDBSuite) TestOverwrite(c *C) {
|
|||
binary.BigEndian.PutUint32(newBuf[:], uint32(i*10))
|
||||
db.Set(buf[:], newBuf[:])
|
||||
}
|
||||
c.Assert(db.Len(), Equals, cnt)
|
||||
c.Assert(db.Size(), Equals, sz)
|
||||
assert.Equal(db.Len(), cnt)
|
||||
assert.Equal(db.Size(), sz)
|
||||
|
||||
for i := 0; i < cnt; i++ {
|
||||
binary.BigEndian.PutUint32(buf[:], uint32(i))
|
||||
val, _ := db.Get(buf[:])
|
||||
v := binary.BigEndian.Uint32(val)
|
||||
if i%3 == 0 {
|
||||
c.Assert(v, Equals, uint32(i*10))
|
||||
assert.Equal(v, uint32(i*10))
|
||||
} else {
|
||||
c.Assert(v, Equals, uint32(i))
|
||||
assert.Equal(v, uint32(i))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -331,77 +333,82 @@ func (s *testMemDBSuite) TestOverwrite(c *C) {
|
|||
|
||||
for it, _ := db.Iter(nil, nil); it.Valid(); it.Next() {
|
||||
binary.BigEndian.PutUint32(buf[:], uint32(i))
|
||||
c.Assert(it.Key(), BytesEquals, buf[:])
|
||||
assert.Equal(it.Key(), buf[:])
|
||||
v := binary.BigEndian.Uint32(it.Value())
|
||||
if i%3 == 0 {
|
||||
c.Assert(v, Equals, uint32(i*10))
|
||||
assert.Equal(v, uint32(i*10))
|
||||
} else {
|
||||
c.Assert(v, Equals, uint32(i))
|
||||
assert.Equal(v, uint32(i))
|
||||
}
|
||||
i++
|
||||
}
|
||||
c.Assert(i, Equals, cnt)
|
||||
assert.Equal(i, cnt)
|
||||
|
||||
i--
|
||||
for it, _ := db.IterReverse(nil); it.Valid(); it.Next() {
|
||||
binary.BigEndian.PutUint32(buf[:], uint32(i))
|
||||
c.Assert(it.Key(), BytesEquals, buf[:])
|
||||
assert.Equal(it.Key(), buf[:])
|
||||
v := binary.BigEndian.Uint32(it.Value())
|
||||
if i%3 == 0 {
|
||||
c.Assert(v, Equals, uint32(i*10))
|
||||
assert.Equal(v, uint32(i*10))
|
||||
} else {
|
||||
c.Assert(v, Equals, uint32(i))
|
||||
assert.Equal(v, uint32(i))
|
||||
}
|
||||
i--
|
||||
}
|
||||
c.Assert(i, Equals, -1)
|
||||
assert.Equal(i, -1)
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestKVLargeThanBlock(c *C) {
|
||||
func TestKVLargeThanBlock(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
db := newMemDB()
|
||||
db.Set([]byte{1}, make([]byte, 1))
|
||||
db.Set([]byte{2}, make([]byte, 4096))
|
||||
c.Assert(len(db.vlog.blocks), Equals, 2)
|
||||
assert.Equal(len(db.vlog.blocks), 2)
|
||||
db.Set([]byte{3}, make([]byte, 3000))
|
||||
c.Assert(len(db.vlog.blocks), Equals, 2)
|
||||
assert.Equal(len(db.vlog.blocks), 2)
|
||||
val, err := db.Get([]byte{3})
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(len(val), Equals, 3000)
|
||||
assert.Nil(err)
|
||||
assert.Equal(len(val), 3000)
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestEmptyDB(c *C) {
|
||||
func TestEmptyDB(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
db := newMemDB()
|
||||
_, err := db.Get([]byte{0})
|
||||
c.Assert(err, NotNil)
|
||||
assert.NotNil(err)
|
||||
it1, _ := db.Iter(nil, nil)
|
||||
it := it1.(*MemdbIterator)
|
||||
it.seekToFirst()
|
||||
c.Assert(it.Valid(), IsFalse)
|
||||
assert.False(it.Valid())
|
||||
it.seekToLast()
|
||||
c.Assert(it.Valid(), IsFalse)
|
||||
assert.False(it.Valid())
|
||||
it.seek([]byte{0xff})
|
||||
c.Assert(it.Valid(), IsFalse)
|
||||
assert.False(it.Valid())
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestReset(c *C) {
|
||||
db := s.fillDB(1000)
|
||||
func TestReset(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
db := fillDB(1000)
|
||||
db.Reset()
|
||||
_, err := db.Get([]byte{0, 0, 0, 0})
|
||||
c.Assert(err, NotNil)
|
||||
assert.NotNil(err)
|
||||
it1, _ := db.Iter(nil, nil)
|
||||
it := it1.(*MemdbIterator)
|
||||
it.seekToFirst()
|
||||
c.Assert(it.Valid(), IsFalse)
|
||||
assert.False(it.Valid())
|
||||
it.seekToLast()
|
||||
c.Assert(it.Valid(), IsFalse)
|
||||
assert.False(it.Valid())
|
||||
it.seek([]byte{0xff})
|
||||
c.Assert(it.Valid(), IsFalse)
|
||||
assert.False(it.Valid())
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestInspectStage(c *C) {
|
||||
func TestInspectStage(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
db := newMemDB()
|
||||
h1 := s.deriveAndFill(0, 1000, 0, db)
|
||||
h2 := s.deriveAndFill(500, 1000, 1, db)
|
||||
h1 := deriveAndFill(0, 1000, 0, db)
|
||||
h2 := deriveAndFill(500, 1000, 1, db)
|
||||
for i := 500; i < 1500; i++ {
|
||||
var kbuf [4]byte
|
||||
// don't update in place
|
||||
|
|
@ -410,25 +417,25 @@ func (s *testMemDBSuite) TestInspectStage(c *C) {
|
|||
binary.BigEndian.PutUint32(vbuf[:], uint32(i+2))
|
||||
db.Set(kbuf[:], vbuf[:])
|
||||
}
|
||||
h3 := s.deriveAndFill(1000, 2000, 3, db)
|
||||
h3 := deriveAndFill(1000, 2000, 3, db)
|
||||
|
||||
db.InspectStage(h3, func(key []byte, _ KeyFlags, val []byte) {
|
||||
k := int(binary.BigEndian.Uint32(key))
|
||||
v := int(binary.BigEndian.Uint32(val))
|
||||
|
||||
c.Assert(k >= 1000 && k < 2000, IsTrue)
|
||||
c.Assert(v-k, DeepEquals, 3)
|
||||
assert.True(k >= 1000 && k < 2000)
|
||||
assert.Equal(v-k, 3)
|
||||
})
|
||||
|
||||
db.InspectStage(h2, func(key []byte, _ KeyFlags, val []byte) {
|
||||
k := int(binary.BigEndian.Uint32(key))
|
||||
v := int(binary.BigEndian.Uint32(val))
|
||||
|
||||
c.Assert(k >= 500 && k < 2000, IsTrue)
|
||||
assert.True(k >= 500 && k < 2000)
|
||||
if k < 1000 {
|
||||
c.Assert(v-k, Equals, 2)
|
||||
assert.Equal(v-k, 2)
|
||||
} else {
|
||||
c.Assert(v-k, Equals, 3)
|
||||
assert.Equal(v-k, 3)
|
||||
}
|
||||
})
|
||||
|
||||
|
|
@ -439,49 +446,53 @@ func (s *testMemDBSuite) TestInspectStage(c *C) {
|
|||
k := int(binary.BigEndian.Uint32(key))
|
||||
v := int(binary.BigEndian.Uint32(val))
|
||||
|
||||
c.Assert(k >= 0 && k < 1500, IsTrue)
|
||||
assert.True(k >= 0 && k < 1500)
|
||||
if k < 500 {
|
||||
c.Assert(v-k, Equals, 0)
|
||||
assert.Equal(v-k, 0)
|
||||
} else {
|
||||
c.Assert(v-k, Equals, 2)
|
||||
assert.Equal(v-k, 2)
|
||||
}
|
||||
})
|
||||
|
||||
db.Release(h1)
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestDirty(c *C) {
|
||||
func TestDirty(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
db := newMemDB()
|
||||
db.Set([]byte{1}, []byte{1})
|
||||
c.Assert(db.Dirty(), IsTrue)
|
||||
assert.True(db.Dirty())
|
||||
|
||||
db = newMemDB()
|
||||
h := db.Staging()
|
||||
db.Set([]byte{1}, []byte{1})
|
||||
db.Cleanup(h)
|
||||
c.Assert(db.Dirty(), IsFalse)
|
||||
assert.False(db.Dirty())
|
||||
|
||||
h = db.Staging()
|
||||
db.Set([]byte{1}, []byte{1})
|
||||
db.Release(h)
|
||||
c.Assert(db.Dirty(), IsTrue)
|
||||
assert.True(db.Dirty())
|
||||
|
||||
// persistent flags will make memdb dirty.
|
||||
db = newMemDB()
|
||||
h = db.Staging()
|
||||
db.SetWithFlags([]byte{1}, []byte{1}, kv.SetKeyLocked)
|
||||
db.Cleanup(h)
|
||||
c.Assert(db.Dirty(), IsTrue)
|
||||
assert.True(db.Dirty())
|
||||
|
||||
// non-persistent flags will not make memdb dirty.
|
||||
db = newMemDB()
|
||||
h = db.Staging()
|
||||
db.SetWithFlags([]byte{1}, []byte{1}, kv.SetPresumeKeyNotExists)
|
||||
db.Cleanup(h)
|
||||
c.Assert(db.Dirty(), IsFalse)
|
||||
assert.False(db.Dirty())
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) TestFlags(c *C) {
|
||||
func TestFlags(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
const cnt = 10000
|
||||
db := newMemDB()
|
||||
h := db.Staging()
|
||||
|
|
@ -500,30 +511,30 @@ func (s *testMemDBSuite) TestFlags(c *C) {
|
|||
var buf [4]byte
|
||||
binary.BigEndian.PutUint32(buf[:], i)
|
||||
_, err := db.Get(buf[:])
|
||||
c.Assert(err, NotNil)
|
||||
assert.NotNil(err)
|
||||
flags, err := db.GetFlags(buf[:])
|
||||
if i%2 == 0 {
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(flags.HasLocked(), IsTrue)
|
||||
c.Assert(flags.HasPresumeKeyNotExists(), IsFalse)
|
||||
assert.Nil(err)
|
||||
assert.True(flags.HasLocked())
|
||||
assert.False(flags.HasPresumeKeyNotExists())
|
||||
} else {
|
||||
c.Assert(err, NotNil)
|
||||
assert.NotNil(err)
|
||||
}
|
||||
}
|
||||
|
||||
c.Assert(db.Len(), Equals, 5000)
|
||||
c.Assert(db.Size(), Equals, 20000)
|
||||
assert.Equal(db.Len(), 5000)
|
||||
assert.Equal(db.Size(), 20000)
|
||||
|
||||
it1, _ := db.Iter(nil, nil)
|
||||
it := it1.(*MemdbIterator)
|
||||
c.Assert(it.Valid(), IsFalse)
|
||||
assert.False(it.Valid())
|
||||
|
||||
it.includeFlags = true
|
||||
it.init()
|
||||
|
||||
for ; it.Valid(); it.Next() {
|
||||
k := binary.BigEndian.Uint32(it.Key())
|
||||
c.Assert(k%2 == 0, IsTrue)
|
||||
assert.True(k%2 == 0)
|
||||
}
|
||||
|
||||
for i := uint32(0); i < cnt; i++ {
|
||||
|
|
@ -535,18 +546,20 @@ func (s *testMemDBSuite) TestFlags(c *C) {
|
|||
var buf [4]byte
|
||||
binary.BigEndian.PutUint32(buf[:], i)
|
||||
_, err := db.Get(buf[:])
|
||||
c.Assert(err, NotNil)
|
||||
assert.NotNil(err)
|
||||
|
||||
// UpdateFlags will create missing node.
|
||||
flags, err := db.GetFlags(buf[:])
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(flags.HasLocked(), IsFalse)
|
||||
assert.Nil(err)
|
||||
assert.False(flags.HasLocked())
|
||||
}
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) checkConsist(c *C, p1 *MemDB, p2 *leveldb.DB) {
|
||||
c.Assert(p1.Len(), Equals, p2.Len())
|
||||
c.Assert(p1.Size(), Equals, p2.Size())
|
||||
func checkConsist(t *testing.T, p1 *MemDB, p2 *leveldb.DB) {
|
||||
assert := assert.New(t)
|
||||
|
||||
assert.Equal(p1.Len(), p2.Len())
|
||||
assert.Equal(p1.Size(), p2.Size())
|
||||
|
||||
it1, _ := p1.Iter(nil, nil)
|
||||
it2 := p2.NewIterator(nil)
|
||||
|
|
@ -554,20 +567,20 @@ func (s *testMemDBSuite) checkConsist(c *C, p1 *MemDB, p2 *leveldb.DB) {
|
|||
var prevKey, prevVal []byte
|
||||
for it2.First(); it2.Valid(); it2.Next() {
|
||||
v, err := p1.Get(it2.Key())
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(v, BytesEquals, it2.Value())
|
||||
assert.Nil(err)
|
||||
assert.Equal(v, it2.Value())
|
||||
|
||||
c.Assert(it1.Key(), BytesEquals, it2.Key())
|
||||
c.Assert(it1.Value(), BytesEquals, it2.Value())
|
||||
assert.Equal(it1.Key(), it2.Key())
|
||||
assert.Equal(it1.Value(), it2.Value())
|
||||
|
||||
it, _ := p1.Iter(it2.Key(), nil)
|
||||
c.Assert(it.Key(), BytesEquals, it2.Key())
|
||||
c.Assert(it.Value(), BytesEquals, it2.Value())
|
||||
assert.Equal(it.Key(), it2.Key())
|
||||
assert.Equal(it.Value(), it2.Value())
|
||||
|
||||
if prevKey != nil {
|
||||
it, _ = p1.IterReverse(it2.Key())
|
||||
c.Assert(it.Key(), BytesEquals, prevKey)
|
||||
c.Assert(it.Value(), BytesEquals, prevVal)
|
||||
assert.Equal(it.Key(), prevKey)
|
||||
assert.Equal(it.Value(), prevVal)
|
||||
}
|
||||
|
||||
it1.Next()
|
||||
|
|
@ -577,20 +590,20 @@ func (s *testMemDBSuite) checkConsist(c *C, p1 *MemDB, p2 *leveldb.DB) {
|
|||
|
||||
it1, _ = p1.IterReverse(nil)
|
||||
for it2.Last(); it2.Valid(); it2.Prev() {
|
||||
c.Assert(it1.Key(), BytesEquals, it2.Key())
|
||||
c.Assert(it1.Value(), BytesEquals, it2.Value())
|
||||
assert.Equal(it1.Key(), it2.Key())
|
||||
assert.Equal(it1.Value(), it2.Value())
|
||||
it1.Next()
|
||||
}
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) fillDB(cnt int) *MemDB {
|
||||
func fillDB(cnt int) *MemDB {
|
||||
db := newMemDB()
|
||||
h := s.deriveAndFill(0, cnt, 0, db)
|
||||
h := deriveAndFill(0, cnt, 0, db)
|
||||
db.Release(h)
|
||||
return db
|
||||
}
|
||||
|
||||
func (s *testMemDBSuite) deriveAndFill(start, end, valueBase int, db *MemDB) int {
|
||||
func deriveAndFill(start, end, valueBase int, db *MemDB) int {
|
||||
h := db.Staging()
|
||||
var kbuf, vbuf [4]byte
|
||||
for i := start; i < end; i++ {
|
||||
|
|
@ -607,24 +620,11 @@ const (
|
|||
indexStep = 2
|
||||
)
|
||||
|
||||
type testKVSuite struct {
|
||||
bs []*MemDB
|
||||
}
|
||||
|
||||
func (s *testKVSuite) SetUpSuite(c *C) {
|
||||
s.bs = make([]*MemDB, 1)
|
||||
s.bs[0] = newMemDB()
|
||||
}
|
||||
|
||||
func (s *testKVSuite) ResetMembuffers() {
|
||||
s.bs[0] = newMemDB()
|
||||
}
|
||||
|
||||
func insertData(c *C, buffer *MemDB) {
|
||||
func insertData(t *testing.T, buffer *MemDB) {
|
||||
for i := startIndex; i < testCount; i++ {
|
||||
val := encodeInt(i * indexStep)
|
||||
err := buffer.Set(val, val)
|
||||
c.Assert(err, IsNil)
|
||||
assert.Nil(t, err)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -638,18 +638,19 @@ func decodeInt(s []byte) int {
|
|||
return n
|
||||
}
|
||||
|
||||
func valToStr(c *C, iter Iterator) string {
|
||||
func valToStr(iter Iterator) string {
|
||||
val := iter.Value()
|
||||
return string(val)
|
||||
}
|
||||
|
||||
func checkNewIterator(c *C, buffer *MemDB) {
|
||||
func checkNewIterator(t *testing.T, buffer *MemDB) {
|
||||
assert := assert.New(t)
|
||||
for i := startIndex; i < testCount; i++ {
|
||||
val := encodeInt(i * indexStep)
|
||||
iter, err := buffer.Iter(val, nil)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(iter.Key(), BytesEquals, val)
|
||||
c.Assert(decodeInt([]byte(valToStr(c, iter))), Equals, i*indexStep)
|
||||
assert.Nil(err)
|
||||
assert.Equal(iter.Key(), val)
|
||||
assert.Equal(decodeInt([]byte(valToStr(iter))), i*indexStep)
|
||||
iter.Close()
|
||||
}
|
||||
|
||||
|
|
@ -657,67 +658,64 @@ func checkNewIterator(c *C, buffer *MemDB) {
|
|||
for i := startIndex; i < testCount-1; i++ {
|
||||
val := encodeInt(i * indexStep)
|
||||
iter, err := buffer.Iter(val, nil)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(iter.Key(), BytesEquals, val)
|
||||
c.Assert(valToStr(c, iter), Equals, string(val))
|
||||
assert.Nil(err)
|
||||
assert.Equal(iter.Key(), val)
|
||||
assert.Equal(valToStr(iter), string(val))
|
||||
|
||||
err = iter.Next()
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(iter.Valid(), IsTrue)
|
||||
assert.Nil(err)
|
||||
assert.True(iter.Valid())
|
||||
|
||||
val = encodeInt((i + 1) * indexStep)
|
||||
c.Assert(iter.Key(), BytesEquals, val)
|
||||
c.Assert(valToStr(c, iter), Equals, string(val))
|
||||
assert.Equal(iter.Key(), val)
|
||||
assert.Equal(valToStr(iter), string(val))
|
||||
iter.Close()
|
||||
}
|
||||
|
||||
// Non exist and beyond maximum seek test
|
||||
iter, err := buffer.Iter(encodeInt(testCount*indexStep), nil)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(iter.Valid(), IsFalse)
|
||||
assert.Nil(err)
|
||||
assert.False(iter.Valid())
|
||||
|
||||
// Non exist but between existing keys seek test,
|
||||
// it returns the smallest key that larger than the one we are seeking
|
||||
inBetween := encodeInt((testCount-1)*indexStep - 1)
|
||||
last := encodeInt((testCount - 1) * indexStep)
|
||||
iter, err = buffer.Iter(inBetween, nil)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(iter.Valid(), IsTrue)
|
||||
c.Assert(iter.Key(), Not(BytesEquals), inBetween)
|
||||
c.Assert(iter.Key(), BytesEquals, last)
|
||||
assert.Nil(err)
|
||||
assert.True(iter.Valid())
|
||||
assert.NotEqual(iter.Key(), inBetween)
|
||||
assert.Equal(iter.Key(), last)
|
||||
iter.Close()
|
||||
}
|
||||
|
||||
func mustGet(c *C, buffer *MemDB) {
|
||||
func mustGet(t *testing.T, buffer *MemDB) {
|
||||
for i := startIndex; i < testCount; i++ {
|
||||
s := encodeInt(i * indexStep)
|
||||
val, err := buffer.Get(s)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(string(val), Equals, string(s))
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, string(val), string(s))
|
||||
}
|
||||
}
|
||||
|
||||
func (s *testKVSuite) TestGetSet(c *C) {
|
||||
defer testleak.AfterTest(c)()
|
||||
for _, buffer := range s.bs {
|
||||
insertData(c, buffer)
|
||||
mustGet(c, buffer)
|
||||
}
|
||||
s.ResetMembuffers()
|
||||
func TestKVGetSet(t *testing.T) {
|
||||
defer testleak.AfterTestT(t)()
|
||||
buffer := newMemDB()
|
||||
insertData(t, buffer)
|
||||
mustGet(t, buffer)
|
||||
}
|
||||
|
||||
func (s *testKVSuite) TestNewIterator(c *C) {
|
||||
defer testleak.AfterTest(c)()
|
||||
for _, buffer := range s.bs {
|
||||
// should be invalid
|
||||
iter, err := buffer.Iter(nil, nil)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(iter.Valid(), IsFalse)
|
||||
func TestNewIterator(t *testing.T) {
|
||||
defer testleak.AfterTestT(t)()
|
||||
assert := assert.New(t)
|
||||
buffer := newMemDB()
|
||||
// should be invalid
|
||||
iter, err := buffer.Iter(nil, nil)
|
||||
assert.Nil(err)
|
||||
assert.False(iter.Valid())
|
||||
|
||||
insertData(c, buffer)
|
||||
checkNewIterator(c, buffer)
|
||||
}
|
||||
s.ResetMembuffers()
|
||||
insertData(t, buffer)
|
||||
checkNewIterator(t, buffer)
|
||||
}
|
||||
|
||||
// FnKeyCmp is the function for iterator the keys
|
||||
|
|
@ -737,32 +735,34 @@ func NextUntil(it Iterator, fn FnKeyCmp) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
func (s *testKVSuite) TestIterNextUntil(c *C) {
|
||||
defer testleak.AfterTest(c)()
|
||||
func TestIterNextUntil(t *testing.T) {
|
||||
defer testleak.AfterTestT(t)()
|
||||
assert := assert.New(t)
|
||||
buffer := newMemDB()
|
||||
insertData(c, buffer)
|
||||
insertData(t, buffer)
|
||||
|
||||
iter, err := buffer.Iter(nil, nil)
|
||||
c.Assert(err, IsNil)
|
||||
assert.Nil(err)
|
||||
|
||||
err = NextUntil(iter, func(k []byte) bool {
|
||||
return false
|
||||
})
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(iter.Valid(), IsFalse)
|
||||
assert.Nil(err)
|
||||
assert.False(iter.Valid())
|
||||
}
|
||||
|
||||
func (s *testKVSuite) TestBasicNewIterator(c *C) {
|
||||
defer testleak.AfterTest(c)()
|
||||
for _, buffer := range s.bs {
|
||||
it, err := buffer.Iter([]byte("2"), nil)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(it.Valid(), IsFalse)
|
||||
}
|
||||
func TestBasicNewIterator(t *testing.T) {
|
||||
defer testleak.AfterTestT(t)()
|
||||
assert := assert.New(t)
|
||||
buffer := newMemDB()
|
||||
it, err := buffer.Iter([]byte("2"), nil)
|
||||
assert.Nil(err)
|
||||
assert.False(it.Valid())
|
||||
}
|
||||
|
||||
func (s *testKVSuite) TestNewIteratorMin(c *C) {
|
||||
defer testleak.AfterTest(c)()
|
||||
func TestNewIteratorMin(t *testing.T) {
|
||||
defer testleak.AfterTestT(t)()
|
||||
assert := assert.New(t)
|
||||
kvs := []struct {
|
||||
key string
|
||||
value string
|
||||
|
|
@ -774,72 +774,72 @@ func (s *testKVSuite) TestNewIteratorMin(c *C) {
|
|||
{"DATA_test_main_db_tbl_tbl_test_record__00000000000000000002_0002", "2"},
|
||||
{"DATA_test_main_db_tbl_tbl_test_record__00000000000000000002_0003", "hello"},
|
||||
}
|
||||
for _, buffer := range s.bs {
|
||||
for _, kv := range kvs {
|
||||
err := buffer.Set([]byte(kv.key), []byte(kv.value))
|
||||
c.Assert(err, IsNil)
|
||||
}
|
||||
|
||||
cnt := 0
|
||||
it, err := buffer.Iter(nil, nil)
|
||||
c.Assert(err, IsNil)
|
||||
for it.Valid() {
|
||||
cnt++
|
||||
err := it.Next()
|
||||
c.Assert(err, IsNil)
|
||||
}
|
||||
c.Assert(cnt, Equals, 6)
|
||||
|
||||
it, err = buffer.Iter([]byte("DATA_test_main_db_tbl_tbl_test_record__00000000000000000000"), nil)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(string(it.Key()), Equals, "DATA_test_main_db_tbl_tbl_test_record__00000000000000000001")
|
||||
buffer := newMemDB()
|
||||
for _, kv := range kvs {
|
||||
err := buffer.Set([]byte(kv.key), []byte(kv.value))
|
||||
assert.Nil(err)
|
||||
}
|
||||
s.ResetMembuffers()
|
||||
|
||||
cnt := 0
|
||||
it, err := buffer.Iter(nil, nil)
|
||||
assert.Nil(err)
|
||||
for it.Valid() {
|
||||
cnt++
|
||||
err := it.Next()
|
||||
assert.Nil(err)
|
||||
}
|
||||
assert.Equal(cnt, 6)
|
||||
|
||||
it, err = buffer.Iter([]byte("DATA_test_main_db_tbl_tbl_test_record__00000000000000000000"), nil)
|
||||
assert.Nil(err)
|
||||
assert.Equal(string(it.Key()), "DATA_test_main_db_tbl_tbl_test_record__00000000000000000001")
|
||||
}
|
||||
|
||||
func (s *testKVSuite) TestMemDBStaging(c *C) {
|
||||
func TestMemDBStaging(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
buffer := newMemDB()
|
||||
err := buffer.Set([]byte("x"), make([]byte, 2))
|
||||
c.Assert(err, IsNil)
|
||||
assert.Nil(err)
|
||||
|
||||
h1 := buffer.Staging()
|
||||
err = buffer.Set([]byte("x"), make([]byte, 3))
|
||||
c.Assert(err, IsNil)
|
||||
assert.Nil(err)
|
||||
|
||||
h2 := buffer.Staging()
|
||||
err = buffer.Set([]byte("yz"), make([]byte, 1))
|
||||
c.Assert(err, IsNil)
|
||||
assert.Nil(err)
|
||||
|
||||
v, _ := buffer.Get([]byte("x"))
|
||||
c.Assert(len(v), Equals, 3)
|
||||
assert.Equal(len(v), 3)
|
||||
|
||||
buffer.Release(h2)
|
||||
|
||||
v, _ = buffer.Get([]byte("yz"))
|
||||
c.Assert(len(v), Equals, 1)
|
||||
assert.Equal(len(v), 1)
|
||||
|
||||
buffer.Cleanup(h1)
|
||||
|
||||
v, _ = buffer.Get([]byte("x"))
|
||||
c.Assert(len(v), Equals, 2)
|
||||
assert.Equal(len(v), 2)
|
||||
}
|
||||
|
||||
func (s *testKVSuite) TestBufferLimit(c *C) {
|
||||
func TestBufferLimit(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
buffer := newMemDB()
|
||||
buffer.bufferSizeLimit = 1000
|
||||
buffer.entrySizeLimit = 500
|
||||
|
||||
err := buffer.Set([]byte("x"), make([]byte, 500))
|
||||
c.Assert(err, NotNil) // entry size limit
|
||||
assert.NotNil(err) // entry size limit
|
||||
|
||||
err = buffer.Set([]byte("x"), make([]byte, 499))
|
||||
c.Assert(err, IsNil)
|
||||
assert.Nil(err)
|
||||
err = buffer.Set([]byte("yz"), make([]byte, 499))
|
||||
c.Assert(err, NotNil) // buffer size limit
|
||||
assert.NotNil(err) // buffer size limit
|
||||
|
||||
err = buffer.Delete(make([]byte, 499))
|
||||
c.Assert(err, IsNil)
|
||||
assert.Nil(err)
|
||||
|
||||
err = buffer.Delete(make([]byte, 500))
|
||||
c.Assert(err, NotNil)
|
||||
assert.NotNil(err)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,125 +34,131 @@ package unionstore
|
|||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
. "github.com/pingcap/check"
|
||||
"github.com/stretchr/testify/assert"
|
||||
tikverr "github.com/tikv/client-go/v2/error"
|
||||
"github.com/tikv/client-go/v2/util/testleak"
|
||||
)
|
||||
|
||||
var _ = Suite(&testUnionStoreSuite{})
|
||||
func TestUnionStoreGetSet(t *testing.T) {
|
||||
defer testleak.AfterTestT(t)()
|
||||
assert := assert.New(t)
|
||||
store := newMemDB()
|
||||
us := NewUnionStore(&mockSnapshot{store})
|
||||
|
||||
type testUnionStoreSuite struct {
|
||||
store *MemDB
|
||||
us *KVUnionStore
|
||||
err := store.Set([]byte("1"), []byte("1"))
|
||||
assert.Nil(err)
|
||||
v, err := us.Get(context.TODO(), []byte("1"))
|
||||
assert.Nil(err)
|
||||
assert.Equal(v, []byte("1"))
|
||||
err = us.GetMemBuffer().Set([]byte("1"), []byte("2"))
|
||||
assert.Nil(err)
|
||||
v, err = us.Get(context.TODO(), []byte("1"))
|
||||
assert.Nil(err)
|
||||
assert.Equal(v, []byte("2"))
|
||||
assert.Equal(us.GetMemBuffer().Size(), 2)
|
||||
assert.Equal(us.GetMemBuffer().Len(), 1)
|
||||
}
|
||||
|
||||
func (s *testUnionStoreSuite) SetUpTest(c *C) {
|
||||
s.store = newMemDB()
|
||||
s.us = NewUnionStore(&mockSnapshot{s.store})
|
||||
func TestUnionStoreDelete(t *testing.T) {
|
||||
defer testleak.AfterTestT(t)()
|
||||
assert := assert.New(t)
|
||||
store := newMemDB()
|
||||
us := NewUnionStore(&mockSnapshot{store})
|
||||
|
||||
err := store.Set([]byte("1"), []byte("1"))
|
||||
assert.Nil(err)
|
||||
err = us.GetMemBuffer().Delete([]byte("1"))
|
||||
assert.Nil(err)
|
||||
_, err = us.Get(context.TODO(), []byte("1"))
|
||||
assert.True(tikverr.IsErrNotFound(err))
|
||||
|
||||
err = us.GetMemBuffer().Set([]byte("1"), []byte("2"))
|
||||
assert.Nil(err)
|
||||
v, err := us.Get(context.TODO(), []byte("1"))
|
||||
assert.Nil(err)
|
||||
assert.Equal(v, []byte("2"))
|
||||
}
|
||||
|
||||
func (s *testUnionStoreSuite) TestGetSet(c *C) {
|
||||
defer testleak.AfterTest(c)()
|
||||
err := s.store.Set([]byte("1"), []byte("1"))
|
||||
c.Assert(err, IsNil)
|
||||
v, err := s.us.Get(context.TODO(), []byte("1"))
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(v, BytesEquals, []byte("1"))
|
||||
err = s.us.GetMemBuffer().Set([]byte("1"), []byte("2"))
|
||||
c.Assert(err, IsNil)
|
||||
v, err = s.us.Get(context.TODO(), []byte("1"))
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(v, BytesEquals, []byte("2"))
|
||||
c.Assert(s.us.GetMemBuffer().Size(), Equals, 2)
|
||||
c.Assert(s.us.GetMemBuffer().Len(), Equals, 1)
|
||||
func TestUnionStoreSeek(t *testing.T) {
|
||||
defer testleak.AfterTestT(t)()
|
||||
assert := assert.New(t)
|
||||
store := newMemDB()
|
||||
us := NewUnionStore(&mockSnapshot{store})
|
||||
|
||||
err := store.Set([]byte("1"), []byte("1"))
|
||||
assert.Nil(err)
|
||||
err = store.Set([]byte("2"), []byte("2"))
|
||||
assert.Nil(err)
|
||||
err = store.Set([]byte("3"), []byte("3"))
|
||||
assert.Nil(err)
|
||||
|
||||
iter, err := us.Iter(nil, nil)
|
||||
assert.Nil(err)
|
||||
checkIterator(t, iter, [][]byte{[]byte("1"), []byte("2"), []byte("3")}, [][]byte{[]byte("1"), []byte("2"), []byte("3")})
|
||||
|
||||
iter, err = us.Iter([]byte("2"), nil)
|
||||
assert.Nil(err)
|
||||
checkIterator(t, iter, [][]byte{[]byte("2"), []byte("3")}, [][]byte{[]byte("2"), []byte("3")})
|
||||
|
||||
err = us.GetMemBuffer().Set([]byte("4"), []byte("4"))
|
||||
assert.Nil(err)
|
||||
iter, err = us.Iter([]byte("2"), nil)
|
||||
assert.Nil(err)
|
||||
checkIterator(t, iter, [][]byte{[]byte("2"), []byte("3"), []byte("4")}, [][]byte{[]byte("2"), []byte("3"), []byte("4")})
|
||||
|
||||
err = us.GetMemBuffer().Delete([]byte("3"))
|
||||
assert.Nil(err)
|
||||
iter, err = us.Iter([]byte("2"), nil)
|
||||
assert.Nil(err)
|
||||
checkIterator(t, iter, [][]byte{[]byte("2"), []byte("4")}, [][]byte{[]byte("2"), []byte("4")})
|
||||
}
|
||||
|
||||
func (s *testUnionStoreSuite) TestDelete(c *C) {
|
||||
defer testleak.AfterTest(c)()
|
||||
err := s.store.Set([]byte("1"), []byte("1"))
|
||||
c.Assert(err, IsNil)
|
||||
err = s.us.GetMemBuffer().Delete([]byte("1"))
|
||||
c.Assert(err, IsNil)
|
||||
_, err = s.us.Get(context.TODO(), []byte("1"))
|
||||
c.Assert(tikverr.IsErrNotFound(err), IsTrue)
|
||||
func TestUnionStoreIterReverse(t *testing.T) {
|
||||
defer testleak.AfterTestT(t)()
|
||||
assert := assert.New(t)
|
||||
store := newMemDB()
|
||||
us := NewUnionStore(&mockSnapshot{store})
|
||||
|
||||
err = s.us.GetMemBuffer().Set([]byte("1"), []byte("2"))
|
||||
c.Assert(err, IsNil)
|
||||
v, err := s.us.Get(context.TODO(), []byte("1"))
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(v, BytesEquals, []byte("2"))
|
||||
err := store.Set([]byte("1"), []byte("1"))
|
||||
assert.Nil(err)
|
||||
err = store.Set([]byte("2"), []byte("2"))
|
||||
assert.Nil(err)
|
||||
err = store.Set([]byte("3"), []byte("3"))
|
||||
assert.Nil(err)
|
||||
|
||||
iter, err := us.IterReverse(nil)
|
||||
assert.Nil(err)
|
||||
checkIterator(t, iter, [][]byte{[]byte("3"), []byte("2"), []byte("1")}, [][]byte{[]byte("3"), []byte("2"), []byte("1")})
|
||||
|
||||
iter, err = us.IterReverse([]byte("3"))
|
||||
assert.Nil(err)
|
||||
checkIterator(t, iter, [][]byte{[]byte("2"), []byte("1")}, [][]byte{[]byte("2"), []byte("1")})
|
||||
|
||||
err = us.GetMemBuffer().Set([]byte("0"), []byte("0"))
|
||||
assert.Nil(err)
|
||||
iter, err = us.IterReverse([]byte("3"))
|
||||
assert.Nil(err)
|
||||
checkIterator(t, iter, [][]byte{[]byte("2"), []byte("1"), []byte("0")}, [][]byte{[]byte("2"), []byte("1"), []byte("0")})
|
||||
|
||||
err = us.GetMemBuffer().Delete([]byte("1"))
|
||||
assert.Nil(err)
|
||||
iter, err = us.IterReverse([]byte("3"))
|
||||
assert.Nil(err)
|
||||
checkIterator(t, iter, [][]byte{[]byte("2"), []byte("0")}, [][]byte{[]byte("2"), []byte("0")})
|
||||
}
|
||||
|
||||
func (s *testUnionStoreSuite) TestSeek(c *C) {
|
||||
defer testleak.AfterTest(c)()
|
||||
err := s.store.Set([]byte("1"), []byte("1"))
|
||||
c.Assert(err, IsNil)
|
||||
err = s.store.Set([]byte("2"), []byte("2"))
|
||||
c.Assert(err, IsNil)
|
||||
err = s.store.Set([]byte("3"), []byte("3"))
|
||||
c.Assert(err, IsNil)
|
||||
|
||||
iter, err := s.us.Iter(nil, nil)
|
||||
c.Assert(err, IsNil)
|
||||
checkIterator(c, iter, [][]byte{[]byte("1"), []byte("2"), []byte("3")}, [][]byte{[]byte("1"), []byte("2"), []byte("3")})
|
||||
|
||||
iter, err = s.us.Iter([]byte("2"), nil)
|
||||
c.Assert(err, IsNil)
|
||||
checkIterator(c, iter, [][]byte{[]byte("2"), []byte("3")}, [][]byte{[]byte("2"), []byte("3")})
|
||||
|
||||
err = s.us.GetMemBuffer().Set([]byte("4"), []byte("4"))
|
||||
c.Assert(err, IsNil)
|
||||
iter, err = s.us.Iter([]byte("2"), nil)
|
||||
c.Assert(err, IsNil)
|
||||
checkIterator(c, iter, [][]byte{[]byte("2"), []byte("3"), []byte("4")}, [][]byte{[]byte("2"), []byte("3"), []byte("4")})
|
||||
|
||||
err = s.us.GetMemBuffer().Delete([]byte("3"))
|
||||
c.Assert(err, IsNil)
|
||||
iter, err = s.us.Iter([]byte("2"), nil)
|
||||
c.Assert(err, IsNil)
|
||||
checkIterator(c, iter, [][]byte{[]byte("2"), []byte("4")}, [][]byte{[]byte("2"), []byte("4")})
|
||||
}
|
||||
|
||||
func (s *testUnionStoreSuite) TestIterReverse(c *C) {
|
||||
defer testleak.AfterTest(c)()
|
||||
err := s.store.Set([]byte("1"), []byte("1"))
|
||||
c.Assert(err, IsNil)
|
||||
err = s.store.Set([]byte("2"), []byte("2"))
|
||||
c.Assert(err, IsNil)
|
||||
err = s.store.Set([]byte("3"), []byte("3"))
|
||||
c.Assert(err, IsNil)
|
||||
|
||||
iter, err := s.us.IterReverse(nil)
|
||||
c.Assert(err, IsNil)
|
||||
checkIterator(c, iter, [][]byte{[]byte("3"), []byte("2"), []byte("1")}, [][]byte{[]byte("3"), []byte("2"), []byte("1")})
|
||||
|
||||
iter, err = s.us.IterReverse([]byte("3"))
|
||||
c.Assert(err, IsNil)
|
||||
checkIterator(c, iter, [][]byte{[]byte("2"), []byte("1")}, [][]byte{[]byte("2"), []byte("1")})
|
||||
|
||||
err = s.us.GetMemBuffer().Set([]byte("0"), []byte("0"))
|
||||
c.Assert(err, IsNil)
|
||||
iter, err = s.us.IterReverse([]byte("3"))
|
||||
c.Assert(err, IsNil)
|
||||
checkIterator(c, iter, [][]byte{[]byte("2"), []byte("1"), []byte("0")}, [][]byte{[]byte("2"), []byte("1"), []byte("0")})
|
||||
|
||||
err = s.us.GetMemBuffer().Delete([]byte("1"))
|
||||
c.Assert(err, IsNil)
|
||||
iter, err = s.us.IterReverse([]byte("3"))
|
||||
c.Assert(err, IsNil)
|
||||
checkIterator(c, iter, [][]byte{[]byte("2"), []byte("0")}, [][]byte{[]byte("2"), []byte("0")})
|
||||
}
|
||||
|
||||
func checkIterator(c *C, iter Iterator, keys [][]byte, values [][]byte) {
|
||||
func checkIterator(t *testing.T, iter Iterator, keys [][]byte, values [][]byte) {
|
||||
assert := assert.New(t)
|
||||
defer iter.Close()
|
||||
c.Assert(len(keys), Equals, len(values))
|
||||
assert.Equal(len(keys), len(values))
|
||||
for i, k := range keys {
|
||||
v := values[i]
|
||||
c.Assert(iter.Valid(), IsTrue)
|
||||
c.Assert(iter.Key(), BytesEquals, k)
|
||||
c.Assert(iter.Value(), BytesEquals, v)
|
||||
c.Assert(iter.Next(), IsNil)
|
||||
assert.True(iter.Valid())
|
||||
assert.Equal(iter.Key(), k)
|
||||
assert.Equal(iter.Value(), v)
|
||||
assert.Nil(iter.Next())
|
||||
}
|
||||
c.Assert(iter.Valid(), IsFalse)
|
||||
assert.False(iter.Valid())
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue