diff --git a/unionstore/memdb_norace_test.go b/unionstore/memdb_norace_test.go
index 17a3706b..07a635f9 100644
--- a/unionstore/memdb_norace_test.go
+++ b/unionstore/memdb_norace_test.go
@@ -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
diff --git a/unionstore/memdb_test.go b/unionstore/memdb_test.go
index 3d4d1e6e..b13fee8b 100644
--- a/unionstore/memdb_test.go
+++ b/unionstore/memdb_test.go
@@ -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)
 }
diff --git a/unionstore/union_store_test.go b/unionstore/union_store_test.go
index 8d9f7bd7..4bf569de 100644
--- a/unionstore/union_store_test.go
+++ b/unionstore/union_store_test.go
@@ -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())
 }