From 79d006244ff38f7582bf8051ee93ece23f8b84b9 Mon Sep 17 00:00:00 2001
From: Yujie Xia <xiayjchn@gmail.com>
Date: Tue, 23 Nov 2021 11:33:05 +0800
Subject: [PATCH 1/4] br/pkg/utils: migrate tests to testify

---
 br/pkg/utils/backoff_test.go    |  67 ++++++------
 br/pkg/utils/env_test.go        |  19 ++--
 br/pkg/utils/json_test.go       |  50 +++------
 br/pkg/utils/key_test.go        |  29 +++---
 br/pkg/utils/main_test.go       |  30 ++++++
 br/pkg/utils/math_test.go       |  70 +++++++------
 br/pkg/utils/progress.go        |  40 +++++---
 br/pkg/utils/progress_test.go   |  27 ++---
 br/pkg/utils/retry_test.go      |  71 +++++++------
 br/pkg/utils/safe_point_test.go |  36 +++----
 br/pkg/utils/schema_test.go     | 176 ++++++++++++++++++--------------
 br/pkg/utils/utils_test.go      |  13 ---
 12 files changed, 324 insertions(+), 304 deletions(-)
 create mode 100644 br/pkg/utils/main_test.go
 delete mode 100644 br/pkg/utils/utils_test.go

diff --git a/br/pkg/utils/backoff_test.go b/br/pkg/utils/backoff_test.go
index 31b1a0214d255..e8af459c78de6 100644
--- a/br/pkg/utils/backoff_test.go
+++ b/br/pkg/utils/backoff_test.go
@@ -4,35 +4,20 @@ package utils_test
 
 import (
 	"context"
+	"testing"
 	"time"
 
-	. "github.com/pingcap/check"
 	berrors "github.com/pingcap/tidb/br/pkg/errors"
-	"github.com/pingcap/tidb/br/pkg/mock"
 	"github.com/pingcap/tidb/br/pkg/utils"
-	"github.com/pingcap/tidb/util/testleak"
+	"github.com/stretchr/testify/require"
 	"go.uber.org/multierr"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
-var _ = Suite(&testBackofferSuite{})
+func TestBackoffWithSuccess(t *testing.T) {
+	t.Parallel()
 
-type testBackofferSuite struct {
-	mock *mock.Cluster
-}
-
-func (s *testBackofferSuite) SetUpSuite(c *C) {
-	var err error
-	s.mock, err = mock.NewCluster()
-	c.Assert(err, IsNil)
-}
-
-func (s *testBackofferSuite) TearDownSuite(c *C) {
-	testleak.AfterTest(c)()
-}
-
-func (s *testBackofferSuite) TestBackoffWithSuccess(c *C) {
 	var counter int
 	backoffer := utils.NewBackoffer(10, time.Nanosecond, time.Nanosecond)
 	err := utils.WithRetry(context.Background(), func() error {
@@ -47,11 +32,13 @@ func (s *testBackofferSuite) TestBackoffWithSuccess(c *C) {
 		}
 		return nil
 	}, backoffer)
-	c.Assert(counter, Equals, 3)
-	c.Assert(err, IsNil)
+	require.Equal(t, 3, counter)
+	require.NoError(t, err)
 }
 
-func (s *testBackofferSuite) TestBackoffWithFatalError(c *C) {
+func TestBackoffWithFatalError(t *testing.T) {
+	t.Parallel()
+
 	var counter int
 	backoffer := utils.NewBackoffer(10, time.Nanosecond, time.Nanosecond)
 	gRPCError := status.Error(codes.Unavailable, "transport is closing")
@@ -69,16 +56,18 @@ func (s *testBackofferSuite) TestBackoffWithFatalError(c *C) {
 		}
 		return nil
 	}, backoffer)
-	c.Assert(counter, Equals, 4)
-	c.Assert(multierr.Errors(err), DeepEquals, []error{
+	require.Equal(t, 4, counter)
+	require.Equal(t, []error{
 		gRPCError,
 		berrors.ErrKVEpochNotMatch,
 		berrors.ErrKVDownloadFailed,
 		berrors.ErrKVRangeIsEmpty,
-	})
+	}, multierr.Errors(err))
 }
 
-func (s *testBackofferSuite) TestBackoffWithFatalRawGRPCError(c *C) {
+func TestBackoffWithFatalRawGRPCError(t *testing.T) {
+	t.Parallel()
+
 	var counter int
 	canceledError := status.Error(codes.Canceled, "context canceled")
 	backoffer := utils.NewBackoffer(10, time.Nanosecond, time.Nanosecond)
@@ -86,21 +75,21 @@ func (s *testBackofferSuite) TestBackoffWithFatalRawGRPCError(c *C) {
 		defer func() { counter++ }()
 		return canceledError // nolint:wrapcheck
 	}, backoffer)
-	c.Assert(counter, Equals, 1)
-	c.Assert(multierr.Errors(err), DeepEquals, []error{
-		canceledError,
-	})
+	require.Equal(t, 1, counter)
+	require.Equal(t, []error{canceledError}, multierr.Errors(err))
 }
 
-func (s *testBackofferSuite) TestBackoffWithRetryableError(c *C) {
+func TestBackoffWithRetryableError(t *testing.T) {
+	t.Parallel()
+
 	var counter int
 	backoffer := utils.NewBackoffer(10, time.Nanosecond, time.Nanosecond)
 	err := utils.WithRetry(context.Background(), func() error {
 		defer func() { counter++ }()
 		return berrors.ErrKVEpochNotMatch
 	}, backoffer)
-	c.Assert(counter, Equals, 10)
-	c.Assert(multierr.Errors(err), DeepEquals, []error{
+	require.Equal(t, 10, counter)
+	require.Equal(t, []error{
 		berrors.ErrKVEpochNotMatch,
 		berrors.ErrKVEpochNotMatch,
 		berrors.ErrKVEpochNotMatch,
@@ -111,10 +100,12 @@ func (s *testBackofferSuite) TestBackoffWithRetryableError(c *C) {
 		berrors.ErrKVEpochNotMatch,
 		berrors.ErrKVEpochNotMatch,
 		berrors.ErrKVEpochNotMatch,
-	})
+	}, multierr.Errors(err))
 }
 
-func (s *testBackofferSuite) TestPdBackoffWithRetryableError(c *C) {
+func TestPdBackoffWithRetryableError(t *testing.T) {
+	t.Parallel()
+
 	var counter int
 	backoffer := utils.NewPDReqBackoffer()
 	gRPCError := status.Error(codes.Unavailable, "transport is closing")
@@ -122,8 +113,8 @@ func (s *testBackofferSuite) TestPdBackoffWithRetryableError(c *C) {
 		defer func() { counter++ }()
 		return gRPCError
 	}, backoffer)
-	c.Assert(counter, Equals, 16)
-	c.Assert(multierr.Errors(err), DeepEquals, []error{
+	require.Equal(t, 16, counter)
+	require.Equal(t, []error{
 		gRPCError,
 		gRPCError,
 		gRPCError,
@@ -140,5 +131,5 @@ func (s *testBackofferSuite) TestPdBackoffWithRetryableError(c *C) {
 		gRPCError,
 		gRPCError,
 		gRPCError,
-	})
+	}, multierr.Errors(err))
 }
diff --git a/br/pkg/utils/env_test.go b/br/pkg/utils/env_test.go
index 89ad840ee7fc7..493f30aaa4240 100644
--- a/br/pkg/utils/env_test.go
+++ b/br/pkg/utils/env_test.go
@@ -4,15 +4,14 @@ package utils
 
 import (
 	"os"
+	"testing"
 
-	"github.com/pingcap/check"
+	"github.com/stretchr/testify/require"
 )
 
-type envSuit struct{}
+func TestProxyFields(t *testing.T) {
+	t.Parallel()
 
-var _ = check.Suite(&envSuit{})
-
-func (s *envSuit) TestProxyFields(c *check.C) {
 	revIndex := map[string]int{
 		"http_proxy":  0,
 		"https_proxy": 1,
@@ -25,20 +24,20 @@ func (s *envSuit) TestProxyFields(c *check.C) {
 	// Each bit of the mask decided whether this index of `envs` would be set.
 	for mask := 0; mask <= 0b111; mask++ {
 		for _, env := range envs {
-			c.Assert(os.Unsetenv(env), check.IsNil)
+			require.NoError(t, os.Unsetenv(env))
 		}
 
 		for i := 0; i < 3; i++ {
 			if (1<<i)&mask != 0 {
-				c.Assert(os.Setenv(envs[i], envPreset[i]), check.IsNil)
+				require.NoError(t, os.Setenv(envs[i], envPreset[i]))
 			}
 		}
 
 		for _, field := range proxyFields() {
 			idx, ok := revIndex[field.Key]
-			c.Assert(ok, check.IsTrue)
-			c.Assert((1<<idx)&mask, check.Not(check.Equals), 0)
-			c.Assert(field.String, check.Equals, envPreset[idx])
+			require.True(t, ok)
+			require.NotEqual(t, 0, (1<<idx)&mask)
+			require.Equal(t, envPreset[idx], field.String)
 		}
 	}
 }
diff --git a/br/pkg/utils/json_test.go b/br/pkg/utils/json_test.go
index 37fe8e9c683a3..caf40bebfcda7 100644
--- a/br/pkg/utils/json_test.go
+++ b/br/pkg/utils/json_test.go
@@ -2,16 +2,11 @@ package utils
 
 import (
 	"encoding/json"
-	"fmt"
-	"reflect"
+	"testing"
 
-	. "github.com/pingcap/check"
+	"github.com/stretchr/testify/require"
 )
 
-type testJSONSuite struct{}
-
-var _ = Suite(&testJSONSuite{})
-
 var testMetaJSONs = [][]byte{
 	[]byte(`{
   "files": [
@@ -212,40 +207,19 @@ var testMetaJSONs = [][]byte{
 }`),
 }
 
-type jsonEquals struct{}
-
-func (j jsonEquals) Info() *CheckerInfo {
-	return &CheckerInfo{
-		Name:   "JSONEquals",
-		Params: []string{"lhs", "rhs"},
-	}
-}
-
-func (j jsonEquals) Check(params []interface{}, _ []string) (result bool, error string) {
-	lhs := params[0].([]byte)
-	rhs := params[1].([]byte)
-
-	lhsMap := map[string]interface{}{}
-	rhsMap := map[string]interface{}{}
+func TestEncodeAndDecode(t *testing.T) {
+	t.Parallel()
 
-	if err := json.Unmarshal(lhs, &lhsMap); err != nil {
-		return false, fmt.Sprintf("failed to unmarshal lhs: %s", error)
-	}
-	if err := json.Unmarshal(rhs, &rhsMap); err != nil {
-		return false, fmt.Sprintf("failed to unmarshal rhs: %s", error)
-	}
-	if !reflect.DeepEqual(lhsMap, rhsMap) {
-		return false, fmt.Sprintf("lhs %s not equals rhs %s", lhsMap, rhsMap)
-	}
-	return true, ""
-}
-
-func (testJSONSuite) TestEncodeAndDecode(c *C) {
 	for _, testMetaJSON := range testMetaJSONs {
 		meta, err := UnmarshalBackupMeta(testMetaJSON)
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 		metaJSON, err := MarshalBackupMeta(meta)
-		c.Assert(err, IsNil)
-		c.Assert(metaJSON, jsonEquals{}, testMetaJSON)
+		require.NoError(t, err)
+
+		var metaMap map[string]interface{}
+		require.NoError(t, json.Unmarshal(metaJSON, &metaMap))
+		var testMetaMap map[string]interface{}
+		require.NoError(t, json.Unmarshal(testMetaJSON, &testMetaMap))
+		require.Equal(t, testMetaMap, metaMap)
 	}
 }
diff --git a/br/pkg/utils/key_test.go b/br/pkg/utils/key_test.go
index a6825d3218d6d..b9b05bf7405b4 100644
--- a/br/pkg/utils/key_test.go
+++ b/br/pkg/utils/key_test.go
@@ -4,15 +4,14 @@ package utils
 
 import (
 	"encoding/hex"
+	"testing"
 
-	. "github.com/pingcap/check"
+	"github.com/stretchr/testify/require"
 )
 
-type testKeySuite struct{}
+func TestParseKey(t *testing.T) {
+	t.Parallel()
 
-var _ = Suite(&testKeySuite{})
-
-func (r *testKeySuite) TestParseKey(c *C) {
 	// test rawKey
 	testRawKey := []struct {
 		rawKey string
@@ -28,8 +27,8 @@ func (r *testKeySuite) TestParseKey(c *C) {
 
 	for _, tt := range testRawKey {
 		parsedKey, err := ParseKey("raw", tt.rawKey)
-		c.Assert(err, IsNil)
-		c.Assert(parsedKey, BytesEquals, tt.ans)
+		require.NoError(t, err)
+		require.Equal(t, tt.ans, parsedKey)
 	}
 
 	// test EscapedKey
@@ -46,8 +45,8 @@ func (r *testKeySuite) TestParseKey(c *C) {
 
 	for _, tt := range testEscapedKey {
 		parsedKey, err := ParseKey("escaped", tt.EscapedKey)
-		c.Assert(err, IsNil)
-		c.Assert(parsedKey, BytesEquals, tt.ans)
+		require.NoError(t, err)
+		require.Equal(t, tt.ans, parsedKey)
 	}
 
 	// test hexKey
@@ -68,8 +67,8 @@ func (r *testKeySuite) TestParseKey(c *C) {
 	for _, tt := range testHexKey {
 		key := hex.EncodeToString([]byte(tt.hexKey))
 		parsedKey, err := ParseKey("hex", key)
-		c.Assert(err, IsNil)
-		c.Assert(parsedKey, BytesEquals, tt.ans)
+		require.NoError(t, err)
+		require.Equal(t, tt.ans, parsedKey)
 	}
 
 	// test other
@@ -89,11 +88,13 @@ func (r *testKeySuite) TestParseKey(c *C) {
 
 	for _, tt := range testNotSupportKey {
 		_, err := ParseKey("notSupport", tt.any)
-		c.Assert(err, ErrorMatches, "unknown format.*")
+		require.Regexp(t, "unknown format.*", err.Error())
 	}
 }
 
-func (r *testKeySuite) TestCompareEndKey(c *C) {
+func TestCompareEndKey(t *testing.T) {
+	t.Parallel()
+
 	// test endKey
 	testCase := []struct {
 		key1 []byte
@@ -110,6 +111,6 @@ func (r *testKeySuite) TestCompareEndKey(c *C) {
 
 	for _, tt := range testCase {
 		res := CompareEndKey(tt.key1, tt.key2)
-		c.Assert(res, Equals, tt.ans)
+		require.Equal(t, tt.ans, res)
 	}
 }
diff --git a/br/pkg/utils/main_test.go b/br/pkg/utils/main_test.go
new file mode 100644
index 0000000000000..47d7fd9b63b21
--- /dev/null
+++ b/br/pkg/utils/main_test.go
@@ -0,0 +1,30 @@
+// Copyright 2021 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+	"testing"
+
+	"github.com/pingcap/tidb/util/testbridge"
+	"go.uber.org/goleak"
+)
+
+func TestMain(m *testing.M) {
+	opts := []goleak.Option{
+		goleak.IgnoreTopFunction("go.opencensus.io/stats/view.(*worker).start"),
+	}
+	testbridge.WorkaroundGoCheckFlags()
+	goleak.VerifyTestMain(m, opts...)
+}
diff --git a/br/pkg/utils/math_test.go b/br/pkg/utils/math_test.go
index 35933c209e4cd..45a3da7587ffd 100644
--- a/br/pkg/utils/math_test.go
+++ b/br/pkg/utils/math_test.go
@@ -3,46 +3,54 @@
 package utils
 
 import (
-	. "github.com/pingcap/check"
-)
+	"testing"
 
-type testMathSuite struct{}
+	"github.com/stretchr/testify/require"
+)
 
-var _ = Suite(&testMathSuite{})
+func TestMinInt(t *testing.T) {
+	t.Parallel()
 
-func (*testMathSuite) TestMinInt(c *C) {
-	c.Assert(MinInt(1, 2), Equals, 1)
-	c.Assert(MinInt(2, 1), Equals, 1)
-	c.Assert(MinInt(4, 2, 1, 3), Equals, 1)
-	c.Assert(MinInt(1, 1), Equals, 1)
+	require.Equal(t, 1, MinInt(1, 2))
+	require.Equal(t, 1, MinInt(2, 1))
+	require.Equal(t, 1, MinInt(4, 2, 1, 3))
+	require.Equal(t, 1, MinInt(1, 1))
 }
 
-func (*testMathSuite) TestMaxInt(c *C) {
-	c.Assert(MaxInt(1, 2), Equals, 2)
-	c.Assert(MaxInt(2, 1), Equals, 2)
-	c.Assert(MaxInt(4, 2, 1, 3), Equals, 4)
-	c.Assert(MaxInt(1, 1), Equals, 1)
+func TestMaxInt(t *testing.T) {
+	t.Parallel()
+
+	require.Equal(t, 2, MaxInt(1, 2))
+	require.Equal(t, 2, MaxInt(2, 1))
+	require.Equal(t, 4, MaxInt(4, 2, 1, 3))
+	require.Equal(t, 1, MaxInt(1, 1))
 }
 
-func (*testMathSuite) TestClampInt(c *C) {
-	c.Assert(ClampInt(100, 1, 3), Equals, 3)
-	c.Assert(ClampInt(2, 1, 3), Equals, 2)
-	c.Assert(ClampInt(0, 1, 3), Equals, 1)
-	c.Assert(ClampInt(0, 1, 1), Equals, 1)
-	c.Assert(ClampInt(100, 1, 1), Equals, 1)
+func TestClampInt(t *testing.T) {
+	t.Parallel()
+
+	require.Equal(t, 3, ClampInt(100, 1, 3))
+	require.Equal(t, 2, ClampInt(2, 1, 3))
+	require.Equal(t, 1, ClampInt(0, 1, 3))
+	require.Equal(t, 1, ClampInt(0, 1, 1))
+	require.Equal(t, 1, ClampInt(100, 1, 1))
 }
 
-func (*testMathSuite) TestMinInt64(c *C) {
-	c.Assert(MinInt(1, 2), Equals, 1)
-	c.Assert(MinInt(2, 1), Equals, 1)
-	c.Assert(MinInt(4, 2, 1, 3), Equals, 1)
-	c.Assert(MinInt(1, 1), Equals, 1)
+func TestMinInt64(t *testing.T) {
+	t.Parallel()
+
+	require.Equal(t, 1, MinInt(1, 2))
+	require.Equal(t, 1, MinInt(2, 1))
+	require.Equal(t, 1, MinInt(4, 2, 1, 3))
+	require.Equal(t, 1, MinInt(1, 1))
 }
 
-func (*testMathSuite) TestNextPowerOfTwo(c *C) {
-	c.Assert(NextPowerOfTwo(1), Equals, int64(1))
-	c.Assert(NextPowerOfTwo(3), Equals, int64(4))
-	c.Assert(NextPowerOfTwo(255), Equals, int64(256))
-	c.Assert(NextPowerOfTwo(1024), Equals, int64(1024))
-	c.Assert(NextPowerOfTwo(0xabcd1234), Equals, int64(0x100000000))
+func TestNextPowerOfTwo(t *testing.T) {
+	t.Parallel()
+
+	require.Equal(t, int64(1), NextPowerOfTwo(1))
+	require.Equal(t, int64(4), NextPowerOfTwo(3))
+	require.Equal(t, int64(256), NextPowerOfTwo(255))
+	require.Equal(t, int64(1024), NextPowerOfTwo(1024))
+	require.Equal(t, int64(0x100000000), NextPowerOfTwo(0xabcd1234))
 }
diff --git a/br/pkg/utils/progress.go b/br/pkg/utils/progress.go
index 4c502b5e22ae6..d75c6345110bd 100644
--- a/br/pkg/utils/progress.go
+++ b/br/pkg/utils/progress.go
@@ -6,6 +6,7 @@ import (
 	"context"
 	"encoding/json"
 	"io"
+	"sync"
 	"sync/atomic"
 	"time"
 
@@ -24,7 +25,9 @@ type ProgressPrinter struct {
 	redirectLog bool
 	progress    int64
 
-	cancel context.CancelFunc
+	closeMu sync.Mutex
+	closeCh chan struct{}
+	closed  chan struct{}
 }
 
 // NewProgressPrinter returns a new progress printer.
@@ -37,9 +40,6 @@ func NewProgressPrinter(
 		name:        name,
 		total:       total,
 		redirectLog: redirectLog,
-		cancel: func() {
-			log.Warn("canceling non-started progress printer")
-		},
 	}
 }
 
@@ -50,7 +50,18 @@ func (pp *ProgressPrinter) Inc() {
 
 // Close closes the current progress bar.
 func (pp *ProgressPrinter) Close() {
-	pp.cancel()
+	pp.closeMu.Lock()
+	defer pp.closeMu.Unlock()
+
+	if pp.closeCh != nil {
+		select {
+		case pp.closeCh <- struct{}{}:
+		default:
+		}
+		<-pp.closed
+	} else {
+		log.Warn("closing no-started progress printer")
+	}
 }
 
 // goPrintProgress starts a gorouinte and prints progress.
@@ -59,8 +70,6 @@ func (pp *ProgressPrinter) goPrintProgress(
 	logFuncImpl logFunc,
 	testWriter io.Writer, // Only for tests
 ) {
-	cctx, cancel := context.WithCancel(ctx)
-	pp.cancel = cancel
 	bar := pb.New64(pp.total)
 	if pp.redirectLog || testWriter != nil {
 		tmpl := `{"P":"{{percent .}}","C":"{{counters . }}","E":"{{etime .}}","R":"{{rtime .}}","S":"{{speed .}}"}`
@@ -86,20 +95,27 @@ func (pp *ProgressPrinter) goPrintProgress(
 	}
 	bar.Start()
 
+	closeCh := make(chan struct{}, 1)
+	closed := make(chan struct{})
+	pp.closeMu.Lock()
+	pp.closeCh = closeCh
+	pp.closed = closed
+	pp.closeMu.Unlock()
 	go func() {
+		defer close(closed)
 		t := time.NewTicker(time.Second)
 		defer t.Stop()
 		defer bar.Finish()
 
 		for {
 			select {
-			case <-cctx.Done():
+			case <-ctx.Done():
+				// a hacky way to adapt the old behavior:
+				// when canceled by the context, leave the progress unchanged.
+				return
+			case <-closeCh:
 				// a hacky way to adapt the old behavior:
-				// when canceled by the outer context, leave the progress unchanged.
 				// when canceled by Close method (the 'internal' way), push the progress to 100%.
-				if ctx.Err() != nil {
-					return
-				}
 				bar.SetCurrent(pp.total)
 				return
 			case <-t.C:
diff --git a/br/pkg/utils/progress_test.go b/br/pkg/utils/progress_test.go
index 311ec2fdf0a6f..a101101166168 100644
--- a/br/pkg/utils/progress_test.go
+++ b/br/pkg/utils/progress_test.go
@@ -4,15 +4,12 @@ package utils
 
 import (
 	"context"
+	"testing"
 	"time"
 
-	. "github.com/pingcap/check"
+	"github.com/stretchr/testify/require"
 )
 
-type testProgressSuite struct{}
-
-var _ = Suite(&testProgressSuite{})
-
 type testWriter struct {
 	fn func(string)
 }
@@ -22,7 +19,9 @@ func (t *testWriter) Write(p []byte) (int, error) {
 	return len(p), nil
 }
 
-func (r *testProgressSuite) TestProgress(c *C) {
+func TestProgress(t *testing.T) {
+	t.Parallel()
+
 	ctx, cancel := context.WithCancel(context.Background())
 
 	var p string
@@ -34,15 +33,16 @@ func (r *testProgressSuite) TestProgress(c *C) {
 	progress2.Inc()
 	time.Sleep(2 * time.Second)
 	p = <-pCh2
-	c.Assert(p, Matches, `.*"P":"50\.00%".*`)
+	require.Regexp(t, `.*"P":"50\.00%".*`, p)
 	progress2.Inc()
 	time.Sleep(2 * time.Second)
 	p = <-pCh2
-	c.Assert(p, Matches, `.*"P":"100\.00%".*`)
+	require.Regexp(t, `.*"P":"100\.00%".*`, p)
 	progress2.Inc()
 	time.Sleep(2 * time.Second)
 	p = <-pCh2
-	c.Assert(p, Matches, `.*"P":"100\.00%".*`)
+	require.Regexp(t, `.*"P":"100\.00%".*`, p)
+	progress2.Close()
 
 	pCh4 := make(chan string, 4)
 	progress4 := NewProgressPrinter("test", 4, false)
@@ -52,12 +52,12 @@ func (r *testProgressSuite) TestProgress(c *C) {
 	progress4.Inc()
 	time.Sleep(2 * time.Second)
 	p = <-pCh4
-	c.Assert(p, Matches, `.*"P":"25\.00%".*`)
+	require.Regexp(t, `.*"P":"25\.00%".*`, p)
 	progress4.Inc()
 	progress4.Close()
 	time.Sleep(2 * time.Second)
 	p = <-pCh4
-	c.Assert(p, Matches, `.*"P":"100\.00%".*`)
+	require.Regexp(t, `.*"P":"100\.00%".*`, p)
 
 	pCh8 := make(chan string, 8)
 	progress8 := NewProgressPrinter("test", 8, false)
@@ -68,10 +68,11 @@ func (r *testProgressSuite) TestProgress(c *C) {
 	progress8.Inc()
 	time.Sleep(2 * time.Second)
 	p = <-pCh8
-	c.Assert(p, Matches, `.*"P":"25\.00%".*`)
+	require.Regexp(t, `.*"P":"25\.00%".*`, p)
 
 	// Cancel should stop progress at the current position.
 	cancel()
 	p = <-pCh8
-	c.Assert(p, Matches, `.*"P":"25\.00%".*`)
+	require.Regexp(t, `.*"P":"25\.00%".*`, p)
+	progress8.Close()
 }
diff --git a/br/pkg/utils/retry_test.go b/br/pkg/utils/retry_test.go
index b5c54287f1cce..52d65fd1c7a23 100644
--- a/br/pkg/utils/retry_test.go
+++ b/br/pkg/utils/retry_test.go
@@ -5,58 +5,57 @@ import (
 	"fmt"
 	"io"
 	"net"
+	"testing"
 
 	"github.com/go-sql-driver/mysql"
-	. "github.com/pingcap/check"
 	"github.com/pingcap/errors"
 	tmysql "github.com/pingcap/tidb/errno"
+	"github.com/stretchr/testify/require"
 	"go.uber.org/multierr"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
-type utilSuite struct{}
+func TestIsRetryableError(t *testing.T) {
+	t.Parallel()
 
-var _ = Suite(&utilSuite{})
-
-func (s *utilSuite) TestIsRetryableError(c *C) {
-	c.Assert(IsRetryableError(context.Canceled), IsFalse)
-	c.Assert(IsRetryableError(context.DeadlineExceeded), IsFalse)
-	c.Assert(IsRetryableError(io.EOF), IsFalse)
-	c.Assert(IsRetryableError(&net.AddrError{}), IsFalse)
-	c.Assert(IsRetryableError(&net.DNSError{}), IsFalse)
-	c.Assert(IsRetryableError(&net.DNSError{IsTimeout: true}), IsTrue)
+	require.False(t, IsRetryableError(context.Canceled))
+	require.False(t, IsRetryableError(context.DeadlineExceeded))
+	require.False(t, IsRetryableError(io.EOF))
+	require.False(t, IsRetryableError(&net.AddrError{}))
+	require.False(t, IsRetryableError(&net.DNSError{}))
+	require.True(t, IsRetryableError(&net.DNSError{IsTimeout: true}))
 
 	// MySQL Errors
-	c.Assert(IsRetryableError(&mysql.MySQLError{}), IsFalse)
-	c.Assert(IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrUnknown}), IsTrue)
-	c.Assert(IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrLockDeadlock}), IsTrue)
-	c.Assert(IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrPDServerTimeout}), IsTrue)
-	c.Assert(IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrTiKVServerTimeout}), IsTrue)
-	c.Assert(IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrTiKVServerBusy}), IsTrue)
-	c.Assert(IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrResolveLockTimeout}), IsTrue)
-	c.Assert(IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrRegionUnavailable}), IsTrue)
-	c.Assert(IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrWriteConflictInTiDB}), IsTrue)
+	require.False(t, IsRetryableError(&mysql.MySQLError{}))
+	require.True(t, IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrUnknown}))
+	require.True(t, IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrLockDeadlock}))
+	require.True(t, IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrPDServerTimeout}))
+	require.True(t, IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrTiKVServerTimeout}))
+	require.True(t, IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrTiKVServerBusy}))
+	require.True(t, IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrResolveLockTimeout}))
+	require.True(t, IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrRegionUnavailable}))
+	require.True(t, IsRetryableError(&mysql.MySQLError{Number: tmysql.ErrWriteConflictInTiDB}))
 
 	// gRPC Errors
-	c.Assert(IsRetryableError(status.Error(codes.Canceled, "")), IsFalse)
-	c.Assert(IsRetryableError(status.Error(codes.Unknown, "")), IsTrue)
-	c.Assert(IsRetryableError(status.Error(codes.DeadlineExceeded, "")), IsTrue)
-	c.Assert(IsRetryableError(status.Error(codes.NotFound, "")), IsTrue)
-	c.Assert(IsRetryableError(status.Error(codes.AlreadyExists, "")), IsTrue)
-	c.Assert(IsRetryableError(status.Error(codes.PermissionDenied, "")), IsTrue)
-	c.Assert(IsRetryableError(status.Error(codes.ResourceExhausted, "")), IsTrue)
-	c.Assert(IsRetryableError(status.Error(codes.Aborted, "")), IsTrue)
-	c.Assert(IsRetryableError(status.Error(codes.OutOfRange, "")), IsTrue)
-	c.Assert(IsRetryableError(status.Error(codes.Unavailable, "")), IsTrue)
-	c.Assert(IsRetryableError(status.Error(codes.DataLoss, "")), IsTrue)
+	require.False(t, IsRetryableError(status.Error(codes.Canceled, "")))
+	require.True(t, IsRetryableError(status.Error(codes.Unknown, "")))
+	require.True(t, IsRetryableError(status.Error(codes.DeadlineExceeded, "")))
+	require.True(t, IsRetryableError(status.Error(codes.NotFound, "")))
+	require.True(t, IsRetryableError(status.Error(codes.AlreadyExists, "")))
+	require.True(t, IsRetryableError(status.Error(codes.PermissionDenied, "")))
+	require.True(t, IsRetryableError(status.Error(codes.ResourceExhausted, "")))
+	require.True(t, IsRetryableError(status.Error(codes.Aborted, "")))
+	require.True(t, IsRetryableError(status.Error(codes.OutOfRange, "")))
+	require.True(t, IsRetryableError(status.Error(codes.Unavailable, "")))
+	require.True(t, IsRetryableError(status.Error(codes.DataLoss, "")))
 
 	// sqlmock errors
-	c.Assert(IsRetryableError(fmt.Errorf("call to database Close was not expected")), IsFalse)
-	c.Assert(IsRetryableError(errors.New("call to database Close was not expected")), IsTrue)
+	require.False(t, IsRetryableError(fmt.Errorf("call to database Close was not expected")))
+	require.True(t, IsRetryableError(errors.New("call to database Close was not expected")))
 
 	// multierr
-	c.Assert(IsRetryableError(multierr.Combine(context.Canceled, context.Canceled)), IsFalse)
-	c.Assert(IsRetryableError(multierr.Combine(&net.DNSError{IsTimeout: true}, &net.DNSError{IsTimeout: true})), IsTrue)
-	c.Assert(IsRetryableError(multierr.Combine(context.Canceled, &net.DNSError{IsTimeout: true})), IsFalse)
+	require.False(t, IsRetryableError(multierr.Combine(context.Canceled, context.Canceled)))
+	require.True(t, IsRetryableError(multierr.Combine(&net.DNSError{IsTimeout: true}, &net.DNSError{IsTimeout: true})))
+	require.False(t, IsRetryableError(multierr.Combine(context.Canceled, &net.DNSError{IsTimeout: true})))
 }
diff --git a/br/pkg/utils/safe_point_test.go b/br/pkg/utils/safe_point_test.go
index ac03a88dee87a..cb964e5b9352f 100644
--- a/br/pkg/utils/safe_point_test.go
+++ b/br/pkg/utils/safe_point_test.go
@@ -5,41 +5,33 @@ package utils_test
 import (
 	"context"
 	"sync"
+	"testing"
 
-	. "github.com/pingcap/check"
 	"github.com/pingcap/tidb/br/pkg/utils"
-	"github.com/pingcap/tidb/util/testleak"
+	"github.com/stretchr/testify/require"
 	pd "github.com/tikv/pd/client"
 )
 
-var _ = Suite(&testSafePointSuite{})
+func TestCheckGCSafepoint(t *testing.T) {
+	t.Parallel()
 
-type testSafePointSuite struct{}
-
-func (s *testSafePointSuite) SetUpSuite(c *C) {}
-
-func (s *testSafePointSuite) TearDownSuite(c *C) {
-	testleak.AfterTest(c)()
-}
-
-func (s *testSafePointSuite) TestCheckGCSafepoint(c *C) {
 	ctx := context.Background()
 	pdClient := &mockSafePoint{safepoint: 2333}
 	{
 		err := utils.CheckGCSafePoint(ctx, pdClient, 2333+1)
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 	}
 	{
 		err := utils.CheckGCSafePoint(ctx, pdClient, 2333)
-		c.Assert(err, NotNil)
+		require.NotNil(t, err)
 	}
 	{
 		err := utils.CheckGCSafePoint(ctx, pdClient, 2333-1)
-		c.Assert(err, NotNil)
+		require.NotNil(t, err)
 	}
 	{
 		err := utils.CheckGCSafePoint(ctx, pdClient, 0)
-		c.Assert(err, ErrorMatches, ".*GC safepoint 2333 exceed TS 0.*")
+		require.Regexp(t, ".*GC safepoint 2333 exceed TS 0.*", err)
 	}
 }
 
@@ -73,7 +65,9 @@ func (m *mockSafePoint) UpdateGCSafePoint(ctx context.Context, safePoint uint64)
 	return m.safepoint, nil
 }
 
-func (s *testSafePointSuite) TestStartServiceSafePointKeeper(c *C) {
+func TestStartServiceSafePointKeeper(t *testing.T) {
+	t.Parallel()
+
 	pdClient := &mockSafePoint{safepoint: 2333}
 
 	cases := []struct {
@@ -128,11 +122,11 @@ func (s *testSafePointSuite) TestStartServiceSafePointKeeper(c *C) {
 	for i, cs := range cases {
 		ctx, cancel := context.WithCancel(context.Background())
 		err := utils.StartServiceSafePointKeeper(ctx, pdClient, cs.sp)
-		checker := IsNil
-		if !cs.ok {
-			checker = NotNil
+		if cs.ok {
+			require.NoErrorf(t, err, "case #%d, %v", i, cs)
+		} else {
+			require.NotNilf(t, err, "case #%d, %v", i, cs)
 		}
-		c.Assert(err, checker, Commentf("case #%d, %v", i, cs))
 		cancel()
 	}
 }
diff --git a/br/pkg/utils/schema_test.go b/br/pkg/utils/schema_test.go
index 5e3e484175760..97ace3c6c130b 100644
--- a/br/pkg/utils/schema_test.go
+++ b/br/pkg/utils/schema_test.go
@@ -6,9 +6,10 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"os"
+	"testing"
 
 	"github.com/golang/protobuf/proto"
-	. "github.com/pingcap/check"
 	backuppb "github.com/pingcap/kvproto/pkg/brpb"
 	"github.com/pingcap/kvproto/pkg/encryptionpb"
 	"github.com/pingcap/tidb/br/pkg/metautil"
@@ -16,21 +17,9 @@ import (
 	"github.com/pingcap/tidb/parser/model"
 	"github.com/pingcap/tidb/statistics/handle"
 	"github.com/pingcap/tidb/tablecodec"
+	"github.com/stretchr/testify/require"
 )
 
-type testSchemaSuite struct {
-	store storage.ExternalStorage
-}
-
-var _ = Suite(&testSchemaSuite{})
-
-func (r *testSchemaSuite) SetUpSuite(c *C) {
-	var err error
-	base := c.MkDir()
-	r.store, err = storage.NewLocalStorage(base)
-	c.Assert(err, IsNil)
-}
-
 func mockBackupMeta(mockSchemas []*backuppb.Schema, mockFiles []*backuppb.File) *backuppb.BackupMeta {
 	return &backuppb.BackupMeta{
 		Files:   mockFiles,
@@ -38,7 +27,15 @@ func mockBackupMeta(mockSchemas []*backuppb.Schema, mockFiles []*backuppb.File)
 	}
 }
 
-func (r *testSchemaSuite) TestLoadBackupMeta(c *C) {
+func TestLoadBackupMeta(t *testing.T) {
+	t.Parallel()
+
+	testDir, err := os.MkdirTemp("", "load_backup_meta_test")
+	require.NoError(t, err)
+	defer os.RemoveAll(testDir)
+	store, err := storage.NewLocalStorage(testDir)
+	require.NoError(t, err)
+
 	tblName := model.NewCIStr("t1")
 	dbName := model.NewCIStr("test")
 	tblID := int64(123)
@@ -58,11 +55,11 @@ func (r *testSchemaSuite) TestLoadBackupMeta(c *C) {
 		},
 	}
 	dbBytes, err := json.Marshal(mockDB)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	tblBytes, err := json.Marshal(mockTbl)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	statsBytes, err := json.Marshal(mockStats)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	mockSchemas := []*backuppb.Schema{
 		{
@@ -89,28 +86,43 @@ func (r *testSchemaSuite) TestLoadBackupMeta(c *C) {
 
 	meta := mockBackupMeta(mockSchemas, mockFiles)
 	data, err := proto.Marshal(meta)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	ctx := context.Background()
-	err = r.store.WriteFile(ctx, metautil.MetaFile, data)
-	c.Assert(err, IsNil)
+	err = store.WriteFile(ctx, metautil.MetaFile, data)
+	require.NoError(t, err)
 
 	dbs, err := LoadBackupTables(
 		ctx,
 		metautil.NewMetaReader(
 			meta,
-			r.store,
+			store,
 			&backuppb.CipherInfo{
 				CipherType: encryptionpb.EncryptionMethod_PLAINTEXT,
 			}),
 	)
 	tbl := dbs[dbName.String()].GetTable(tblName.String())
-	c.Assert(err, IsNil)
-	c.Assert(tbl.Files, HasLen, 1)
-	c.Assert(tbl.Files[0].Name, Equals, "1.sst")
+	require.NoError(t, err)
+	require.Equal(t, 1, len(tbl.Files))
+	require.Equal(t, "1.sst", tbl.Files[0].Name)
 }
 
-func (r *testSchemaSuite) TestLoadBackupMetaPartionTable(c *C) {
+func newStore(t require.TestingT) (store storage.ExternalStorage, cleanFunc func()) {
+	base, err := os.MkdirTemp("", "br_schema_test")
+	require.NoError(t, err)
+	store, err = storage.NewLocalStorage(base)
+	require.NoError(t, err)
+	return store, func() {
+		require.NoError(t, os.RemoveAll(base))
+	}
+}
+
+func TestLoadBackupMetaPartionTable(t *testing.T) {
+	t.Parallel()
+
+	store, cleanFunc := newStore(t)
+	defer cleanFunc()
+
 	tblName := model.NewCIStr("t1")
 	dbName := model.NewCIStr("test")
 	tblID := int64(123)
@@ -138,11 +150,11 @@ func (r *testSchemaSuite) TestLoadBackupMetaPartionTable(c *C) {
 		},
 	}
 	dbBytes, err := json.Marshal(mockDB)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	tblBytes, err := json.Marshal(mockTbl)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	statsBytes, err := json.Marshal(mockStats)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	mockSchemas := []*backuppb.Schema{
 		{
@@ -180,25 +192,25 @@ func (r *testSchemaSuite) TestLoadBackupMetaPartionTable(c *C) {
 	meta := mockBackupMeta(mockSchemas, mockFiles)
 
 	data, err := proto.Marshal(meta)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	ctx := context.Background()
-	err = r.store.WriteFile(ctx, metautil.MetaFile, data)
-	c.Assert(err, IsNil)
+	err = store.WriteFile(ctx, metautil.MetaFile, data)
+	require.NoError(t, err)
 
 	dbs, err := LoadBackupTables(
 		ctx,
 		metautil.NewMetaReader(
 			meta,
-			r.store,
+			store,
 			&backuppb.CipherInfo{
 				CipherType: encryptionpb.EncryptionMethod_PLAINTEXT,
 			},
 		),
 	)
 	tbl := dbs[dbName.String()].GetTable(tblName.String())
-	c.Assert(err, IsNil)
-	c.Assert(tbl.Files, HasLen, 3)
+	require.NoError(t, err)
+	require.Equal(t, 3, len(tbl.Files))
 	contains := func(name string) bool {
 		for i := range tbl.Files {
 			if tbl.Files[i].Name == name {
@@ -207,9 +219,9 @@ func (r *testSchemaSuite) TestLoadBackupMetaPartionTable(c *C) {
 		}
 		return false
 	}
-	c.Assert(contains("1.sst"), IsTrue)
-	c.Assert(contains("2.sst"), IsTrue)
-	c.Assert(contains("3.sst"), IsTrue)
+	require.True(t, contains("1.sst"))
+	require.True(t, contains("2.sst"))
+	require.True(t, contains("3.sst"))
 }
 
 func buildTableAndFiles(name string, tableID, fileCount int) (*model.TableInfo, []*backuppb.File) {
@@ -231,7 +243,7 @@ func buildTableAndFiles(name string, tableID, fileCount int) (*model.TableInfo,
 	return mockTbl, mockFiles
 }
 
-func buildBenchmarkBackupmeta(c *C, dbName string, tableCount, fileCountPerTable int) *backuppb.BackupMeta {
+func buildBenchmarkBackupmeta(b *testing.B, dbName string, tableCount, fileCountPerTable int) *backuppb.BackupMeta {
 	mockFiles := make([]*backuppb.File, 0, tableCount*fileCountPerTable)
 	mockSchemas := make([]*backuppb.Schema, 0, tableCount)
 	for i := 1; i <= tableCount; i++ {
@@ -246,9 +258,9 @@ func buildBenchmarkBackupmeta(c *C, dbName string, tableCount, fileCountPerTable
 			},
 		}
 		dbBytes, err := json.Marshal(mockDB)
-		c.Assert(err, IsNil)
+		require.NoError(b, err)
 		tblBytes, err := json.Marshal(mockTbl)
-		c.Assert(err, IsNil)
+		require.NoError(b, err)
 		mockSchemas = append(mockSchemas, &backuppb.Schema{
 			Db:    dbBytes,
 			Table: tblBytes,
@@ -257,87 +269,95 @@ func buildBenchmarkBackupmeta(c *C, dbName string, tableCount, fileCountPerTable
 	return mockBackupMeta(mockSchemas, mockFiles)
 }
 
-// Run `go test github.com/pingcap/tidb/br/pkg/utils -check.b -test.v` to get benchmark result.
-func (r *testSchemaSuite) BenchmarkLoadBackupMeta64(c *C) {
-	meta := buildBenchmarkBackupmeta(c, "bench", 64, 64)
-	c.ResetTimer()
-	for i := 0; i < c.N; i++ {
+func BenchmarkLoadBackupMeta64(b *testing.B) {
+	store, cleanFunc := newStore(b)
+	defer cleanFunc()
+
+	meta := buildBenchmarkBackupmeta(b, "bench", 64, 64)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		data, err := proto.Marshal(meta)
-		c.Assert(err, IsNil)
+		require.NoError(b, err)
 
 		ctx := context.Background()
-		err = r.store.WriteFile(ctx, metautil.MetaFile, data)
-		c.Assert(err, IsNil)
+		err = store.WriteFile(ctx, metautil.MetaFile, data)
+		require.NoError(b, err)
 
 		dbs, err := LoadBackupTables(
 			ctx,
 			metautil.NewMetaReader(
 				meta,
-				r.store,
+				store,
 				&backuppb.CipherInfo{
 					CipherType: encryptionpb.EncryptionMethod_PLAINTEXT,
 				},
 			),
 		)
-		c.Assert(err, IsNil)
-		c.Assert(dbs, HasLen, 1)
-		c.Assert(dbs, HasKey, "bench")
-		c.Assert(dbs["bench"].Tables, HasLen, 64)
+		require.NoError(b, err)
+		require.Equal(b, 1, len(dbs))
+		require.Contains(b, dbs, "bench")
+		require.Equal(b, 64, len(dbs["bench"].Tables))
 	}
 }
 
-func (r *testSchemaSuite) BenchmarkLoadBackupMeta1024(c *C) {
-	meta := buildBenchmarkBackupmeta(c, "bench", 1024, 64)
-	c.ResetTimer()
-	for i := 0; i < c.N; i++ {
+func BenchmarkLoadBackupMeta1024(b *testing.B) {
+	store, cleanFunc := newStore(b)
+	defer cleanFunc()
+
+	meta := buildBenchmarkBackupmeta(b, "bench", 1024, 64)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		data, err := proto.Marshal(meta)
-		c.Assert(err, IsNil)
+		require.NoError(b, err)
 
 		ctx := context.Background()
-		err = r.store.WriteFile(ctx, metautil.MetaFile, data)
-		c.Assert(err, IsNil)
+		err = store.WriteFile(ctx, metautil.MetaFile, data)
+		require.NoError(b, err)
 
 		dbs, err := LoadBackupTables(
 			ctx,
 			metautil.NewMetaReader(
 				meta,
-				r.store,
+				store,
 				&backuppb.CipherInfo{
 					CipherType: encryptionpb.EncryptionMethod_PLAINTEXT,
 				},
 			),
 		)
-		c.Assert(err, IsNil)
-		c.Assert(dbs, HasLen, 1)
-		c.Assert(dbs, HasKey, "bench")
-		c.Assert(dbs["bench"].Tables, HasLen, 1024)
+		require.NoError(b, err)
+		require.Equal(b, 1, len(dbs))
+		require.Contains(b, dbs, "bench")
+		require.Equal(b, 1024, len(dbs["bench"].Tables))
 	}
 }
 
-func (r *testSchemaSuite) BenchmarkLoadBackupMeta10240(c *C) {
-	meta := buildBenchmarkBackupmeta(c, "bench", 10240, 64)
-	c.ResetTimer()
-	for i := 0; i < c.N; i++ {
+func BenchmarkLoadBackupMeta10240(b *testing.B) {
+	store, cleanFunc := newStore(b)
+	defer cleanFunc()
+
+	meta := buildBenchmarkBackupmeta(b, "bench", 10240, 64)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		data, err := proto.Marshal(meta)
-		c.Assert(err, IsNil)
+		require.NoError(b, err)
 
 		ctx := context.Background()
-		err = r.store.WriteFile(ctx, metautil.MetaFile, data)
-		c.Assert(err, IsNil)
+		err = store.WriteFile(ctx, metautil.MetaFile, data)
+		require.NoError(b, err)
 
 		dbs, err := LoadBackupTables(
 			ctx,
 			metautil.NewMetaReader(
 				meta,
-				r.store,
+				store,
 				&backuppb.CipherInfo{
 					CipherType: encryptionpb.EncryptionMethod_PLAINTEXT,
 				},
 			),
 		)
-		c.Assert(err, IsNil)
-		c.Assert(dbs, HasLen, 1)
-		c.Assert(dbs, HasKey, "bench")
-		c.Assert(dbs["bench"].Tables, HasLen, 10240)
+		require.NoError(b, err)
+		require.Equal(b, 1, len(dbs))
+		require.Contains(b, dbs, "bench")
+		require.Equal(b, 10240, len(dbs["bench"].Tables))
 	}
 }
diff --git a/br/pkg/utils/utils_test.go b/br/pkg/utils/utils_test.go
deleted file mode 100644
index ff8affa7c74b6..0000000000000
--- a/br/pkg/utils/utils_test.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2020 PingCAP, Inc. Licensed under Apache-2.0.
-
-package utils
-
-import (
-	"testing"
-
-	. "github.com/pingcap/check"
-)
-
-func TestT(t *testing.T) {
-	TestingT(t)
-}

From db816c760afe9b23ce00b8b3989b5cdde83052e5 Mon Sep 17 00:00:00 2001
From: Yujie Xia <xiayjchn@gmail.com>
Date: Tue, 23 Nov 2021 15:31:22 +0800
Subject: [PATCH 2/4] use more suitable method

---
 br/pkg/utils/key_test.go        |  1 +
 br/pkg/utils/progress_test.go   | 14 +++++++-------
 br/pkg/utils/safe_point_test.go |  9 +++++----
 br/pkg/utils/schema_test.go     | 16 ++++++++--------
 4 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/br/pkg/utils/key_test.go b/br/pkg/utils/key_test.go
index b9b05bf7405b4..6bb1c00f55bab 100644
--- a/br/pkg/utils/key_test.go
+++ b/br/pkg/utils/key_test.go
@@ -88,6 +88,7 @@ func TestParseKey(t *testing.T) {
 
 	for _, tt := range testNotSupportKey {
 		_, err := ParseKey("notSupport", tt.any)
+		require.Error(t, err)
 		require.Regexp(t, "unknown format.*", err.Error())
 	}
 }
diff --git a/br/pkg/utils/progress_test.go b/br/pkg/utils/progress_test.go
index a101101166168..a8503c966db39 100644
--- a/br/pkg/utils/progress_test.go
+++ b/br/pkg/utils/progress_test.go
@@ -33,15 +33,15 @@ func TestProgress(t *testing.T) {
 	progress2.Inc()
 	time.Sleep(2 * time.Second)
 	p = <-pCh2
-	require.Regexp(t, `.*"P":"50\.00%".*`, p)
+	require.Contains(t, p, `"P":"50.00%"`)
 	progress2.Inc()
 	time.Sleep(2 * time.Second)
 	p = <-pCh2
-	require.Regexp(t, `.*"P":"100\.00%".*`, p)
+	require.Contains(t, p, `"P":"100.00%"`)
 	progress2.Inc()
 	time.Sleep(2 * time.Second)
 	p = <-pCh2
-	require.Regexp(t, `.*"P":"100\.00%".*`, p)
+	require.Contains(t, p, `"P":"100.00%"`)
 	progress2.Close()
 
 	pCh4 := make(chan string, 4)
@@ -52,12 +52,12 @@ func TestProgress(t *testing.T) {
 	progress4.Inc()
 	time.Sleep(2 * time.Second)
 	p = <-pCh4
-	require.Regexp(t, `.*"P":"25\.00%".*`, p)
+	require.Contains(t, p, `"P":"25.00%"`)
 	progress4.Inc()
 	progress4.Close()
 	time.Sleep(2 * time.Second)
 	p = <-pCh4
-	require.Regexp(t, `.*"P":"100\.00%".*`, p)
+	require.Contains(t, p, `"P":"100.00%"`)
 
 	pCh8 := make(chan string, 8)
 	progress8 := NewProgressPrinter("test", 8, false)
@@ -68,11 +68,11 @@ func TestProgress(t *testing.T) {
 	progress8.Inc()
 	time.Sleep(2 * time.Second)
 	p = <-pCh8
-	require.Regexp(t, `.*"P":"25\.00%".*`, p)
+	require.Contains(t, p, `"P":"25.00%"`)
 
 	// Cancel should stop progress at the current position.
 	cancel()
 	p = <-pCh8
-	require.Regexp(t, `.*"P":"25\.00%".*`, p)
+	require.Contains(t, p, `"P":"25.00%"`)
 	progress8.Close()
 }
diff --git a/br/pkg/utils/safe_point_test.go b/br/pkg/utils/safe_point_test.go
index cb964e5b9352f..f80f7fff4c9dc 100644
--- a/br/pkg/utils/safe_point_test.go
+++ b/br/pkg/utils/safe_point_test.go
@@ -23,15 +23,16 @@ func TestCheckGCSafepoint(t *testing.T) {
 	}
 	{
 		err := utils.CheckGCSafePoint(ctx, pdClient, 2333)
-		require.NotNil(t, err)
+		require.Error(t, err)
 	}
 	{
 		err := utils.CheckGCSafePoint(ctx, pdClient, 2333-1)
-		require.NotNil(t, err)
+		require.Error(t, err)
 	}
 	{
 		err := utils.CheckGCSafePoint(ctx, pdClient, 0)
-		require.Regexp(t, ".*GC safepoint 2333 exceed TS 0.*", err)
+		require.Error(t, err)
+		require.Regexp(t, ".*GC safepoint 2333 exceed TS 0.*", err.Error())
 	}
 }
 
@@ -125,7 +126,7 @@ func TestStartServiceSafePointKeeper(t *testing.T) {
 		if cs.ok {
 			require.NoErrorf(t, err, "case #%d, %v", i, cs)
 		} else {
-			require.NotNilf(t, err, "case #%d, %v", i, cs)
+			require.Errorf(t, err, "case #%d, %v", i, cs)
 		}
 		cancel()
 	}
diff --git a/br/pkg/utils/schema_test.go b/br/pkg/utils/schema_test.go
index 97ace3c6c130b..d523969c73ab9 100644
--- a/br/pkg/utils/schema_test.go
+++ b/br/pkg/utils/schema_test.go
@@ -103,7 +103,7 @@ func TestLoadBackupMeta(t *testing.T) {
 	)
 	tbl := dbs[dbName.String()].GetTable(tblName.String())
 	require.NoError(t, err)
-	require.Equal(t, 1, len(tbl.Files))
+	require.Len(t, tbl.Files, 1)
 	require.Equal(t, "1.sst", tbl.Files[0].Name)
 }
 
@@ -210,7 +210,7 @@ func TestLoadBackupMetaPartionTable(t *testing.T) {
 	)
 	tbl := dbs[dbName.String()].GetTable(tblName.String())
 	require.NoError(t, err)
-	require.Equal(t, 3, len(tbl.Files))
+	require.Len(t, tbl.Files, 3)
 	contains := func(name string) bool {
 		for i := range tbl.Files {
 			if tbl.Files[i].Name == name {
@@ -294,9 +294,9 @@ func BenchmarkLoadBackupMeta64(b *testing.B) {
 			),
 		)
 		require.NoError(b, err)
-		require.Equal(b, 1, len(dbs))
+		require.Len(b, dbs, 1)
 		require.Contains(b, dbs, "bench")
-		require.Equal(b, 64, len(dbs["bench"].Tables))
+		require.Len(b, dbs["bench"].Tables, 64)
 	}
 }
 
@@ -325,9 +325,9 @@ func BenchmarkLoadBackupMeta1024(b *testing.B) {
 			),
 		)
 		require.NoError(b, err)
-		require.Equal(b, 1, len(dbs))
+		require.Len(b, dbs, 1)
 		require.Contains(b, dbs, "bench")
-		require.Equal(b, 1024, len(dbs["bench"].Tables))
+		require.Len(b, dbs["bench"].Tables, 1024)
 	}
 }
 
@@ -356,8 +356,8 @@ func BenchmarkLoadBackupMeta10240(b *testing.B) {
 			),
 		)
 		require.NoError(b, err)
-		require.Equal(b, 1, len(dbs))
+		require.Len(b, dbs, 1)
 		require.Contains(b, dbs, "bench")
-		require.Equal(b, 10240, len(dbs["bench"].Tables))
+		require.Len(b, dbs["bench"].Tables, 10240)
 	}
 }

From c6cff732f718989c7c7c97dd494282c9b1150c7c Mon Sep 17 00:00:00 2001
From: Yujie Xia <xiayjchn@gmail.com>
Date: Tue, 23 Nov 2021 16:28:32 +0800
Subject: [PATCH 3/4] address comments

---
 br/pkg/utils/env_test.go    |  2 +-
 br/pkg/utils/json_test.go   |  8 +-------
 br/pkg/utils/schema_test.go | 34 +++++++++++++---------------------
 3 files changed, 15 insertions(+), 29 deletions(-)

diff --git a/br/pkg/utils/env_test.go b/br/pkg/utils/env_test.go
index 493f30aaa4240..6934ef3c6e870 100644
--- a/br/pkg/utils/env_test.go
+++ b/br/pkg/utils/env_test.go
@@ -36,7 +36,7 @@ func TestProxyFields(t *testing.T) {
 		for _, field := range proxyFields() {
 			idx, ok := revIndex[field.Key]
 			require.True(t, ok)
-			require.NotEqual(t, 0, (1<<idx)&mask)
+			require.NotZero(t, (1<<idx)&mask)
 			require.Equal(t, envPreset[idx], field.String)
 		}
 	}
diff --git a/br/pkg/utils/json_test.go b/br/pkg/utils/json_test.go
index caf40bebfcda7..a026aa4b81733 100644
--- a/br/pkg/utils/json_test.go
+++ b/br/pkg/utils/json_test.go
@@ -1,7 +1,6 @@
 package utils
 
 import (
-	"encoding/json"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -215,11 +214,6 @@ func TestEncodeAndDecode(t *testing.T) {
 		require.NoError(t, err)
 		metaJSON, err := MarshalBackupMeta(meta)
 		require.NoError(t, err)
-
-		var metaMap map[string]interface{}
-		require.NoError(t, json.Unmarshal(metaJSON, &metaMap))
-		var testMetaMap map[string]interface{}
-		require.NoError(t, json.Unmarshal(testMetaJSON, &testMetaMap))
-		require.Equal(t, testMetaMap, metaMap)
+		require.JSONEq(t, string(testMetaJSON), string(metaJSON))
 	}
 }
diff --git a/br/pkg/utils/schema_test.go b/br/pkg/utils/schema_test.go
index d523969c73ab9..a8cc861fcd11e 100644
--- a/br/pkg/utils/schema_test.go
+++ b/br/pkg/utils/schema_test.go
@@ -30,9 +30,7 @@ func mockBackupMeta(mockSchemas []*backuppb.Schema, mockFiles []*backuppb.File)
 func TestLoadBackupMeta(t *testing.T) {
 	t.Parallel()
 
-	testDir, err := os.MkdirTemp("", "load_backup_meta_test")
-	require.NoError(t, err)
-	defer os.RemoveAll(testDir)
+	testDir := t.TempDir()
 	store, err := storage.NewLocalStorage(testDir)
 	require.NoError(t, err)
 
@@ -107,21 +105,12 @@ func TestLoadBackupMeta(t *testing.T) {
 	require.Equal(t, "1.sst", tbl.Files[0].Name)
 }
 
-func newStore(t require.TestingT) (store storage.ExternalStorage, cleanFunc func()) {
-	base, err := os.MkdirTemp("", "br_schema_test")
-	require.NoError(t, err)
-	store, err = storage.NewLocalStorage(base)
-	require.NoError(t, err)
-	return store, func() {
-		require.NoError(t, os.RemoveAll(base))
-	}
-}
-
 func TestLoadBackupMetaPartionTable(t *testing.T) {
 	t.Parallel()
 
-	store, cleanFunc := newStore(t)
-	defer cleanFunc()
+	testDir := os.TempDir()
+	store, err := storage.NewLocalStorage(testDir)
+	require.NoError(t, err)
 
 	tblName := model.NewCIStr("t1")
 	dbName := model.NewCIStr("test")
@@ -270,8 +259,9 @@ func buildBenchmarkBackupmeta(b *testing.B, dbName string, tableCount, fileCount
 }
 
 func BenchmarkLoadBackupMeta64(b *testing.B) {
-	store, cleanFunc := newStore(b)
-	defer cleanFunc()
+	testDir := os.TempDir()
+	store, err := storage.NewLocalStorage(testDir)
+	require.NoError(b, err)
 
 	meta := buildBenchmarkBackupmeta(b, "bench", 64, 64)
 	b.ResetTimer()
@@ -301,8 +291,9 @@ func BenchmarkLoadBackupMeta64(b *testing.B) {
 }
 
 func BenchmarkLoadBackupMeta1024(b *testing.B) {
-	store, cleanFunc := newStore(b)
-	defer cleanFunc()
+	testDir := os.TempDir()
+	store, err := storage.NewLocalStorage(testDir)
+	require.NoError(b, err)
 
 	meta := buildBenchmarkBackupmeta(b, "bench", 1024, 64)
 	b.ResetTimer()
@@ -332,8 +323,9 @@ func BenchmarkLoadBackupMeta1024(b *testing.B) {
 }
 
 func BenchmarkLoadBackupMeta10240(b *testing.B) {
-	store, cleanFunc := newStore(b)
-	defer cleanFunc()
+	testDir := os.TempDir()
+	store, err := storage.NewLocalStorage(testDir)
+	require.NoError(b, err)
 
 	meta := buildBenchmarkBackupmeta(b, "bench", 10240, 64)
 	b.ResetTimer()

From 05704c9bf95f55f8f3649eaf95f7f7f5ddca7ffd Mon Sep 17 00:00:00 2001
From: Yujie Xia <xiayjchn@gmail.com>
Date: Tue, 23 Nov 2021 16:41:09 +0800
Subject: [PATCH 4/4] fix tempDir

---
 br/pkg/utils/schema_test.go | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/br/pkg/utils/schema_test.go b/br/pkg/utils/schema_test.go
index a8cc861fcd11e..243b72932322c 100644
--- a/br/pkg/utils/schema_test.go
+++ b/br/pkg/utils/schema_test.go
@@ -6,7 +6,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"os"
 	"testing"
 
 	"github.com/golang/protobuf/proto"
@@ -108,7 +107,7 @@ func TestLoadBackupMeta(t *testing.T) {
 func TestLoadBackupMetaPartionTable(t *testing.T) {
 	t.Parallel()
 
-	testDir := os.TempDir()
+	testDir := t.TempDir()
 	store, err := storage.NewLocalStorage(testDir)
 	require.NoError(t, err)
 
@@ -259,7 +258,7 @@ func buildBenchmarkBackupmeta(b *testing.B, dbName string, tableCount, fileCount
 }
 
 func BenchmarkLoadBackupMeta64(b *testing.B) {
-	testDir := os.TempDir()
+	testDir := b.TempDir()
 	store, err := storage.NewLocalStorage(testDir)
 	require.NoError(b, err)
 
@@ -291,7 +290,7 @@ func BenchmarkLoadBackupMeta64(b *testing.B) {
 }
 
 func BenchmarkLoadBackupMeta1024(b *testing.B) {
-	testDir := os.TempDir()
+	testDir := b.TempDir()
 	store, err := storage.NewLocalStorage(testDir)
 	require.NoError(b, err)
 
@@ -323,7 +322,7 @@ func BenchmarkLoadBackupMeta1024(b *testing.B) {
 }
 
 func BenchmarkLoadBackupMeta10240(b *testing.B) {
-	testDir := os.TempDir()
+	testDir := b.TempDir()
 	store, err := storage.NewLocalStorage(testDir)
 	require.NoError(b, err)