diff --git a/g/container/garray/garray_z_unit_basic_test.go b/g/container/garray/garray_z_unit_basic_test.go
index fd785bc62..2d6344795 100644
--- a/g/container/garray/garray_z_unit_basic_test.go
+++ b/g/container/garray/garray_z_unit_basic_test.go
@@ -17,84 +17,98 @@ import (
 )
 
 func Test_IntArray_Unique(t *testing.T) {
-	expect := []int{1, 2, 3, 4, 5, 6}
-	array := garray.NewIntArray()
-	array.Append(1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6)
-	array.Unique()
-	gtest.Assert(array.Slice(), expect)
+	gtest.Case(t, func() {
+		expect := []int{1, 2, 3, 4, 5, 6}
+		array := garray.NewIntArray()
+		array.Append(1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6)
+		array.Unique()
+		gtest.Assert(array.Slice(), expect)
+	})
 }
 
 func Test_SortedIntArray1(t *testing.T) {
-	expect := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-	array := garray.NewSortedIntArray()
-	for i := 10; i > -1; i-- {
-		array.Add(i)
-	}
-	gtest.Assert(array.Slice(), expect)
-	gtest.Assert(array.Add().Slice(), expect)
-	gtest.Assert(array.Add(-1).Slice(), []int{-1,0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
+	gtest.Case(t, func() {
+		expect := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+		array := garray.NewSortedIntArray()
+		for i := 10; i > -1; i-- {
+			array.Add(i)
+		}
+		gtest.Assert(array.Slice(), expect)
+		gtest.Assert(array.Add().Slice(), expect)
+		gtest.Assert(array.Add(-1).Slice(), []int{-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
+	})
 }
 
 func Test_SortedIntArray2(t *testing.T) {
-	expect := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
-	array := garray.NewSortedIntArray()
-	array2 := garray.NewSortedIntArray(true)
-	for i := 0; i <= 10; i++ {
-		array.Add(i)
-		array2.Add(i)
-	}
-	gtest.Assert(array.Slice(), expect)
-	gtest.Assert(array2.Slice(), expect)
+	gtest.Case(t, func() {
+		expect := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+		array := garray.NewSortedIntArray()
+		array2 := garray.NewSortedIntArray(true)
+		for i := 0; i <= 10; i++ {
+			array.Add(i)
+			array2.Add(i)
+		}
+		gtest.Assert(array.Slice(), expect)
+		gtest.Assert(array2.Slice(), expect)
+	})
 }
 
 func Test_SortedStringArray1(t *testing.T) {
-	expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
-	array := garray.NewSortedStringArray()
-	for i := 10; i > -1; i-- {
-		array.Add(gconv.String(i))
-	}
-	gtest.Assert(array.Slice(), expect)
-	gtest.Assert(array.Add().Slice(), expect)
+	gtest.Case(t, func() {
+		expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
+		array := garray.NewSortedStringArray()
+		for i := 10; i > -1; i-- {
+			array.Add(gconv.String(i))
+		}
+		gtest.Assert(array.Slice(), expect)
+		gtest.Assert(array.Add().Slice(), expect)
+	})
 }
 
 func Test_SortedStringArray2(t *testing.T) {
-	expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
-	array := garray.NewSortedStringArray()
-	array2 := garray.NewSortedStringArray(true)
-	for i := 0; i <= 10; i++ {
-		array.Add(gconv.String(i))
-		array2.Add(gconv.String(i))
-	}
-	gtest.Assert(array.Slice(), expect)
-	gtest.Assert(array2.Slice(), expect)
+	gtest.Case(t, func() {
+		expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
+		array := garray.NewSortedStringArray()
+		array2 := garray.NewSortedStringArray(true)
+		for i := 0; i <= 10; i++ {
+			array.Add(gconv.String(i))
+			array2.Add(gconv.String(i))
+		}
+		gtest.Assert(array.Slice(), expect)
+		gtest.Assert(array2.Slice(), expect)
+	})
 }
 
 func Test_SortedArray1(t *testing.T) {
-	expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
-	array := garray.NewSortedArray(func(v1, v2 interface{}) int {
-		return strings.Compare(gconv.String(v1), gconv.String(v2))
+	gtest.Case(t, func() {
+		expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
+		array := garray.NewSortedArray(func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		})
+		for i := 10; i > -1; i-- {
+			array.Add(gconv.String(i))
+		}
+		gtest.Assert(array.Slice(), expect)
 	})
-	for i := 10; i > -1; i-- {
-		array.Add(gconv.String(i))
-	}
-	gtest.Assert(array.Slice(), expect)
 }
 
 func Test_SortedArray2(t *testing.T) {
-	expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
-	array := garray.NewSortedArray(func(v1, v2 interface{}) int {
-		return strings.Compare(gconv.String(v1), gconv.String(v2))
+	gtest.Case(t, func() {
+		expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
+		array := garray.NewSortedArray(func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		})
+		array2 := garray.NewSortedArray(func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}, true)
+		for i := 0; i <= 10; i++ {
+			array.Add(gconv.String(i))
+			array2.Add(gconv.String(i))
+		}
+		gtest.Assert(array.Slice(), expect)
+		gtest.Assert(array.Add(), expect)
+		gtest.Assert(array2.Slice(), expect)
 	})
-	array2 := garray.NewSortedArray(func(v1, v2 interface{}) int {
-		return strings.Compare(gconv.String(v1), gconv.String(v2))
-	},true)
-	for i := 0; i <= 10; i++ {
-		array.Add(gconv.String(i))
-		array2.Add(gconv.String(i))
-	}
-	gtest.Assert(array.Slice(), expect)
-	gtest.Assert(array.Add(), expect)
-	gtest.Assert(array2.Slice(), expect)
 }
 
 func TestNewFromCopy(t *testing.T) {
@@ -104,6 +118,5 @@ func TestNewFromCopy(t *testing.T) {
 		gtest.AssertIN(array1.PopRands(2), a1)
 		gtest.Assert(len(array1.PopRands(1)), 1)
 		gtest.Assert(len(array1.PopRands(9)), 3)
-
 	})
 }
diff --git a/g/container/garray/garray_z_unit_int_test.go b/g/container/garray/garray_z_unit_int_test.go
index 5e632158c..6cdb7590e 100644
--- a/g/container/garray/garray_z_unit_int_test.go
+++ b/g/container/garray/garray_z_unit_int_test.go
@@ -61,7 +61,6 @@ func TestIntArray_Sort(t *testing.T) {
 		gtest.Assert(array.Slice(), expect2)
 		array2.Sort(true)
 		gtest.Assert(array2.Slice(), expect2)
-
 	})
 }
 
@@ -192,7 +191,7 @@ func TestIntArray_SubSlice(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []int{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewIntArrayFrom(a1)
-		array2 := garray.NewIntArrayFrom(a1,true)
+		array2 := garray.NewIntArrayFrom(a1, true)
 		gtest.Assert(array1.SubSlice(6), []int{6})
 		gtest.Assert(array1.SubSlice(5), []int{5, 6})
 		gtest.Assert(array1.SubSlice(8), nil)
@@ -234,7 +233,6 @@ func TestIntArray_PopRands(t *testing.T) {
 		ns2 := array.PopRands(7)
 		gtest.AssertIN(len(ns2), 6)
 		gtest.AssertIN(ns2, []int{100, 200, 300, 400, 500, 600})
-
 	})
 }
 
@@ -295,13 +293,10 @@ func TestSortedIntArray_SetArray(t *testing.T) {
 func TestSortedIntArray_Sort(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []int{0, 3, 2, 1}
-
 		array1 := garray.NewSortedIntArrayFrom(a1)
 		array2 := array1.Sort()
-
 		gtest.Assert(array2.Len(), 4)
 		gtest.Assert(array2, []int{0, 1, 2, 3})
-
 	})
 }
 
@@ -337,7 +332,6 @@ func TestSortedIntArray_Remove(t *testing.T) {
 		i3 = array2.Remove(1)
 		gtest.Assert(array2.Search(4), -1)
 		gtest.Assert(i3, 4)
-
 	})
 }
 
@@ -349,7 +343,6 @@ func TestSortedIntArray_PopLeft(t *testing.T) {
 		gtest.Assert(i1, 1)
 		gtest.Assert(array1.Len(), 3)
 		gtest.Assert(array1.Search(1), -1)
-
 	})
 }
 
@@ -389,7 +382,6 @@ func TestSortedIntArray_PopRands(t *testing.T) {
 		gtest.Assert(array2.Len(), 0)
 		gtest.Assert(len(ns2), 4)
 		gtest.AssertIN(ns2, []int{1, 3, 5, 2})
-
 	})
 }
 
@@ -406,7 +398,6 @@ func TestSortedIntArray_PopLefts(t *testing.T) {
 		ns2 := array2.PopLefts(5)
 		gtest.Assert(array2.Len(), 0)
 		gtest.AssertIN(ns2, []int{1, 3, 5, 2})
-
 	})
 }
 
@@ -462,7 +453,6 @@ func TestSortedIntArray_Contains(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []int{1, 3, 5}
 		array1 := garray.NewSortedIntArrayFrom(a1)
-		//gtest.Assert(array1.Contains(3),true) //todo 这一行应该返回true
 		gtest.Assert(array1.Contains(4), false)
 	})
 }
@@ -483,7 +473,6 @@ func TestSortedIntArray_Clear(t *testing.T) {
 		array1 := garray.NewSortedIntArrayFrom(a1)
 		array1.Clear()
 		gtest.Assert(array1.Len(), 0)
-
 	})
 }
 
@@ -497,7 +486,6 @@ func TestSortedIntArray_Chunk(t *testing.T) {
 		gtest.Assert(ns1[0], []int{1, 2})
 		gtest.Assert(ns1[2], []int{5})
 		gtest.Assert(len(ns2), 0)
-
 	})
 }
 
@@ -520,13 +508,12 @@ func TestSortedIntArray_SubSlice(t *testing.T) {
 		gtest.Assert(len(ns4), 1)
 		gtest.Assert(ns4, []int{4})
 
-		array3 := garray.NewSortedIntArrayFrom(a1,true)
+		array3 := garray.NewSortedIntArrayFrom(a1, true)
 		gtest.Assert(array3.SubSlice(2, 2), []int{3, 4})
 		gtest.Assert(array3.SubSlice(-1, 2), []int{5})
 		gtest.Assert(array3.SubSlice(-9, 2), nil)
-		gtest.Assert(array3.SubSlice(4, -2), []int{3,4})
+		gtest.Assert(array3.SubSlice(4, -2), []int{3, 4})
 		gtest.Assert(array3.SubSlice(1, -3), nil)
-
 	})
 }
 
@@ -546,7 +533,6 @@ func TestSortedIntArray_Rands(t *testing.T) {
 		ns1 := array1.Rands(2) //按每几个元素切成一个数组
 		gtest.AssertIN(ns1, a1)
 		gtest.Assert(len(ns1), 2)
-
 		ns2 := array1.Rands(6) //按每几个元素切成一个数组
 		gtest.AssertIN(ns2, a1)
 		gtest.Assert(len(ns2), 5)
@@ -571,7 +557,6 @@ func TestSortedIntArray_SetUnique(t *testing.T) {
 		array1.SetUnique(true)
 		gtest.Assert(array1.Len(), 5)
 		gtest.Assert(array1, []int{1, 2, 3, 4, 5})
-
 	})
 }
 
@@ -583,7 +568,6 @@ func TestIntArray_SetArray(t *testing.T) {
 		array1.SetArray(a2)
 		gtest.Assert(array1.Len(), 2)
 		gtest.Assert(array1, []int{6, 7})
-
 	})
 }
 
@@ -595,7 +579,6 @@ func TestIntArray_Replace(t *testing.T) {
 		array1 := garray.NewIntArrayFrom(a1)
 		array1.Replace(a2)
 		gtest.Assert(array1, []int{6, 7, 3, 5})
-
 		array1.Replace(a3)
 		gtest.Assert(array1, []int{9, 10, 11, 12})
 	})
@@ -675,243 +658,260 @@ func TestIntArray_Remove(t *testing.T) {
 }
 
 func TestSortedIntArray_LockFunc(t *testing.T) {
-	n1 := []int{1, 2, 4, 3}
-	a1 := garray.NewSortedIntArrayFrom(n1)
+	gtest.Case(t, func() {
+		n1 := []int{1, 2, 4, 3}
+		a1 := garray.NewSortedIntArrayFrom(n1)
 
-	ch1 := make(chan int64, 2)
-	go a1.LockFunc(func(n1 []int) { //互斥锁
-		for i := 1; i <= 4; i++ {
-			gtest.Assert(i, n1[i-1])
-		}
-		n1[3] = 7
-		time.Sleep(1 * time.Second) //暂停一秒
+		ch1 := make(chan int64, 2)
+		go a1.LockFunc(func(n1 []int) { //互斥锁
+			for i := 1; i <= 4; i++ {
+				gtest.Assert(i, n1[i-1])
+			}
+			n1[3] = 7
+			time.Sleep(1 * time.Second) //暂停一秒
+		})
+
+		go func() {
+			time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		// 相差大于0.6秒，说明在读取a1.len时，发生了等待。  防止ci抖动,以豪秒为单位
+		gtest.AssertGT(t2-t1, 600)
+		gtest.Assert(a1.Contains(7), true)
 	})
 
-	go func() {
-		time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-		a1.Len()
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-	}()
-
-	t1 := <-ch1
-	t2 := <-ch1
-	// 相差大于0.6秒，说明在读取a1.len时，发生了等待。  防止ci抖动,以豪秒为单位
-	gtest.AssertGT(t2-t1, 600)
-	gtest.Assert(a1.Contains(7), true)
 }
 
 func TestSortedIntArray_RLockFunc(t *testing.T) {
-	n1 := []int{1, 2, 4, 3}
-	a1 := garray.NewSortedIntArrayFrom(n1)
+	gtest.Case(t, func() {
+		n1 := []int{1, 2, 4, 3}
+		a1 := garray.NewSortedIntArrayFrom(n1)
 
-	ch1 := make(chan int64, 2)
-	go a1.RLockFunc(func(n1 []int) { //读锁
-		for i := 1; i <= 4; i++ {
-			gtest.Assert(i, n1[i-1])
-		}
-		n1[3] = 7
-		time.Sleep(1 * time.Second) //暂停一秒
+		ch1 := make(chan int64, 2)
+		go a1.RLockFunc(func(n1 []int) { //读锁
+			for i := 1; i <= 4; i++ {
+				gtest.Assert(i, n1[i-1])
+			}
+			n1[3] = 7
+			time.Sleep(1 * time.Second) //暂停一秒
+		})
+
+		go func() {
+			time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
+		// 防止ci抖动,以豪秒为单位
+		gtest.AssertLT(t2-t1, 2)
+		gtest.Assert(a1.Contains(7), true)
 	})
-
-	go func() {
-		time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-		a1.Len()
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-	}()
-
-	t1 := <-ch1
-	t2 := <-ch1
-	// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
-	// 防止ci抖动,以豪秒为单位
-	gtest.AssertLT(t2-t1, 2)
-	gtest.Assert(a1.Contains(7), true)
 }
 
 func TestSortedIntArray_Merge(t *testing.T) {
-	n1 := []int{1, 2, 4, 3}
-	n2 := []int{7, 8, 9}
-	n3 := []int{3, 6}
+	gtest.Case(t, func() {
+		n1 := []int{1, 2, 4, 3}
+		n2 := []int{7, 8, 9}
+		n3 := []int{3, 6}
 
-	s1 := []string{"a", "b", "c"}
-	in1 := []interface{}{1, "a", 2, "b"}
+		s1 := []string{"a", "b", "c"}
+		in1 := []interface{}{1, "a", 2, "b"}
 
-	func1 := func(v1, v2 interface{}) int {
-		return strings.Compare(gconv.String(v1), gconv.String(v2))
-	}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
 
-	a1 := garray.NewSortedIntArrayFrom(n1)
-	b1 := garray.NewStringArrayFrom(s1)
-	b2 := garray.NewIntArrayFrom(n3)
-	b3 := garray.NewArrayFrom(in1)
-	b4 := garray.NewSortedStringArrayFrom(s1)
-	b5 := garray.NewSortedIntArrayFrom(n3)
-	b6:=garray.NewSortedArrayFrom(in1,func1)
+		a1 := garray.NewSortedIntArrayFrom(n1)
+		b1 := garray.NewStringArrayFrom(s1)
+		b2 := garray.NewIntArrayFrom(n3)
+		b3 := garray.NewArrayFrom(in1)
+		b4 := garray.NewSortedStringArrayFrom(s1)
+		b5 := garray.NewSortedIntArrayFrom(n3)
+		b6 := garray.NewSortedArrayFrom(in1, func1)
 
-	gtest.Assert(a1.Merge(n2).Len(), 7)
-	gtest.Assert(a1.Merge(n3).Len(), 9)
-	gtest.Assert(a1.Merge(b1).Len(), 12)
-	gtest.Assert(a1.Merge(b2).Len(), 14)
-	gtest.Assert(a1.Merge(b3).Len(), 18)
-	gtest.Assert(a1.Merge(b4).Len(), 21)
-	gtest.Assert(a1.Merge(b5).Len(), 23)
-	gtest.Assert(a1.Merge(b6).Len(), 27)
+		gtest.Assert(a1.Merge(n2).Len(), 7)
+		gtest.Assert(a1.Merge(n3).Len(), 9)
+		gtest.Assert(a1.Merge(b1).Len(), 12)
+		gtest.Assert(a1.Merge(b2).Len(), 14)
+		gtest.Assert(a1.Merge(b3).Len(), 18)
+		gtest.Assert(a1.Merge(b4).Len(), 21)
+		gtest.Assert(a1.Merge(b5).Len(), 23)
+		gtest.Assert(a1.Merge(b6).Len(), 27)
+	})
 
 }
 
 func TestSortedArray_LockFunc(t *testing.T) {
-	n1 := []interface{}{1, 2, 4, 3}
+	gtest.Case(t, func() {
+		n1 := []interface{}{1, 2, 4, 3}
 
-	func1 := func(v1, v2 interface{}) int {
-		return strings.Compare(gconv.String(v1), gconv.String(v2))
-	}
-	a1 := garray.NewSortedArrayFrom(n1, func1)
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		a1 := garray.NewSortedArrayFrom(n1, func1)
 
-	ch1 := make(chan int64, 2)
-	go a1.LockFunc(func(n1 []interface{}) { //互斥锁
-		n1[3] = 7
-		time.Sleep(1 * time.Second) //暂停一秒
+		ch1 := make(chan int64, 2)
+		go a1.LockFunc(func(n1 []interface{}) { //互斥锁
+			n1[3] = 7
+			time.Sleep(1 * time.Second) //暂停一秒
+		})
+
+		go func() {
+			time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		// 相差大于0.6秒，说明在读取a1.len时，发生了等待。  防止ci抖动,以豪秒为单位
+		gtest.AssertGT(t2-t1, 600)
+		gtest.Assert(a1.Contains(7), true)
 	})
-
-	go func() {
-		time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-		a1.Len()
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-	}()
-
-	t1 := <-ch1
-	t2 := <-ch1
-	// 相差大于0.6秒，说明在读取a1.len时，发生了等待。  防止ci抖动,以豪秒为单位
-	gtest.AssertGT(t2-t1, 600)
-	gtest.Assert(a1.Contains(7), true)
 }
 
 func TestSortedArray_RLockFunc(t *testing.T) {
-	n1 := []interface{}{1, 2, 4, 3}
+	gtest.Case(t, func() {
+		n1 := []interface{}{1, 2, 4, 3}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		a1 := garray.NewSortedArrayFrom(n1, func1)
 
-	func1 := func(v1, v2 interface{}) int {
-		return strings.Compare(gconv.String(v1), gconv.String(v2))
-	}
-	a1 := garray.NewSortedArrayFrom(n1, func1)
+		ch1 := make(chan int64, 2)
+		go a1.RLockFunc(func(n1 []interface{}) { //互斥锁
+			n1[3] = 7
+			time.Sleep(1 * time.Second) //暂停一秒
+		})
 
-	ch1 := make(chan int64, 2)
-	go a1.RLockFunc(func(n1 []interface{}) { //互斥锁
-		n1[3] = 7
-		time.Sleep(1 * time.Second) //暂停一秒
+		go func() {
+			time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
+		// 防止ci抖动,以豪秒为单位
+		gtest.AssertLT(t2-t1, 20)
+		gtest.Assert(a1.Contains(7), true)
 	})
-
-	go func() {
-		time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-		a1.Len()
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-	}()
-
-	t1 := <-ch1
-	t2 := <-ch1
-	// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
-	// 防止ci抖动,以豪秒为单位
-	gtest.AssertLT(t2-t1, 20)
-	gtest.Assert(a1.Contains(7), true)
 }
 
 func TestSortedArray_Merge(t *testing.T) {
-	n1 := []interface{}{1, 2, 4, 3}
-	n2 := []int{7, 8, 9}
-	n3 := []int{3, 6}
+	gtest.Case(t, func() {
+		n1 := []interface{}{1, 2, 4, 3}
+		n2 := []int{7, 8, 9}
+		n3 := []int{3, 6}
 
-	s1 := []string{"a", "b", "c"}
-	in1 := []interface{}{1, "a", 2, "b"}
+		s1 := []string{"a", "b", "c"}
+		in1 := []interface{}{1, "a", 2, "b"}
 
-	func1 := func(v1, v2 interface{}) int {
-		return strings.Compare(gconv.String(v1), gconv.String(v2))
-	}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
 
-	a1 := garray.NewSortedArrayFrom(n1, func1)
-	b1 := garray.NewStringArrayFrom(s1)
-	b2 := garray.NewIntArrayFrom(n3)
-	b3 := garray.NewArrayFrom(in1)
-	b4 := garray.NewSortedStringArrayFrom(s1)
-	b5 := garray.NewSortedIntArrayFrom(n3)
+		a1 := garray.NewSortedArrayFrom(n1, func1)
+		b1 := garray.NewStringArrayFrom(s1)
+		b2 := garray.NewIntArrayFrom(n3)
+		b3 := garray.NewArrayFrom(in1)
+		b4 := garray.NewSortedStringArrayFrom(s1)
+		b5 := garray.NewSortedIntArrayFrom(n3)
 
-	gtest.Assert(a1.Merge(n2).Len(), 7)
-	gtest.Assert(a1.Merge(n3).Len(), 9)
-	gtest.Assert(a1.Merge(b1).Len(), 12)
-	gtest.Assert(a1.Merge(b2).Len(), 14)
-	gtest.Assert(a1.Merge(b3).Len(), 18)
-	gtest.Assert(a1.Merge(b4).Len(), 21)
-	gtest.Assert(a1.Merge(b5).Len(), 23)
+		gtest.Assert(a1.Merge(n2).Len(), 7)
+		gtest.Assert(a1.Merge(n3).Len(), 9)
+		gtest.Assert(a1.Merge(b1).Len(), 12)
+		gtest.Assert(a1.Merge(b2).Len(), 14)
+		gtest.Assert(a1.Merge(b3).Len(), 18)
+		gtest.Assert(a1.Merge(b4).Len(), 21)
+		gtest.Assert(a1.Merge(b5).Len(), 23)
+	})
 }
 
 func TestIntArray_SortFunc(t *testing.T) {
-	n1 := []int{1, 2, 3, 5, 4}
-	a1 := garray.NewIntArrayFrom(n1)
+	gtest.Case(t, func() {
+		n1 := []int{1, 2, 3, 5, 4}
+		a1 := garray.NewIntArrayFrom(n1)
 
-	func1 := func(v1, v2 int) bool {
-		if v1 > v2 {
-			return false
-		}
-		return true
-	}
-	func2 := func(v1, v2 int) bool {
-		if v1 > v2 {
+		func1 := func(v1, v2 int) bool {
+			if v1 > v2 {
+				return false
+			}
 			return true
 		}
-		return true
-	}
-	a2 := a1.SortFunc(func1)
-	gtest.Assert(a2, []int{1, 2, 3, 4, 5})
-	a3 := a1.SortFunc(func2)
-	gtest.Assert(a3, []int{5, 4, 3, 2, 1})
-
+		func2 := func(v1, v2 int) bool {
+			if v1 > v2 {
+				return true
+			}
+			return true
+		}
+		a2 := a1.SortFunc(func1)
+		gtest.Assert(a2, []int{1, 2, 3, 4, 5})
+		a3 := a1.SortFunc(func2)
+		gtest.Assert(a3, []int{5, 4, 3, 2, 1})
+	})
 }
 
 func TestIntArray_LockFunc(t *testing.T) {
-	n1 := []int{1, 2, 4, 3}
-	a1 := garray.NewIntArrayFrom(n1)
-	ch1 := make(chan int64, 2)
-	go a1.LockFunc(func(n1 []int) { //互斥锁
-		n1[3] = 7
-		time.Sleep(1 * time.Second) //暂停一秒
+	gtest.Case(t, func() {
+		n1 := []int{1, 2, 4, 3}
+		a1 := garray.NewIntArrayFrom(n1)
+		ch1 := make(chan int64, 2)
+		go a1.LockFunc(func(n1 []int) { //互斥锁
+			n1[3] = 7
+			time.Sleep(1 * time.Second) //暂停一秒
+		})
+
+		go func() {
+			time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		// 相差大于0.6秒，说明在读取a1.len时，发生了等待。  防止ci抖动,以豪秒为单位
+		gtest.AssertGT(t2-t1, 600)
+		gtest.Assert(a1.Contains(7), true)
 	})
-
-	go func() {
-		time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-		a1.Len()
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-	}()
-
-	t1 := <-ch1
-	t2 := <-ch1
-	// 相差大于0.6秒，说明在读取a1.len时，发生了等待。  防止ci抖动,以豪秒为单位
-	gtest.AssertGT(t2-t1, 600)
-	gtest.Assert(a1.Contains(7), true)
 }
 
 func TestIntArray_RLockFunc(t *testing.T) {
-	n1 := []int{1, 2, 4, 3}
-	a1 := garray.NewIntArrayFrom(n1)
+	gtest.Case(t, func() {
+		n1 := []int{1, 2, 4, 3}
+		a1 := garray.NewIntArrayFrom(n1)
 
-	ch1 := make(chan int64, 2)
-	go a1.RLockFunc(func(n1 []int) { //互斥锁
-		n1[3] = 7
-		time.Sleep(1 * time.Second) //暂停一秒
+		ch1 := make(chan int64, 2)
+		go a1.RLockFunc(func(n1 []int) { //互斥锁
+			n1[3] = 7
+			time.Sleep(1 * time.Second) //暂停一秒
+		})
+
+		go func() {
+			time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
+		// 防止ci抖动,以豪秒为单位
+		gtest.AssertLT(t2-t1, 20)
+		gtest.Assert(a1.Contains(7), true)
 	})
-
-	go func() {
-		time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-		a1.Len()
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-	}()
-
-	t1 := <-ch1
-	t2 := <-ch1
-	// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
-	// 防止ci抖动,以豪秒为单位
-	gtest.AssertLT(t2-t1, 20)
-	gtest.Assert(a1.Contains(7), true)
 }
diff --git a/g/container/garray/garray_z_unit_interface_test.go b/g/container/garray/garray_z_unit_interface_test.go
index c94a2136f..f4f0fd9a6 100644
--- a/g/container/garray/garray_z_unit_interface_test.go
+++ b/g/container/garray/garray_z_unit_interface_test.go
@@ -42,22 +42,20 @@ func Test_Array_Basic(t *testing.T) {
 
 		n1 := []interface{}{0, 1, 2, 3}
 		a1 := garray.NewArrayFrom(n1)
-		i1:=a1.Remove(3)
-		gtest.Assert(gconv.Int(i1),3)
-		i2:=a1.Remove(1)
-		gtest.Assert(gconv.Int(i2),1)
-		gtest.Assert(a1.Len(),2)
-		gtest.Assert(a1.Contains(1),false)
+		i1 := a1.Remove(3)
+		gtest.Assert(gconv.Int(i1), 3)
+		i2 := a1.Remove(1)
+		gtest.Assert(gconv.Int(i2), 1)
+		gtest.Assert(a1.Len(), 2)
+		gtest.Assert(a1.Contains(1), false)
 
-		a2 := garray.NewArrayFrom(n1,true)
+		a2 := garray.NewArrayFrom(n1, true)
 		gtest.Assert(a2.Slice(), n1)
-		gtest.Assert(a2.Search(100),-1)
-
-		n2:=[]interface{}{}
-		a3:=garray.NewArrayFrom(n2)
-		gtest.Assert(a3.Search(3),-1)
-
+		gtest.Assert(a2.Search(100), -1)
 
+		n2 := []interface{}{}
+		a3 := garray.NewArrayFrom(n2)
+		gtest.Assert(a3.Search(3), -1)
 
 	})
 }
@@ -138,45 +136,41 @@ func TestArray_Range(t *testing.T) {
 		gtest.Assert(array1.Range(0, 2), []interface{}{0, 1})
 		gtest.Assert(array1.Range(-1, 10), value1)
 		gtest.Assert(array1.Range(9, 1), nil)
-		a1 := garray.NewArrayFrom(value1,true)
+		a1 := garray.NewArrayFrom(value1, true)
 		gtest.Assert(a1.Range(0, 1), []interface{}{0})
-
-
-
 	})
 }
 
 func TestArray_Merge(t *testing.T) {
 	gtest.Case(t, func() {
 		n1 := []interface{}{1, 2, 4, 3}
-		n2:=[]int{7,8,9}
-		n3:=[]int{3,6}
+		n2 := []int{7, 8, 9}
+		n3 := []int{3, 6}
 
-		s1:=[]string{"a","b","c"}
-		in1:=[]interface{}{1,"a",2,"b"}
-		func1:=func(v1,v2 interface{})int{
+		s1 := []string{"a", "b", "c"}
+		in1 := []interface{}{1, "a", 2, "b"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 
 		a1 := garray.NewArrayFrom(n1)
-		a11 := garray.NewSortedArrayFrom(n1,func1)
+		a11 := garray.NewSortedArrayFrom(n1, func1)
 		b1 := garray.NewStringArrayFrom(s1)
-		b2:=garray.NewIntArrayFrom(n3)
-		b3:=garray.NewArrayFrom(in1)
-		b4:=garray.NewSortedStringArrayFrom(s1)
-		b5:=garray.NewSortedIntArrayFrom(n3)
-		b6:=garray.NewSortedArrayFrom(n1,func1)
+		b2 := garray.NewIntArrayFrom(n3)
+		b3 := garray.NewArrayFrom(in1)
+		b4 := garray.NewSortedStringArrayFrom(s1)
+		b5 := garray.NewSortedIntArrayFrom(n3)
+		b6 := garray.NewSortedArrayFrom(n1, func1)
 
-		gtest.Assert(a1.Merge(n2).Len(),7)
-		gtest.Assert(a1.Merge(n3).Len(),9)
-		gtest.Assert(a1.Merge(b1).Len(),12)
-		gtest.Assert(a1.Merge(b2).Len(),14)
-		gtest.Assert(a1.Merge(b3).Len(),18)
-		gtest.Assert(a1.Merge(b4).Len(),21)
-		gtest.Assert(a1.Merge(b5).Len(),23)
-		gtest.Assert(a1.Merge(b6).Len(),27)
-
-		gtest.Assert(a11.Merge(b6).Len(),8)
+		gtest.Assert(a1.Merge(n2).Len(), 7)
+		gtest.Assert(a1.Merge(n3).Len(), 9)
+		gtest.Assert(a1.Merge(b1).Len(), 12)
+		gtest.Assert(a1.Merge(b2).Len(), 14)
+		gtest.Assert(a1.Merge(b3).Len(), 18)
+		gtest.Assert(a1.Merge(b4).Len(), 21)
+		gtest.Assert(a1.Merge(b5).Len(), 23)
+		gtest.Assert(a1.Merge(b6).Len(), 27)
+		gtest.Assert(a11.Merge(b6).Len(), 8)
 	})
 }
 
@@ -189,8 +183,6 @@ func TestArray_Fill(t *testing.T) {
 		gtest.Assert(array1.Fill(1, 2, 100).Slice(), []interface{}{0, 100, 100})
 		gtest.Assert(array2.Fill(0, 2, 100).Slice(), []interface{}{100, 100})
 		gtest.Assert(array2.Fill(-1, 2, 100).Slice(), []interface{}{100, 100})
-
-
 	})
 }
 
@@ -226,27 +218,25 @@ func TestArray_SubSlice(t *testing.T) {
 		gtest.Assert(array1.SubSlice(5, 8), []interface{}{5, 6})
 		gtest.Assert(array1.SubSlice(8, 1), nil)
 
-		array2 := garray.NewArrayFrom(a1,false)
+		array2 := garray.NewArrayFrom(a1, false)
 		gtest.Assert(array2.SubSlice(2, 2), []interface{}{2, 3})
 
 		a2 := []interface{}{0, 1, 2, 3, 4, 5, 6}
-		array3 := garray.NewArrayFrom(a2,true)
+		array3 := garray.NewArrayFrom(a2, true)
 		gtest.Assert(array3.SubSlice(2, 2), []interface{}{2, 3})
 		gtest.Assert(array3.SubSlice(-1, 2), []interface{}{6})
 		gtest.Assert(array3.SubSlice(-9, 2), nil)
-		gtest.Assert(array3.SubSlice(4, -2), []interface{}{2,3})
+		gtest.Assert(array3.SubSlice(4, -2), []interface{}{2, 3})
 		gtest.Assert(array3.SubSlice(1, -3), nil)
 
 	})
 }
 
-
-
 func TestArray_Rand(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(a1)
-		i1:=array1.Rand()
+		i1 := array1.Rand()
 		gtest.Assert(array1.Contains(i1), true)
 		gtest.Assert(len(array1.Rands(2)), 2)
 		gtest.Assert(len(array1.Rands(10)), 7)
@@ -323,7 +313,6 @@ func TestArray_Sum(t *testing.T) {
 		gtest.Assert(array1.Sum(), 6)
 		gtest.Assert(array2.Sum(), 0)
 		gtest.Assert(array3.Sum(), 3)
-
 	})
 }
 
@@ -405,7 +394,6 @@ func TestSortedArray_SetArray(t *testing.T) {
 		gtest.Assert(array1.Len(), 4)
 		gtest.Assert(array1, []interface{}{"e", "g", "h", "k"})
 	})
-
 }
 
 func TestSortedArray_Sort(t *testing.T) {
@@ -419,7 +407,6 @@ func TestSortedArray_Sort(t *testing.T) {
 		gtest.Assert(array1.Len(), 3)
 		gtest.Assert(array1, []interface{}{"a", "c", "f"})
 	})
-
 }
 
 func TestSortedArray_Get(t *testing.T) {
@@ -432,7 +419,6 @@ func TestSortedArray_Get(t *testing.T) {
 		gtest.Assert(array1.Get(2), "f")
 		gtest.Assert(array1.Get(1), "c")
 	})
-
 }
 
 func TestSortedArray_Remove(t *testing.T) {
@@ -457,7 +443,6 @@ func TestSortedArray_Remove(t *testing.T) {
 		gtest.Assert(array1.Len(), 1)
 		gtest.Assert(array1.Contains("d"), false)
 	})
-
 }
 
 func TestSortedArray_PopLeft(t *testing.T) {
@@ -472,7 +457,6 @@ func TestSortedArray_PopLeft(t *testing.T) {
 		gtest.Assert(array1.Len(), 3)
 		gtest.Assert(array1, []interface{}{"b", "c", "d"})
 	})
-
 }
 
 func TestSortedArray_PopRight(t *testing.T) {
@@ -487,7 +471,6 @@ func TestSortedArray_PopRight(t *testing.T) {
 		gtest.Assert(array1.Len(), 3)
 		gtest.Assert(array1, []interface{}{"a", "b", "c"})
 	})
-
 }
 
 func TestSortedArray_PopRand(t *testing.T) {
@@ -500,7 +483,6 @@ func TestSortedArray_PopRand(t *testing.T) {
 		i1 := array1.PopRand()
 		gtest.AssertIN(i1, []interface{}{"a", "d", "c", "b"})
 		gtest.Assert(array1.Len(), 3)
-
 	})
 }
 
@@ -520,7 +502,6 @@ func TestSortedArray_PopRands(t *testing.T) {
 		gtest.Assert(len(i1), 2)
 		gtest.AssertIN(i2, []interface{}{"a", "d", "c", "b"})
 		gtest.Assert(array1.Len(), 0)
-
 	})
 }
 
@@ -540,7 +521,6 @@ func TestSortedArray_PopLefts(t *testing.T) {
 		gtest.Assert(len(i2), 4)
 		gtest.AssertIN(i1, []interface{}{"a", "d", "c", "b", "e", "f"})
 		gtest.Assert(array1.Len(), 0)
-
 	})
 }
 
@@ -555,10 +535,8 @@ func TestSortedArray_PopRights(t *testing.T) {
 		gtest.Assert(len(i1), 2)
 		gtest.Assert(i1, []interface{}{"e", "f"})
 		gtest.Assert(array1.Len(), 4)
-
 		i2 := array1.PopRights(10)
 		gtest.Assert(len(i2), 4)
-
 	})
 }
 
@@ -569,7 +547,7 @@ func TestSortedArray_Range(t *testing.T) {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
-		array2 := garray.NewSortedArrayFrom(a1, func1,true)
+		array2 := garray.NewSortedArrayFrom(a1, func1, true)
 		i1 := array1.Range(2, 5)
 		gtest.Assert(i1, []interface{}{"c", "d", "e"})
 		gtest.Assert(array1.Len(), 6)
@@ -604,7 +582,6 @@ func TestSortedArray_Sum(t *testing.T) {
 		gtest.Assert(array1.Sum(), 0)
 		gtest.Assert(array2.Sum(), 6)
 		gtest.Assert(array3.Sum(), 15)
-
 	})
 }
 
@@ -620,14 +597,12 @@ func TestSortedArray_Clone(t *testing.T) {
 		gtest.Assert(array1, array2)
 		array1.Remove(1)
 		gtest.AssertNE(array1, array2)
-
 	})
 }
 
 func TestSortedArray_Clear(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
-
 		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
@@ -635,14 +610,12 @@ func TestSortedArray_Clear(t *testing.T) {
 		gtest.Assert(array1.Len(), 6)
 		array1.Clear()
 		gtest.Assert(array1.Len(), 0)
-
 	})
 }
 
 func TestSortedArray_Chunk(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []interface{}{"a", "d", "c", "b", "e"}
-
 		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
@@ -660,12 +633,11 @@ func TestSortedArray_Chunk(t *testing.T) {
 func TestSortedArray_SubSlice(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []interface{}{"a", "d", "c", "b", "e"}
-
 		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
-		array2 := garray.NewSortedArrayFrom(a1, func1,true)
+		array2 := garray.NewSortedArrayFrom(a1, func1, true)
 		i1 := array1.SubSlice(2, 3)
 		gtest.Assert(len(i1), 3)
 		gtest.Assert(i1, []interface{}{"c", "d", "e"})
@@ -685,14 +657,12 @@ func TestSortedArray_SubSlice(t *testing.T) {
 
 		i1 = array2.SubSlice(1, -9)
 		gtest.Assert(i1, nil)
-
 	})
 }
 
 func TestSortedArray_Rand(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []interface{}{"a", "d", "c"}
-
 		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
@@ -706,7 +676,6 @@ func TestSortedArray_Rand(t *testing.T) {
 func TestSortedArray_Rands(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []interface{}{"a", "d", "c"}
-
 		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
@@ -724,14 +693,12 @@ func TestSortedArray_Rands(t *testing.T) {
 func TestSortedArray_Join(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []interface{}{"a", "d", "c"}
-
 		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		gtest.Assert(array1.Join(","), "a,c,d")
 		gtest.Assert(array1.Join("."), "a.c.d")
-
 	})
 }
 
@@ -747,14 +714,12 @@ func TestSortedArray_CountValues(t *testing.T) {
 		gtest.Assert(len(m1), 3)
 		gtest.Assert(m1["c"], 2)
 		gtest.Assert(m1["a"], 1)
-
 	})
 }
 
 func TestSortedArray_SetUnique(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []interface{}{"a", "d", "c", "c"}
-
 		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
@@ -765,54 +730,54 @@ func TestSortedArray_SetUnique(t *testing.T) {
 	})
 }
 
-
 func TestArray_LockFunc(t *testing.T) {
-	n1 := []interface{}{1, 2, 4, 3}
-	a1 := garray.NewArrayFrom(n1)
-	ch1 := make(chan int64, 2)
-	go a1.LockFunc(func(n1 []interface{}) { //互斥锁
-		n1[3] = 7
-		time.Sleep(1 * time.Second) //暂停一秒
+	gtest.Case(t, func() {
+		n1 := []interface{}{1, 2, 4, 3}
+		a1 := garray.NewArrayFrom(n1)
+		ch1 := make(chan int64, 2)
+		go a1.LockFunc(func(n1 []interface{}) { //互斥锁
+			n1[3] = 7
+			time.Sleep(1 * time.Second) //暂停一秒
+		})
+
+		go func() {
+			time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		// 相差大于0.6秒，说明在读取a1.len时，发生了等待。  防止ci抖动,以豪秒为单位
+		gtest.AssertGT(t2-t1, 600)
+		gtest.Assert(a1.Contains(7), true)
 	})
-
-	go func() {
-		time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-		a1.Len()
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-	}()
-
-	t1 := <-ch1
-	t2 := <-ch1
-	// 相差大于0.6秒，说明在读取a1.len时，发生了等待。  防止ci抖动,以豪秒为单位
-	gtest.AssertGT(t2-t1, 600)
-	gtest.Assert(a1.Contains(7), true)
 }
 
 func TestArray_RLockFunc(t *testing.T) {
-	n1 := []interface{}{1, 2, 4, 3}
-	a1 := garray.NewArrayFrom(n1)
+	gtest.Case(t, func() {
+		n1 := []interface{}{1, 2, 4, 3}
+		a1 := garray.NewArrayFrom(n1)
 
-	ch1 := make(chan int64, 2)
-	go a1.RLockFunc(func(n1 []interface{}) { //互斥锁
-		n1[3] = 7
-		time.Sleep(1 * time.Second) //暂停一秒
+		ch1 := make(chan int64, 2)
+		go a1.RLockFunc(func(n1 []interface{}) { //互斥锁
+			n1[3] = 7
+			time.Sleep(1 * time.Second) //暂停一秒
+		})
+
+		go func() {
+			time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
+		// 防止ci抖动,以豪秒为单位
+		gtest.AssertLT(t2-t1, 20)
+		gtest.Assert(a1.Contains(7), true)
 	})
-
-	go func() {
-		time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-		a1.Len()
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-	}()
-
-	t1 := <-ch1
-	t2 := <-ch1
-	// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
-	// 防止ci抖动,以豪秒为单位
-	gtest.AssertLT(t2-t1, 20)
-	gtest.Assert(a1.Contains(7), true)
 }
-
-
-
diff --git a/g/container/garray/garray_z_unit_string_test.go b/g/container/garray/garray_z_unit_string_test.go
index 0cf71f57d..bca25e1eb 100644
--- a/g/container/garray/garray_z_unit_string_test.go
+++ b/g/container/garray/garray_z_unit_string_test.go
@@ -107,7 +107,7 @@ func TestString_Range(t *testing.T) {
 	gtest.Case(t, func() {
 		value1 := []string{"0", "1", "2", "3", "4", "5", "6"}
 		array1 := garray.NewStringArrayFrom(value1)
-		array2 := garray.NewStringArrayFrom(value1,true)
+		array2 := garray.NewStringArrayFrom(value1, true)
 		gtest.Assert(array1.Range(0, 1), []interface{}{"0"})
 		gtest.Assert(array1.Range(1, 2), []interface{}{"1"})
 		gtest.Assert(array1.Range(0, 2), []interface{}{"0", "1"})
@@ -117,7 +117,6 @@ func TestString_Range(t *testing.T) {
 	})
 }
 
-
 func TestStringArray_Fill(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []string{"0"}
@@ -164,11 +163,11 @@ func TestStringArray_SubSlice(t *testing.T) {
 		gtest.Assert(array1.SubSlice(5, 8), []string{"5", "6"})
 		gtest.Assert(array1.SubSlice(8, 1), nil)
 
-		array3 := garray.NewStringArrayFrom(a1,true)
+		array3 := garray.NewStringArrayFrom(a1, true)
 		gtest.Assert(array3.SubSlice(2, 2), []string{"2", "3"})
 		gtest.Assert(array3.SubSlice(-1, 2), []string{"6"})
 		gtest.Assert(array3.SubSlice(-9, 2), nil)
-		gtest.Assert(array3.SubSlice(4, -2), []string{"2","3"})
+		gtest.Assert(array3.SubSlice(4, -2), []string{"2", "3"})
 		gtest.Assert(array3.SubSlice(1, -3), nil)
 	})
 }
@@ -285,26 +284,6 @@ func TestStringArray_Sum(t *testing.T) {
 	})
 }
 
-//func TestStringArray_SortFunc(t *testing.T) {
-//    gtest.Case(t, func() {
-//        a1 := []string{"0","1","2","3","4","5","6"}
-//        //a2 := []string{"0","a","3","4","5","6"}
-//        array1 := garray.NewStringArrayFrom(a1)
-//
-//        lesss:=func(v1,v2 string)bool{
-//            if v1>v2{
-//                return true
-//            }
-//            return false
-//        }
-//        gtest.Assert(array1.Len(),7)
-//        gtest.Assert(lesss("1","2"),false)
-//        gtest.Assert(array1.SortFunc(lesss("1","2"))  ,false)
-//
-//
-//    })
-//}
-
 func TestStringArray_PopRand(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
@@ -329,7 +308,6 @@ func TestStringArray_CountValues(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []string{"0", "1", "2", "3", "4", "4", "6"}
 		array1 := garray.NewStringArrayFrom(a1)
-
 		m1 := array1.CountValues()
 		gtest.Assert(len(m1), 6)
 		gtest.Assert(m1["2"], 1)
@@ -375,7 +353,6 @@ func TestSortedStringArray_Sort(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []string{"a", "d", "c", "b"}
 		array1 := garray.NewSortedStringArrayFrom(a1)
-
 		gtest.Assert(array1, []string{"a", "b", "c", "d"})
 		array1.Sort()
 		gtest.Assert(array1.Len(), 4)
@@ -390,7 +367,6 @@ func TestSortedStringArray_Get(t *testing.T) {
 		array1 := garray.NewSortedStringArrayFrom(a1)
 		gtest.Assert(array1.Get(2), "c")
 		gtest.Assert(array1.Get(0), "a")
-
 	})
 }
 
@@ -496,7 +472,7 @@ func TestSortedStringArray_Range(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
 		array1 := garray.NewSortedStringArrayFrom(a1)
-		array2 := garray.NewSortedStringArrayFrom(a1,true)
+		array2 := garray.NewSortedStringArrayFrom(a1, true)
 		s1 := array1.Range(2, 4)
 		gtest.Assert(len(s1), 2)
 		gtest.Assert(s1, []string{"c", "d"})
@@ -509,7 +485,6 @@ func TestSortedStringArray_Range(t *testing.T) {
 		gtest.Assert(array1.Range(10, 2), nil)
 		gtest.Assert(array2.Range(4, 8), []string{"e", "f", "g"})
 
-
 	})
 }
 
@@ -549,7 +524,7 @@ func TestSortedStringArray_SubSlice(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
 		array1 := garray.NewSortedStringArrayFrom(a1)
-		array2 := garray.NewSortedStringArrayFrom(a1,true)
+		array2 := garray.NewSortedStringArrayFrom(a1, true)
 		s1 := array1.SubSlice(1, 3)
 		gtest.Assert(len(s1), 3)
 		gtest.Assert(s1, []string{"b", "c", "d"})
@@ -560,10 +535,10 @@ func TestSortedStringArray_SubSlice(t *testing.T) {
 
 		s3 := array1.SubSlice(10, 2)
 		gtest.Assert(len(s3), 0)
-		gtest.Assert(array1.SubSlice(-2, 2),[]string{"f", "g"})
-		gtest.Assert(array1.SubSlice(-10, 2),nil)
-		gtest.Assert(array1.SubSlice(2, -3),nil)
-		gtest.Assert(array2.SubSlice(2, 3),[]string{"c", "d","e"})
+		gtest.Assert(array1.SubSlice(-2, 2), []string{"f", "g"})
+		gtest.Assert(array1.SubSlice(-10, 2), nil)
+		gtest.Assert(array1.SubSlice(2, -3), nil)
+		gtest.Assert(array2.SubSlice(2, 3), []string{"c", "d", "e"})
 
 	})
 }
@@ -573,7 +548,6 @@ func TestSortedStringArray_Len(t *testing.T) {
 		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
 		array1 := garray.NewSortedStringArrayFrom(a1)
 		gtest.Assert(array1.Len(), 7)
-
 	})
 }
 
@@ -582,7 +556,6 @@ func TestSortedStringArray_Rand(t *testing.T) {
 		a1 := []string{"e", "a", "d"}
 		array1 := garray.NewSortedStringArrayFrom(a1)
 		gtest.AssertIN(array1.Rand(), []string{"e", "a", "d"})
-
 	})
 }
 
@@ -617,7 +590,6 @@ func TestSortedStringArray_CountValues(t *testing.T) {
 		m1 := array1.CountValues()
 		gtest.Assert(m1["a"], 2)
 		gtest.Assert(m1["d"], 1)
-
 	})
 }
 
@@ -653,184 +625,195 @@ func TestStringArray_Remove(t *testing.T) {
 		s1 = array1.Remove(3)
 		gtest.Assert(s1, "c")
 		gtest.Assert(array1.Len(), 3)
-
 	})
 }
 
 func TestSortedStringArray_LockFunc(t *testing.T) {
-	s1 := []string{"a", "b", "c", "d"}
-	a1 := garray.NewSortedStringArrayFrom(s1)
+	gtest.Case(t, func() {
+		s1 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewSortedStringArrayFrom(s1)
 
-	ch1 := make(chan int64, 2)
-	go a1.LockFunc(func(n1 []string) { //互斥锁
-		n1[3] = "e"
-		time.Sleep(1 * time.Second) //暂停一秒
+		ch1 := make(chan int64, 2)
+		go a1.LockFunc(func(n1 []string) { //互斥锁
+			n1[3] = "e"
+			time.Sleep(1 * time.Second) //暂停一秒
+		})
+
+		go func() {
+			time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		// 相差大于0.6秒，说明在读取a1.len时，发生了等待。  防止ci抖动,以豪秒为单位
+		gtest.AssertGT(t2-t1, 600)
+		gtest.Assert(a1.Contains("e"), true)
 	})
-
-	go func() {
-		time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-		a1.Len()
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-	}()
-
-	t1 := <-ch1
-	t2 := <-ch1
-	// 相差大于0.6秒，说明在读取a1.len时，发生了等待。  防止ci抖动,以豪秒为单位
-	gtest.AssertGT(t2-t1, 600)
-	gtest.Assert(a1.Contains("e"), true)
 }
 
 func TestSortedStringArray_RLockFunc(t *testing.T) {
-	s1 := []string{"a", "b", "c", "d"}
-	a1 := garray.NewSortedStringArrayFrom(s1)
+	gtest.Case(t, func() {
+		s1 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewSortedStringArrayFrom(s1)
 
-	ch1 := make(chan int64, 2)
-	go a1.RLockFunc(func(n1 []string) { //读锁
-		n1[3] = "e"
-		time.Sleep(1 * time.Second) //暂停一秒
+		ch1 := make(chan int64, 2)
+		go a1.RLockFunc(func(n1 []string) { //读锁
+			n1[3] = "e"
+			time.Sleep(1 * time.Second) //暂停一秒
+		})
+
+		go func() {
+			time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
+		// 防止ci抖动,以豪秒为单位
+		gtest.AssertLT(t2-t1, 2)
+		gtest.Assert(a1.Contains("e"), true)
 	})
-
-	go func() {
-		time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-		a1.Len()
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-	}()
-
-	t1 := <-ch1
-	t2 := <-ch1
-	// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
-	// 防止ci抖动,以豪秒为单位
-	gtest.AssertLT(t2-t1, 2)
-	gtest.Assert(a1.Contains("e"), true)
 }
 
 func TestSortedStringArray_Merge(t *testing.T) {
-	//n1 := []int{1, 2, 4, 3}
-	n2 := []int{7, 8, 9}
-	n3 := []int{3, 6}
+	gtest.Case(t, func() {
+		//n1 := []int{1, 2, 4, 3}
+		n2 := []int{7, 8, 9}
+		n3 := []int{3, 6}
 
-	s1 := []string{"a", "b", "c"}
-	in1 := []interface{}{1, "a", 2, "b"}
+		s1 := []string{"a", "b", "c"}
+		in1 := []interface{}{1, "a", 2, "b"}
 
-	func1:=func(v1,v2 interface{})int{
-		return strings.Compare(gconv.String(v1), gconv.String(v2))
-	}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
 
-	a1 := garray.NewSortedStringArrayFrom(s1)
-	b1 := garray.NewStringArrayFrom(s1)
-	b2 := garray.NewIntArrayFrom(n3)
-	b3 := garray.NewArrayFrom(in1)
-	b4 := garray.NewSortedStringArrayFrom(s1)
-	b5 := garray.NewSortedIntArrayFrom(n3)
-	b6 := garray.NewSortedArrayFrom(in1,func1)
+		a1 := garray.NewSortedStringArrayFrom(s1)
+		b1 := garray.NewStringArrayFrom(s1)
+		b2 := garray.NewIntArrayFrom(n3)
+		b3 := garray.NewArrayFrom(in1)
+		b4 := garray.NewSortedStringArrayFrom(s1)
+		b5 := garray.NewSortedIntArrayFrom(n3)
+		b6 := garray.NewSortedArrayFrom(in1, func1)
 
-	gtest.Assert(a1.Merge(n2).Len(), 6)
-	gtest.Assert(a1.Merge(n3).Len(), 8)
-	gtest.Assert(a1.Merge(b1).Len(), 11)
-	gtest.Assert(a1.Merge(b2).Len(), 13)
-	gtest.Assert(a1.Merge(b3).Len(), 17)
-	gtest.Assert(a1.Merge(b4).Len(), 20)
-	gtest.Assert(a1.Merge(b5).Len(), 22)
-	gtest.Assert(a1.Merge(b6).Len(), 26)
+		gtest.Assert(a1.Merge(n2).Len(), 6)
+		gtest.Assert(a1.Merge(n3).Len(), 8)
+		gtest.Assert(a1.Merge(b1).Len(), 11)
+		gtest.Assert(a1.Merge(b2).Len(), 13)
+		gtest.Assert(a1.Merge(b3).Len(), 17)
+		gtest.Assert(a1.Merge(b4).Len(), 20)
+		gtest.Assert(a1.Merge(b5).Len(), 22)
+		gtest.Assert(a1.Merge(b6).Len(), 26)
+	})
 }
 
 func TestStringArray_SortFunc(t *testing.T) {
-	s1 := []string{"a", "b", "d", "c"}
-	a1 := garray.NewStringArrayFrom(s1)
-	func1 := func(v1, v2 string) bool {
-		return strings.Compare(gconv.String(v1), gconv.String(v2)) < 0
-	}
-	func2 := func(v1, v2 string) bool {
-		return strings.Compare(gconv.String(v1), gconv.String(v2)) > 0
-	}
+	gtest.Case(t, func() {
+		s1 := []string{"a", "b", "d", "c"}
+		a1 := garray.NewStringArrayFrom(s1)
+		func1 := func(v1, v2 string) bool {
+			return strings.Compare(gconv.String(v1), gconv.String(v2)) < 0
+		}
+		func2 := func(v1, v2 string) bool {
+			return strings.Compare(gconv.String(v1), gconv.String(v2)) > 0
+		}
 
-	a2 := a1.SortFunc(func1)
-	gtest.Assert(a2, []string{"a", "b", "c", "d"})
+		a2 := a1.SortFunc(func1)
+		gtest.Assert(a2, []string{"a", "b", "c", "d"})
 
-	a3 := a1.SortFunc(func2)
-	gtest.Assert(a3, []string{"d", "c", "b", "a"})
+		a3 := a1.SortFunc(func2)
+		gtest.Assert(a3, []string{"d", "c", "b", "a"})
+	})
 
 }
 
-
 func TestStringArray_LockFunc(t *testing.T) {
-	s1 := []string{"a", "b", "c", "d"}
-	a1 := garray.NewStringArrayFrom(s1)
+	gtest.Case(t, func() {
+		s1 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewStringArrayFrom(s1)
 
-	ch1 := make(chan int64, 2)
-	go a1.LockFunc(func(n1 []string) { //互斥锁
-		n1[3] = "f"
-		time.Sleep(1 * time.Second) //暂停一秒
+		ch1 := make(chan int64, 2)
+		go a1.LockFunc(func(n1 []string) { //互斥锁
+			n1[3] = "f"
+			time.Sleep(1 * time.Second) //暂停一秒
+		})
+
+		go func() {
+			time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		// 相差大于0.6秒，说明在读取a1.len时，发生了等待。  防止ci抖动,以豪秒为单位
+		gtest.AssertGT(t2-t1, 600)
+		gtest.Assert(a1.Contains("f"), true)
 	})
-
-	go func() {
-		time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-		a1.Len()
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-	}()
-
-	t1 := <-ch1
-	t2 := <-ch1
-	// 相差大于0.6秒，说明在读取a1.len时，发生了等待。  防止ci抖动,以豪秒为单位
-	gtest.AssertGT(t2-t1, 600)
-	gtest.Assert(a1.Contains("f"), true)
 }
 
 func TestStringArray_RLockFunc(t *testing.T) {
-	s1 := []string{"a", "b", "c", "d"}
-	a1 := garray.NewStringArrayFrom(s1)
+	gtest.Case(t, func() {
+		s1 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewStringArrayFrom(s1)
 
-	ch1 := make(chan int64, 2)
-	go a1.RLockFunc(func(n1 []string) { //读锁
-		n1[2] = "g"
-		time.Sleep(1 * time.Second) //暂停一秒
+		ch1 := make(chan int64, 2)
+		go a1.RLockFunc(func(n1 []string) { //读锁
+			n1[2] = "g"
+			time.Sleep(1 * time.Second) //暂停一秒
+		})
+
+		go func() {
+			time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
+		// 防止ci抖动,以豪秒为单位
+		gtest.AssertLT(t2-t1, 2)
+		gtest.Assert(a1.Contains("g"), true)
 	})
-
-	go func() {
-		time.Sleep(10 * time.Millisecond) //故意暂停0.01秒,等另一个goroutine执行锁后，再开始执行.
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-		a1.Len()
-		ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
-	}()
-
-	t1 := <-ch1
-	t2 := <-ch1
-	// 由于另一个goroutine加的读锁，其它可读,所以ch1的操作间隔是很小的.a.len 操作并没有等待,
-	// 防止ci抖动,以豪秒为单位
-	gtest.AssertLT(t2-t1, 2)
-	gtest.Assert(a1.Contains("g"), true)
-
 }
 
 func TestStringArray_Merge(t *testing.T) {
-	//n1 := []int{1, 2, 4, 3}
-	n2 := []int{7, 8, 9}
-	n3 := []int{3, 6}
+	gtest.Case(t, func() {
+		//n1 := []int{1, 2, 4, 3}
+		n2 := []int{7, 8, 9}
+		n3 := []int{3, 6}
 
-	s1 := []string{"a", "b", "c"}
-	in1 := []interface{}{1, "a", 2, "b"}
+		s1 := []string{"a", "b", "c"}
+		in1 := []interface{}{1, "a", 2, "b"}
 
-	func1:=func(v1,v2 interface{})int{
-		return strings.Compare(gconv.String(v1), gconv.String(v2))
-	}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
 
-	a1 := garray.NewStringArrayFrom(s1)
-	b1 := garray.NewStringArrayFrom(s1)
-	b2 := garray.NewIntArrayFrom(n3)
-	b3 := garray.NewArrayFrom(in1)
-	b4 := garray.NewSortedStringArrayFrom(s1)
-	b5 := garray.NewSortedIntArrayFrom(n3)
-	b6 := garray.NewSortedArrayFrom(in1,func1)
+		a1 := garray.NewStringArrayFrom(s1)
+		b1 := garray.NewStringArrayFrom(s1)
+		b2 := garray.NewIntArrayFrom(n3)
+		b3 := garray.NewArrayFrom(in1)
+		b4 := garray.NewSortedStringArrayFrom(s1)
+		b5 := garray.NewSortedIntArrayFrom(n3)
+		b6 := garray.NewSortedArrayFrom(in1, func1)
 
-	gtest.Assert(a1.Merge(n2).Len(), 6)
-	gtest.Assert(a1.Merge(n3).Len(), 8)
-	gtest.Assert(a1.Merge(b1).Len(), 11)
-	gtest.Assert(a1.Merge(b2).Len(), 13)
-	gtest.Assert(a1.Merge(b3).Len(), 17)
-	gtest.Assert(a1.Merge(b4).Len(), 20)
-	gtest.Assert(a1.Merge(b5).Len(), 22)
-	gtest.Assert(a1.Merge(b6).Len(), 26)
+		gtest.Assert(a1.Merge(n2).Len(), 6)
+		gtest.Assert(a1.Merge(n3).Len(), 8)
+		gtest.Assert(a1.Merge(b1).Len(), 11)
+		gtest.Assert(a1.Merge(b2).Len(), 13)
+		gtest.Assert(a1.Merge(b3).Len(), 17)
+		gtest.Assert(a1.Merge(b4).Len(), 20)
+		gtest.Assert(a1.Merge(b5).Len(), 22)
+		gtest.Assert(a1.Merge(b6).Len(), 26)
+	})
 }