test: add parallel running for all unit test functions

2025-12-19 17:02:23 +08:00 · 2023-06-30 10:18:45 +08:00
parent ab364744b6
commit 8229de2f10
15 changed files with 480 additions and 16 deletions
--- a/mathutil/mathutil_test.go
+++ b/mathutil/mathutil_test.go
@@ -8,6 +8,8 @@ import (
 )

 func TestExponent(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestExponent")

 	assert.Equal(int64(1), Exponent(10, 0))
@@ -16,6 +18,8 @@ func TestExponent(t *testing.T) {
 }

 func TestFibonacci(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFibonacci")

 	assert.Equal(0, Fibonacci(1, 1, 0))
@@ -25,6 +29,8 @@ func TestFibonacci(t *testing.T) {
 }

 func TestFactorial(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFactorial")

 	assert.Equal(uint(1), Factorial(0))
@@ -34,6 +40,8 @@ func TestFactorial(t *testing.T) {
 }

 func TestPercent(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPercent")

 	assert.EqualValues(50, Percent(1, 2, 2))
@@ -42,6 +50,8 @@ func TestPercent(t *testing.T) {
 }

 func TestRoundToFloat(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestRoundToFloat")

 	assert.Equal(float64(0), RoundToFloat(0, 0))
@@ -53,6 +63,8 @@ func TestRoundToFloat(t *testing.T) {
 }

 func TestRoundToString(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestRoundToString")

 	assert.Equal("0", RoundToString(0, 0))
@@ -63,6 +75,8 @@ func TestRoundToString(t *testing.T) {
 }

 func TestTruncRound(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestTruncRound")

 	assert.Equal(float64(0), TruncRound(0, 0))
@@ -74,6 +88,8 @@ func TestTruncRound(t *testing.T) {
 }

 func TestAverage(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestAverage")

 	assert.Equal(0, Average(0, 0))
@@ -84,6 +100,8 @@ func TestAverage(t *testing.T) {
 }

 func TestSum(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSum")

 	assert.Equal(1, Sum(0, 1))
@@ -91,6 +109,8 @@ func TestSum(t *testing.T) {
 }

 func TestMax(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMax")

 	assert.Equal(0, Max(0, 0))
@@ -102,6 +122,8 @@ func TestMax(t *testing.T) {
 }

 func TestMaxBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "MaxBy")

 	res1 := MaxBy([]string{"a", "ab", "abc"}, func(v1, v2 string) bool {
@@ -121,6 +143,8 @@ func TestMaxBy(t *testing.T) {
 }

 func TestMin(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMin")

 	assert.Equal(0, Min(0, 0))
@@ -129,6 +153,8 @@ func TestMin(t *testing.T) {
 }

 func TestMinBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMinBy")

 	res1 := MinBy([]string{"a", "ab", "abc"}, func(v1, v2 string) bool {
@@ -148,6 +174,8 @@ func TestMinBy(t *testing.T) {
 }

 func TestRange(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestRange")

 	result1 := Range(1, 4)
@@ -164,6 +192,8 @@ func TestRange(t *testing.T) {
 }

 func TestRangeWithStep(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestRangeWithStep")

 	result1 := RangeWithStep(1, 4, 1)
@@ -178,6 +208,8 @@ func TestRangeWithStep(t *testing.T) {
 }

 func TestAngleToRadian(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestAngleToRadian")

 	result1 := AngleToRadian(45)
@@ -190,6 +222,8 @@ func TestAngleToRadian(t *testing.T) {
 }

 func TestRadianToAngle(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestAngleToRadian")

 	result1 := RadianToAngle(math.Pi)
@@ -202,6 +236,8 @@ func TestRadianToAngle(t *testing.T) {
 }

 func TestPointDistance(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPointDistance")

 	result1 := PointDistance(1, 1, 4, 5)
@@ -210,6 +246,8 @@ func TestPointDistance(t *testing.T) {
 }

 func TestIsPrime(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsPrime")

 	assert.Equal(false, IsPrime(-1))
@@ -221,6 +259,8 @@ func TestIsPrime(t *testing.T) {
 }

 func TestGCD(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestGCD")

 	assert.Equal(1, GCD(1, 1))
@@ -246,6 +286,8 @@ func TestGCD(t *testing.T) {
 }

 func TestLCM(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLCM")

 	assert.Equal(1, LCM(1))
@@ -259,6 +301,8 @@ func TestLCM(t *testing.T) {
 }

 func TestCos(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCos")

 	assert.EqualValues(1, Cos(0))
@@ -269,6 +313,8 @@ func TestCos(t *testing.T) {
 }

 func TestSin(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSin")

 	assert.EqualValues(0, Sin(0))
@@ -279,6 +325,8 @@ func TestSin(t *testing.T) {
 }

 func TestLog(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLog")

 	assert.EqualValues(3, Log(8, 2))
@@ -287,6 +335,8 @@ func TestLog(t *testing.T) {
 }

 func TestAbs(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestAbs")

 	assert.Equal(0, Abs(0))
@@ -296,5 +346,4 @@ func TestAbs(t *testing.T) {

 	assert.Equal(int64(1), Abs(int64(-1)))
 	assert.Equal(float32(1), Abs(float32(-1)))
-
 }
--- a/netutil/http_test.go
+++ b/netutil/http_test.go
@@ -126,6 +126,8 @@ func TestHttpDelete(t *testing.T) {
 }

 func TestConvertMapToQueryString(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestConvertMapToQueryString")

 	var m = map[string]any{
@@ -133,6 +135,7 @@ func TestConvertMapToQueryString(t *testing.T) {
 		"a": 1,
 		"b": 2,
 	}
+
 	assert.Equal("a=1&b=2&c=3", ConvertMapToQueryString(m))
 }

@@ -163,6 +166,8 @@ func TestParseResponse(t *testing.T) {
 }

 func TestHttpClient_Get(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestHttpClient_Get")

 	request := &HttpRequest{
@@ -218,6 +223,8 @@ func TestHttpClent_Post(t *testing.T) {
 }

 func TestStructToUrlValues(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestStructToUrlValues")

 	type TodoQuery struct {
--- a/netutil/net_test.go
+++ b/netutil/net_test.go
@@ -9,6 +9,8 @@ import (
 )

 func TestGetInternalIp(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestGetInternalIp")

 	internalIp := GetInternalIp()
@@ -17,6 +19,8 @@ func TestGetInternalIp(t *testing.T) {
 }

 func TestGetRequestPublicIp(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestGetPublicIpInfo")

 	ip := "36.112.24.10"
@@ -50,6 +54,8 @@ func TestGetRequestPublicIp(t *testing.T) {
 // }

 func TestIsPublicIP(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsPublicIP")

 	ips := []net.IP{
@@ -69,6 +75,8 @@ func TestIsPublicIP(t *testing.T) {
 }

 func TestIsInternalIP(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsInternalIP")

 	ips := []net.IP{
@@ -110,14 +118,9 @@ func TestEncodeUrl(t *testing.T) {
 	assert.Equal(expected, encodedUrl)
 }

-// func TestDownloadFile(t *testing.T) {
-// 	assert := internal.NewAssert(t, "TestDownloadFile")
-
-// 	err := DownloadFile("./lancet_logo.jpg", "https://picx.zhimg.com/v2-fc82a4199749de9cfb71e32e54f489d3_720w.jpg?source=172ae18b")
-// 	assert.IsNil(err)
-// }
-
 func TestIsPingConnected(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsPingConnected")

 	// in github action env, this will fail
@@ -129,6 +132,8 @@ func TestIsPingConnected(t *testing.T) {
 }

 func TestTelnetConnected(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestTelnetConnected")

 	result1 := IsTelnetConnected("bing.com", "80")
--- a/pointer/pointer_test.go
+++ b/pointer/pointer_test.go
@@ -7,6 +7,8 @@ import (
 )

 func TestOf(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestOf")

 	result1 := Of(123)
@@ -17,6 +19,8 @@ func TestOf(t *testing.T) {
 }

 func TestUnwrap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUnwrap")

 	a := 123
@@ -27,6 +31,8 @@ func TestUnwrap(t *testing.T) {
 }

 func TestExtractPointer(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestExtractPointer")

 	a := 1
--- a/promise/promise_test.go
+++ b/promise/promise_test.go
@@ -9,6 +9,8 @@ import (
 )

 func TestResolve(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestResolve")

 	p := Resolve("abc")
@@ -18,6 +20,8 @@ func TestResolve(t *testing.T) {
 }

 func TestReject(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestReject")

 	err := errors.New("error")
@@ -28,6 +32,8 @@ func TestReject(t *testing.T) {
 }

 func TestThen(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestThen")

 	p1 := New(func(resolve func(string), reject func(error)) {
@@ -48,6 +54,8 @@ func TestThen(t *testing.T) {
 }

 func TestPromise_Then(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPromise_Then")

 	p1 := New(func(resolve func(int), reject func(error)) {
@@ -68,6 +76,8 @@ func TestPromise_Then(t *testing.T) {
 }

 func TestCatch(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCatch")

 	p1 := New(func(resolve func(string), reject func(error)) {
@@ -93,6 +103,8 @@ func TestCatch(t *testing.T) {
 }

 func TestPromise_Catch(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPromise_Catch")

 	p1 := New(func(resolve func(string), reject func(error)) {
@@ -118,6 +130,8 @@ func TestPromise_Catch(t *testing.T) {
 }

 func TestAll(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPromise_All")

 	t.Run("AllPromisesFullfilled", func(_ *testing.T) {
@@ -180,7 +194,6 @@ func TestAll(t *testing.T) {
 		_, err := p.Await()

 		assert.IsNotNil(err)
-		// assert.Equal("error1", err.Error())
 	})

 }
@@ -227,7 +240,6 @@ func TestAny(t *testing.T) {
 		_, err := p.Await()

 		assert.IsNotNil(err)
-		// assert.Equal("error1", err.Error())
 	})

 }
@@ -275,7 +287,6 @@ func TestRace(t *testing.T) {
 		val, err := p.Await()

 		assert.IsNotNil(err)
-		// assert.Equal("error1", err.Error())
 		assert.Equal("", val)
 	})

@@ -296,7 +307,6 @@ func TestRace(t *testing.T) {
 		_, err := p.Await()

 		assert.IsNotNil(err)
-		// assert.Equal("error1", err.Error())
 	})

 }
--- a/random/random_test.go
+++ b/random/random_test.go
@@ -9,6 +9,8 @@ import (
 )

 func TestRandString(t *testing.T) {
+	t.Parallel()
+
 	pattern := `^[a-zA-Z]+$`
 	reg := regexp.MustCompile(pattern)

@@ -20,6 +22,8 @@ func TestRandString(t *testing.T) {
 }

 func TestRandUpper(t *testing.T) {
+	t.Parallel()
+
 	pattern := `^[A-Z]+$`
 	reg := regexp.MustCompile(pattern)

@@ -31,6 +35,8 @@ func TestRandUpper(t *testing.T) {
 }

 func TestRandLower(t *testing.T) {
+	t.Parallel()
+
 	pattern := `^[a-z]+$`
 	reg := regexp.MustCompile(pattern)

@@ -42,6 +48,8 @@ func TestRandLower(t *testing.T) {
 }

 func TestRandNumeral(t *testing.T) {
+	t.Parallel()
+
 	pattern := `^[0-9]+$`
 	reg := regexp.MustCompile(pattern)

@@ -53,6 +61,8 @@ func TestRandNumeral(t *testing.T) {
 }

 func TestRandNumeralOrLetter(t *testing.T) {
+	t.Parallel()
+
 	pattern := `^[0-9a-zA-Z]+$`
 	reg := regexp.MustCompile(pattern)

@@ -64,6 +74,8 @@ func TestRandNumeralOrLetter(t *testing.T) {
 }

 func TestRandInt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestRandInt")

 	r1 := RandInt(1, 10)
@@ -79,6 +91,8 @@ func TestRandInt(t *testing.T) {
 }

 func TestRandBytes(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestRandBytes")

 	randBytes := RandBytes(4)
@@ -93,6 +107,8 @@ func TestRandBytes(t *testing.T) {
 }

 func TestUUIdV4(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUUIdV4")

 	uuid, err := UUIdV4()
@@ -105,6 +121,8 @@ func TestUUIdV4(t *testing.T) {
 }

 func TestRandUniqueIntSlice(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestRandUniqueIntSlice")

 	r1 := RandUniqueIntSlice(5, 0, 9)
--- a/retry/retry_test.go
+++ b/retry/retry_test.go
@@ -10,6 +10,8 @@ import (
 )

 func TestRetryFailed(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestRetryFailed")

 	var number int
@@ -25,6 +27,8 @@ func TestRetryFailed(t *testing.T) {
 }

 func TestRetrySucceeded(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestRetrySucceeded")

 	var number int
@@ -43,6 +47,8 @@ func TestRetrySucceeded(t *testing.T) {
 }

 func TestSetRetryTimes(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSetRetryTimes")

 	var number int
@@ -58,6 +64,8 @@ func TestSetRetryTimes(t *testing.T) {
 }

 func TestCancelRetry(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCancelRetry")

 	ctx, cancel := context.WithCancel(context.TODO())
--- a/slice/slice_test.go
+++ b/slice/slice_test.go
@@ -10,6 +10,8 @@ import (
 )

 func TestContain(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestContain")

 	assert.Equal(true, Contain([]string{"a", "b", "c"}, "a"))
@@ -21,6 +23,8 @@ func TestContain(t *testing.T) {
 }

 func TestContainBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestContainBy")

 	type foo struct {
@@ -43,6 +47,8 @@ func TestContainBy(t *testing.T) {
 }

 func TestContainSubSlice(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestContainSubSlice")
 	assert.Equal(true, ContainSubSlice([]string{"a", "a", "b", "c"}, []string{"a", "a"}))
 	assert.Equal(false, ContainSubSlice([]string{"a", "a", "b", "c"}, []string{"a", "d"}))
@@ -51,6 +57,8 @@ func TestContainSubSlice(t *testing.T) {
 }

 func TestChunk(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestChunk")

 	arr := []string{"a", "b", "c", "d", "e"}
@@ -79,6 +87,8 @@ func TestChunk(t *testing.T) {
 }

 func TestCompact(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TesCompact")

 	assert.Equal([]int{}, Compact([]int{0}))
@@ -90,6 +100,8 @@ func TestCompact(t *testing.T) {
 }

 func TestConcat(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "Concat")

 	assert.Equal([]int{1, 2, 3, 4, 5}, Concat([]int{1, 2, 3}, []int{4, 5}))
@@ -97,6 +109,8 @@ func TestConcat(t *testing.T) {
 }

 func TestEqual(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestEqual")

 	slice1 := []int{1, 2, 3}
@@ -115,6 +129,8 @@ func FuzzEqual(f *testing.F) {
 }

 func TestEqualWith(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestEqualWith")

 	slice1 := []int{1, 2, 3}
@@ -128,6 +144,8 @@ func TestEqualWith(t *testing.T) {
 }

 func TestEvery(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestEvery")

 	nums := []int{1, 2, 3, 5}
@@ -139,6 +157,8 @@ func TestEvery(t *testing.T) {
 }

 func TestNone(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestNone")

 	nums := []int{1, 2, 3, 5}
@@ -150,6 +170,8 @@ func TestNone(t *testing.T) {
 }

 func TestSome(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSome")

 	nums := []int{1, 2, 3, 5}
@@ -161,6 +183,8 @@ func TestSome(t *testing.T) {
 }

 func TestFilter(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFilter")

 	nums := []int{1, 2, 3, 4, 5}
@@ -193,6 +217,8 @@ func TestFilter(t *testing.T) {
 }

 func TestGroupBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestGroupBy")

 	nums := []int{1, 2, 3, 4, 5, 6}
@@ -206,6 +232,8 @@ func TestGroupBy(t *testing.T) {
 }

 func TestGroupWith(t *testing.T) {
+	t.Parallel()
+
 	nums := []float64{6.1, 4.2, 6.3}
 	floor := func(num float64) float64 {
 		return math.Floor(num)
@@ -220,6 +248,8 @@ func TestGroupWith(t *testing.T) {
 }

 func TestCount(t *testing.T) {
+	t.Parallel()
+
 	numbers := []int{1, 2, 3, 3, 5, 6}

 	assert := internal.NewAssert(t, "TestCountBy")
@@ -229,6 +259,8 @@ func TestCount(t *testing.T) {
 }

 func TestCountBy(t *testing.T) {
+	t.Parallel()
+
 	nums := []int{1, 2, 3, 4, 5, 6}
 	evenFunc := func(i, num int) bool {
 		return (num % 2) == 0
@@ -239,6 +271,8 @@ func TestCountBy(t *testing.T) {
 }

 func TestFind(t *testing.T) {
+	t.Parallel()
+
 	nums := []int{1, 2, 3, 4, 5}
 	even := func(i, num int) bool {
 		return num%2 == 0
@@ -251,6 +285,8 @@ func TestFind(t *testing.T) {
 }

 func TestFindBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFindBy")

 	nums := []int{1, 2, 3, 4, 5}
@@ -269,6 +305,8 @@ func TestFindBy(t *testing.T) {
 }

 func TestFindLastBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFindLastBy")

 	nums := []int{1, 2, 3, 4, 5}
@@ -289,6 +327,8 @@ func TestFindLastBy(t *testing.T) {
 }

 func TestFindLast(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFindLast")

 	nums := []int{1, 2, 3, 4, 5}
@@ -304,6 +344,8 @@ func TestFindLast(t *testing.T) {
 }

 func TestFindFoundNothing(t *testing.T) {
+	t.Parallel()
+
 	nums := []int{1, 1, 1, 1, 1, 1}
 	findFunc := func(i, num int) bool {
 		return num > 1
@@ -315,6 +357,8 @@ func TestFindFoundNothing(t *testing.T) {
 }

 func TestFlatten(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFlatten")

 	input := [][][]string{{{"a", "b"}}, {{"c", "d"}}}
@@ -324,6 +368,8 @@ func TestFlatten(t *testing.T) {
 }

 func TestFlattenDeep(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFlattenDeep")

 	input := [][][]string{{{"a", "b"}}, {{"c", "d"}}}
@@ -333,6 +379,8 @@ func TestFlattenDeep(t *testing.T) {
 }

 func TestForEach(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestForEach")

 	numbers := []int{1, 2, 3, 4, 5}
@@ -348,6 +396,8 @@ func TestForEach(t *testing.T) {
 }

 func TestForEachWithBreak(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestForEach")

 	numbers := []int{1, 2, 3, 4, 5}
@@ -366,6 +416,8 @@ func TestForEachWithBreak(t *testing.T) {
 }

 func TestMap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMap")

 	nums := []int{1, 2, 3, 4}
@@ -398,6 +450,8 @@ func TestMap(t *testing.T) {
 }

 func TestFilterMap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFilterMap")

 	nums := []int{1, 2, 3, 4, 5}
@@ -415,6 +469,8 @@ func TestFilterMap(t *testing.T) {
 }

 func TestFlatMap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFlatMap")

 	nums := []int{1, 2, 3, 4}
@@ -428,6 +484,8 @@ func TestFlatMap(t *testing.T) {
 }

 func TestReduce(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestReduce")

 	cases := [][]int{
@@ -448,6 +506,8 @@ func TestReduce(t *testing.T) {
 }

 func TestReduceBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestReduceBy")

 	result1 := ReduceBy([]int{1, 2, 3, 4}, 0, func(_ int, item int, agg int) int {
@@ -464,6 +524,8 @@ func TestReduceBy(t *testing.T) {
 }

 func TestReduceRight(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestReduceRight")

 	result := ReduceRight([]int{1, 2, 3, 4}, "", func(_ int, item int, agg string) string {
@@ -474,6 +536,8 @@ func TestReduceRight(t *testing.T) {
 }

 func TestIntSlice(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIntSlice")

 	var nums []any
@@ -483,6 +547,8 @@ func TestIntSlice(t *testing.T) {
 }

 func TestStringSlice(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestStringSlice")

 	var strs []any
@@ -492,6 +558,8 @@ func TestStringSlice(t *testing.T) {
 }

 func TestInterfaceSlice(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestInterfaceSlice")

 	strs := []string{"a", "b", "c"}
@@ -501,6 +569,8 @@ func TestInterfaceSlice(t *testing.T) {
 }

 func TestDeleteAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDeleteAt")

 	assert.Equal([]string{"a", "b", "c"}, DeleteAt([]string{"a", "b", "c"}, -1))
@@ -518,6 +588,8 @@ func TestDeleteAt(t *testing.T) {
 }

 func TestDrop(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDrop")

 	assert.Equal([]int{}, Drop([]int{}, 0))
@@ -533,6 +605,8 @@ func TestDrop(t *testing.T) {
 }

 func TestDropRight(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDropRight")

 	assert.Equal([]int{}, DropRight([]int{}, 0))
@@ -548,6 +622,8 @@ func TestDropRight(t *testing.T) {
 }

 func TestDropWhile(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDropWhile")

 	numbers := []int{1, 2, 3, 4, 5}
@@ -569,6 +645,8 @@ func TestDropWhile(t *testing.T) {
 }

 func TestDropRightWhile(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDropRightWhile")

 	numbers := []int{1, 2, 3, 4, 5}
@@ -590,6 +668,8 @@ func TestDropRightWhile(t *testing.T) {
 }

 func TestInsertAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestInsertAt")

 	strs := []string{"a", "b", "c"}
@@ -604,6 +684,8 @@ func TestInsertAt(t *testing.T) {
 }

 func TestUpdateAt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUpdateAt")

 	assert.Equal([]string{"a", "b", "c"}, UpdateAt([]string{"a", "b", "c"}, -1, "1"))
@@ -613,6 +695,8 @@ func TestUpdateAt(t *testing.T) {
 }

 func TestUnique(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUnique")

 	assert.Equal([]int{1, 2, 3}, Unique([]int{1, 2, 2, 3}))
@@ -620,6 +704,8 @@ func TestUnique(t *testing.T) {
 }

 func TestUniqueBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUniqueBy")

 	actual := UniqueBy([]int{1, 2, 3, 4, 5, 6}, func(val int) int {
@@ -629,6 +715,8 @@ func TestUniqueBy(t *testing.T) {
 }

 func TestUnion(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUnion")

 	s1 := []int{1, 3, 4, 6}
@@ -641,6 +729,8 @@ func TestUnion(t *testing.T) {
 }

 func TestUnionBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUnionBy")

 	testFunc := func(i int) int {
@@ -652,6 +742,8 @@ func TestUnionBy(t *testing.T) {
 }

 func TestMerge(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestMerge")

 	s1 := []int{1, 2, 3, 4}
@@ -664,6 +756,8 @@ func TestMerge(t *testing.T) {
 }

 func TestIntersection(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIntersection")

 	s1 := []int{1, 2, 2, 3}
@@ -690,6 +784,8 @@ func TestIntersection(t *testing.T) {
 }

 func TestSymmetricDifference(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSymmetricDifference")

 	s1 := []int{1, 2, 3}
@@ -702,6 +798,8 @@ func TestSymmetricDifference(t *testing.T) {
 }

 func TestReverse(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestReverse")

 	s1 := []int{1, 2, 3, 4, 5}
@@ -714,6 +812,8 @@ func TestReverse(t *testing.T) {
 }

 func TestDifference(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDifference")

 	s1 := []int{1, 2, 3, 4, 5}
@@ -723,6 +823,8 @@ func TestDifference(t *testing.T) {
 }

 func TestDifferenceWith(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDifferenceWith")

 	s1 := []int{1, 2, 3, 4, 5}
@@ -735,6 +837,8 @@ func TestDifferenceWith(t *testing.T) {
 }

 func TestDifferenceBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestDifferenceBy")

 	s1 := []int{1, 2, 3, 4, 5} // after add one: 2 3 4 5 6
@@ -747,6 +851,8 @@ func TestDifferenceBy(t *testing.T) {
 }

 func TestIsAscending(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsAscending")

 	assert.Equal(true, IsAscending([]int{1, 2, 3, 4, 5}))
@@ -755,6 +861,8 @@ func TestIsAscending(t *testing.T) {
 }

 func TestIsDescending(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsDescending")

 	assert.Equal(true, IsDescending([]int{5, 4, 3, 2, 1}))
@@ -763,6 +871,8 @@ func TestIsDescending(t *testing.T) {
 }

 func TestIsSorted(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsSorted")

 	assert.Equal(true, IsSorted([]int{5, 4, 3, 2, 1}))
@@ -771,6 +881,8 @@ func TestIsSorted(t *testing.T) {
 }

 func TestIsSortedByKey(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsSortedByKey")

 	assert.Equal(true, IsSortedByKey([]string{"a", "ab", "abc"}, func(s string) int {
@@ -787,6 +899,8 @@ func TestIsSortedByKey(t *testing.T) {
 }

 func TestSort(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSort")

 	numbers := []int{1, 4, 3, 2, 5}
@@ -807,6 +921,8 @@ func TestSort(t *testing.T) {
 }

 func TestSortBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSortBy")

 	numbers := []int{1, 4, 3, 2, 5}
@@ -836,6 +952,8 @@ func TestSortBy(t *testing.T) {
 }

 func TestSortByFielDesc(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSortByFielDesc")

 	type student struct {
@@ -862,6 +980,8 @@ func TestSortByFielDesc(t *testing.T) {
 }

 func TestSortByFieldAsc(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSortByFieldAsc")

 	type student struct {
@@ -888,12 +1008,16 @@ func TestSortByFieldAsc(t *testing.T) {
 }

 func TestWithout(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestWithout")
 	assert.Equal([]int{3, 4, 5}, Without([]int{1, 2, 3, 4, 5}, 1, 2))
 	assert.Equal([]int{1, 2, 3, 4, 5}, Without([]int{1, 2, 3, 4, 5}))
 }

 func TestShuffle(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestShuffle")

 	numbers := []int{1, 2, 3, 4, 5}
@@ -903,6 +1027,8 @@ func TestShuffle(t *testing.T) {
 }

 func TestIndexOf(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIndexOf")

 	arr := []string{"a", "a", "b", "c"}
@@ -942,6 +1068,8 @@ func TestIndexOf(t *testing.T) {
 }

 func TestLastIndexOf(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLastIndexOf")

 	arr := []string{"a", "b", "b", "c"}
@@ -951,6 +1079,8 @@ func TestLastIndexOf(t *testing.T) {
 }

 func TestToSlice(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToSlice")

 	str1 := "a"
@@ -960,6 +1090,8 @@ func TestToSlice(t *testing.T) {
 }

 func TestToSlicePointer(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestToSlicePointer")

 	str1 := "a"
@@ -969,6 +1101,8 @@ func TestToSlicePointer(t *testing.T) {
 }

 func TestAppendIfAbsent(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestAppendIfAbsent")

 	str1 := []string{"a", "b"}
@@ -977,6 +1111,8 @@ func TestAppendIfAbsent(t *testing.T) {
 }

 func TestReplace(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestReplace")

 	strs := []string{"a", "b", "a", "c", "d", "a"}
@@ -995,6 +1131,8 @@ func TestReplace(t *testing.T) {
 }

 func TestReplaceAll(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestReplaceAll")

 	strs := []string{"a", "b", "a", "c", "d", "a"}
@@ -1004,6 +1142,8 @@ func TestReplaceAll(t *testing.T) {
 }

 func TestKeyBy(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestKeyBy")

 	result := KeyBy([]string{"a", "ab", "abc"}, func(str string) int {
@@ -1014,6 +1154,8 @@ func TestKeyBy(t *testing.T) {
 }

 func TestRepeat(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestRepeat")

 	assert.Equal([]string{}, Repeat("a", 0))
--- a/stream/stream_test.go
+++ b/stream/stream_test.go
@@ -8,6 +8,8 @@ import (
 )

 func TestOf(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFromSlice")

 	stream := Of(1, 2, 3)
@@ -15,6 +17,8 @@ func TestOf(t *testing.T) {
 }

 func TestGenerate(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFromSlice")

 	n := 0
@@ -33,14 +37,17 @@ func TestGenerate(t *testing.T) {
 }

 func TestFromSlice(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFromSlice")

 	stream := FromSlice([]int{1, 2, 3})
-
 	assert.Equal([]int{1, 2, 3}, stream.ToSlice())
 }

 func TestFromChannel(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFromChannel")

 	ch := make(chan int)
@@ -57,6 +64,8 @@ func TestFromChannel(t *testing.T) {
 }

 func TestFromRange(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestFromRange")

 	s1 := FromRange(1, 5, 1)
@@ -67,6 +76,8 @@ func TestFromRange(t *testing.T) {
 }

 func TestStream_Distinct(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestStream_Distinct")

 	nums := FromSlice([]int{1, 2, 2, 3, 3, 3})
@@ -99,6 +110,8 @@ func TestStream_Distinct(t *testing.T) {
 }

 func TestStream_Filter(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestStream_Filter")

 	stream := FromSlice([]int{1, 2, 3, 4, 5})
--- a/structs/field_test.go
+++ b/structs/field_test.go
@@ -1,12 +1,15 @@
 package structs

 import (
-	"github.com/duke-git/lancet/v2/internal"
 	"reflect"
 	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
 )

 func TestField_Tag(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestField_Tag")

 	type Parent struct {
@@ -17,11 +20,14 @@ func TestField_Tag(t *testing.T) {
 	s := New(p1)
 	n, _ := s.Field("Name")
 	tag := n.Tag()
+
 	assert.Equal("name", tag.Name)
 	assert.Equal(true, tag.HasOption("omitempty"))
 }

 func TestField_Value(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestField_Value")

 	type Parent struct {
@@ -36,7 +42,10 @@ func TestField_Value(t *testing.T) {
 }

 func TestField_IsEmbedded(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestField_IsEmbedded")
+
 	type Parent struct {
 		Name string
 	}
@@ -51,11 +60,14 @@ func TestField_IsEmbedded(t *testing.T) {
 	s := New(c1)
 	n, _ := s.Field("Name")
 	a, _ := s.Field("Age")
+
 	assert.Equal(true, n.IsEmbedded())
 	assert.Equal(false, a.IsEmbedded())
 }

 func TestField_IsExported(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestField_IsEmbedded")

 	type Parent struct {
@@ -66,11 +78,14 @@ func TestField_IsExported(t *testing.T) {
 	s := New(p1)
 	n, _ := s.Field("Name")
 	a, _ := s.Field("age")
+
 	assert.Equal(true, n.IsExported())
 	assert.Equal(false, a.IsExported())
 }

 func TestField_IsZero(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestField_IsZero")

 	type Parent struct {
@@ -81,11 +96,14 @@ func TestField_IsZero(t *testing.T) {
 	s := New(p1)
 	n, _ := s.Field("Name")
 	a, _ := s.Field("Age")
+
 	assert.Equal(true, n.IsZero())
 	assert.Equal(false, a.IsZero())
 }

 func TestField_Name(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestField_Name")

 	type Parent struct {
@@ -102,6 +120,8 @@ func TestField_Name(t *testing.T) {
 }

 func TestField_Kind(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestField_Kind")

 	type Parent struct {
@@ -118,6 +138,8 @@ func TestField_Kind(t *testing.T) {
 }

 func TestField_IsSlice(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestField_IsSlice")

 	type Parent struct {
@@ -133,6 +155,8 @@ func TestField_IsSlice(t *testing.T) {
 }

 func TestField_MapValue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestField_MapValue")

 	t.Run("nested struct", func(t *testing.T) {
--- a/structs/struct_test.go
+++ b/structs/struct_test.go
@@ -8,8 +8,9 @@ import (
 )

 func TestStruct_ToMap(t *testing.T) {
-	assert := internal.NewAssert(t, "TestStruct_ToMap")
+	t.Parallel()

+	assert := internal.NewAssert(t, "TestStruct_ToMap")
 	t.Run("invalid struct", func(t *testing.T) {
 		m, _ := ToMap(1)
 		var expected map[string]any
@@ -65,6 +66,8 @@ func TestStruct_ToMap(t *testing.T) {
 }

 func TestStruct_Fields(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestStruct_Fields")

 	type Parent struct {
@@ -91,6 +94,8 @@ func TestStruct_Fields(t *testing.T) {
 }

 func TestStruct_Field(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestStruct_Field")

 	type Parent struct {
@@ -109,6 +114,7 @@ func TestStruct_Field(t *testing.T) {

 	s := New(p1)
 	a, ok := s.Field("A")
+
 	assert.Equal(true, ok)
 	assert.Equal(reflect.String, a.Kind())
 	assert.Equal("1", a.Value())
@@ -118,6 +124,8 @@ func TestStruct_Field(t *testing.T) {
 }

 func TestStruct_IsStruct(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestStruct_Field")

 	type Test1 struct{}
--- a/strutil/string_test.go
+++ b/strutil/string_test.go
@@ -8,6 +8,8 @@ import (
 )

 func TestCamelCase(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCamelCase")

 	cases := map[string]string{
@@ -27,6 +29,8 @@ func TestCamelCase(t *testing.T) {
 }

 func TestCapitalize(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestCapitalize")

 	cases := map[string]string{
@@ -46,6 +50,8 @@ func TestCapitalize(t *testing.T) {
 }

 func TestKebabCase(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestKebabCase")

 	cases := map[string]string{
@@ -69,6 +75,8 @@ func TestKebabCase(t *testing.T) {
 }

 func TestUpperKebabCase(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUpperKebabCase")

 	cases := map[string]string{
@@ -92,6 +100,8 @@ func TestUpperKebabCase(t *testing.T) {
 }

 func TestSnakeCase(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSnakeCase")

 	cases := map[string]string{
@@ -115,6 +125,8 @@ func TestSnakeCase(t *testing.T) {
 }

 func TestUpperSnakeCase(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUpperSnakeCase")

 	cases := map[string]string{
@@ -138,6 +150,8 @@ func TestUpperSnakeCase(t *testing.T) {
 }

 func TestUpperFirst(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLowerFirst")

 	cases := map[string]string{
@@ -154,6 +168,8 @@ func TestUpperFirst(t *testing.T) {
 }

 func TestLowerFirst(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestLowerFirst")

 	cases := map[string]string{
@@ -170,6 +186,8 @@ func TestLowerFirst(t *testing.T) {
 }

 func TestPad(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPad")

 	assert.Equal("a ", Pad("a", 2, ""))
@@ -192,6 +210,8 @@ func TestPadEnd(t *testing.T) {
 }

 func TestPadStart(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestPadStart")

 	assert.Equal("a", PadStart("a", 1, "b"))
@@ -204,6 +224,8 @@ func TestPadStart(t *testing.T) {
 }

 func TestBefore(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBefore")

 	assert.Equal("lancet", Before("lancet", ""))
@@ -213,6 +235,8 @@ func TestBefore(t *testing.T) {
 }

 func TestBeforeLast(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBeforeLast")

 	assert.Equal("lancet", BeforeLast("lancet", ""))
@@ -223,6 +247,8 @@ func TestBeforeLast(t *testing.T) {
 }

 func TestAfter(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestAfter")

 	assert.Equal("lancet", After("lancet", ""))
@@ -232,6 +258,8 @@ func TestAfter(t *testing.T) {
 }

 func TestAfterLast(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestAfterLast")

 	assert.Equal("lancet", AfterLast("lancet", ""))
@@ -243,6 +271,8 @@ func TestAfterLast(t *testing.T) {
 }

 func TestIsString(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsString")

 	assert.Equal(true, IsString("lancet"))
@@ -253,6 +283,8 @@ func TestIsString(t *testing.T) {
 }

 func TestReverse(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestReverse")

 	assert.Equal("cba", Reverse("abc"))
@@ -260,6 +292,8 @@ func TestReverse(t *testing.T) {
 }

 func TestWrap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestWrap")

 	assert.Equal("ab", Wrap("ab", ""))
@@ -270,6 +304,8 @@ func TestWrap(t *testing.T) {
 }

 func TestUnwrap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestUnwrap")

 	assert.Equal("", Unwrap("", "*"))
@@ -288,6 +324,8 @@ func TestUnwrap(t *testing.T) {
 }

 func TestSplitEx(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSplitEx")

 	assert.Equal([]string{}, SplitEx(" a b c ", "", true))
@@ -300,6 +338,8 @@ func TestSplitEx(t *testing.T) {
 }

 func TestSubstring(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSubstring")

 	assert.Equal("bcd", Substring("abcde", 1, 3))
@@ -311,6 +351,8 @@ func TestSubstring(t *testing.T) {
 }

 func TestSplitWords(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSplitWords")

 	cases := map[string][]string{
@@ -327,6 +369,8 @@ func TestSplitWords(t *testing.T) {
 }

 func TestWordCount(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestSplitWords")

 	cases := map[string]int{
@@ -343,6 +387,8 @@ func TestWordCount(t *testing.T) {
 }

 func TestRemoveNonPrintable(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestRemoveNonPrintable")

 	assert.Equal("hello world", RemoveNonPrintable("hello\u00a0 \u200bworld\n"))
@@ -350,47 +396,67 @@ func TestRemoveNonPrintable(t *testing.T) {
 }

 func TestStringToBytes(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestStringToBytes")
+
 	str := "abc"
 	bytes := StringToBytes(str)
+
 	assert.Equal(reflect.DeepEqual(bytes, []byte{'a', 'b', 'c'}), true)
 }

 func TestBytesToString(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestBytesToString")
+
 	bytes := []byte{'a', 'b', 'c'}
 	str := BytesToString(bytes)
+
 	assert.Equal(str == "abc", true)
 }

 func TestIsBlank(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsBlank")
 	assert.Equal(IsBlank(""), true)
 	assert.Equal(IsBlank("\t\v\f\n"), true)
+
 	assert.Equal(IsBlank(" 中文"), false)
 }

 func TestHasPrefixAny(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestHasPrefixAny")
 	str := "foo bar"
 	prefixes := []string{"fo", "xyz", "hello"}
 	notMatches := []string{"oom", "world"}
+
 	assert.Equal(HasPrefixAny(str, prefixes), true)
 	assert.Equal(HasPrefixAny(str, notMatches), false)
 }

 func TestHasSuffixAny(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestHasSuffixAny")
 	str := "foo bar"
 	suffixes := []string{"bar", "xyz", "hello"}
 	notMatches := []string{"oom", "world"}
+
 	assert.Equal(HasSuffixAny(str, suffixes), true)
 	assert.Equal(HasSuffixAny(str, notMatches), false)
 }

 func TestIndexOffset(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIndexOffset")
 	str := "foo bar hello world"
+
 	assert.Equal(IndexOffset(str, "o", 5), 12)
 	assert.Equal(IndexOffset(str, "o", 0), 1)
 	assert.Equal(IndexOffset(str, "d", len(str)-1), len(str)-1)
@@ -399,6 +465,8 @@ func TestIndexOffset(t *testing.T) {
 }

 func TestReplaceWithMap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestReplaceWithMap")

 	str := "ac ab ab ac"
@@ -412,6 +480,8 @@ func TestReplaceWithMap(t *testing.T) {
 }

 func TestTrim(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestTrim")

 	str1 := "$ ab	cd $ "
@@ -422,6 +492,8 @@ func TestTrim(t *testing.T) {
 }

 func TestSplitAndTrim(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestTrim")

 	str := " a,b, c,d,$1 "
@@ -434,6 +506,8 @@ func TestSplitAndTrim(t *testing.T) {
 }

 func TestHideString(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestTrim")

 	str := "13242658976"
@@ -452,6 +526,8 @@ func TestHideString(t *testing.T) {
 }

 func TestContainsAll(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestContainsAll")

 	assert.Equal(true, ContainsAll("hello world", []string{"hello", "world"}))
@@ -460,6 +536,8 @@ func TestContainsAll(t *testing.T) {
 }

 func TestContainsAny(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestContainsAny")

 	assert.Equal(true, ContainsAny("hello world", []string{"hello", "world"}))
--- a/system/os_test.go
+++ b/system/os_test.go
@@ -8,6 +8,8 @@ import (
 )

 func TestOsDetection(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestOsJudgment")

 	osType, _, _ := ExecCommand("echo $OSTYPE")
@@ -20,6 +22,8 @@ func TestOsDetection(t *testing.T) {
 }

 func TestOsEnvOperation(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestOsEnvOperation")

 	envNotExist := GetOsEnv("foo")
@@ -44,6 +48,8 @@ func TestOsEnvOperation(t *testing.T) {
 }

 func TestExecCommand(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestExecCommand")

 	// linux or mac
@@ -79,6 +85,8 @@ func TestExecCommand(t *testing.T) {
 // }

 func TestGetOsBits(t *testing.T) {
+	t.Parallel()
+
 	osBits := GetOsBits()
 	switch osBits {
 	case 32, 64:
--- a/validator/validator_test.go
+++ b/validator/validator_test.go
@@ -11,6 +11,8 @@ import (
 )

 func TestIsAllUpper(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsAllUpper")

 	assert.Equal(true, IsAllUpper("ABC"))
@@ -26,6 +28,8 @@ func TestIsAllUpper(t *testing.T) {
 }

 func TestIsAllLower(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsAllLower")

 	assert.Equal(true, IsAllLower("abc"))
@@ -41,6 +45,8 @@ func TestIsAllLower(t *testing.T) {
 }

 func TestContainLower(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestContainLower")

 	assert.Equal(true, ContainLower("abc"))
@@ -57,6 +63,8 @@ func TestContainLower(t *testing.T) {
 }

 func TestContainUpper(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestContainUpper")

 	assert.Equal(true, ContainUpper("ABC"))
@@ -73,6 +81,8 @@ func TestContainUpper(t *testing.T) {
 }

 func TestContainLetter(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestContainLetter")

 	assert.Equal(true, ContainLetter("ABC"))
@@ -87,6 +97,8 @@ func TestContainLetter(t *testing.T) {
 }

 func TestContainNumber(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestContainNumber")

 	assert.Equal(true, ContainNumber("123"))
@@ -104,6 +116,8 @@ func TestContainNumber(t *testing.T) {
 }

 func TestIsJSON(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsJSON")

 	assert.Equal(true, IsJSON("{}"))
@@ -118,6 +132,8 @@ func TestIsJSON(t *testing.T) {
 }

 func TestIsNumber(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsNumber")

 	assert.Equal(false, IsNumber(""))
@@ -127,6 +143,8 @@ func TestIsNumber(t *testing.T) {
 }

 func TestIsFloat(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsFloat")

 	assert.Equal(false, IsFloat(""))
@@ -136,6 +154,8 @@ func TestIsFloat(t *testing.T) {
 }

 func TestIsInt(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsInt")

 	assert.Equal(false, IsInt(""))
@@ -146,6 +166,8 @@ func TestIsInt(t *testing.T) {
 }

 func TestIsNumberStr(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsNumberStr")

 	assert.Equal(true, IsNumberStr("3."))
@@ -156,6 +178,8 @@ func TestIsNumberStr(t *testing.T) {
 }

 func TestIsFloatStr(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsFloatStr")

 	assert.Equal(true, IsFloatStr("3."))
@@ -166,6 +190,8 @@ func TestIsFloatStr(t *testing.T) {
 }

 func TestIsIntStr(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsIntStr")

 	assert.Equal(true, IsIntStr("+3"))
@@ -175,6 +201,8 @@ func TestIsIntStr(t *testing.T) {
 }

 func TestIsPort(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsPort")

 	assert.Equal(true, IsPort("1"))
@@ -187,6 +215,8 @@ func TestIsPort(t *testing.T) {
 }

 func TestIsIp(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsIntStr")

 	assert.Equal(true, IsIp("127.0.0.1"))
@@ -196,6 +226,8 @@ func TestIsIp(t *testing.T) {
 }

 func TestIsIpV4(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsIpV4")

 	assert.Equal(true, IsIpV4("127.0.0.1"))
@@ -203,6 +235,8 @@ func TestIsIpV4(t *testing.T) {
 }

 func TestIsIpV6(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsIpV6")

 	assert.Equal(false, IsIpV6("127.0.0.1"))
@@ -210,6 +244,8 @@ func TestIsIpV6(t *testing.T) {
 }

 func TestIsUrl(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsUrl")

 	assert.Equal(true, IsUrl("http://abc.com"))
@@ -219,6 +255,8 @@ func TestIsUrl(t *testing.T) {
 }

 func TestIsDns(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsDns")

 	assert.Equal(true, IsDns("abc.com"))
@@ -227,6 +265,8 @@ func TestIsDns(t *testing.T) {
 }

 func TestIsEmail(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsEmail")

 	assert.Equal(true, IsEmail("abc@xyz.com"))
@@ -234,6 +274,8 @@ func TestIsEmail(t *testing.T) {
 }

 func TestContainChinese(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestContainChinese")

 	assert.Equal(true, ContainChinese("你好"))
@@ -242,6 +284,8 @@ func TestContainChinese(t *testing.T) {
 }

 func TestIsChineseMobile(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsChineseMobile")

 	assert.Equal(true, IsChineseMobile("13263527980"))
@@ -249,6 +293,8 @@ func TestIsChineseMobile(t *testing.T) {
 }

 func TestIsChinesePhone(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsChinesePhone")

 	assert.Equal(true, IsChinesePhone("010-32116675"))
@@ -259,6 +305,8 @@ func TestIsChinesePhone(t *testing.T) {
 }

 func TestIsChineseIdNum(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsChineseIdNum")

 	assert.Equal(true, IsChineseIdNum("210911192105130715"))
@@ -268,6 +316,8 @@ func TestIsChineseIdNum(t *testing.T) {
 }

 func TestIsCreditCard(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsCreditCard")

 	assert.Equal(true, IsCreditCard("4111111111111111"))
@@ -275,6 +325,8 @@ func TestIsCreditCard(t *testing.T) {
 }

 func TestIsBase64(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsBase64")

 	assert.Equal(true, IsBase64("aGVsbG8="))
@@ -282,6 +334,8 @@ func TestIsBase64(t *testing.T) {
 }

 func TestIsEmptyString(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsEmptyString")

 	assert.Equal(true, IsEmptyString(""))
@@ -291,6 +345,8 @@ func TestIsEmptyString(t *testing.T) {
 }

 func TestIsAlpha(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsAlpha")

 	assert.Equal(true, IsAlpha("abc"))
@@ -301,6 +357,8 @@ func TestIsAlpha(t *testing.T) {
 }

 func TestIsRegexMatch(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsRegexMatch")

 	assert.Equal(true, IsRegexMatch("abc", `^[a-zA-Z]+$`))
@@ -309,6 +367,8 @@ func TestIsRegexMatch(t *testing.T) {
 }

 func TestIsStrongPassword(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsStrongPassword")

 	assert.Equal(false, IsStrongPassword("abc", 3))
@@ -321,6 +381,8 @@ func TestIsStrongPassword(t *testing.T) {
 }

 func TestIsWeakPassword(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsWeakPassword")

 	assert.Equal(true, IsWeakPassword("abc"))
@@ -331,6 +393,8 @@ func TestIsWeakPassword(t *testing.T) {
 }

 func TestIsZeroValue(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsZeroValue")

 	var (
@@ -438,6 +502,8 @@ func TestIsZeroValue(t *testing.T) {
 }

 func TestIsGBK(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsGBK")

 	str := "你好"
@@ -448,6 +514,8 @@ func TestIsGBK(t *testing.T) {
 }

 func TestIsASCII(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsASCII")

 	assert.Equal(true, IsASCII("ABC"))
@@ -458,6 +526,8 @@ func TestIsASCII(t *testing.T) {
 }

 func TestIsPrintable(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestIsPrintable")

 	assert.Equal(true, IsPrintable("ABC"))
--- a/xerror/xerror_test.go
+++ b/xerror/xerror_test.go
@@ -10,11 +10,15 @@ import (
 )

 func TestTryUnwrap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestTryUnwrap")
 	assert.Equal(42, TryUnwrap(strconv.Atoi("42")))
 }

 func TestTryUnwrapFail(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestTryUnwrapFail")

 	_, err := strconv.Atoi("4o2")
@@ -27,6 +31,8 @@ func TestTryUnwrapFail(t *testing.T) {
 }

 func TestNew(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestNew")

 	err := New("error occurs")
@@ -34,6 +40,8 @@ func TestNew(t *testing.T) {
 }

 func TestWrap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestWrap")

 	err := New("wrong password")
@@ -43,6 +51,8 @@ func TestWrap(t *testing.T) {
 }

 func TestXError_Wrap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestXError_Wrap")

 	err1 := New("error").With("level", "high")
@@ -52,6 +62,8 @@ func TestXError_Wrap(t *testing.T) {
 }

 func TestXError_Unwrap(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestXError_Unwrap")

 	err1 := New("error").With("level", "high")
@@ -64,6 +76,8 @@ func TestXError_Unwrap(t *testing.T) {
 }

 func TestXError_StackTrace(t *testing.T) {
+	// t.Parallel()
+
 	assert := internal.NewAssert(t, "TestXError_StackTrace")

 	err := New("error")
@@ -72,11 +86,13 @@ func TestXError_StackTrace(t *testing.T) {

 	assert.Equal(3, len(stacks))
 	assert.Equal("github.com/duke-git/lancet/v2/xerror.TestXError_StackTrace", stacks[0].Func)
-	assert.Equal(69, stacks[0].Line)
+	assert.Equal(83, stacks[0].Line)
 	assert.Equal(true, strings.Contains(stacks[0].File, "xerror_test.go"))
 }

 func TestXError_With_Id_Is_Values(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestXError_With_Id_Is_Values")

 	baseErr := New("baseError")
@@ -94,6 +110,8 @@ func TestXError_With_Id_Is_Values(t *testing.T) {
 }

 func TestXError_Info(t *testing.T) {
+	t.Parallel()
+
 	assert := internal.NewAssert(t, "TestXError_Info")

 	cause := errors.New("error")