add reverse feature for function Sort of normal array; fulfil unit test cases for StringArray

g/container/garray/garray_normal_int.go

@@ -98,10 +98,19 @@ func (a *IntArray) Sum() (sum int) {
 }
 
 // 将数组重新排序(从小到大).
-func (a *IntArray) Sort() *IntArray {
+func (a *IntArray) Sort(reverse...bool) *IntArray {
     a.mu.Lock()
     defer a.mu.Unlock()
-    sort.Ints(a.array)
+    if len(reverse) > 0 && reverse[0] {
+        sort.Slice(a.array, func(i, j int) bool {
+            if a.array[i] < a.array[j] {
+                return false
+            }
+            return true
+        })
+    } else {
+        sort.Ints(a.array)
+    }
     return a
 }
 

g/container/garray/garray_normal_interface.go

@@ -101,7 +101,7 @@ func (a *Array) Sum() (sum int) {
     return
 }
 
-// 将数组重新排序(从小到大).
+// 将数组重新排序.
 func (a *Array) Sort(less func(i, j int) bool) *Array {
     a.mu.Lock()
     defer a.mu.Unlock()

g/container/garray/garray_normal_string.go

@@ -98,10 +98,19 @@ func (a *StringArray) Sum() (sum int) {
 }
 
 // 将数组重新排序(从小到大).
-func (a *StringArray) Sort() *StringArray {
+func (a *StringArray) Sort(reverse...bool) *StringArray {
     a.mu.Lock()
     defer a.mu.Unlock()
-    sort.Strings(a.array)
+    if len(reverse) > 0 && reverse[0] {
+        sort.Slice(a.array, func(i, j int) bool {
+            if strings.Compare(a.array[i], a.array[j]) < 0 {
+                return false
+            }
+            return true
+        })
+    } else {
+        sort.Strings(a.array)
+    }
     return a
 }
 

g/container/garray/garray_sorted_interface.go

@@ -59,7 +59,7 @@ func (a *SortedArray) SetArray(array []interface{}) *SortedArray {
 }
 
 // 将数组重新排序(从小到大).
-func (a *SortedArray) Sort(reverse...bool) *SortedArray {
+func (a *SortedArray) Sort() *SortedArray {
     a.mu.Lock()
     defer a.mu.Unlock()
     sort.Slice(a.array, func(i, j int) bool {

g/container/garray/garray_z_unit_int_test.go

@@ -40,13 +40,16 @@ func Test_IntArray_Basic(t *testing.T) {
 
 func TestIntArray_Sort(t *testing.T) {
     gtest.Case(t, func() {
-        expect := []int{0, 1, 2, 3}
-        array  := garray.NewIntArray(0, 0)
+        expect1 := []int{0, 1, 2, 3}
+        expect2 := []int{3, 2, 1, 0}
+        array   := garray.NewIntArray(0, 0)
         for i := 3; i >= 0; i-- {
             array.Append(i)
         }
         array.Sort()
-        gtest.Assert(array.Slice(), expect)
+        gtest.Assert(array.Slice(), expect1)
+        array.Sort(true)
+        gtest.Assert(array.Slice(), expect2)
     })
 }
 

g/container/garray/garray_z_unit_string_test.go

@@ -0,0 +1,165 @@
+// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://gitee.com/johng/gf.
+
+// go test *.go
+
+package garray_test
+
+import (
+    "gitee.com/johng/gf/g/container/garray"
+    "gitee.com/johng/gf/g/test/gtest"
+    "gitee.com/johng/gf/g/util/gconv"
+    "testing"
+)
+
+func Test_StringArray_Basic(t *testing.T) {
+    gtest.Case(t, func() {
+        expect := []string{"0", "1", "2", "3"}
+        array  := garray.NewStringArrayFrom(expect)
+        gtest.Assert(array.Slice(), expect)
+        array.Set(0, "100")
+        gtest.Assert(array.Get(0),        100)
+        gtest.Assert(array.Get(1),        1)
+        gtest.Assert(array.Search("100"),   0)
+        gtest.Assert(array.Contains("100"), true)
+        gtest.Assert(array.Remove(0),     100)
+        gtest.Assert(array.Contains("100"), false)
+        array.Append("4")
+        gtest.Assert(array.Len(), 4)
+        array.InsertBefore(0, "100")
+        array.InsertAfter(0, "200")
+        gtest.Assert(array.Slice(), []string{"100", "200", "1", "2", "3", "4"})
+        array.InsertBefore(5, "300")
+        array.InsertAfter(6, "400")
+        gtest.Assert(array.Slice(), []string{"100", "200", "1", "2", "3", "300", "4", "400"})
+        gtest.Assert(array.Clear().Len(), 0)
+    })
+}
+
+func TestStringArray_Sort(t *testing.T) {
+    gtest.Case(t, func() {
+        expect1 := []string{"0", "1", "2", "3"}
+        expect2 := []string{"3", "2", "1", "0"}
+        array   := garray.NewStringArray(0, 0)
+        for i := 3; i >= 0; i-- {
+            array.Append(gconv.String(i))
+        }
+        array.Sort()
+        gtest.Assert(array.Slice(), expect1)
+        array.Sort(true)
+        gtest.Assert(array.Slice(), expect2)
+    })
+}
+
+func TestStringArray_Unique(t *testing.T) {
+    gtest.Case(t, func() {
+        expect := []string{"1", "1", "2", "3"}
+        array  := garray.NewStringArrayFrom(expect)
+        gtest.Assert(array.Unique().Slice(), []string{"1", "2", "3"})
+    })
+}
+
+func TestStringArray_PushAndPop(t *testing.T) {
+    gtest.Case(t, func() {
+        expect := []string{"0", "1", "2", "3"}
+        array  := garray.NewStringArrayFrom(expect)
+        gtest.Assert(array.Slice(),     expect)
+        gtest.Assert(array.PopLeft(),   "0")
+        gtest.Assert(array.PopRight(),  "3")
+        gtest.AssertIN(array.PopRand(), []string{"1", "2"})
+        gtest.AssertIN(array.PopRand(), []string{"1", "2"})
+        gtest.Assert(array.Len(), 0)
+        array.PushLeft("1").PushRight("2")
+        gtest.Assert(array.Slice(),    []string{"1", "2"})
+    })
+}
+
+func TestStringArray_Merge(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []string{"0", "1", "2", "3"}
+        a2 := []string{"4", "5", "6", "7"}
+        array1 := garray.NewStringArrayFrom(a1)
+        array2 := garray.NewStringArrayFrom(a2)
+        gtest.Assert(array1.Merge(array2).Slice(), []string{"0","1","2","3","4","5","6","7"})
+    })
+}
+
+func TestStringArray_Fill(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []string{"0"}
+        a2 := []string{"0"}
+        array1 := garray.NewStringArrayFrom(a1)
+        array2 := garray.NewStringArrayFrom(a2)
+        gtest.Assert(array1.Fill(1, 2, "100").Slice(), []string{"0","100","100"})
+        gtest.Assert(array2.Fill(0, 2, "100").Slice(), []string{"100","100"})
+    })
+}
+
+func TestStringArray_Chunk(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []string{"1","2","3","4","5"}
+        array1 := garray.NewStringArrayFrom(a1)
+        chunks := array1.Chunk(2)
+        gtest.Assert(len(chunks), 3)
+        gtest.Assert(chunks[0], []string{"1","2"})
+        gtest.Assert(chunks[1], []string{"3","4"})
+        gtest.Assert(chunks[2], []string{"5"})
+    })
+}
+
+func TestStringArray_Pad(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []string{"0"}
+        array1 := garray.NewStringArrayFrom(a1)
+        gtest.Assert(array1.Pad(3,  "1").Slice(), []string{"0","1","1"})
+        gtest.Assert(array1.Pad(-4, "1").Slice(), []string{"1","0","1","1"})
+        gtest.Assert(array1.Pad(3,  "1").Slice(), []string{"1","0","1","1"})
+    })
+}
+
+func TestStringArray_SubSlice(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []string{"0","1","2","3","4","5","6"}
+        array1 := garray.NewStringArrayFrom(a1)
+        gtest.Assert(array1.SubSlice(0, 2), []string{"0","1"})
+        gtest.Assert(array1.SubSlice(2, 2), []string{"2","3"})
+        gtest.Assert(array1.SubSlice(5, 8), []string{"5","6"})
+    })
+}
+
+func TestStringArray_Rand(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []string{"0","1","2","3","4","5","6"}
+        array1 := garray.NewStringArrayFrom(a1)
+        gtest.Assert(len(array1.Rand(2)),  "2")
+        gtest.Assert(len(array1.Rand(10)), "7")
+        gtest.AssertIN(array1.Rand(1)[0], a1)
+    })
+}
+
+func TestStringArray_Shuffle(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []string{"0","1","2","3","4","5","6"}
+        array1 := garray.NewStringArrayFrom(a1)
+        gtest.Assert(array1.Shuffle().Len(), 7)
+    })
+}
+
+func TestStringArray_Reverse(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []string{"0","1","2","3","4","5","6"}
+        array1 := garray.NewStringArrayFrom(a1)
+        gtest.Assert(array1.Reverse().Slice(), []string{"6","5","4","3","2","1","0"})
+    })
+}
+
+func TestStringArray_Join(t *testing.T) {
+    gtest.Case(t, func() {
+        a1 := []string{"0","1","2","3","4","5","6"}
+        array1 := garray.NewStringArrayFrom(a1)
+        gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
+    })
+}