diff --git a/container/garray/garray_z_example_normal_any_test.go b/container/garray/garray_z_example_normal_any_test.go
index a7b914ef5..782a4999d 100644
--- a/container/garray/garray_z_example_normal_any_test.go
+++ b/container/garray/garray_z_example_normal_any_test.go
@@ -46,6 +46,8 @@ func ExampleNew() {
 	a.Set(0, 100)
 	fmt.Println(a.Slice())
 
+	fmt.Println(a.At(0))
+
 	// Search item and return its index.
 	fmt.Println(a.Search(5))
 
@@ -66,6 +68,7 @@ func ExampleNew() {
 	// false
 	// [0 1 2 3 4 5 6 7 8 9 10 11]
 	// [100 1 2 3 4 5 6 7 8 9 10 11]
+	// 100
 	// 5
 	// [1 2 3 4 5 6 7 8 9 10 11]
 	// [1 2 3 4 5 6 7 8 9 10 11]
diff --git a/container/garray/garray_z_example_normal_int_test.go b/container/garray/garray_z_example_normal_int_test.go
index 6052ca601..ceaf278ae 100644
--- a/container/garray/garray_z_example_normal_int_test.go
+++ b/container/garray/garray_z_example_normal_int_test.go
@@ -54,6 +54,14 @@ func ExampleNewIntArraySize() {
 	// [10 20 15] 3 5
 }
 
+func ExampleNewIntArrayRange() {
+	s := garray.NewIntArrayRange(1, 5, 1)
+	fmt.Println(s.Slice(), s.Len(), cap(s.Slice()))
+
+	// Output:
+	// [1 2 3 4 5] 5 5
+}
+
 func ExampleNewIntArrayFrom() {
 	s := garray.NewIntArrayFrom(g.SliceInt{10, 20, 15, 30})
 	fmt.Println(s.Slice(), s.Len(), cap(s.Slice()))
@@ -83,9 +91,12 @@ func ExampleIntArray_Get() {
 	s := garray.NewIntArrayFrom(g.SliceInt{10, 20, 15, 30})
 	sGet, sBool := s.Get(3)
 	fmt.Println(sGet, sBool)
+	sGet, sBool = s.Get(99)
+	fmt.Println(sGet, sBool)
 
 	// Output:
 	// 30 true
+	// 0 false
 }
 
 func ExampleIntArray_Set() {
diff --git a/container/garray/garray_z_unit_normal_any_test.go b/container/garray/garray_z_unit_normal_any_test.go
index 7532fbe86..bacfe2556 100644
--- a/container/garray/garray_z_unit_normal_any_test.go
+++ b/container/garray/garray_z_unit_normal_any_test.go
@@ -25,9 +25,24 @@ func Test_Array_Basic(t *testing.T) {
 		array := garray.NewArrayFrom(expect)
 		array2 := garray.NewArrayFrom(expect)
 		array3 := garray.NewArrayFrom([]interface{}{})
+		array4 := garray.NewArrayRange(1, 5, 1)
+
 		t.Assert(array.Slice(), expect)
 		t.Assert(array.Interfaces(), expect)
-		array.Set(0, 100)
+		err := array.Set(0, 100)
+		t.AssertNil(err)
+
+		err = array.Set(100, 100)
+		t.AssertNE(err, nil)
+
+		t.Assert(array.IsEmpty(), false)
+
+		copyArray := array.DeepCopy()
+		ca := copyArray.(*garray.Array)
+		ca.Set(0, 1)
+		cval, _ := ca.Get(0)
+		val, _ := array.Get(0)
+		t.AssertNE(cval, val)
 
 		v, ok := array.Get(0)
 		t.Assert(v, 100)
@@ -37,6 +52,10 @@ func Test_Array_Basic(t *testing.T) {
 		t.Assert(v, 1)
 		t.Assert(ok, true)
 
+		v, ok = array.Get(4)
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+
 		t.Assert(array.Search(100), 0)
 		t.Assert(array3.Search(100), -1)
 		t.Assert(array.Contains(100), true)
@@ -71,6 +90,12 @@ func Test_Array_Basic(t *testing.T) {
 		array.InsertAfter(6, 400)
 		t.Assert(array.Slice(), []interface{}{100, 200, 2, 2, 3, 300, 4, 400})
 		t.Assert(array.Clear().Len(), 0)
+		err = array.InsertBefore(99, 9900)
+		t.AssertNE(err, nil)
+		err = array.InsertAfter(99, 9900)
+		t.AssertNE(err, nil)
+
+		t.Assert(array4.String(), "[1,2,3,4,5]")
 	})
 }
 
@@ -99,6 +124,11 @@ func TestArray_Unique(t *testing.T) {
 		array := garray.NewArrayFrom(expect)
 		t.Assert(array.Unique().Slice(), []interface{}{1, 2, 3, 4, 5})
 	})
+	gtest.C(t, func(t *gtest.T) {
+		expect := []interface{}{}
+		array := garray.NewArrayFrom(expect)
+		t.Assert(array.Unique().Slice(), []interface{}{})
+	})
 }
 
 func TestArray_PushAndPop(t *testing.T) {
@@ -382,6 +412,21 @@ func TestArray_Rand(t *testing.T) {
 		t.Assert(a1.Contains(i1), true)
 		t.Assert(a1.Len(), 4)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []interface{}{}
+		array1 := garray.NewArrayFrom(a1)
+		rand, found := array1.Rand()
+		t.AssertNil(rand)
+		t.Assert(found, false)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []interface{}{}
+		array1 := garray.NewArrayFrom(a1)
+		rand := array1.Rands(1)
+		t.AssertNil(rand)
+	})
 }
 
 func TestArray_Shuffle(t *testing.T) {
@@ -412,6 +457,12 @@ func TestArray_Join(t *testing.T) {
 		array1 := garray.NewArrayFrom(a1)
 		t.Assert(array1.Join("."), `0.1."a".\a`)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []interface{}{}
+		array1 := garray.NewArrayFrom(a1)
+		t.Assert(len(array1.Join(".")), 0)
+	})
 }
 
 func TestArray_String(t *testing.T) {
@@ -419,6 +470,8 @@ func TestArray_String(t *testing.T) {
 		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(a1)
 		t.Assert(array1.String(), `[0,1,2,3,4,5,6]`)
+		array1 = nil
+		t.Assert(array1.String(), "")
 	})
 }
 
diff --git a/container/garray/garray_z_unit_normal_int_test.go b/container/garray/garray_z_unit_normal_int_test.go
index 545cbfc74..57300ede8 100644
--- a/container/garray/garray_z_unit_normal_int_test.go
+++ b/container/garray/garray_z_unit_normal_int_test.go
@@ -63,6 +63,19 @@ func Test_IntArray_Basic(t *testing.T) {
 		array.InsertAfter(6, 400)
 		t.Assert(array.Slice(), []int{100, 200, 1, 2, 3, 300, 4, 400})
 		t.Assert(array.Clear().Len(), 0)
+		err := array.InsertBefore(99, 300)
+		t.AssertNE(err, nil)
+		err = array.InsertAfter(99, 400)
+		t.AssertNE(err, nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewIntArrayFrom([]int{0, 1, 2, 3})
+		copyArray := array.DeepCopy().(*garray.IntArray)
+		copyArray.Set(0, 1)
+		cval, _ := copyArray.Get(0)
+		val, _ := array.Get(0)
+		t.AssertNE(cval, val)
 	})
 }
 
@@ -89,6 +102,8 @@ func TestIntArray_Unique(t *testing.T) {
 		expect := []int{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
 		array := garray.NewIntArrayFrom(expect)
 		t.Assert(array.Unique().Slice(), []int{1, 2, 3, 4, 5})
+		array2 := garray.NewIntArrayFrom([]int{})
+		t.Assert(array2.Unique().Slice(), []int{})
 	})
 }
 
@@ -374,6 +389,14 @@ func TestIntArray_Rand(t *testing.T) {
 		v, ok := array1.Rand()
 		t.AssertIN(v, a1)
 		t.Assert(ok, true)
+
+		array2 := garray.NewIntArrayFrom([]int{})
+		v, ok = array2.Rand()
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+
+		intSlices := array2.Rands(1)
+		t.Assert(intSlices, nil)
 	})
 }
 
@@ -420,6 +443,8 @@ func TestIntArray_String(t *testing.T) {
 		a1 := []int{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewIntArrayFrom(a1)
 		t.Assert(array1.String(), "[0,1,2,3,4,5,6]")
+		array1 = nil
+		t.Assert(array1.String(), "")
 	})
 }
 
diff --git a/container/garray/garray_z_unit_normal_str_test.go b/container/garray/garray_z_unit_normal_str_test.go
index 26130cce4..a6da223c3 100644
--- a/container/garray/garray_z_unit_normal_str_test.go
+++ b/container/garray/garray_z_unit_normal_str_test.go
@@ -34,6 +34,10 @@ func Test_StrArray_Basic(t *testing.T) {
 		t.Assert(v, 100)
 		t.Assert(ok, true)
 
+		v, ok = array3.Get(0)
+		t.Assert(v, "")
+		t.Assert(ok, false)
+
 		t.Assert(array.Search("100"), 0)
 		t.Assert(array.Contains("100"), true)
 
@@ -61,12 +65,28 @@ func Test_StrArray_Basic(t *testing.T) {
 		t.Assert(array.Clear().Len(), 0)
 		t.Assert(array2.Slice(), expect)
 		t.Assert(array3.Search("100"), -1)
+		err := array.InsertBefore(99, "300")
+		t.AssertNE(err, nil)
+		array.InsertAfter(99, "400")
+		t.AssertNE(err, nil)
+
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewStrArrayFrom([]string{"0", "1", "2", "3"})
+
+		copyArray := array.DeepCopy().(*garray.StrArray)
+		copyArray.Set(0, "1")
+		cval, _ := copyArray.Get(0)
+		val, _ := array.Get(0)
+		t.AssertNE(cval, val)
 	})
 }
 
 func TestStrArray_ContainsI(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		s := garray.NewStrArray()
+		t.Assert(s.Contains("A"), false)
 		s.Append("a", "b", "C")
 		t.Assert(s.Contains("A"), false)
 		t.Assert(s.Contains("a"), true)
@@ -94,6 +114,8 @@ func TestStrArray_Unique(t *testing.T) {
 		expect := []string{"1", "1", "2", "2", "3", "3", "2", "2"}
 		array := garray.NewStrArrayFrom(expect)
 		t.Assert(array.Unique().Slice(), []string{"1", "2", "3"})
+		array1 := garray.NewStrArrayFrom([]string{})
+		t.Assert(array1.Unique().Slice(), []string{})
 	})
 }
 
@@ -364,6 +386,13 @@ func TestStrArray_Rand(t *testing.T) {
 		v, ok := array1.Rand()
 		t.Assert(ok, true)
 		t.AssertIN(v, a1)
+
+		array2 := garray.NewStrArrayFrom([]string{})
+		v, ok = array2.Rand()
+		t.Assert(ok, false)
+		t.Assert(v, "")
+		strArray := array2.Rands(1)
+		t.AssertNil(strArray)
 	})
 }
 
@@ -406,6 +435,11 @@ func TestStrArray_Join(t *testing.T) {
 		array1 := garray.NewStrArrayFrom(a1)
 		t.Assert(array1.Join("."), `0.1."a".\a`)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{}
+		array1 := garray.NewStrArrayFrom(a1)
+		t.Assert(array1.Join("."), "")
+	})
 }
 
 func TestStrArray_String(t *testing.T) {
@@ -413,6 +447,9 @@ func TestStrArray_String(t *testing.T) {
 		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
 		array1 := garray.NewStrArrayFrom(a1)
 		t.Assert(array1.String(), `["0","1","2","3","4","5","6"]`)
+
+		array1 = nil
+		t.Assert(array1.String(), "")
 	})
 }
 
diff --git a/container/garray/garray_z_unit_sorted_any_test.go b/container/garray/garray_z_unit_sorted_any_test.go
index d7dad282e..5af1ed2f9 100644
--- a/container/garray/garray_z_unit_sorted_any_test.go
+++ b/container/garray/garray_z_unit_sorted_any_test.go
@@ -61,6 +61,18 @@ func TestNewSortedArrayFromCopy(t *testing.T) {
 	})
 }
 
+func TestNewSortedArrayRange(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		func1 := func(v1, v2 interface{}) int {
+			return gconv.Int(v1) - gconv.Int(v2)
+		}
+
+		array1 := garray.NewSortedArrayRange(1, 5, 1, func1)
+		t.Assert(array1.Len(), 5)
+		t.Assert(array1, []interface{}{1, 2, 3, 4, 5})
+	})
+}
+
 func TestSortedArray_SetArray(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []interface{}{"a", "f", "c"}
@@ -106,10 +118,26 @@ func TestSortedArray_Get(t *testing.T) {
 		v, ok = array1.Get(1)
 		t.Assert(v, "c")
 		t.Assert(ok, true)
+
+		v, ok = array1.Get(99)
+		t.Assert(v, nil)
+		t.Assert(ok, false)
 	})
 
 }
 
+func TestSortedArray_At(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []interface{}{"a", "f", "c"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		v := array1.At(2)
+		t.Assert(v, "f")
+	})
+}
+
 func TestSortedArray_Remove(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []interface{}{"a", "d", "c", "b"}
@@ -461,6 +489,11 @@ func TestSortedArray_Rand(t *testing.T) {
 		t.Assert(ok, true)
 		t.AssertIN(i1, []interface{}{"a", "d", "c"})
 		t.Assert(array1.Len(), 3)
+
+		array2 := garray.NewSortedArrayFrom([]interface{}{}, func1)
+		v, ok := array2.Rand()
+		t.Assert(ok, false)
+		t.Assert(v, nil)
 	})
 }
 
@@ -479,6 +512,10 @@ func TestSortedArray_Rands(t *testing.T) {
 
 		i1 = array1.Rands(4)
 		t.Assert(len(i1), 4)
+
+		array2 := garray.NewSortedArrayFrom([]interface{}{}, func1)
+		v := array2.Rands(1)
+		t.Assert(v, nil)
 	})
 }
 
@@ -498,6 +535,12 @@ func TestSortedArray_Join(t *testing.T) {
 		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorString)
 		t.Assert(array1.Join("."), `"a".0.1.\a`)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []interface{}{}
+		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorString)
+		t.Assert(array1.Join("."), "")
+	})
 }
 
 func TestSortedArray_String(t *testing.T) {
@@ -505,6 +548,9 @@ func TestSortedArray_String(t *testing.T) {
 		a1 := []interface{}{0, 1, "a", "b"}
 		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorString)
 		t.Assert(array1.String(), `[0,1,"a","b"]`)
+
+		array1 = nil
+		t.Assert(array1.String(), "")
 	})
 }
 
@@ -541,6 +587,11 @@ func TestSortedArray_Unique(t *testing.T) {
 		array1.Unique()
 		t.Assert(array1.Len(), 5)
 		t.Assert(array1, []interface{}{1, 2, 3, 4, 5})
+
+		array2 := garray.NewSortedArrayFrom([]interface{}{}, gutil.ComparatorInt)
+		array2.Unique()
+		t.Assert(array2.Len(), 0)
+		t.Assert(array2, []interface{}{})
 	})
 }
 
@@ -878,3 +929,22 @@ func TestSortedArray_Walk(t *testing.T) {
 		}), g.Slice{"key-1", "key-2"})
 	})
 }
+
+func TestSortedArray_IsEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedArrayFrom([]interface{}{}, gutil.ComparatorString)
+		t.Assert(array.IsEmpty(), true)
+	})
+}
+
+func TestSortedArray_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedArrayFrom([]interface{}{1, 2, 3, 4, 5}, gutil.ComparatorString)
+		copyArray := array.DeepCopy().(*garray.SortedArray)
+		array.Add(6)
+		copyArray.Add(7)
+		cval, _ := copyArray.Get(5)
+		val, _ := array.Get(5)
+		t.AssertNE(cval, val)
+	})
+}
diff --git a/container/garray/garray_z_unit_sorted_int_test.go b/container/garray/garray_z_unit_sorted_int_test.go
index 73a33968e..658fe4b25 100644
--- a/container/garray/garray_z_unit_sorted_int_test.go
+++ b/container/garray/garray_z_unit_sorted_int_test.go
@@ -19,6 +19,26 @@ import (
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
+func TestNewSortedIntArrayComparator(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{0, 3, 2, 1, 4, 5, 6}
+		array1 := garray.NewSortedIntArrayComparator(func(a, b int) int {
+			return a - b
+		}, true)
+		array1.Append(a1...)
+		t.Assert(array1.Len(), 7)
+		t.Assert(array1.Interfaces(), []int{0, 1, 2, 3, 4, 5, 6})
+	})
+}
+
+func TestNewSortedIntArrayRange(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array1 := garray.NewSortedIntArrayRange(1, 5, 1)
+		t.Assert(array1.Len(), 5)
+		t.Assert(array1.Interfaces(), []int{1, 2, 3, 4, 5})
+	})
+}
+
 func TestNewSortedIntArrayFrom(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []int{0, 3, 2, 1, 4, 5, 6}
@@ -37,6 +57,17 @@ func TestNewSortedIntArrayFromCopy(t *testing.T) {
 	})
 }
 
+func TestSortedIntArray_At(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{0, 3, 2, 1}
+
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		v := array1.At(1)
+
+		t.Assert(v, 1)
+	})
+}
+
 func TestSortedIntArray_SetArray(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []int{0, 1, 2, 3}
@@ -78,6 +109,10 @@ func TestSortedIntArray_Get(t *testing.T) {
 		v, ok = array1.Get(3)
 		t.Assert(v, 5)
 		t.Assert(ok, true)
+
+		v, ok = array1.Get(99)
+		t.Assert(v, 0)
+		t.Assert(ok, false)
 	})
 }
 
@@ -294,6 +329,9 @@ func TestSortedIntArray_Join(t *testing.T) {
 		a1 := []int{1, 3, 5}
 		array1 := garray.NewSortedIntArrayFrom(a1)
 		t.Assert(array1.Join("."), `1.3.5`)
+
+		array2 := garray.NewSortedIntArrayFrom([]int{})
+		t.Assert(array2.Join("."), "")
 	})
 }
 
@@ -302,6 +340,9 @@ func TestSortedIntArray_String(t *testing.T) {
 		a1 := []int{1, 3, 5}
 		array1 := garray.NewSortedIntArrayFrom(a1)
 		t.Assert(array1.String(), `[1,3,5]`)
+
+		array1 = nil
+		t.Assert(array1.String(), "")
 	})
 }
 
@@ -406,6 +447,11 @@ func TestSortedIntArray_Rand(t *testing.T) {
 		ns1, ok := array1.Rand()
 		t.AssertIN(ns1, a1)
 		t.Assert(ok, true)
+
+		array2 := garray.NewSortedIntArrayFrom([]int{})
+		ns2, ok := array2.Rand()
+		t.Assert(ns2, 0)
+		t.Assert(ok, false)
 	})
 }
 
@@ -419,6 +465,10 @@ func TestSortedIntArray_Rands(t *testing.T) {
 
 		ns2 := array1.Rands(6)
 		t.Assert(len(ns2), 6)
+
+		array2 := garray.NewSortedIntArrayFrom([]int{})
+		val := array2.Rands(1)
+		t.Assert(val, nil)
 	})
 }
 
@@ -450,6 +500,10 @@ func TestSortedIntArray_Unique(t *testing.T) {
 		array1.Unique()
 		t.Assert(array1.Len(), 5)
 		t.Assert(array1, []int{1, 2, 3, 4, 5})
+
+		array2 := garray.NewSortedIntArrayFrom([]int{})
+		array2.Unique()
+		t.Assert(array2.Len(), 0)
 	})
 }
 
@@ -731,3 +785,22 @@ func TestSortedIntArray_Walk(t *testing.T) {
 		}), g.Slice{11, 12})
 	})
 }
+
+func TestSortedIntArray_IsEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedIntArrayFrom([]int{})
+		t.Assert(array.IsEmpty(), true)
+	})
+}
+
+func TestSortedIntArray_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedIntArrayFrom([]int{1, 2, 3, 4, 5})
+		copyArray := array.DeepCopy().(*garray.SortedIntArray)
+		array.Add(6)
+		copyArray.Add(7)
+		cval, _ := copyArray.Get(5)
+		val, _ := array.Get(5)
+		t.AssertNE(cval, val)
+	})
+}
diff --git a/container/garray/garray_z_unit_sorted_str_test.go b/container/garray/garray_z_unit_sorted_str_test.go
index e93c1a59d..d64005334 100644
--- a/container/garray/garray_z_unit_sorted_str_test.go
+++ b/container/garray/garray_z_unit_sorted_str_test.go
@@ -9,6 +9,7 @@
 package garray_test
 
 import (
+	"github.com/gogf/gf/v2/text/gstr"
 	"testing"
 	"time"
 
@@ -19,6 +20,18 @@ import (
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
+func TestNewSortedStrArrayComparator(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b"}
+		s1 := garray.NewSortedStrArrayComparator(func(a, b string) int {
+			return gstr.Compare(a, b)
+		})
+		s1.Add(a1...)
+		t.Assert(s1.Len(), 4)
+		t.Assert(s1, []string{"a", "b", "c", "d"})
+	})
+}
+
 func TestNewSortedStrArrayFrom(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []string{"a", "d", "c", "b"}
@@ -58,6 +71,9 @@ func TestSortedStrArray_ContainsI(t *testing.T) {
 		t.Assert(s.Contains("A"), false)
 		t.Assert(s.Contains("a"), true)
 		t.Assert(s.ContainsI("A"), true)
+
+		s = garray.NewSortedStrArray()
+		t.Assert(s.Contains("A"), false)
 	})
 }
 
@@ -85,6 +101,10 @@ func TestSortedStrArray_Get(t *testing.T) {
 		v, ok = array1.Get(0)
 		t.Assert(v, "a")
 		t.Assert(ok, true)
+
+		v, ok = array1.Get(99)
+		t.Assert(v, "")
+		t.Assert(ok, false)
 	})
 }
 
@@ -361,6 +381,11 @@ func TestSortedStrArray_Rand(t *testing.T) {
 		v, ok := array1.Rand()
 		t.AssertIN(v, []string{"e", "a", "d"})
 		t.Assert(ok, true)
+
+		array2 := garray.NewSortedStrArrayFrom([]string{})
+		v, ok = array2.Rand()
+		t.Assert(v, "")
+		t.Assert(ok, false)
 	})
 }
 
@@ -375,6 +400,10 @@ func TestSortedStrArray_Rands(t *testing.T) {
 
 		s1 = array1.Rands(4)
 		t.Assert(len(s1), 4)
+
+		array2 := garray.NewSortedStrArrayFrom([]string{})
+		val := array2.Rands(1)
+		t.Assert(val, nil)
 	})
 }
 
@@ -391,6 +420,11 @@ func TestSortedStrArray_Join(t *testing.T) {
 		array1 := garray.NewSortedStrArrayFrom(a1)
 		t.Assert(array1.Join("."), `"b".\c.a`)
 	})
+
+	gtest.C(t, func(t *gtest.T) {
+		array1 := garray.NewSortedStrArrayFrom([]string{})
+		t.Assert(array1.Join("."), "")
+	})
 }
 
 func TestSortedStrArray_String(t *testing.T) {
@@ -398,6 +432,9 @@ func TestSortedStrArray_String(t *testing.T) {
 		a1 := []string{"e", "a", "d"}
 		array1 := garray.NewSortedStrArrayFrom(a1)
 		t.Assert(array1.String(), `["a","d","e"]`)
+
+		array1 = nil
+		t.Assert(array1.String(), "")
 	})
 }
 
@@ -469,6 +506,11 @@ func TestSortedStrArray_Unique(t *testing.T) {
 		array1.Unique()
 		t.Assert(array1.Len(), 3)
 		t.Assert(array1, []string{"1", "2", "3"})
+
+		array2 := garray.NewSortedStrArrayFrom([]string{})
+		array2.Unique()
+		t.Assert(array2.Len(), 0)
+		t.Assert(array2, []string{})
 	})
 }
 
@@ -755,3 +797,15 @@ func TestSortedStrArray_Walk(t *testing.T) {
 		}), g.Slice{"key-1", "key-2"})
 	})
 }
+
+func TestSortedStrArray_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedStrArrayFrom([]string{"a", "b", "c", "d"})
+		copyArray := array.DeepCopy().(*garray.SortedStrArray)
+		array.Add("e")
+		copyArray.Add("f")
+		cval, _ := copyArray.Get(4)
+		val, _ := array.Get(4)
+		t.AssertNE(cval, val)
+	})
+}
diff --git a/container/glist/glist_z_unit_test.go b/container/glist/glist_z_unit_test.go
index a381030fe..2a6dbc8ec 100644
--- a/container/glist/glist_z_unit_test.go
+++ b/container/glist/glist_z_unit_test.go
@@ -755,3 +755,13 @@ func TestList_UnmarshalValue(t *testing.T) {
 		t.Assert(tlist.List.FrontAll(), []interface{}{1, 2, 3})
 	})
 }
+
+func TestList_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewFrom([]interface{}{1, 2, "a", `"b"`, `\c`})
+		copyList := l.DeepCopy()
+		cl := copyList.(*List)
+		cl.PopBack()
+		t.AssertNE(l.Size(), cl.Size())
+	})
+}