fix issue in gqueue.Size

fix更新

DONATOR.MD

@@ -13,6 +13,7 @@
 |[zfan_codes](https://gitee.com/zfan_codes)|gitee|￥10.00
 |[arden](https://github.com/arden)|alipay|￥10.00
 |潘兄|wechat|￥100.00
+|Fly的狐狸|wechat|￥100.00
 |土豆相公|alipay|￥66.60
 |上海金保证网络科技|bank|￥2000.00
 

README.MD

@@ -11,11 +11,7 @@
 
 </div>
 
-<!--
-GoFrame is a modular, loose-coupled, production-ready and most-powerful application development framework of golang. Providing a series of core components and dozens of practical modules, such as: cache, logging, containers, timer, validator, database orm, etc. Supporting web server integrated with router, cookie, session, logger, configure, template, https, hooks, rewrites and many more features. 
--->
-
-`GF(GoFrame)` is a modular, loose-coupled, production-ready and most-powerful application development framework of golang. Providing a series of core components and dozens of practical modules, such as: memcache, configure, validator, logging, array/queue/set/map containers, timer/timing tasks, file/memory lock, object pool, database ORM, etc. Supporting web server integrated with router, cookie, session, logger, template, https, hooks, rewrites and many more features. 
+`GF(GoFrame)` is a modular, full-featured and production-ready application development framework of golang. Providing a series of core components and dozens of practical modules, such as: memcache, configure, validator, logging, array/queue/set/map containers, timer/timing tasks, file/memory lock, object pool, database ORM, etc. Supporting web server integrated with router, cookie, session, logger, template, https, hooks, rewrites and many more features. 
 
 
 # Installation

README_ZH.MD

@@ -11,7 +11,7 @@
 
 </div>
 
-`GF(Go Frame)`是一款模块化、松耦合、生产级Go应用开发框架。提供了常用的核心开发组件，如：缓存、日志、文件、时间、队列、数组、集合、字符串、定时器、命令行、文件锁、内存锁、对象池、连接池、数据校验、数据编码、文件监控、定时任务、数据库ORM、TCP/UDP组件、进程管理/通信、
+`GF(Go Frame)`是一款模块化、高性能、生产级Go应用开发框架。提供了常用的核心开发组件，如：缓存、日志、文件、时间、队列、数组、集合、字符串、定时器、命令行、文件锁、内存锁、对象池、连接池、数据校验、数据编码、文件监控、定时任务、数据库ORM、TCP/UDP组件、进程管理/通信、
 并发安全容器等等。并提供了Web服务开发的系列核心组件，如：Router、Cookie、Session、服务注册、配置管理、模板引擎等等，支持热重启、热更新、多域名、多端口、多服务、HTTPS、Rewrite等特性。
 
 

g/container/garray/garray_normal_int.go

@@ -22,14 +22,14 @@ type IntArray struct {
 }
 
 // NewIntArray creates and returns an empty array.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewIntArray(unsafe...bool) *IntArray {
 	return NewIntArraySize(0, 0, unsafe...)
 }
 
 // NewIntArraySize create and returns an array with given size and cap.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewIntArraySize(size int, cap int, unsafe...bool) *IntArray {
     return &IntArray{
@@ -39,7 +39,7 @@ func NewIntArraySize(size int, cap int, unsafe...bool) *IntArray {
 }
 
 // NewIntArrayFrom creates and returns an array with given slice <array>.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewIntArrayFrom(array []int, unsafe...bool) *IntArray {
 	return &IntArray{
@@ -49,7 +49,7 @@ func NewIntArrayFrom(array []int, unsafe...bool) *IntArray {
 }
 
 // NewIntArrayFromCopy creates and returns an array from a copy of given slice <array>.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewIntArrayFromCopy(array []int, unsafe...bool) *IntArray {
     newArray := make([]int, len(array))
@@ -110,7 +110,7 @@ func (a *IntArray) Sum() (sum int) {
 }
 
 // Sort sorts the array in increasing order.
-// The param <reverse> controls whether sort
+// The parameter <reverse> controls whether sort
 // in increasing order(default) or decreasing order
 func (a *IntArray) Sort(reverse...bool) *IntArray {
     a.mu.Lock()

g/container/garray/garray_normal_interface.go

@@ -22,7 +22,7 @@ type Array struct {
 }
 
 // New creates and returns an empty array.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func New(unsafe...bool) *Array {
     return NewArraySize(0, 0, unsafe...)
@@ -34,7 +34,7 @@ func NewArray(unsafe...bool) *Array {
 }
 
 // NewArraySize create and returns an array with given size and cap.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewArraySize(size int, cap int, unsafe...bool) *Array {
     return &Array{
@@ -54,7 +54,7 @@ func NewFromCopy(array []interface{}, unsafe...bool) *Array {
 }
 
 // NewArrayFrom creates and returns an array with given slice <array>.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewArrayFrom(array []interface{}, unsafe...bool) *Array {
     return &Array{
@@ -64,7 +64,7 @@ func NewArrayFrom(array []interface{}, unsafe...bool) *Array {
 }
 
 // NewArrayFromCopy creates and returns an array from a copy of given slice <array>.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewArrayFromCopy(array []interface{}, unsafe...bool) *Array {
     newArray := make([]interface{}, len(array))

g/container/garray/garray_normal_string.go

@@ -23,14 +23,14 @@ type StringArray struct {
 }
 
 // NewStringArray creates and returns an empty array.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewStringArray(unsafe...bool) *StringArray {
     return NewStringArraySize(0, 0, unsafe...)
 }
 
 // NewStringArraySize create and returns an array with given size and cap.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewStringArraySize(size int, cap int, unsafe...bool) *StringArray {
     return &StringArray{
@@ -40,7 +40,7 @@ func NewStringArraySize(size int, cap int, unsafe...bool) *StringArray {
 }
 
 // NewStringArrayFrom creates and returns an array with given slice <array>.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewStringArrayFrom(array []string, unsafe...bool) *StringArray {
 	return &StringArray {
@@ -50,7 +50,7 @@ func NewStringArrayFrom(array []string, unsafe...bool) *StringArray {
 }
 
 // NewStringArrayFromCopy creates and returns an array from a copy of given slice <array>.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewStringArrayFromCopy(array []string, unsafe...bool) *StringArray {
     newArray := make([]string, len(array))
@@ -111,7 +111,7 @@ func (a *StringArray) Sum() (sum int) {
 }
 
 // Sort sorts the array in increasing order.
-// The param <reverse> controls whether sort
+// The parameter <reverse> controls whether sort
 // in increasing order(default) or decreasing order
 func (a *StringArray) Sort(reverse...bool) *StringArray {
     a.mu.Lock()

g/container/garray/garray_sorted_int.go

@@ -26,14 +26,14 @@ type SortedIntArray struct {
 }
 
 // NewSortedIntArray creates and returns an empty sorted array.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewSortedIntArray(unsafe...bool) *SortedIntArray {
     return NewSortedIntArraySize(0, unsafe...)
 }
 
 // NewSortedIntArraySize create and returns an sorted array with given size and cap.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewSortedIntArraySize(cap int, unsafe...bool) *SortedIntArray {
     return &SortedIntArray {
@@ -53,7 +53,7 @@ func NewSortedIntArraySize(cap int, unsafe...bool) *SortedIntArray {
 }
 
 // NewIntArrayFrom creates and returns an sorted array with given slice <array>.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewSortedIntArrayFrom(array []int, unsafe...bool) *SortedIntArray {
     a := NewSortedIntArraySize(0, unsafe...)
@@ -63,15 +63,12 @@ func NewSortedIntArrayFrom(array []int, unsafe...bool) *SortedIntArray {
 }
 
 // NewSortedIntArrayFromCopy creates and returns an sorted array from a copy of given slice <array>.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewSortedIntArrayFromCopy(array []int, unsafe...bool) *SortedIntArray {
     newArray := make([]int, len(array))
     copy(newArray, array)
-    return &SortedIntArray{
-        mu    : rwmutex.New(unsafe...),
-        array : newArray,
-    }
+    return NewSortedIntArrayFrom(newArray, unsafe...)
 }
 
 // SetArray sets the underlying slice array with the given <array>.
@@ -84,7 +81,7 @@ func (a *SortedIntArray) SetArray(array []int) *SortedIntArray {
 }
 
 // Sort sorts the array in increasing order.
-// The param <reverse> controls whether sort
+// The parameter <reverse> controls whether sort
 // in increasing order(default) or decreasing order.
 func (a *SortedIntArray) Sort() *SortedIntArray {
     a.mu.Lock()
@@ -280,17 +277,23 @@ func (a *SortedIntArray) Slice() []int {
 
 // Contains checks whether a value exists in the array.
 func (a *SortedIntArray) Contains(value int) bool {
-    return a.Search(value) == 0
+    return a.Search(value) != -1
 }
 
 // Search searches array by <value>, returns the index of <value>,
 // or returns -1 if not exists.
 func (a *SortedIntArray) Search(value int) (index int) {
-    index, _ = a.binSearch(value, true)
-    return
+    if i, r := a.binSearch(value, true); r == 0 {
+    	return i
+    }
+    return -1
 }
 
 // Binary search.
+// It returns the last compared index and the result.
+// If <result> equals to 0, it means the value at <index> is equals to <value>.
+// If <result> lesser than 0, it means the value at <index> is lesser than <value>.
+// If <result> greater than 0, it means the value at <index> is greater than <value>.
 func (a *SortedIntArray) binSearch(value int, lock bool) (index int, result int) {
     if len(a.array) == 0 {
         return -1, -2

g/container/garray/garray_sorted_interface.go

@@ -26,8 +26,8 @@ type SortedArray struct {
 }
 
 // NewSortedArray creates and returns an empty sorted array.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety, which is false in default.
-// The param <comparator> used to compare values to sort in array,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety, which is false in default.
+// The parameter <comparator> used to compare values to sort in array,
 // if it returns value < 0, means v1 < v2;
 // if it returns value = 0, means v1 = v2;
 // if it returns value > 0, means v1 > v2;
@@ -36,19 +36,19 @@ func NewSortedArray(comparator func(v1, v2 interface{}) int, unsafe...bool) *Sor
 }
 
 // NewSortedArraySize create and returns an sorted array with given size and cap.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewSortedArraySize(cap int, comparator func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
     return &SortedArray{
-        mu          : rwmutex.New(unsafe...),
-        unique      : gtype.NewBool(),
-        array       : make([]interface{}, 0, cap),
+        mu         : rwmutex.New(unsafe...),
+        unique     : gtype.NewBool(),
+        array      : make([]interface{}, 0, cap),
         comparator : comparator,
     }
 }
 
 // NewSortedArrayFrom creates and returns an sorted array with given slice <array>.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewSortedArrayFrom(array []interface{}, comparator func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
     a := NewSortedArraySize(0, comparator, unsafe...)
@@ -60,15 +60,12 @@ func NewSortedArrayFrom(array []interface{}, comparator func(v1, v2 interface{})
 }
 
 // NewSortedArrayFromCopy creates and returns an sorted array from a copy of given slice <array>.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedArrayFromCopy(array []interface{}, unsafe...bool) *SortedArray {
+func NewSortedArrayFromCopy(array []interface{}, comparator func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
     newArray := make([]interface{}, len(array))
     copy(newArray, array)
-    return &SortedArray{
-        mu    : rwmutex.New(unsafe...),
-        array : newArray,
-    }
+    return NewSortedArrayFrom(newArray, comparator, unsafe...)
 }
 
 // SetArray sets the underlying slice array with the given <array>.
@@ -83,7 +80,7 @@ func (a *SortedArray) SetArray(array []interface{}) *SortedArray {
 }
 
 // Sort sorts the array in increasing order.
-// The param <reverse> controls whether sort
+// The parameter <reverse> controls whether sort
 // in increasing order(default) or decreasing order
 func (a *SortedArray) Sort() *SortedArray {
     a.mu.Lock()
@@ -281,17 +278,23 @@ func (a *SortedArray) Slice() []interface{} {
 
 // Contains checks whether a value exists in the array.
 func (a *SortedArray) Contains(value interface{}) bool {
-    return a.Search(value) == 0
+    return a.Search(value) != -1
 }
 
 // Search searches array by <value>, returns the index of <value>,
 // or returns -1 if not exists.
 func (a *SortedArray) Search(value interface{}) (index int) {
-    index, _ = a.binSearch(value, true)
-    return
+	if i, r := a.binSearch(value, true); r == 0 {
+		return i
+	}
+	return -1
 }
 
 // Binary search.
+// It returns the last compared index and the result.
+// If <result> equals to 0, it means the value at <index> is equals to <value>.
+// If <result> lesser than 0, it means the value at <index> is lesser than <value>.
+// If <result> greater than 0, it means the value at <index> is greater than <value>.
 func (a *SortedArray) binSearch(value interface{}, lock bool)(index int, result int) {
     if len(a.array) == 0 {
         return -1, -2

g/container/garray/garray_sorted_string.go

@@ -27,14 +27,14 @@ type SortedStringArray struct {
 }
 
 // NewSortedStringArray creates and returns an empty sorted array.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewSortedStringArray(unsafe...bool) *SortedStringArray {
     return NewSortedStringArraySize(0, unsafe...)
 }
 
 // NewSortedStringArraySize create and returns an sorted array with given size and cap.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewSortedStringArraySize(cap int, unsafe...bool) *SortedStringArray {
     return &SortedStringArray {
@@ -48,7 +48,7 @@ func NewSortedStringArraySize(cap int, unsafe...bool) *SortedStringArray {
 }
 
 // NewSortedStringArrayFrom creates and returns an sorted array with given slice <array>.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewSortedStringArrayFrom(array []string, unsafe...bool) *SortedStringArray {
     a := NewSortedStringArraySize(0, unsafe...)
@@ -58,15 +58,12 @@ func NewSortedStringArrayFrom(array []string, unsafe...bool) *SortedStringArray
 }
 
 // NewSortedStringArrayFromCopy creates and returns an sorted array from a copy of given slice <array>.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
 func NewSortedStringArrayFromCopy(array []string, unsafe...bool) *SortedStringArray {
     newArray := make([]string, len(array))
     copy(newArray, array)
-    return &SortedStringArray{
-        mu    : rwmutex.New(unsafe...),
-        array : newArray,
-    }
+    return NewSortedStringArrayFrom(newArray, unsafe...)
 }
 
 // SetArray sets the underlying slice array with the given <array>.
@@ -79,7 +76,7 @@ func (a *SortedStringArray) SetArray(array []string) *SortedStringArray {
 }
 
 // Sort sorts the array in increasing order.
-// The param <reverse> controls whether sort
+// The parameter <reverse> controls whether sort
 // in increasing order(default) or decreasing order.
 func (a *SortedStringArray) Sort() *SortedStringArray {
     a.mu.Lock()
@@ -275,17 +272,23 @@ func (a *SortedStringArray) Slice() []string {
 
 // Contains checks whether a value exists in the array.
 func (a *SortedStringArray) Contains(value string) bool {
-    return a.Search(value) == 0
+    return a.Search(value) != -1
 }
 
 // Search searches array by <value>, returns the index of <value>,
 // or returns -1 if not exists.
 func (a *SortedStringArray) Search(value string) (index int) {
-    index, _ = a.binSearch(value, true)
-    return
+	if i, r := a.binSearch(value, true); r == 0 {
+		return i
+	}
+	return -1
 }
 
 // Binary search.
+// It returns the last compared index and the result.
+// If <result> equals to 0, it means the value at <index> is equals to <value>.
+// If <result> lesser than 0, it means the value at <index> is lesser than <value>.
+// If <result> greater than 0, it means the value at <index> is greater than <value>.
 func (a *SortedStringArray) binSearch(value string, lock bool) (index int, result int) {
     if len(a.array) == 0 {
         return -1, -2

g/container/garray/garray_z_bench_test.go

@@ -9,35 +9,35 @@
 package garray_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"testing"
 )
 
 var (
-    sortedIntArray = garray.NewSortedIntArray()
+	sortedIntArray = garray.NewSortedIntArray()
 )
 
 func BenchmarkSortedIntArray_Add(b *testing.B) {
-    b.N = 1000
-    for i := 0; i < b.N; i++ {
-        sortedIntArray.Add(i)
-    }
+	b.N = 1000
+	for i := 0; i < b.N; i++ {
+		sortedIntArray.Add(i)
+	}
 }
 
 func BenchmarkSortedIntArray_Search(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sortedIntArray.Search(i)
-    }
+	for i := 0; i < b.N; i++ {
+		sortedIntArray.Search(i)
+	}
 }
 
 func BenchmarkSortedIntArray_PopLeft(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sortedIntArray.PopLeft()
-    }
+	for i := 0; i < b.N; i++ {
+		sortedIntArray.PopLeft()
+	}
 }
 
 func BenchmarkSortedIntArray_PopRight(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sortedIntArray.PopLeft()
-    }
+	for i := 0; i < b.N; i++ {
+		sortedIntArray.PopLeft()
+	}
 }

g/container/garray/garray_z_unit_basic_test.go

@@ -9,75 +9,86 @@
 package garray_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/test/gtest"
-    "github.com/gogf/gf/g/util/gconv"
-    "strings"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/util/gconv"
+	"strings"
+	"testing"
 )
 
 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)
+	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)
+	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)
 }
 
 func Test_SortedIntArray2(t *testing.T) {
-    expect := []int{0,1,2,3,4,5,6,7,8,9,10}
-    array  := garray.NewSortedIntArray()
-    for i := 0; i <= 10; i++ {
-        array.Add(i)
-    }
-    gtest.Assert(array.Slice(), expect)
+	expect := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	array := garray.NewSortedIntArray()
+	for i := 0; i <= 10; i++ {
+		array.Add(i)
+	}
+	gtest.Assert(array.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)
+	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)
 }
 
 func Test_SortedStringArray2(t *testing.T) {
-    expect := []string{"0","1","10","2","3","4","5","6","7","8","9"}
-    array  := garray.NewSortedStringArray()
-    for i := 0; i <= 10; i++ {
-        array.Add(gconv.String(i))
-    }
-    gtest.Assert(array.Slice(), expect)
+	expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
+	array := garray.NewSortedStringArray()
+	for i := 0; i <= 10; i++ {
+		array.Add(gconv.String(i))
+	}
+	gtest.Assert(array.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))
-    })
-    for i := 10; i > -1; i-- {
-        array.Add(gconv.String(i))
-    }
-    gtest.Assert(array.Slice(), expect)
+	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)
 }
 
 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))
-    })
-    for i := 0; i <= 10; i++ {
-        array.Add(gconv.String(i))
-    }
-    gtest.Assert(array.Slice(), expect)
-}
+	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 := 0; i <= 10; i++ {
+		array.Add(gconv.String(i))
+	}
+	gtest.Assert(array.Slice(), expect)
+}
+
+func TestNewFromCopy(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"100", "200", "300", "400", "500", "600"}
+		array1 := garray.NewFromCopy(a1)
+		gtest.AssertIN(array1.PopRands(2), a1)
+		gtest.Assert(len(array1.PopRands(1)), 1)
+		gtest.Assert(len(array1.PopRands(9)), 3)
+
+	})
+}

g/container/garray/garray_z_unit_int_test.go

@@ -9,193 +9,602 @@
 package garray_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
 )
 
 func Test_IntArray_Basic(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []int{0, 1, 2, 3}
-        array  := garray.NewIntArrayFrom(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(), []int{100, 200, 1, 2, 3, 4})
-        array.InsertBefore(5, 300)
-        array.InsertAfter(6, 400)
-        gtest.Assert(array.Slice(), []int{100, 200, 1, 2, 3, 300, 4, 400})
-        gtest.Assert(array.Clear().Len(), 0)
-    })
+	gtest.Case(t, func() {
+		expect := []int{0, 1, 2, 3}
+		array := garray.NewIntArrayFrom(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(), []int{100, 200, 1, 2, 3, 4})
+		array.InsertBefore(5, 300)
+		array.InsertAfter(6, 400)
+		gtest.Assert(array.Slice(), []int{100, 200, 1, 2, 3, 300, 4, 400})
+		gtest.Assert(array.Clear().Len(), 0)
+	})
 }
 
 func TestIntArray_Sort(t *testing.T) {
-    gtest.Case(t, func() {
-        expect1 := []int{0, 1, 2, 3}
-        expect2 := []int{3, 2, 1, 0}
-        array   := garray.NewIntArray()
-        for i := 3; i >= 0; i-- {
-            array.Append(i)
-        }
-        array.Sort()
-        gtest.Assert(array.Slice(), expect1)
-        array.Sort(true)
-        gtest.Assert(array.Slice(), expect2)
-    })
+	gtest.Case(t, func() {
+		expect1 := []int{0, 1, 2, 3}
+		expect2 := []int{3, 2, 1, 0}
+		array := garray.NewIntArray()
+		for i := 3; i >= 0; i-- {
+			array.Append(i)
+		}
+		array.Sort()
+		gtest.Assert(array.Slice(), expect1)
+		array.Sort(true)
+		gtest.Assert(array.Slice(), expect2)
+	})
 }
 
 func TestIntArray_Unique(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []int{1, 1, 2, 3}
-        array  := garray.NewIntArrayFrom(expect)
-        gtest.Assert(array.Unique().Slice(), []int{1, 2, 3})
-    })
+	gtest.Case(t, func() {
+		expect := []int{1, 1, 2, 3}
+		array := garray.NewIntArrayFrom(expect)
+		gtest.Assert(array.Unique().Slice(), []int{1, 2, 3})
+	})
 }
 
 func TestIntArray_PushAndPop(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []int{0, 1, 2, 3}
-        array  := garray.NewIntArrayFrom(expect)
-        gtest.Assert(array.Slice(),     expect)
-        gtest.Assert(array.PopLeft(),   0)
-        gtest.Assert(array.PopRight(),  3)
-        gtest.AssertIN(array.PopRand(), []int{1, 2})
-        gtest.AssertIN(array.PopRand(), []int{1, 2})
-        gtest.Assert(array.Len(), 0)
-        array.PushLeft(1).PushRight(2)
-        gtest.Assert(array.Slice(),    []int{1, 2})
-    })
+	gtest.Case(t, func() {
+		expect := []int{0, 1, 2, 3}
+		array := garray.NewIntArrayFrom(expect)
+		gtest.Assert(array.Slice(), expect)
+		gtest.Assert(array.PopLeft(), 0)
+		gtest.Assert(array.PopRight(), 3)
+		gtest.AssertIN(array.PopRand(), []int{1, 2})
+		gtest.AssertIN(array.PopRand(), []int{1, 2})
+		gtest.Assert(array.Len(), 0)
+		array.PushLeft(1).PushRight(2)
+		gtest.Assert(array.Slice(), []int{1, 2})
+	})
 }
 
 func TestIntArray_PopLeftsAndPopRights(t *testing.T) {
-    gtest.Case(t, func() {
-        value1 := []int{0,1,2,3,4,5,6}
-        value2 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(value1)
-        array2 := garray.NewIntArrayFrom(value2)
-        gtest.Assert(array1.PopLefts(2), []int{0,1})
-        gtest.Assert(array1.Slice(), []int{2,3,4,5,6})
-        gtest.Assert(array1.PopRights(2), []int{5,6})
-        gtest.Assert(array1.Slice(), []int{2,3,4})
-        gtest.Assert(array1.PopRights(20), []int{2,3,4})
-        gtest.Assert(array1.Slice(), []int{})
-        gtest.Assert(array2.PopLefts(20), []int{0,1,2,3,4,5,6})
-        gtest.Assert(array2.Slice(), []int{})
-    })
+	gtest.Case(t, func() {
+		value1 := []int{0, 1, 2, 3, 4, 5, 6}
+		value2 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(value1)
+		array2 := garray.NewIntArrayFrom(value2)
+		gtest.Assert(array1.PopLefts(2), []int{0, 1})
+		gtest.Assert(array1.Slice(), []int{2, 3, 4, 5, 6})
+		gtest.Assert(array1.PopRights(2), []int{5, 6})
+		gtest.Assert(array1.Slice(), []int{2, 3, 4})
+		gtest.Assert(array1.PopRights(20), []int{2, 3, 4})
+		gtest.Assert(array1.Slice(), []int{})
+		gtest.Assert(array2.PopLefts(20), []int{0, 1, 2, 3, 4, 5, 6})
+		gtest.Assert(array2.Slice(), []int{})
+	})
 }
 
 func TestIntArray_Range(t *testing.T) {
-    gtest.Case(t, func() {
-        value1 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(value1)
-        gtest.Assert(array1.Range(0, 1), []int{0})
-        gtest.Assert(array1.Range(1, 2), []int{1})
-        gtest.Assert(array1.Range(0, 2), []int{0, 1})
-        gtest.Assert(array1.Range(-1, 10), value1)
-    })
+	gtest.Case(t, func() {
+		value1 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(value1)
+		gtest.Assert(array1.Range(0, 1), []int{0})
+		gtest.Assert(array1.Range(1, 2), []int{1})
+		gtest.Assert(array1.Range(0, 2), []int{0, 1})
+		gtest.Assert(array1.Range(-1, 10), value1)
+	})
 }
 
 func TestIntArray_Merge(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0, 1, 2, 3}
-        a2 := []int{4, 5, 6, 7}
-        array1 := garray.NewIntArrayFrom(a1)
-        array2 := garray.NewIntArrayFrom(a2)
-        gtest.Assert(array1.Merge(array2).Slice(), []int{0,1,2,3,4,5,6,7})
-    })
+	gtest.Case(t, func() {
+		a1 := []int{0, 1, 2, 3}
+		a2 := []int{4, 5, 6, 7}
+		array1 := garray.NewIntArrayFrom(a1)
+		array2 := garray.NewIntArrayFrom(a2)
+		gtest.Assert(array1.Merge(array2).Slice(), []int{0, 1, 2, 3, 4, 5, 6, 7})
+	})
 }
 
 func TestIntArray_Fill(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0}
-        a2 := []int{0}
-        array1 := garray.NewIntArrayFrom(a1)
-        array2 := garray.NewIntArrayFrom(a2)
-        gtest.Assert(array1.Fill(1, 2, 100).Slice(), []int{0,100,100})
-        gtest.Assert(array2.Fill(0, 2, 100).Slice(), []int{100,100})
-    })
+	gtest.Case(t, func() {
+		a1 := []int{0}
+		a2 := []int{0}
+		array1 := garray.NewIntArrayFrom(a1)
+		array2 := garray.NewIntArrayFrom(a2)
+		gtest.Assert(array1.Fill(1, 2, 100).Slice(), []int{0, 100, 100})
+		gtest.Assert(array2.Fill(0, 2, 100).Slice(), []int{100, 100})
+	})
 }
 
 func TestIntArray_Chunk(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{1,2,3,4,5}
-        array1 := garray.NewIntArrayFrom(a1)
-        chunks := array1.Chunk(2)
-        gtest.Assert(len(chunks), 3)
-        gtest.Assert(chunks[0], []int{1,2})
-        gtest.Assert(chunks[1], []int{3,4})
-        gtest.Assert(chunks[2], []int{5})
-    })
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5}
+		array1 := garray.NewIntArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		gtest.Assert(len(chunks), 3)
+		gtest.Assert(chunks[0], []int{1, 2})
+		gtest.Assert(chunks[1], []int{3, 4})
+		gtest.Assert(chunks[2], []int{5})
+	})
 }
 
 func TestIntArray_Pad(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0}
-        array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(array1.Pad(3,  1).Slice(), []int{0,1,1})
-        gtest.Assert(array1.Pad(-4, 1).Slice(), []int{1,0,1,1})
-        gtest.Assert(array1.Pad(3,  1).Slice(), []int{1,0,1,1})
-    })
+	gtest.Case(t, func() {
+		a1 := []int{0}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.Pad(3, 1).Slice(), []int{0, 1, 1})
+		gtest.Assert(array1.Pad(-4, 1).Slice(), []int{1, 0, 1, 1})
+		gtest.Assert(array1.Pad(3, 1).Slice(), []int{1, 0, 1, 1})
+	})
 }
 
 func TestIntArray_SubSlice(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(array1.SubSlice(0, 2), []int{0,1})
-        gtest.Assert(array1.SubSlice(2, 2), []int{2,3})
-        gtest.Assert(array1.SubSlice(5, 8), []int{5,6})
-    })
+	gtest.Case(t, func() {
+		a1 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.SubSlice(0, 2), []int{0, 1})
+		gtest.Assert(array1.SubSlice(2, 2), []int{2, 3})
+		gtest.Assert(array1.SubSlice(5, 8), []int{5, 6})
+	})
 }
 
 func TestIntArray_Rand(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(len(array1.Rands(2)),  2)
-        gtest.Assert(len(array1.Rands(10)), 7)
-        gtest.AssertIN(array1.Rands(1)[0], a1)
-        gtest.AssertIN(array1.Rand(), a1)
-    })
+	gtest.Case(t, func() {
+		a1 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(len(array1.Rands(2)), 2)
+		gtest.Assert(len(array1.Rands(10)), 7)
+		gtest.AssertIN(array1.Rands(1)[0], a1)
+		gtest.AssertIN(array1.Rand(), a1)
+	})
 }
 
 func TestIntArray_PopRands(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{100, 200, 300, 400, 500, 600}
-        array := garray.NewFromCopy(a1)
-        gtest.AssertIN(array.PopRands(2), a1)
-    })
+	gtest.Case(t, func() {
+		a1 := []int{100, 200, 300, 400, 500, 600}
+		array := garray.NewIntArrayFrom(a1)
+		ns1 := array.PopRands(2)
+		gtest.AssertIN(ns1, []int{100, 200, 300, 400, 500, 600})
+		gtest.AssertIN(len(ns1), 2)
+
+		ns2 := array.PopRands(7)
+		gtest.AssertIN(len(ns2), 6)
+		gtest.AssertIN(ns2, []int{100, 200, 300, 400, 500, 600})
+
+	})
 }
 
 func TestIntArray_Shuffle(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(array1.Shuffle().Len(), 7)
-    })
+	gtest.Case(t, func() {
+		a1 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.Shuffle().Len(), 7)
+	})
 }
 
 func TestIntArray_Reverse(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(array1.Reverse().Slice(), []int{6,5,4,3,2,1,0})
-    })
+	gtest.Case(t, func() {
+		a1 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.Reverse().Slice(), []int{6, 5, 4, 3, 2, 1, 0})
+	})
 }
 
 func TestIntArray_Join(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
-    })
-}
+	gtest.Case(t, func() {
+		a1 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
+	})
+}
+
+func TestNewSortedIntArrayFrom(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{0, 3, 2, 1, 4, 5, 6}
+		array1 := garray.NewSortedIntArrayFrom(a1, true)
+		gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
+	})
+}
+
+func TestNewSortedIntArrayFromCopy(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{0, 5, 2, 1, 4, 3, 6}
+		array1 := garray.NewSortedIntArrayFromCopy(a1, false)
+		gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
+	})
+}
+
+func TestSortedIntArray_SetArray(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{0, 1, 2, 3}
+		a2 := []int{4, 5, 6}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		array2 := array1.SetArray(a2)
+
+		gtest.Assert(array2.Len(), 3)
+		gtest.Assert(array2.Search(3), -1)
+		gtest.Assert(array2.Search(5), 1)
+		gtest.Assert(array2.Search(6), 2)
+	})
+}
+
+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})
+
+	})
+}
+
+func TestSortedIntArray_Get(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 0}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		gtest.Assert(array1.Get(0), 0)
+		gtest.Assert(array1.Get(1), 1)
+		gtest.Assert(array1.Get(3), 5)
+
+	})
+}
+
+func TestSortedIntArray_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 0}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		i1 := array1.Remove(2)
+		gtest.Assert(i1, 3)
+		gtest.Assert(array1.Search(5), 2)
+
+		// 再次删除剩下的数组中的第一个
+		i2 := array1.Remove(0)
+		gtest.Assert(i2, 0)
+		gtest.Assert(array1.Search(5), 1)
+
+		a2 := []int{1, 3, 4}
+		array2 := garray.NewSortedIntArrayFrom(a2)
+		i3 := array2.Remove(1)
+		gtest.Assert(array2.Search(1), 0)
+		gtest.Assert(i3, 3)
+		i3 = array2.Remove(1)
+		gtest.Assert(array2.Search(4), -1)
+		gtest.Assert(i3, 4)
+
+	})
+}
+
+func TestSortedIntArray_PopLeft(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		i1 := array1.PopLeft()
+		gtest.Assert(i1, 1)
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Search(1), -1)
+
+	})
+}
+
+func TestSortedIntArray_PopRight(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		i1 := array1.PopRight()
+		gtest.Assert(i1, 5)
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Search(5), -1)
+	})
+}
+
+func TestSortedIntArray_PopRand(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		i1 := array1.PopRand()
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Search(i1), -1)
+		gtest.AssertIN(i1, []int{1, 3, 5, 2})
+	})
+}
+
+func TestSortedIntArray_PopRands(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.PopRands(2)
+		gtest.Assert(array1.Len(), 2)
+		gtest.AssertIN(ns1, []int{1, 3, 5, 2})
+
+		a2 := []int{1, 3, 5, 2}
+		array2 := garray.NewSortedIntArrayFrom(a2)
+		ns2 := array2.PopRands(5)
+		gtest.Assert(array2.Len(), 0)
+		gtest.Assert(len(ns2), 4)
+		gtest.AssertIN(ns2, []int{1, 3, 5, 2})
+
+	})
+}
+
+func TestSortedIntArray_PopLefts(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.PopLefts(2)
+		gtest.Assert(array1.Len(), 2)
+		gtest.Assert(ns1, []int{1, 2})
+
+		a2 := []int{1, 3, 5, 2}
+		array2 := garray.NewSortedIntArrayFrom(a2)
+		ns2 := array2.PopLefts(5)
+		gtest.Assert(array2.Len(), 0)
+		gtest.AssertIN(ns2, []int{1, 3, 5, 2})
+
+	})
+}
+
+func TestSortedIntArray_PopRights(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.PopRights(2)
+		gtest.Assert(array1.Len(), 2)
+		gtest.Assert(ns1, []int{3, 5})
+
+		a2 := []int{1, 3, 5, 2}
+		array2 := garray.NewSortedIntArrayFrom(a2)
+		ns2 := array2.PopRights(5)
+		gtest.Assert(array2.Len(), 0)
+		gtest.AssertIN(ns2, []int{1, 3, 5, 2})
+	})
+}
+
+func TestSortedIntArray_Range(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2, 6, 7}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.Range(1, 4)
+		gtest.Assert(len(ns1), 3)
+		gtest.Assert(ns1, []int{2, 3, 5})
+
+		ns2 := array1.Range(5, 4)
+		gtest.Assert(len(ns2), 0)
+
+		ns3 := array1.Range(-1, 4)
+		gtest.Assert(len(ns3), 4)
+
+		nsl := array1.Range(5, 8)
+		gtest.Assert(len(nsl), 1)
+
+	})
+}
+
+func TestSortedIntArray_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		n1 := array1.Sum()
+		gtest.Assert(n1, 9)
+	})
+}
+
+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)
+	})
+}
+
+func TestSortedIntArray_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		array2 := array1.Clone()
+		gtest.Assert(array2.Len(), 3)
+		gtest.Assert(array2, array1)
+	})
+}
+
+func TestSortedIntArray_Clear(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		array1.Clear()
+		gtest.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedIntArray_Chunk(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.Chunk(2) //按每几个元素切成一个数组
+		ns2 := array1.Chunk(-1)
+		t.Log(ns1)
+		gtest.Assert(len(ns1), 3)
+		gtest.Assert(ns1[0], []int{1, 2})
+		gtest.Assert(ns1[2], []int{5})
+		gtest.Assert(len(ns2), 0)
+
+	})
+}
+
+func TestSortedIntArray_SubSlice(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.SubSlice(1, 2)
+		gtest.Assert(len(ns1), 2)
+		gtest.Assert(ns1, []int{2, 3})
+
+		ns2 := array1.SubSlice(7, 2)
+		gtest.Assert(len(ns2), 0)
+
+		ns3 := array1.SubSlice(3, 5)
+		gtest.Assert(len(ns3), 2)
+		gtest.Assert(ns3, []int{4, 5})
+
+		ns4 := array1.SubSlice(3, 1)
+		gtest.Assert(len(ns4), 1)
+		gtest.Assert(ns4, []int{4})
+	})
+}
+
+func TestSortedIntArray_Rand(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.Rand() //按每几个元素切成一个数组
+		gtest.AssertIN(ns1, a1)
+	})
+}
+
+func TestSortedIntArray_Rands(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		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)
+	})
+}
+
+func TestSortedIntArray_CountValues(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5, 3}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.CountValues() //按每几个元素切成一个数组
+		gtest.Assert(len(ns1), 5)
+		gtest.Assert(ns1[2], 1)
+		gtest.Assert(ns1[3], 2)
+	})
+}
+
+func TestSortedIntArray_SetUnique(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5, 3}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		array1.SetUnique(true)
+		gtest.Assert(array1.Len(), 5)
+		gtest.Assert(array1, []int{1, 2, 3, 4, 5})
+
+	})
+}
+
+func TestIntArray_SetArray(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5}
+		a2 := []int{6, 7}
+		array1 := garray.NewIntArrayFrom(a1)
+		array1.SetArray(a2)
+		gtest.Assert(array1.Len(), 2)
+		gtest.Assert(array1, []int{6, 7})
+
+	})
+}
+
+func TestIntArray_Replace(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5}
+		a2 := []int{6, 7}
+		a3 := []int{9, 10, 11, 12, 13}
+		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})
+	})
+}
+
+func TestIntArray_Clear(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5}
+		array1 := garray.NewIntArrayFrom(a1)
+		array1.Clear()
+		gtest.Assert(array1.Len(), 0)
+	})
+}
+
+func TestIntArray_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5}
+		array1 := garray.NewIntArrayFrom(a1)
+		array2 := array1.Clone()
+		gtest.Assert(array1, array2)
+	})
+}
+
+func TestArray_Get(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.Get(2), 3)
+		gtest.Assert(array1.Len(), 4)
+	})
+}
+
+func TestIntArray_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.Sum(), 11)
+	})
+}
+
+func TestIntArray_CountValues(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5, 3}
+		array1 := garray.NewIntArrayFrom(a1)
+		m1 := array1.CountValues()
+		gtest.Assert(len(m1), 4)
+		gtest.Assert(m1[1], 1)
+		gtest.Assert(m1[3], 2)
+	})
+}
+
+func TestNewIntArrayFromCopy(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5, 3}
+		array1 := garray.NewIntArrayFromCopy(a1)
+		gtest.Assert(array1.Len(), 5)
+		gtest.Assert(array1, a1)
+	})
+}
+
+func TestIntArray_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5, 4}
+		array1 := garray.NewIntArrayFrom(a1)
+		n1 := array1.Remove(1)
+		gtest.Assert(n1, 2)
+		gtest.Assert(array1.Len(), 4)
+
+		n1 = array1.Remove(0)
+		gtest.Assert(n1, 1)
+		gtest.Assert(array1.Len(), 3)
+
+		n1 = array1.Remove(2)
+		gtest.Assert(n1, 4)
+		gtest.Assert(array1.Len(), 2)
+	})
+}

g/container/garray/garray_z_unit_interface_test.go

@@ -9,196 +9,670 @@
 package garray_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/util/gconv"
+	"strings"
+	"testing"
 )
 
 func Test_Array_Basic(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []interface{}{0, 1, 2, 3}
-        array  := garray.NewArrayFrom(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(), []interface{}{100, 200, 1, 2, 3, 4})
-        array.InsertBefore(5, 300)
-        array.InsertAfter(6, 400)
-        gtest.Assert(array.Slice(), []interface{}{100, 200, 1, 2, 3, 300, 4, 400})
-        gtest.Assert(array.Clear().Len(), 0)
-    })
+	gtest.Case(t, func() {
+		expect := []interface{}{0, 1, 2, 3}
+		array := garray.NewArrayFrom(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(), []interface{}{100, 200, 1, 2, 3, 4})
+		array.InsertBefore(5, 300)
+		array.InsertAfter(6, 400)
+		gtest.Assert(array.Slice(), []interface{}{100, 200, 1, 2, 3, 300, 4, 400})
+		gtest.Assert(array.Clear().Len(), 0)
+	})
 }
 
 func TestArray_Sort(t *testing.T) {
-    gtest.Case(t, func() {
-        expect1 := []interface{}{0, 1, 2, 3}
-        expect2 := []interface{}{3, 2, 1, 0}
-        array   := garray.NewArray()
-        for i := 3; i >= 0; i-- {
-            array.Append(i)
-        }
-        array.SortFunc(func(v1, v2 interface{}) bool {
-            return v1.(int) < v2.(int)
-        })
-        gtest.Assert(array.Slice(), expect1)
-        array.SortFunc(func(v1, v2 interface{}) bool {
-            return v1.(int) > v2.(int)
-        })
-        gtest.Assert(array.Slice(), expect2)
-    })
+	gtest.Case(t, func() {
+		expect1 := []interface{}{0, 1, 2, 3}
+		expect2 := []interface{}{3, 2, 1, 0}
+		array := garray.NewArray()
+		for i := 3; i >= 0; i-- {
+			array.Append(i)
+		}
+		array.SortFunc(func(v1, v2 interface{}) bool {
+			return v1.(int) < v2.(int)
+		})
+		gtest.Assert(array.Slice(), expect1)
+		array.SortFunc(func(v1, v2 interface{}) bool {
+			return v1.(int) > v2.(int)
+		})
+		gtest.Assert(array.Slice(), expect2)
+	})
 }
 
 func TestArray_Unique(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []interface{}{1, 1, 2, 3}
-        array  := garray.NewArrayFrom(expect)
-        gtest.Assert(array.Unique().Slice(), []interface{}{1, 2, 3})
-    })
+	gtest.Case(t, func() {
+		expect := []interface{}{1, 1, 2, 3}
+		array := garray.NewArrayFrom(expect)
+		gtest.Assert(array.Unique().Slice(), []interface{}{1, 2, 3})
+	})
 }
 
 func TestArray_PushAndPop(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []interface{}{0, 1, 2, 3}
-        array  := garray.NewArrayFrom(expect)
-        gtest.Assert(array.Slice(),     expect)
-        gtest.Assert(array.PopLeft(),   0)
-        gtest.Assert(array.PopRight(),  3)
-        gtest.AssertIN(array.PopRand(), []interface{}{1, 2})
-        gtest.AssertIN(array.PopRand(), []interface{}{1, 2})
-        gtest.Assert(array.Len(), 0)
-        array.PushLeft(1).PushRight(2)
-        gtest.Assert(array.Slice(),    []interface{}{1, 2})
-    })
+	gtest.Case(t, func() {
+		expect := []interface{}{0, 1, 2, 3}
+		array := garray.NewArrayFrom(expect)
+		gtest.Assert(array.Slice(), expect)
+		gtest.Assert(array.PopLeft(), 0)
+		gtest.Assert(array.PopRight(), 3)
+		gtest.AssertIN(array.PopRand(), []interface{}{1, 2})
+		gtest.AssertIN(array.PopRand(), []interface{}{1, 2})
+		gtest.Assert(array.Len(), 0)
+		array.PushLeft(1).PushRight(2)
+		gtest.Assert(array.Slice(), []interface{}{1, 2})
+	})
 }
 
 func TestArray_PopRands(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{100, 200, 300, 400, 500, 600}
-        array := garray.NewFromCopy(a1)
-        gtest.AssertIN(array.PopRands(2), a1)
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{100, 200, 300, 400, 500, 600}
+		array := garray.NewFromCopy(a1)
+		gtest.AssertIN(array.PopRands(2), a1)
+	})
 }
 
 func TestArray_PopLeftsAndPopRights(t *testing.T) {
-    gtest.Case(t, func() {
-        value1 := []interface{}{0,1,2,3,4,5,6}
-        value2 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(value1)
-        array2 := garray.NewArrayFrom(value2)
-        gtest.Assert(array1.PopLefts(2), []interface{}{0,1})
-        gtest.Assert(array1.Slice(), []interface{}{2,3,4,5,6})
-        gtest.Assert(array1.PopRights(2), []interface{}{5,6})
-        gtest.Assert(array1.Slice(), []interface{}{2,3,4})
-        gtest.Assert(array1.PopRights(20), []interface{}{2,3,4})
-        gtest.Assert(array1.Slice(), []interface{}{})
-        gtest.Assert(array2.PopLefts(20), []interface{}{0,1,2,3,4,5,6})
-        gtest.Assert(array2.Slice(), []interface{}{})
-    })
+	gtest.Case(t, func() {
+		value1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		value2 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(value1)
+		array2 := garray.NewArrayFrom(value2)
+		gtest.Assert(array1.PopLefts(2), []interface{}{0, 1})
+		gtest.Assert(array1.Slice(), []interface{}{2, 3, 4, 5, 6})
+		gtest.Assert(array1.PopRights(2), []interface{}{5, 6})
+		gtest.Assert(array1.Slice(), []interface{}{2, 3, 4})
+		gtest.Assert(array1.PopRights(20), []interface{}{2, 3, 4})
+		gtest.Assert(array1.Slice(), []interface{}{})
+		gtest.Assert(array2.PopLefts(20), []interface{}{0, 1, 2, 3, 4, 5, 6})
+		gtest.Assert(array2.Slice(), []interface{}{})
+	})
 }
 
 func TestArray_Range(t *testing.T) {
-    gtest.Case(t, func() {
-        value1 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(value1)
-        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})
-        gtest.Assert(array1.Range(-1, 10), value1)
-    })
+	gtest.Case(t, func() {
+		value1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(value1)
+		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})
+		gtest.Assert(array1.Range(-1, 10), value1)
+	})
 }
 
 func TestArray_Merge(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0, 1, 2, 3}
-        a2 := []interface{}{4, 5, 6, 7}
-        array1 := garray.NewArrayFrom(a1)
-        array2 := garray.NewArrayFrom(a2)
-        gtest.Assert(array1.Merge(array2).Slice(), []interface{}{0,1,2,3,4,5,6,7})
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3}
+		a2 := []interface{}{4, 5, 6, 7}
+		array1 := garray.NewArrayFrom(a1)
+		array2 := garray.NewArrayFrom(a2)
+		gtest.Assert(array1.Merge(array2).Slice(), []interface{}{0, 1, 2, 3, 4, 5, 6, 7})
+	})
 }
 
 func TestArray_Fill(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0}
-        a2 := []interface{}{0}
-        array1 := garray.NewArrayFrom(a1)
-        array2 := garray.NewArrayFrom(a2)
-        gtest.Assert(array1.Fill(1, 2, 100).Slice(), []interface{}{0,100,100})
-        gtest.Assert(array2.Fill(0, 2, 100).Slice(), []interface{}{100,100})
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0}
+		a2 := []interface{}{0}
+		array1 := garray.NewArrayFrom(a1)
+		array2 := garray.NewArrayFrom(a2)
+		gtest.Assert(array1.Fill(1, 2, 100).Slice(), []interface{}{0, 100, 100})
+		gtest.Assert(array2.Fill(0, 2, 100).Slice(), []interface{}{100, 100})
+	})
 }
 
 func TestArray_Chunk(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{1,2,3,4,5}
-        array1 := garray.NewArrayFrom(a1)
-        chunks := array1.Chunk(2)
-        gtest.Assert(len(chunks), 3)
-        gtest.Assert(chunks[0], []interface{}{1,2})
-        gtest.Assert(chunks[1], []interface{}{3,4})
-        gtest.Assert(chunks[2], []interface{}{5})
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{1, 2, 3, 4, 5}
+		array1 := garray.NewArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		gtest.Assert(len(chunks), 3)
+		gtest.Assert(chunks[0], []interface{}{1, 2})
+		gtest.Assert(chunks[1], []interface{}{3, 4})
+		gtest.Assert(chunks[2], []interface{}{5})
+	})
 }
 
 func TestArray_Pad(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0}
-        array1 := garray.NewArrayFrom(a1)
-        gtest.Assert(array1.Pad(3,  1).Slice(), []interface{}{0,1,1})
-        gtest.Assert(array1.Pad(-4, 1).Slice(), []interface{}{1,0,1,1})
-        gtest.Assert(array1.Pad(3,  1).Slice(), []interface{}{1,0,1,1})
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0}
+		array1 := garray.NewArrayFrom(a1)
+		gtest.Assert(array1.Pad(3, 1).Slice(), []interface{}{0, 1, 1})
+		gtest.Assert(array1.Pad(-4, 1).Slice(), []interface{}{1, 0, 1, 1})
+		gtest.Assert(array1.Pad(3, 1).Slice(), []interface{}{1, 0, 1, 1})
+	})
 }
 
 func TestArray_SubSlice(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(a1)
-        gtest.Assert(array1.SubSlice(0, 2), []interface{}{0,1})
-        gtest.Assert(array1.SubSlice(2, 2), []interface{}{2,3})
-        gtest.Assert(array1.SubSlice(5, 8), []interface{}{5,6})
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(a1)
+		gtest.Assert(array1.SubSlice(0, 2), []interface{}{0, 1})
+		gtest.Assert(array1.SubSlice(2, 2), []interface{}{2, 3})
+		gtest.Assert(array1.SubSlice(5, 8), []interface{}{5, 6})
+	})
 }
 
 func TestArray_Rand(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(a1)
-        gtest.Assert(len(array1.Rands(2)),  2)
-        gtest.Assert(len(array1.Rands(10)), 7)
-        gtest.AssertIN(array1.Rands(1)[0], a1)
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(a1)
+		gtest.Assert(len(array1.Rands(2)), 2)
+		gtest.Assert(len(array1.Rands(10)), 7)
+		gtest.AssertIN(array1.Rands(1)[0], a1)
+	})
 }
 
 func TestArray_Shuffle(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(a1)
-        gtest.Assert(array1.Shuffle().Len(), 7)
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(a1)
+		gtest.Assert(array1.Shuffle().Len(), 7)
+	})
 }
 
 func TestArray_Reverse(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(a1)
-        gtest.Assert(array1.Reverse().Slice(), []interface{}{6,5,4,3,2,1,0})
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(a1)
+		gtest.Assert(array1.Reverse().Slice(), []interface{}{6, 5, 4, 3, 2, 1, 0})
+	})
 }
 
 func TestArray_Join(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(a1)
-        gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
-    })
-}
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(a1)
+		gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
+	})
+}
+
+func TestArray_Replace(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		a2 := []interface{}{"a", "b", "c"}
+		a3 := []interface{}{"m", "n", "p", "z", "x", "y", "d", "u"}
+		array1 := garray.NewArrayFrom(a1)
+		array2 := array1.Replace(a2)
+		gtest.Assert(array2.Len(), 7)
+		gtest.Assert(array2.Contains("b"), true)
+		gtest.Assert(array2.Contains(4), true)
+		gtest.Assert(array2.Contains("v"), false)
+		array3 := array1.Replace(a3)
+		gtest.Assert(array3.Len(), 7)
+		gtest.Assert(array3.Contains(4), false)
+		gtest.Assert(array3.Contains("p"), true)
+		gtest.Assert(array3.Contains("u"), false)
+	})
+}
+
+func TestArray_SetArray(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		a2 := []interface{}{"a", "b", "c"}
+
+		array1 := garray.NewArrayFrom(a1)
+		array1 = array1.SetArray(a2)
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Contains("b"), true)
+		gtest.Assert(array1.Contains("5"), false)
+	})
+}
+
+func TestArray_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3}
+		a2 := []interface{}{"a", "b", "c"}
+		a3 := []interface{}{"a", "1", "2"}
+
+		array1 := garray.NewArrayFrom(a1)
+		array2 := garray.NewArrayFrom(a2)
+		array3 := garray.NewArrayFrom(a3)
+
+		gtest.Assert(array1.Sum(), 6)
+		gtest.Assert(array2.Sum(), 0)
+		gtest.Assert(array3.Sum(), 3)
+
+	})
+}
+
+func TestArray_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3}
+		array1 := garray.NewArrayFrom(a1)
+		array2 := array1.Clone()
+
+		gtest.Assert(array1.Len(), 4)
+		gtest.Assert(array2.Sum(), 6)
+		gtest.AssertEQ(array1, array2)
+
+	})
+}
+
+func TestArray_CountValues(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "b", "c", "d", "e", "d"}
+		array1 := garray.NewArrayFrom(a1)
+		array2 := array1.CountValues()
+		gtest.Assert(len(array2), 5)
+		gtest.Assert(array2["b"], 1)
+		gtest.Assert(array2["d"], 2)
+	})
+}
+
+func TestSortedArray_NewSortedArrayFrom(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "f", "c"}
+		a2 := []interface{}{"h", "j", "i", "k"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		func2 := func(v1, v2 interface{}) int {
+			return -1
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array2 := garray.NewSortedArrayFrom(a2, func2)
+
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1, []interface{}{"a", "c", "f"})
+
+		gtest.Assert(array2.Len(), 4)
+		gtest.Assert(array2, []interface{}{"k", "i", "j", "h"})
+	})
+}
+
+func TestNewSortedArrayFromCopy(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "f", "c"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		func2 := func(v1, v2 interface{}) int {
+			return -1
+		}
+		array1 := garray.NewSortedArrayFromCopy(a1, func1)
+		array2 := garray.NewSortedArrayFromCopy(a1, func2)
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1, []interface{}{"a", "c", "f"})
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array2, []interface{}{"c", "f", "a"})
+	})
+}
+
+func TestSortedArray_SetArray(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "f", "c"}
+		a2 := []interface{}{"e", "h", "g", "k"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array1.SetArray(a2)
+		gtest.Assert(array1.Len(), 4)
+		gtest.Assert(array1, []interface{}{"e", "g", "h", "k"})
+	})
+
+}
+
+func TestSortedArray_Sort(t *testing.T) {
+	gtest.Case(t, func() {
+		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)
+		array1.Sort()
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1, []interface{}{"a", "c", "f"})
+	})
+
+}
+
+func TestSortedArray_Get(t *testing.T) {
+	gtest.Case(t, func() {
+		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)
+		gtest.Assert(array1.Get(2), "f")
+		gtest.Assert(array1.Get(1), "c")
+	})
+
+}
+
+func TestSortedArray_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.Remove(1)
+		gtest.Assert(gconv.String(i1), "b")
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Contains("b"), false)
+
+		i2 := array1.Remove(0)
+		gtest.Assert(gconv.String(i2), "a")
+		gtest.Assert(array1.Len(), 2)
+		gtest.Assert(array1.Contains("a"), false)
+
+		i3 := array1.Remove(1)
+		gtest.Assert(gconv.String(i3), "d")
+		gtest.Assert(array1.Len(), 1)
+		gtest.Assert(array1.Contains("d"), false)
+	})
+
+}
+
+func TestSortedArray_PopLeft(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.PopLeft()
+		gtest.Assert(gconv.String(i1), "a")
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1, []interface{}{"b", "c", "d"})
+	})
+
+}
+
+func TestSortedArray_PopRight(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.PopRight()
+		gtest.Assert(gconv.String(i1), "d")
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1, []interface{}{"a", "b", "c"})
+	})
+
+}
+
+func TestSortedArray_PopRand(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.PopRand()
+		gtest.AssertIN(i1, []interface{}{"a", "d", "c", "b"})
+		gtest.Assert(array1.Len(), 3)
+
+	})
+}
+
+func TestSortedArray_PopRands(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.PopRands(2)
+		gtest.Assert(len(i1), 2)
+		gtest.AssertIN(i1, []interface{}{"a", "d", "c", "b"})
+		gtest.Assert(array1.Len(), 2)
+
+		i2 := array1.PopRands(3)
+		gtest.Assert(len(i1), 2)
+		gtest.AssertIN(i2, []interface{}{"a", "d", "c", "b"})
+		gtest.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedArray_PopLefts(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))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.PopLefts(2)
+		gtest.Assert(len(i1), 2)
+		gtest.AssertIN(i1, []interface{}{"a", "d", "c", "b", "e", "f"})
+		gtest.Assert(array1.Len(), 4)
+
+		i2 := array1.PopLefts(5)
+		gtest.Assert(len(i2), 4)
+		gtest.AssertIN(i1, []interface{}{"a", "d", "c", "b", "e", "f"})
+		gtest.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedArray_PopRights(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))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.PopRights(2)
+		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)
+
+	})
+}
+
+func TestSortedArray_Range(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))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.Range(2, 5)
+		gtest.Assert(i1, []interface{}{"c", "d", "e"})
+		gtest.Assert(array1.Len(), 6)
+
+		i2 := array1.Range(7, 5)
+		gtest.Assert(len(i2), 0)
+		i2 = array1.Range(-1, 2)
+		gtest.Assert(i2, []interface{}{"a", "b"})
+
+		i2 = array1.Range(4, 10)
+		gtest.Assert(len(i2), 2)
+		gtest.Assert(i2, []interface{}{"e", "f"})
+
+	})
+}
+
+func TestSortedArray_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
+		a2 := []interface{}{"1", "2", "3", "b", "e", "f"}
+		a3 := []interface{}{"4", "5", "6"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array2 := garray.NewSortedArrayFrom(a2, func1)
+		array3 := garray.NewSortedArrayFrom(a3, func1)
+		gtest.Assert(array1.Sum(), 0)
+		gtest.Assert(array2.Sum(), 6)
+		gtest.Assert(array3.Sum(), 15)
+
+	})
+}
+
+func TestSortedArray_Clone(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))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array2 := array1.Clone()
+		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))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		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))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.Chunk(2)
+		gtest.Assert(len(i1), 3)
+		gtest.Assert(i1[0], []interface{}{"a", "b"})
+		gtest.Assert(i1[2], []interface{}{"e"})
+
+		i1 = array1.Chunk(0)
+		gtest.Assert(len(i1), 0)
+	})
+}
+
+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)
+		i1 := array1.SubSlice(2, 3)
+		gtest.Assert(len(i1), 3)
+		gtest.Assert(i1, []interface{}{"c", "d", "e"})
+
+		i1 = array1.SubSlice(2, 6)
+		gtest.Assert(len(i1), 3)
+		gtest.Assert(i1, []interface{}{"c", "d", "e"})
+
+		i1 = array1.SubSlice(7, 2)
+		gtest.Assert(len(i1), 0)
+
+	})
+}
+
+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))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.Rand()
+		gtest.AssertIN(i1, []interface{}{"a", "d", "c"})
+		gtest.Assert(array1.Len(), 3)
+	})
+}
+
+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))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.Rands(2)
+		gtest.AssertIN(i1, []interface{}{"a", "d", "c"})
+		gtest.Assert(len(i1), 2)
+		gtest.Assert(array1.Len(), 3)
+
+		i1 = array1.Rands(4)
+		gtest.Assert(len(i1), 3)
+	})
+}
+
+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")
+
+	})
+}
+
+func TestSortedArray_CountValues(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))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		m1 := array1.CountValues()
+		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))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array1.SetUnique(true)
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1, []interface{}{"a", "c", "d"})
+	})
+}

g/container/garray/garray_z_unit_string_test.go

@@ -9,193 +9,631 @@
 package garray_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/test/gtest"
-    "github.com/gogf/gf/g/util/gconv"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/util/gconv"
+	"strings"
+	"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)
-    })
+	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()
-        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)
-    })
+	gtest.Case(t, func() {
+		expect1 := []string{"0", "1", "2", "3"}
+		expect2 := []string{"3", "2", "1", "0"}
+		array := garray.NewStringArray()
+		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"})
-    })
+	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"})
-    })
+	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_PopLeftsAndPopRights(t *testing.T) {
-    gtest.Case(t, func() {
-        value1 := []string{"0","1","2","3","4","5","6"}
-        value2 := []string{"0","1","2","3","4","5","6"}
-        array1 := garray.NewStringArrayFrom(value1)
-        array2 := garray.NewStringArrayFrom(value2)
-        gtest.Assert(array1.PopLefts(2), []interface{}{"0","1"})
-        gtest.Assert(array1.Slice(), []interface{}{"2","3","4","5","6"})
-        gtest.Assert(array1.PopRights(2), []interface{}{"5","6"})
-        gtest.Assert(array1.Slice(), []interface{}{"2","3","4"})
-        gtest.Assert(array1.PopRights(20), []interface{}{"2","3","4"})
-        gtest.Assert(array1.Slice(), []interface{}{})
-        gtest.Assert(array2.PopLefts(20), []interface{}{"0","1","2","3","4","5","6"})
-        gtest.Assert(array2.Slice(), []interface{}{})
-    })
+	gtest.Case(t, func() {
+		value1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		value2 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStringArrayFrom(value1)
+		array2 := garray.NewStringArrayFrom(value2)
+		gtest.Assert(array1.PopLefts(2), []interface{}{"0", "1"})
+		gtest.Assert(array1.Slice(), []interface{}{"2", "3", "4", "5", "6"})
+		gtest.Assert(array1.PopRights(2), []interface{}{"5", "6"})
+		gtest.Assert(array1.Slice(), []interface{}{"2", "3", "4"})
+		gtest.Assert(array1.PopRights(20), []interface{}{"2", "3", "4"})
+		gtest.Assert(array1.Slice(), []interface{}{})
+		gtest.Assert(array2.PopLefts(20), []interface{}{"0", "1", "2", "3", "4", "5", "6"})
+		gtest.Assert(array2.Slice(), []interface{}{})
+	})
 }
 
 func TestString_Range(t *testing.T) {
-    gtest.Case(t, func() {
-        value1 := []string{"0","1","2","3","4","5","6"}
-        array1 := garray.NewStringArrayFrom(value1)
-        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"})
-        gtest.Assert(array1.Range(-1, 10), value1)
-    })
+	gtest.Case(t, func() {
+		value1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStringArrayFrom(value1)
+		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"})
+		gtest.Assert(array1.Range(-1, 10), value1)
+	})
 }
 
 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"})
-    })
+	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"})
-    })
+	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"})
+		s1 := array2.Fill(-1, 2, "100")
+		gtest.Assert(s1.Len(), 2)
+	})
 }
 
 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"})
-    })
+	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"})
+		gtest.Assert(len(array1.Chunk(0)), 0)
+
+	})
 }
 
 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"})
-    })
+	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"})
-    })
+	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.Rands(2)),  "2")
-        gtest.Assert(len(array1.Rands(10)), "7")
-        gtest.AssertIN(array1.Rands(1)[0], a1)
-    })
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStringArrayFrom(a1)
+		gtest.Assert(len(array1.Rands(2)), "2")
+		gtest.Assert(len(array1.Rands(10)), "7")
+		gtest.AssertIN(array1.Rands(1)[0], a1)
+		gtest.Assert(len(array1.Rand()), 1)
+		gtest.AssertIN(array1.Rand(), a1)
+
+	})
 }
 
 func TestStringArray_PopRands(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{"100", "200", "300", "400", "500", "600"}
-        array := garray.NewFromCopy(a1)
-        gtest.AssertIN(array.PopRands(2), a1)
-    })
+	gtest.Case(t, func() {
+		a1 := []string{"a", "b", "c", "d", "e", "f", "g"}
+		a2 := []string{"1", "2", "3", "4", "5", "6", "7"}
+		array1 := garray.NewStringArrayFrom(a1)
+		//todo gtest.AssertIN(array1.PopRands(1),a1)
+		gtest.AssertIN(array1.PopRands(1), strings.Join(a1, ","))
+		gtest.AssertNI(array1.PopRands(1), strings.Join(a2, ","))
+
+	})
 }
 
 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)
-    })
+	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"})
-    })
+	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")
-    })
-}
+	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")
+	})
+}
+
+func TestNewStringArrayFromCopy(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		a2 := garray.NewStringArrayFromCopy(a1)
+		a3 := garray.NewStringArrayFromCopy(a1, true)
+		gtest.Assert(a2.Contains("1"), true)
+		gtest.Assert(a2.Len(), 7)
+		gtest.Assert(a2, a3)
+	})
+}
+
+func TestStringArray_SetArray(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		a2 := []string{"a", "b", "c", "d"}
+		array1 := garray.NewStringArrayFrom(a1)
+		gtest.Assert(array1.Contains("2"), true)
+		gtest.Assert(array1.Len(), 7)
+
+		array1 = array1.SetArray(a2)
+		gtest.Assert(array1.Contains("2"), false)
+		gtest.Assert(array1.Contains("c"), true)
+		gtest.Assert(array1.Len(), 4)
+	})
+}
+
+func TestStringArray_Replace(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		a2 := []string{"a", "b", "c", "d"}
+		a3 := []string{"o", "p", "q", "x", "y", "z", "w", "r", "v"}
+		array1 := garray.NewStringArrayFrom(a1)
+		gtest.Assert(array1.Contains("2"), true)
+		gtest.Assert(array1.Len(), 7)
+
+		array1 = array1.Replace(a2)
+		gtest.Assert(array1.Contains("2"), false)
+		gtest.Assert(array1.Contains("c"), true)
+		gtest.Assert(array1.Contains("5"), true)
+		gtest.Assert(array1.Len(), 7)
+
+		array1 = array1.Replace(a3)
+		gtest.Assert(array1.Contains("2"), false)
+		gtest.Assert(array1.Contains("c"), false)
+		gtest.Assert(array1.Contains("5"), false)
+		gtest.Assert(array1.Contains("p"), true)
+		gtest.Assert(array1.Contains("r"), false)
+		gtest.Assert(array1.Len(), 7)
+
+	})
+}
+
+func TestStringArray_Sum(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)
+		array2 := garray.NewStringArrayFrom(a2)
+		gtest.Assert(array1.Sum(), 21)
+		gtest.Assert(array2.Sum(), 18)
+	})
+}
+
+//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"}
+		array1 := garray.NewStringArrayFrom(a1)
+		str1 := array1.PopRand()
+		gtest.Assert(strings.Contains("0,1,2,3,4,5,6", str1), true)
+		gtest.Assert(array1.Len(), 6)
+	})
+}
+
+func TestStringArray_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStringArrayFrom(a1)
+		array2 := array1.Clone()
+		gtest.Assert(array2, array1)
+		gtest.Assert(array2.Len(), 7)
+	})
+}
+
+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)
+		gtest.Assert(m1["4"], 2)
+
+	})
+}
+
+func TestNewSortedStringArrayFrom(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"a", "d", "c", "b"}
+		s1 := garray.NewSortedStringArrayFrom(a1, true)
+		gtest.Assert(s1, []string{"a", "b", "c", "d"})
+		s2 := garray.NewSortedStringArrayFrom(a1, false)
+		gtest.Assert(s2, []string{"a", "b", "c", "d"})
+	})
+}
+
+func TestNewSortedStringArrayFromCopy(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"a", "d", "c", "b"}
+		s1 := garray.NewSortedStringArrayFromCopy(a1, true)
+		gtest.Assert(s1.Len(), 4)
+		gtest.Assert(s1, []string{"a", "b", "c", "d"})
+	})
+}
+
+func TestSortedStringArray_SetArray(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"a", "d", "c", "b"}
+		a2 := []string{"f", "g", "h"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		array1.SetArray(a2)
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Contains("d"), false)
+		gtest.Assert(array1.Contains("b"), false)
+		gtest.Assert(array1.Contains("g"), true)
+
+	})
+}
+
+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() //todo 这个SortedStringArray.sort这个方法没有必要，
+		gtest.Assert(array1.Len(), 4)
+		gtest.Assert(array1.Contains("c"), true)
+		gtest.Assert(array1, []string{"a", "b", "c", "d"})
+	})
+}
+
+func TestSortedStringArray_Get(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		gtest.Assert(array1.Get(2), "c")
+		gtest.Assert(array1.Get(0), "a")
+
+	})
+}
+
+func TestSortedStringArray_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		gtest.Assert(array1.Remove(2), "c")
+		gtest.Assert(array1.Get(2), "d")
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Contains("c"), false)
+
+		gtest.Assert(array1.Remove(0), "a")
+		gtest.Assert(array1.Len(), 2)
+		gtest.Assert(array1.Contains("a"), false)
+
+		// 此时array1里的元素只剩下2个
+		gtest.Assert(array1.Remove(1), "d")
+		gtest.Assert(array1.Len(), 1)
+
+	})
+}
+
+func TestSortedStringArray_PopLeft(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.PopLeft()
+		gtest.Assert(s1, "a")
+		gtest.Assert(array1.Len(), 4)
+		gtest.Assert(array1.Contains("a"), false)
+	})
+}
+
+func TestSortedStringArray_PopRight(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.PopRight()
+		gtest.Assert(s1, "e")
+		gtest.Assert(array1.Len(), 4)
+		gtest.Assert(array1.Contains("e"), false)
+	})
+}
+
+func TestSortedStringArray_PopRand(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.PopRand()
+		gtest.AssertIN(s1, []string{"e", "a", "d", "c", "b"})
+		gtest.Assert(array1.Len(), 4)
+		gtest.Assert(array1.Contains(s1), false)
+	})
+}
+
+func TestSortedStringArray_PopRands(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.PopRands(2)
+		gtest.AssertIN(s1, []string{"e", "a", "d", "c", "b"})
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(len(s1), 2)
+
+		s1 = array1.PopRands(4)
+		gtest.Assert(len(s1), 3)
+		gtest.AssertIN(s1, []string{"e", "a", "d", "c", "b"})
+	})
+}
+
+func TestSortedStringArray_PopLefts(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.PopLefts(2)
+		gtest.Assert(s1, []string{"a", "b"})
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(len(s1), 2)
+
+		s1 = array1.PopLefts(4)
+		gtest.Assert(len(s1), 3)
+		gtest.Assert(s1, []string{"c", "d", "e"})
+	})
+}
+
+func TestSortedStringArray_PopRights(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.PopRights(2)
+		gtest.Assert(s1, []string{"f", "g"})
+		gtest.Assert(array1.Len(), 5)
+		gtest.Assert(len(s1), 2)
+		s1 = array1.PopRights(6)
+		gtest.Assert(len(s1), 5)
+		gtest.Assert(s1, []string{"a", "b", "c", "d", "e"})
+		gtest.Assert(array1.Len(), 0)
+	})
+}
+
+func TestSortedStringArray_Range(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.Range(2, 4)
+		gtest.Assert(len(s1), 2)
+		gtest.Assert(s1, []string{"c", "d"})
+
+		s1 = array1.Range(-1, 2)
+		gtest.Assert(len(s1), 2)
+		gtest.Assert(s1, []string{"a", "b"})
+
+		s1 = array1.Range(4, 8)
+		gtest.Assert(len(s1), 3)
+		gtest.Assert(s1, []string{"e", "f", "g"})
+	})
+}
+
+func TestSortedStringArray_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		a2 := []string{"1", "2", "3", "4", "a"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		array2 := garray.NewSortedStringArrayFrom(a2)
+		gtest.Assert(array1.Sum(), 0)
+		gtest.Assert(array2.Sum(), 10)
+	})
+}
+
+func TestSortedStringArray_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		array2 := array1.Clone()
+		gtest.Assert(array1, array2)
+		array1.Remove(1)
+		gtest.Assert(array2.Len(), 7)
+	})
+}
+
+func TestSortedStringArray_Clear(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		array1.Clear()
+		gtest.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedStringArray_SubSlice(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.SubSlice(1, 3)
+		gtest.Assert(len(s1), 3)
+		gtest.Assert(s1, []string{"b", "c", "d"})
+		gtest.Assert(array1.Len(), 7)
+
+		s2 := array1.SubSlice(1, 10)
+		gtest.Assert(len(s2), 6)
+
+		s3 := array1.SubSlice(10, 2)
+		gtest.Assert(len(s3), 0)
+
+	})
+}
+
+func TestSortedStringArray_Len(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		gtest.Assert(array1.Len(), 7)
+
+	})
+}
+
+func TestSortedStringArray_Rand(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		gtest.AssertIN(array1.Rand(), []string{"e", "a", "d"})
+
+	})
+}
+
+func TestSortedStringArray_Rands(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.Rands(2)
+
+		gtest.AssertIN(s1, []string{"e", "a", "d"})
+		gtest.Assert(len(s1), 2)
+
+		s1 = array1.Rands(4)
+		gtest.AssertIN(s1, []string{"e", "a", "d"})
+		gtest.Assert(len(s1), 3)
+	})
+}
+
+func TestSortedStringArray_Join(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		gtest.Assert(array1.Join(","), "a,d,e")
+		gtest.Assert(array1.Join("."), "a.d.e")
+	})
+}
+
+func TestSortedStringArray_CountValues(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "a", "c"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		m1 := array1.CountValues()
+		gtest.Assert(m1["a"], 2)
+		gtest.Assert(m1["d"], 1)
+
+	})
+}
+
+func TestSortedStringArray_Chunk(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "a", "c"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		array2 := array1.Chunk(2)
+		gtest.Assert(len(array2), 3)
+		gtest.Assert(len(array2[0]), 2)
+		gtest.Assert(array2[1], []string{"c", "d"})
+	})
+}
+
+func TestSortedStringArray_SetUnique(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "a", "c"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		array2 := array1.SetUnique(true)
+		gtest.Assert(array2.Len(), 4)
+		gtest.Assert(array2, []string{"a", "c", "d", "e"})
+	})
+}
+
+func TestStringArray_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "a", "c"}
+		array1 := garray.NewStringArrayFrom(a1)
+		s1 := array1.Remove(1)
+		gtest.Assert(s1, "a")
+		gtest.Assert(array1.Len(), 4)
+		s1 = array1.Remove(3)
+		gtest.Assert(s1, "c")
+		gtest.Assert(array1.Len(), 3)
+
+	})
+}

g/container/gchan/gchan.go

@@ -10,55 +10,61 @@
 package gchan
 
 import (
-    "errors"
-    "github.com/gogf/gf/g/container/gtype"
+	"errors"
+
+	"github.com/gogf/gf/g/container/gtype"
 )
 
 // Graceful channel.
 type Chan struct {
-    channel chan interface{}
-    closed  *gtype.Bool
+	channel chan interface{}
+	closed  *gtype.Bool
 }
 
 // New creates a graceful channel with given <limit>.
 func New(limit int) *Chan {
-    return &Chan {
-	    channel : make(chan interface{}, limit),
-        closed  : gtype.NewBool(),
-    }
+	return &Chan{
+		channel: make(chan interface{}, limit),
+		closed:  gtype.NewBool(),
+	}
 }
 
 // Push pushes <value> to channel.
 // It is safe to be called repeatedly.
 func (c *Chan) Push(value interface{}) error {
-    if c.closed.Val() {
-        return errors.New("channel is closed")
-    }
-    c.channel <- value
-    return nil
+	if c.closed.Val() {
+		return errors.New("channel is closed")
+	}
+	c.channel <- value
+	return nil
 }
 
 // Pop pops value from channel.
 // If there's no value in channel, it would block to wait.
 // If the channel is closed, it will return a nil value immediately.
 func (c *Chan) Pop() interface{} {
-    return <- c.channel
+	return <-c.channel
 }
 
 // Close closes the channel.
 // It is safe to be called repeatedly.
 func (c *Chan) Close() {
-    if !c.closed.Set(true) {
-        close(c.channel)
-    }
+	if !c.closed.Set(true) {
+		close(c.channel)
+	}
 }
 
 // See Len.
 func (c *Chan) Size() int {
-    return c.Len()
+	return c.Len()
 }
 
 // Len returns the length of the channel.
 func (c *Chan) Len() int {
 	return len(c.channel)
-}
+}
+
+// Cap returns the capacity of the channel.
+func (c *Chan) Cap() int {
+	return cap(c.channel)
+}

g/container/gchan/gchan_bench_test.go

@@ -1,32 +0,0 @@
-// Copyright 2017 gf Author(https://github.com/gogf/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://github.com/gogf/gf.
-
-// go test *.go -bench=".*"
-
-package gchan_test
-
-import (
-    "testing"
-    "github.com/gogf/gf/g/container/gchan"
-)
-
-var length = 10000000
-var q1 = gchan.New(length)
-var q2 = make(chan int, length)
-
-func BenchmarkGchanPushAndPop(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        q1.Push(i)
-        q1.Pop()
-    }
-}
-
-func BenchmarkChannelPushAndPop(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        q2 <- i
-        <- q2
-    }
-}

g/container/gchan/gchan_z_unit_test.go

@@ -0,0 +1,47 @@
+package gchan_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/gogf/gf/g/container/gchan"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+func Test_Gchan(t *testing.T) {
+	gtest.Case(t, func() {
+		ch := gchan.New(10)
+
+		gtest.Assert(ch.Cap(), 10)
+		gtest.Assert(ch.Push(1), nil)
+		gtest.Assert(ch.Len(), 1)
+		gtest.Assert(ch.Size(), 1)
+		ch.Pop()
+		gtest.Assert(ch.Len(), 0)
+		gtest.Assert(ch.Size(), 0)
+		ch.Close()
+		gtest.Assert(ch.Push(1), errors.New("channel is closed"))
+
+		ch = gchan.New(0)
+		ch1 := gchan.New(0)
+		go func() {
+			var i = 0
+			for {
+				v := ch.Pop()
+				if v == nil {
+					ch1.Push(i)
+					break
+				}
+				gtest.Assert(v, i)
+				i++
+			}
+		}()
+
+		for index := 0; index < 10; index++ {
+			ch.Push(index)
+		}
+		ch.Close()
+		gtest.Assert(ch1.Pop(), 10)
+		ch1.Close()
+	})
+}

g/container/glist/glist.go

@@ -209,7 +209,7 @@ func (l *List) Len() (length int) {
 	return
 }
 
-// Alias of Len.
+// Size is alias of Len.
 func (l *List) Size() int {
 	return l.Len()
 }

g/container/glist/glist_z_unit_test.go

@@ -7,361 +7,577 @@
 package glist
 
 import (
-    "container/list"
-    "testing"
+	"container/list"
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/util/gconv"
+
+	"testing"
 )
 
 // 检查链表长度
 func checkListLen(t *testing.T, l *List, len int) bool {
-    if n := l.Len(); n != len {
-        t.Errorf("l.Len() = %d, want %d", n, len)
-        return false
-    }
-    return true
+	if n := l.Len(); n != len {
+		t.Errorf("l.Len() = %d, want %d", n, len)
+		return false
+	}
+	return true
 }
 
 // 检查指针地址
 func checkListPointers(t *testing.T, l *List, es []*Element) {
-    if !checkListLen(t, l, len(es)) {
-        return
-    }
-    l.RLockFunc(func(list *list.List) {
-        for i, e := 0, l.list.Front(); i < list.Len(); i, e = i + 1, e.Next() {
-            if e.Prev() != es[i].Prev() {
-                t.Errorf("list[%d].Prev = %p, want %p", i, e.Prev(), es[i].Prev())
-            }
-            if e.Next() != es[i].Next() {
-                t.Errorf("list[%d].Next = %p, want %p", i, e.Next(), es[i].Next())
-            }
-        }
-    })
+	if !checkListLen(t, l, len(es)) {
+		return
+	}
+	l.RLockFunc(func(list *list.List) {
+		for i, e := 0, l.list.Front(); i < list.Len(); i, e = i+1, e.Next() {
+			if e.Prev() != es[i].Prev() {
+				t.Errorf("list[%d].Prev = %p, want %p", i, e.Prev(), es[i].Prev())
+			}
+			if e.Next() != es[i].Next() {
+				t.Errorf("list[%d].Next = %p, want %p", i, e.Next(), es[i].Next())
+			}
+		}
+	})
 }
 
 func TestBasic(t *testing.T) {
-    l := New()
-    l.PushFront(1)
-    l.PushFront(2)
-    if v := l.PopBack(); v != 1 {
-        t.Errorf("EXPECT %v, GOT %v", 1, v)
-    } else {
-        //fmt.Println(v)
-    }
-    if v := l.PopBack(); v != 2 {
-        t.Errorf("EXPECT %v, GOT %v", 2, v)
-    } else {
-        //fmt.Println(v)
-    }
-    if v := l.PopBack(); v != nil {
-        t.Errorf("EXPECT %v, GOT %v", nil, v)
-    } else {
-        //fmt.Println(v)
-    }
-    l.PushBack(1)
-    l.PushBack(2)
-    if v := l.PopFront(); v != 1 {
-        t.Errorf("EXPECT %v, GOT %v", 1, v)
-    } else {
-        //fmt.Println(v)
-    }
-    if v := l.PopFront(); v != 2 {
-        t.Errorf("EXPECT %v, GOT %v", 2, v)
-    } else {
-        //fmt.Println(v)
-    }
-    if v := l.PopFront(); v != nil {
-        t.Errorf("EXPECT %v, GOT %v", nil, v)
-    } else {
-        //fmt.Println(v)
-    }
+	l := New()
+	l.PushFront(1)
+	l.PushFront(2)
+	if v := l.PopBack(); v != 1 {
+		t.Errorf("EXPECT %v, GOT %v", 1, v)
+	} else {
+		//fmt.Println(v)
+	}
+	if v := l.PopBack(); v != 2 {
+		t.Errorf("EXPECT %v, GOT %v", 2, v)
+	} else {
+		//fmt.Println(v)
+	}
+	if v := l.PopBack(); v != nil {
+		t.Errorf("EXPECT %v, GOT %v", nil, v)
+	} else {
+		//fmt.Println(v)
+	}
+	l.PushBack(1)
+	l.PushBack(2)
+	if v := l.PopFront(); v != 1 {
+		t.Errorf("EXPECT %v, GOT %v", 1, v)
+	} else {
+		//fmt.Println(v)
+	}
+	if v := l.PopFront(); v != 2 {
+		t.Errorf("EXPECT %v, GOT %v", 2, v)
+	} else {
+		//fmt.Println(v)
+	}
+	if v := l.PopFront(); v != nil {
+		t.Errorf("EXPECT %v, GOT %v", nil, v)
+	} else {
+		//fmt.Println(v)
+	}
 }
 
 func TestList(t *testing.T) {
-    l := New()
-    checkListPointers(t, l, []*Element{})
+	l := New()
+	checkListPointers(t, l, []*Element{})
 
-    // Single element list
-    e := l.PushFront("a")
-    checkListPointers(t, l, []*Element{e})
-    l.MoveToFront(e)
-    checkListPointers(t, l, []*Element{e})
-    l.MoveToBack(e)
-    checkListPointers(t, l, []*Element{e})
-    l.Remove(e)
-    checkListPointers(t, l, []*Element{})
+	// Single element list
+	e := l.PushFront("a")
+	checkListPointers(t, l, []*Element{e})
+	l.MoveToFront(e)
+	checkListPointers(t, l, []*Element{e})
+	l.MoveToBack(e)
+	checkListPointers(t, l, []*Element{e})
+	l.Remove(e)
+	checkListPointers(t, l, []*Element{})
 
-    // Bigger list
-    e2 := l.PushFront(2)
-    e1 := l.PushFront(1)
-    e3 := l.PushBack(3)
-    e4 := l.PushBack("banana")
-    checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+	// Bigger list
+	e2 := l.PushFront(2)
+	e1 := l.PushFront(1)
+	e3 := l.PushBack(3)
+	e4 := l.PushBack("banana")
+	checkListPointers(t, l, []*Element{e1, e2, e3, e4})
 
-    l.Remove(e2)
-    checkListPointers(t, l, []*Element{e1, e3, e4})
+	l.Remove(e2)
+	checkListPointers(t, l, []*Element{e1, e3, e4})
 
-    l.MoveToFront(e3) // move from middle
-    checkListPointers(t, l, []*Element{e3, e1, e4})
+	l.MoveToFront(e3) // move from middle
+	checkListPointers(t, l, []*Element{e3, e1, e4})
 
-    l.MoveToFront(e1)
-    l.MoveToBack(e3) // move from middle
-    checkListPointers(t, l, []*Element{e1, e4, e3})
+	l.MoveToFront(e1)
+	l.MoveToBack(e3) // move from middle
+	checkListPointers(t, l, []*Element{e1, e4, e3})
 
-    l.MoveToFront(e3) // move from back
-    checkListPointers(t, l, []*Element{e3, e1, e4})
-    l.MoveToFront(e3) // should be no-op
-    checkListPointers(t, l, []*Element{e3, e1, e4})
+	l.MoveToFront(e3) // move from back
+	checkListPointers(t, l, []*Element{e3, e1, e4})
+	l.MoveToFront(e3) // should be no-op
+	checkListPointers(t, l, []*Element{e3, e1, e4})
 
-    l.MoveToBack(e3) // move from front
-    checkListPointers(t, l, []*Element{e1, e4, e3})
-    l.MoveToBack(e3) // should be no-op
-    checkListPointers(t, l, []*Element{e1, e4, e3})
+	l.MoveToBack(e3) // move from front
+	checkListPointers(t, l, []*Element{e1, e4, e3})
+	l.MoveToBack(e3) // should be no-op
+	checkListPointers(t, l, []*Element{e1, e4, e3})
 
-    e2 = l.InsertBefore(2, e1) // insert before front
-    checkListPointers(t, l, []*Element{e2, e1, e4, e3})
-    l.Remove(e2)
-    e2 = l.InsertBefore(2, e4) // insert before middle
-    checkListPointers(t, l, []*Element{e1, e2, e4, e3})
-    l.Remove(e2)
-    e2 = l.InsertBefore(2, e3) // insert before back
-    checkListPointers(t, l, []*Element{e1, e4, e2, e3})
-    l.Remove(e2)
+	e2 = l.InsertBefore(2, e1) // insert before front
+	checkListPointers(t, l, []*Element{e2, e1, e4, e3})
+	l.Remove(e2)
+	e2 = l.InsertBefore(2, e4) // insert before middle
+	checkListPointers(t, l, []*Element{e1, e2, e4, e3})
+	l.Remove(e2)
+	e2 = l.InsertBefore(2, e3) // insert before back
+	checkListPointers(t, l, []*Element{e1, e4, e2, e3})
+	l.Remove(e2)
 
-    e2 = l.InsertAfter(2, e1) // insert after front
-    checkListPointers(t, l, []*Element{e1, e2, e4, e3})
-    l.Remove(e2)
-    e2 = l.InsertAfter(2, e4) // insert after middle
-    checkListPointers(t, l, []*Element{e1, e4, e2, e3})
-    l.Remove(e2)
-    e2 = l.InsertAfter(2, e3) // insert after back
-    checkListPointers(t, l, []*Element{e1, e4, e3, e2})
-    l.Remove(e2)
+	e2 = l.InsertAfter(2, e1) // insert after front
+	checkListPointers(t, l, []*Element{e1, e2, e4, e3})
+	l.Remove(e2)
+	e2 = l.InsertAfter(2, e4) // insert after middle
+	checkListPointers(t, l, []*Element{e1, e4, e2, e3})
+	l.Remove(e2)
+	e2 = l.InsertAfter(2, e3) // insert after back
+	checkListPointers(t, l, []*Element{e1, e4, e3, e2})
+	l.Remove(e2)
 
-    // Check standard iteration.
-    sum := 0
-    for e := l.Front(); e != nil; e = e.Next() {
-        if i, ok := e.Value.(int); ok {
-            sum += i
-        }
-    }
-    if sum != 4 {
-        t.Errorf("sum over l = %d, want 4", sum)
-    }
+	// Check standard iteration.
+	sum := 0
+	for e := l.Front(); e != nil; e = e.Next() {
+		if i, ok := e.Value.(int); ok {
+			sum += i
+		}
+	}
+	if sum != 4 {
+		t.Errorf("sum over l = %d, want 4", sum)
+	}
 
-    // Clear all elements by iterating
-    var next *Element
-    for e := l.Front(); e != nil; e = next {
-        next = e.Next()
-        l.Remove(e)
-    }
-    checkListPointers(t, l, []*Element{})
+	// Clear all elements by iterating
+	var next *Element
+	for e := l.Front(); e != nil; e = next {
+		next = e.Next()
+		l.Remove(e)
+	}
+	checkListPointers(t, l, []*Element{})
 }
 
 func checkList(t *testing.T, l *List, es []interface{}) {
-    if !checkListLen(t, l, len(es)) {
-        return
-    }
+	if !checkListLen(t, l, len(es)) {
+		return
+	}
 
-    i := 0
-    for e := l.Front(); e != nil; e = e.Next() {
-        le := e.Value.(int)
-        if le != es[i] {
-            t.Errorf("elt[%d].Value() = %v, want %v", i, le, es[i])
-        }
-        i++
-    }
+	i := 0
+	for e := l.Front(); e != nil; e = e.Next() {
+
+		switch e.Value.(type) {
+		case int:
+			if le := e.Value.(int); le != es[i] {
+				t.Errorf("elt[%d].Value() = %v, want %v", i, le, es[i])
+			}
+			// default string
+		default:
+			if le := e.Value.(string); le != es[i] {
+				t.Errorf("elt[%v].Value() = %v, want %v", i, le, es[i])
+			}
+		}
+
+		i++
+	}
+
+	//for e := l.Front(); e != nil; e = e.Next() {
+	//	le := e.Value.(int)
+	//	if le != es[i] {
+	//		t.Errorf("elt[%d].Value() = %v, want %v", i, le, es[i])
+	//	}
+	//	i++
+	//}
 }
 
 func TestExtending(t *testing.T) {
-    l1 := New()
-    l2 := New()
+	l1 := New()
+	l2 := New()
 
-    l1.PushBack(1)
-    l1.PushBack(2)
-    l1.PushBack(3)
+	l1.PushBack(1)
+	l1.PushBack(2)
+	l1.PushBack(3)
 
-    l2.PushBack(4)
-    l2.PushBack(5)
+	l2.PushBack(4)
+	l2.PushBack(5)
 
-    l3 := New()
-    l3.PushBackList(l1)
-    checkList(t, l3, []interface{}{1, 2, 3})
-    l3.PushBackList(l2)
-    checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
+	l3 := New()
+	l3.PushBackList(l1)
+	checkList(t, l3, []interface{}{1, 2, 3})
+	l3.PushBackList(l2)
+	checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
 
-    l3 = New()
-    l3.PushFrontList(l2)
-    checkList(t, l3, []interface{}{4, 5})
-    l3.PushFrontList(l1)
-    checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
+	l3 = New()
+	l3.PushFrontList(l2)
+	checkList(t, l3, []interface{}{4, 5})
+	l3.PushFrontList(l1)
+	checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
 
-    checkList(t, l1, []interface{}{1, 2, 3})
-    checkList(t, l2, []interface{}{4, 5})
+	checkList(t, l1, []interface{}{1, 2, 3})
+	checkList(t, l2, []interface{}{4, 5})
 
-    l3 = New()
-    l3.PushBackList(l1)
-    checkList(t, l3, []interface{}{1, 2, 3})
-    l3.PushBackList(l3)
-    checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
+	l3 = New()
+	l3.PushBackList(l1)
+	checkList(t, l3, []interface{}{1, 2, 3})
+	l3.PushBackList(l3)
+	checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
 
-    l3 = New()
-    l3.PushFrontList(l1)
-    checkList(t, l3, []interface{}{1, 2, 3})
-    l3.PushFrontList(l3)
-    checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
+	l3 = New()
+	l3.PushFrontList(l1)
+	checkList(t, l3, []interface{}{1, 2, 3})
+	l3.PushFrontList(l3)
+	checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
 
-    l3 = New()
-    l1.PushBackList(l3)
-    checkList(t, l1, []interface{}{1, 2, 3})
-    l1.PushFrontList(l3)
-    checkList(t, l1, []interface{}{1, 2, 3})
+	l3 = New()
+	l1.PushBackList(l3)
+	checkList(t, l1, []interface{}{1, 2, 3})
+	l1.PushFrontList(l3)
+	checkList(t, l1, []interface{}{1, 2, 3})
 }
 
 func TestRemove(t *testing.T) {
-    l := New()
-    e1 := l.PushBack(1)
-    e2 := l.PushBack(2)
-    checkListPointers(t, l, []*Element{e1, e2})
-    //e := l.Front()
-    //l.Remove(e)
-    //checkListPointers(t, l, []*Element{e2})
-    //l.Remove(e)
-    //checkListPointers(t, l, []*Element{e2})
+	l := New()
+	e1 := l.PushBack(1)
+	e2 := l.PushBack(2)
+	checkListPointers(t, l, []*Element{e1, e2})
+	//e := l.Front()
+	//l.Remove(e)
+	//checkListPointers(t, l, []*Element{e2})
+	//l.Remove(e)
+	//checkListPointers(t, l, []*Element{e2})
 }
 
 func TestIssue4103(t *testing.T) {
-    l1 := New()
-    l1.PushBack(1)
-    l1.PushBack(2)
+	l1 := New()
+	l1.PushBack(1)
+	l1.PushBack(2)
 
-    l2 := New()
-    l2.PushBack(3)
-    l2.PushBack(4)
+	l2 := New()
+	l2.PushBack(3)
+	l2.PushBack(4)
 
-    e := l1.Front()
-    l2.Remove(e) // l2 should not change because e is not an element of l2
-    if n := l2.Len(); n != 2 {
-        t.Errorf("l2.Len() = %d, want 2", n)
-    }
+	e := l1.Front()
+	l2.Remove(e) // l2 should not change because e is not an element of l2
+	if n := l2.Len(); n != 2 {
+		t.Errorf("l2.Len() = %d, want 2", n)
+	}
 
-    l1.InsertBefore(8, e)
-    if n := l1.Len(); n != 3 {
-        t.Errorf("l1.Len() = %d, want 3", n)
-    }
+	l1.InsertBefore(8, e)
+	if n := l1.Len(); n != 3 {
+		t.Errorf("l1.Len() = %d, want 3", n)
+	}
 }
 
 func TestIssue6349(t *testing.T) {
-    l := New()
-    l.PushBack(1)
-    l.PushBack(2)
+	l := New()
+	l.PushBack(1)
+	l.PushBack(2)
 
-    e := l.Front()
-    l.Remove(e)
-    if e.Value != 1 {
-        t.Errorf("e.value = %d, want 1", e.Value)
-    }
-    //if e.Next() != nil {
-    //    t.Errorf("e.Next() != nil")
-    //}
-    //if e.Prev() != nil {
-    //    t.Errorf("e.Prev() != nil")
-    //}
+	e := l.Front()
+	l.Remove(e)
+	if e.Value != 1 {
+		t.Errorf("e.value = %d, want 1", e.Value)
+	}
+	//if e.Next() != nil {
+	//    t.Errorf("e.Next() != nil")
+	//}
+	//if e.Prev() != nil {
+	//    t.Errorf("e.Prev() != nil")
+	//}
 }
 
 func TestMove(t *testing.T) {
-    l := New()
-    e1 := l.PushBack(1)
-    e2 := l.PushBack(2)
-    e3 := l.PushBack(3)
-    e4 := l.PushBack(4)
+	l := New()
+	e1 := l.PushBack(1)
+	e2 := l.PushBack(2)
+	e3 := l.PushBack(3)
+	e4 := l.PushBack(4)
 
-    l.MoveAfter(e3, e3)
-    checkListPointers(t, l, []*Element{e1, e2, e3, e4})
-    l.MoveBefore(e2, e2)
-    checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+	l.MoveAfter(e3, e3)
+	checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+	l.MoveBefore(e2, e2)
+	checkListPointers(t, l, []*Element{e1, e2, e3, e4})
 
-    l.MoveAfter(e3, e2)
-    checkListPointers(t, l, []*Element{e1, e2, e3, e4})
-    l.MoveBefore(e2, e3)
-    checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+	l.MoveAfter(e3, e2)
+	checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+	l.MoveBefore(e2, e3)
+	checkListPointers(t, l, []*Element{e1, e2, e3, e4})
 
-    l.MoveBefore(e2, e4)
-    checkListPointers(t, l, []*Element{e1, e3, e2, e4})
-    e2, e3 = e3, e2
+	l.MoveBefore(e2, e4)
+	checkListPointers(t, l, []*Element{e1, e3, e2, e4})
+	e2, e3 = e3, e2
 
-    l.MoveBefore(e4, e1)
-    checkListPointers(t, l, []*Element{e4, e1, e2, e3})
-    e1, e2, e3, e4 = e4, e1, e2, e3
+	l.MoveBefore(e4, e1)
+	checkListPointers(t, l, []*Element{e4, e1, e2, e3})
+	e1, e2, e3, e4 = e4, e1, e2, e3
 
-    l.MoveAfter(e4, e1)
-    checkListPointers(t, l, []*Element{e1, e4, e2, e3})
-    e2, e3, e4 = e4, e2, e3
+	l.MoveAfter(e4, e1)
+	checkListPointers(t, l, []*Element{e1, e4, e2, e3})
+	e2, e3, e4 = e4, e2, e3
 
-    l.MoveAfter(e2, e3)
-    checkListPointers(t, l, []*Element{e1, e3, e2, e4})
-    e2, e3 = e3, e2
+	l.MoveAfter(e2, e3)
+	checkListPointers(t, l, []*Element{e1, e3, e2, e4})
+	e2, e3 = e3, e2
 }
 
 // Test PushFront, PushBack, PushFrontList, PushBackList with uninitialized List
 func TestZeroList(t *testing.T) {
-    var l1 = New()
-    l1.PushFront(1)
-    checkList(t, l1, []interface{}{1})
+	var l1 = New()
+	l1.PushFront(1)
+	checkList(t, l1, []interface{}{1})
 
-    var l2 = New()
-    l2.PushBack(1)
-    checkList(t, l2, []interface{}{1})
+	var l2 = New()
+	l2.PushBack(1)
+	checkList(t, l2, []interface{}{1})
 
-    var l3 = New()
-    l3.PushFrontList(l1)
-    checkList(t, l3, []interface{}{1})
+	var l3 = New()
+	l3.PushFrontList(l1)
+	checkList(t, l3, []interface{}{1})
 
-    var l4 = New()
-    l4.PushBackList(l2)
-    checkList(t, l4, []interface{}{1})
+	var l4 = New()
+	l4.PushBackList(l2)
+	checkList(t, l4, []interface{}{1})
 }
 
 // Test that a list l is not modified when calling InsertBefore with a mark that is not an element of l.
 func TestInsertBeforeUnknownMark(t *testing.T) {
-    l := New()
-    l.PushBack(1)
-    l.PushBack(2)
-    l.PushBack(3)
-    l.InsertBefore(1, new(Element))
-    checkList(t, l, []interface{}{1, 2, 3})
+	l := New()
+	l.PushBack(1)
+	l.PushBack(2)
+	l.PushBack(3)
+	l.InsertBefore(1, new(Element))
+	checkList(t, l, []interface{}{1, 2, 3})
 }
 
 // Test that a list l is not modified when calling InsertAfter with a mark that is not an element of l.
 func TestInsertAfterUnknownMark(t *testing.T) {
-    l := New()
-    l.PushBack(1)
-    l.PushBack(2)
-    l.PushBack(3)
-    l.InsertAfter(1, new(Element))
-    checkList(t, l, []interface{}{1, 2, 3})
+	l := New()
+	l.PushBack(1)
+	l.PushBack(2)
+	l.PushBack(3)
+	l.InsertAfter(1, new(Element))
+	checkList(t, l, []interface{}{1, 2, 3})
 }
 
 // Test that a list l is not modified when calling MoveAfter or MoveBefore with a mark that is not an element of l.
 func TestMoveUnknownMark(t *testing.T) {
-    l1 := New()
-    e1 := l1.PushBack(1)
+	l1 := New()
+	e1 := l1.PushBack(1)
 
-    l2 := New()
-    e2 := l2.PushBack(2)
+	l2 := New()
+	e2 := l2.PushBack(2)
 
-    l1.MoveAfter(e1, e2)
-    checkList(t, l1, []interface{}{1})
-    checkList(t, l2, []interface{}{2})
+	l1.MoveAfter(e1, e2)
+	checkList(t, l1, []interface{}{1})
+	checkList(t, l2, []interface{}{2})
 
-    l1.MoveBefore(e1, e2)
-    checkList(t, l1, []interface{}{1})
-    checkList(t, l2, []interface{}{2})
+	l1.MoveBefore(e1, e2)
+	checkList(t, l1, []interface{}{1})
+	checkList(t, l2, []interface{}{2})
 }
 
 func TestList_RemoveAll(t *testing.T) {
-    l := New()
-    l.PushBack(1)
-    l.RemoveAll()
-    checkList(t, l, []interface{}{})
-    l.PushBack(2)
-    checkList(t, l, []interface{}{2})
-}
+	l := New()
+	l.PushBack(1)
+	l.RemoveAll()
+	checkList(t, l, []interface{}{})
+	l.PushBack(2)
+	checkList(t, l, []interface{}{2})
+}
+
+func TestList_PushFronts(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2}
+	l.PushFronts(a1)
+	checkList(t, l, []interface{}{2, 1})
+	a1 = []interface{}{3, 4, 5}
+	l.PushFronts(a1)
+	checkList(t, l, []interface{}{5, 4, 3, 2, 1})
+}
+
+func TestList_PushBacks(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2}
+	l.PushBacks(a1)
+	checkList(t, l, []interface{}{1, 2})
+	a1 = []interface{}{3, 4, 5}
+	l.PushBacks(a1)
+	checkList(t, l, []interface{}{1, 2, 3, 4, 5})
+}
+
+func TestList_PopBacks(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	a2 := []interface{}{"a", "c", "b", "e"}
+	l.PushFronts(a1)
+	i1 := l.PopBacks(2)
+	gtest.Assert(i1, []interface{}{"1", "2"})
+
+	l.PushBacks(a2) //4.3,a,c,b,e
+	i1 = l.PopBacks(3)
+	gtest.Assert(i1, []interface{}{"e", "b", "c"})
+
+}
+
+func TestList_PopFronts(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.PopFronts(2)
+	gtest.Assert(i1, []interface{}{"4", "3"})
+	gtest.Assert(l.Len(), 2)
+}
+
+func TestList_PopBackAll(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.PopBackAll()
+	gtest.Assert(i1, []interface{}{1, 2, 3, 4})
+	gtest.Assert(l.Len(), 0)
+
+}
+
+func TestList_PopFrontAll(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.PopFrontAll()
+	gtest.Assert(i1, []interface{}{4, 3, 2, 1})
+	gtest.Assert(l.Len(), 0)
+}
+
+func TestList_FrontAll(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.FrontAll()
+	gtest.Assert(i1, []interface{}{4, 3, 2, 1})
+	gtest.Assert(l.Len(), 4)
+}
+
+func TestList_BackAll(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.BackAll()
+	gtest.Assert(i1, []interface{}{1, 2, 3, 4})
+	gtest.Assert(l.Len(), 4)
+}
+
+func TestList_FrontValue(t *testing.T) {
+	l := New()
+	l2 := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.FrontValue()
+	gtest.Assert(gconv.Int(i1), 4)
+	gtest.Assert(l.Len(), 4)
+
+	i1 = l2.FrontValue()
+	gtest.Assert(i1, nil)
+}
+
+func TestList_BackValue(t *testing.T) {
+	l := New()
+	l2 := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.BackValue()
+	gtest.Assert(gconv.Int(i1), 1)
+	gtest.Assert(l.Len(), 4)
+
+	i1 = l2.FrontValue()
+	gtest.Assert(i1, nil)
+
+}
+
+func TestList_Back(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	e1 := l.Back()
+	gtest.Assert(e1.Value, 1)
+	gtest.Assert(l.Len(), 4)
+}
+
+func TestList_Size(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	gtest.Assert(l.Size(), 4)
+	l.PopFront()
+	gtest.Assert(l.Size(), 3)
+}
+
+func TestList_Removes(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	e1 := l.Back()
+	l.Removes([]*Element{e1})
+	gtest.Assert(l.Len(), 3)
+
+	e2 := l.Back()
+	l.Removes([]*Element{e2})
+	gtest.Assert(l.Len(), 2)
+	checkList(t, l, []interface{}{4, 3})
+
+}
+
+func TestList_Clear(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	l.Clear()
+	gtest.Assert(l.Len(), 0)
+}
+
+func TestList_IteratorAsc(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 5, 6, 3, 4}
+	l.PushFronts(a1)
+	e1 := l.Back()
+	fun1 := func(e *Element) bool {
+		if gconv.Int(e1.Value) > 2 {
+			return true
+		}
+		return false
+	}
+	checkList(t, l, []interface{}{4, 3, 6, 5, 2, 1})
+	l.IteratorAsc(fun1)
+	checkList(t, l, []interface{}{4, 3, 6, 5, 2, 1})
+}
+
+func TestList_IteratorDesc(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	e1 := l.Back()
+	fun1 := func(e *Element) bool {
+		if gconv.Int(e1.Value) > 6 {
+			return true
+		}
+		return false
+	}
+	l.IteratorDesc(fun1)
+	gtest.Assert(l.Len(), 4)
+	checkList(t, l, []interface{}{4, 3, 2, 1})
+}
+
+func TestList_Iterator(t *testing.T) {
+	l := New()
+	a1 := []interface{}{"a", "b", "c", "d", "e"}
+	l.PushFronts(a1)
+	e1 := l.Back()
+	fun1 := func(e *Element) bool {
+		if gconv.String(e1.Value) > "c" {
+			return true
+		}
+		return false
+	}
+	checkList(t, l, []interface{}{"e", "d", "c", "b", "a"})
+	l.Iterator(fun1)
+	checkList(t, l, []interface{}{"e", "d", "c", "b", "a"})
+}

g/container/gmap/gmap.go

@@ -12,7 +12,7 @@ type Map     = AnyAnyMap
 type HashMap = AnyAnyMap
 
 // New returns an empty hash map.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func New(unsafe ...bool) *Map {
 	return NewAnyAnyMap(unsafe...)
@@ -21,14 +21,14 @@ func New(unsafe ...bool) *Map {
 // NewFrom returns a hash map from given map <data>.
 // Note that, the param <data> map will be set as the underlying data map(no deep copy),
 // there might be some concurrent-safe issues when changing the map outside.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
 func NewFrom(data map[interface{}]interface{}, unsafe...bool) *Map {
 	return NewAnyAnyMapFrom(data, unsafe...)
 }
 
 // NewHashMap returns an empty hash map.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func NewHashMap(unsafe ...bool) *Map {
 	return NewAnyAnyMap(unsafe...)
@@ -37,7 +37,7 @@ func NewHashMap(unsafe ...bool) *Map {
 // NewHashMapFrom returns a hash map from given map <data>.
 // Note that, the param <data> map will be set as the underlying data map(no deep copy),
 // there might be some concurrent-safe issues when changing the map outside.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
 func NewHashMapFrom(data map[interface{}]interface{}, unsafe...bool) *Map {
 	return NewAnyAnyMapFrom(data, unsafe...)

g/container/gmap/gmap_hash_any_any_map.go

@@ -17,7 +17,7 @@ type AnyAnyMap struct {
 }
 
 // NewAnyAnyMap returns an empty hash map.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func NewAnyAnyMap(unsafe ...bool) *AnyAnyMap {
 	return &AnyAnyMap{

g/container/gmap/gmap_hash_int_any_map.go

@@ -19,7 +19,7 @@ type IntAnyMap struct {
 }
 
 // NewIntAnyMap returns an empty IntAnyMap object.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func NewIntAnyMap(unsafe...bool) *IntAnyMap {
 	return &IntAnyMap{

g/container/gmap/gmap_hash_int_int_map.go

@@ -16,7 +16,7 @@ type IntIntMap struct {
 }
 
 // NewIntIntMap returns an empty IntIntMap object.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func NewIntIntMap(unsafe...bool) *IntIntMap {
 	return &IntIntMap{

g/container/gmap/gmap_hash_int_str_map.go

@@ -17,7 +17,7 @@ type IntStrMap struct {
 }
 
 // NewIntStrMap returns an empty IntStrMap object.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func NewIntStrMap(unsafe ...bool) *IntStrMap {
 	return &IntStrMap{

g/container/gmap/gmap_hash_str_any_map.go

@@ -19,7 +19,7 @@ type StrAnyMap struct {
 }
 
 // NewStrAnyMap returns an empty StrAnyMap object.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func NewStrAnyMap(unsafe ...bool) *StrAnyMap {
 	return &StrAnyMap{

g/container/gmap/gmap_hash_str_int_map.go

@@ -18,7 +18,7 @@ type StrIntMap struct {
 }
 
 // NewStrIntMap returns an empty StrIntMap object.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func NewStrIntMap(unsafe ...bool) *StrIntMap {
 	return &StrIntMap{

g/container/gmap/gmap_hash_str_str_map.go

@@ -17,7 +17,7 @@ type StrStrMap struct {
 }
 
 // NewStrStrMap returns an empty StrStrMap object.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func NewStrStrMap(unsafe...bool) *StrStrMap {
 	return &StrStrMap{

g/container/gmap/gmap_link_map.go

@@ -25,7 +25,7 @@ type gListMapNode struct {
 
 // NewListMap returns an empty link map.
 // ListMap is backed by a hash table to store values and doubly-linked list to store ordering.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func NewListMap(unsafe ...bool) *ListMap {
 	return &ListMap{

g/container/gmap/gmap_tree_map.go

@@ -14,7 +14,7 @@ import (
 type TreeMap = gtree.RedBlackTree
 
 // NewTreeMap instantiates a tree map with the custom comparator.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
 func NewTreeMap(comparator func(v1, v2 interface{}) int, unsafe...bool) *TreeMap {
 	return gtree.NewRedBlackTree(comparator, unsafe...)
@@ -23,7 +23,7 @@ func NewTreeMap(comparator func(v1, v2 interface{}) int, unsafe...bool) *TreeMap
 // NewTreeMapFrom instantiates a tree map with the custom comparator and <data> map.
 // Note that, the param <data> map will be set as the underlying data map(no deep copy),
 // there might be some concurrent-safe issues when changing the map outside.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
 func NewTreeMapFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, unsafe...bool) *TreeMap {
 	return gtree.NewRedBlackTreeFrom(comparator, data, unsafe...)

g/container/gpool/gpool_z_unit_test.go

@@ -0,0 +1,92 @@
+package gpool_test
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/g/container/gpool"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+var nf gpool.NewFunc = func() (i interface{}, e error) {
+	return "hello", nil
+}
+
+var assertIndex int = 0
+var ef gpool.ExpireFunc = func(i interface{}) {
+	assertIndex++
+	gtest.Assert(i, assertIndex)
+}
+
+func Test_Gpool(t *testing.T) {
+	gtest.Case(t, func() {
+		//
+		//expire = 0
+		p1 := gpool.New(0, nf)
+		p1.Put(1)
+		p1.Put(2)
+		time.Sleep(1 * time.Second)
+		//test won't be timeout
+		v1, err1 := p1.Get()
+		gtest.Assert(err1, nil)
+		gtest.Assert(v1, 1)
+		//test clear
+		p1.Clear()
+		gtest.Assert(p1.Size(), 0)
+		//test newFunc
+		v1, err1 = p1.Get()
+		gtest.Assert(err1, nil)
+		gtest.Assert(v1, "hello")
+		//put data again
+		p1.Put(3)
+		p1.Put(4)
+		v1, err1 = p1.Get()
+		gtest.Assert(err1, nil)
+		gtest.Assert(v1, 3)
+		//test close
+		p1.Close()
+		v1, err1 = p1.Get()
+		gtest.Assert(err1, nil)
+		gtest.Assert(v1, "hello")
+
+	})
+
+	gtest.Case(t, func() {
+		//
+		//expire > 0
+		p2 := gpool.New(2000, nil, ef)
+		for index := 0; index < 10; index++ {
+			p2.Put(index)
+		}
+		gtest.Assert(p2.Size(), 10)
+		v2, err2 := p2.Get()
+		gtest.Assert(err2, nil)
+		gtest.Assert(v2, 0)
+		//test timeout expireFunc
+		time.Sleep(3 * time.Second)
+		v2, err2 = p2.Get()
+		gtest.Assert(err2, errors.New("pool is empty"))
+		gtest.Assert(v2, nil)
+		//test close expireFunc
+		for index := 0; index < 10; index++ {
+			p2.Put(index)
+		}
+		gtest.Assert(p2.Size(), 10)
+		v2, err2 = p2.Get()
+		gtest.Assert(err2, nil)
+		gtest.Assert(v2, 0)
+		assertIndex = 0
+		p2.Close()
+		time.Sleep(3 * time.Second)
+	})
+
+	gtest.Case(t, func() {
+		//
+		//expire < 0
+		p3 := gpool.New(-1, nil)
+		v3, err3 := p3.Get()
+		gtest.Assert(err3, errors.New("pool is empty"))
+		gtest.Assert(v3, nil)
+	})
+}

g/container/gqueue/gqueue.go

@@ -110,9 +110,16 @@ func (q *Queue) Close() {
     close(q.closed)
 }
 
-// Size returns the length of the queue.
-func (q *Queue) Size() int {
-    return len(q.C) + q.list.Len()
+// Len returns the length of the queue.
+func (q *Queue) Len() (length int) {
+	if q.list != nil {
+		length += q.list.Len()
+	}
+	length += len(q.C)
+    return
 }
 
-
+// Size is alias of Len.
+func (q *Queue) Size() int {
+	return q.Len()
+}

g/container/gset/gset.go

@@ -19,7 +19,7 @@ type Set struct {
 }
 
 // New create and returns a new set, which contains un-repeated items.
-// The param <unsafe> used to specify whether using set in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using set in un-concurrent-safety,
 // which is false in default.
 func New(unsafe...bool) *Set {
     return NewSet(unsafe...)

g/container/gset/gset_int_set.go

@@ -19,7 +19,7 @@ type IntSet struct {
 }
 
 // New create and returns a new set, which contains un-repeated items.
-// The param <unsafe> used to specify whether using set in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using set in un-concurrent-safety,
 // which is false in default.
 func NewIntSet(unsafe...bool) *IntSet {
 	return &IntSet{

g/container/gset/gset_string_set.go

@@ -19,7 +19,7 @@ type StringSet struct {
 }
 
 // New create and returns a new set, which contains un-repeated items.
-// The param <unsafe> used to specify whether using set in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using set in un-concurrent-safety,
 // which is false in default.
 func NewStringSet(unsafe...bool) *StringSet {
 	return &StringSet {

g/container/gset/gset_z_unit_int_test.go

@@ -9,152 +9,208 @@
 package gset_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/container/gset"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/container/gset"
+	"github.com/gogf/gf/g/test/gtest"
+	"strings"
+	"testing"
 )
 
 func TestIntSet_Basic(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewIntSet()
-        s.Add(1).Add(1).Add(2)
-        s.Add([]int{3,4}...)
-        gtest.Assert(s.Size(), 4)
-        gtest.AssertIN(1, s.Slice())
-        gtest.AssertIN(2, s.Slice())
-        gtest.AssertIN(3, s.Slice())
-        gtest.AssertIN(4, s.Slice())
-        gtest.AssertNI(0, s.Slice())
-        gtest.Assert(s.Contains(4), true)
-        gtest.Assert(s.Contains(5), false)
-        s.Remove(1)
-        gtest.Assert(s.Size(), 3)
-        s.Clear()
-        gtest.Assert(s.Size(), 0)
-    })
+	gtest.Case(t, func() {
+		s := gset.NewIntSet()
+		s.Add(1).Add(1).Add(2)
+		s.Add([]int{3, 4}...)
+		gtest.Assert(s.Size(), 4)
+		gtest.AssertIN(1, s.Slice())
+		gtest.AssertIN(2, s.Slice())
+		gtest.AssertIN(3, s.Slice())
+		gtest.AssertIN(4, s.Slice())
+		gtest.AssertNI(0, s.Slice())
+		gtest.Assert(s.Contains(4), true)
+		gtest.Assert(s.Contains(5), false)
+		s.Remove(1)
+		gtest.Assert(s.Size(), 3)
+		s.Clear()
+		gtest.Assert(s.Size(), 0)
+	})
 }
 
 func TestIntSet_Iterator(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewIntSet()
-        s.Add(1).Add(2).Add(3)
-        gtest.Assert(s.Size(), 3)
+	gtest.Case(t, func() {
+		s := gset.NewIntSet()
+		s.Add(1).Add(2).Add(3)
+		gtest.Assert(s.Size(), 3)
 
-        a1 := garray.New()
-        a2 := garray.New()
-        s.Iterator(func(v int) bool {
-            a1.Append(1)
-            return false
-        })
-        s.Iterator(func(v int) bool {
-            a2.Append(1)
-            return true
-        })
-        gtest.Assert(a1.Len(), 1)
-        gtest.Assert(a2.Len(), 3)
-    })
+		a1 := garray.New()
+		a2 := garray.New()
+		s.Iterator(func(v int) bool {
+			a1.Append(1)
+			return false
+		})
+		s.Iterator(func(v int) bool {
+			a2.Append(1)
+			return true
+		})
+		gtest.Assert(a1.Len(), 1)
+		gtest.Assert(a2.Len(), 3)
+	})
 }
 
 func TestIntSet_LockFunc(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewIntSet()
-        s.Add(1).Add(2).Add(3)
-        gtest.Assert(s.Size(), 3)
-        s.LockFunc(func(m map[int]struct{}) {
-            delete(m, 1)
-        })
-        gtest.Assert(s.Size(), 2)
-        s.RLockFunc(func(m map[int]struct{}) {
-            gtest.Assert(m, map[int]struct{}{
-                3 : struct{}{},
-                2 : struct{}{},
-            })
-        })
-    })
+	gtest.Case(t, func() {
+		s := gset.NewIntSet()
+		s.Add(1).Add(2).Add(3)
+		gtest.Assert(s.Size(), 3)
+		s.LockFunc(func(m map[int]struct{}) {
+			delete(m, 1)
+		})
+		gtest.Assert(s.Size(), 2)
+		s.RLockFunc(func(m map[int]struct{}) {
+			gtest.Assert(m, map[int]struct{}{
+				3: struct{}{},
+				2: struct{}{},
+			})
+		})
+	})
 }
 
 func TestIntSet_Equal(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewIntSet()
-        s2 := gset.NewIntSet()
-        s3 := gset.NewIntSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(1).Add(2).Add(3)
-        s3.Add(1).Add(2).Add(3).Add(4)
-        gtest.Assert(s1.Equal(s2), true)
-        gtest.Assert(s1.Equal(s3), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s3 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(1).Add(2).Add(3)
+		s3.Add(1).Add(2).Add(3).Add(4)
+		gtest.Assert(s1.Equal(s2), true)
+		gtest.Assert(s1.Equal(s3), false)
+	})
 }
 
 func TestIntSet_IsSubsetOf(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewIntSet()
-        s2 := gset.NewIntSet()
-        s3 := gset.NewIntSet()
-        s1.Add(1).Add(2)
-        s2.Add(1).Add(2).Add(3)
-        s3.Add(1).Add(2).Add(3).Add(4)
-        gtest.Assert(s1.IsSubsetOf(s2), true)
-        gtest.Assert(s2.IsSubsetOf(s3), true)
-        gtest.Assert(s1.IsSubsetOf(s3), true)
-        gtest.Assert(s2.IsSubsetOf(s1), false)
-        gtest.Assert(s3.IsSubsetOf(s2), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s3 := gset.NewIntSet()
+		s1.Add(1).Add(2)
+		s2.Add(1).Add(2).Add(3)
+		s3.Add(1).Add(2).Add(3).Add(4)
+		gtest.Assert(s1.IsSubsetOf(s2), true)
+		gtest.Assert(s2.IsSubsetOf(s3), true)
+		gtest.Assert(s1.IsSubsetOf(s3), true)
+		gtest.Assert(s2.IsSubsetOf(s1), false)
+		gtest.Assert(s3.IsSubsetOf(s2), false)
+	})
 }
 
 func TestIntSet_Union(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewIntSet()
-        s2 := gset.NewIntSet()
-        s1.Add(1).Add(2)
-        s2.Add(3).Add(4)
-        s3 := s1.Union(s2)
-        gtest.Assert(s3.Contains(1), true)
-        gtest.Assert(s3.Contains(2), true)
-        gtest.Assert(s3.Contains(3), true)
-        gtest.Assert(s3.Contains(4), true)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s1.Add(1).Add(2)
+		s2.Add(3).Add(4)
+		s3 := s1.Union(s2)
+		gtest.Assert(s3.Contains(1), true)
+		gtest.Assert(s3.Contains(2), true)
+		gtest.Assert(s3.Contains(3), true)
+		gtest.Assert(s3.Contains(4), true)
+	})
 }
 
 func TestIntSet_Diff(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewIntSet()
-        s2 := gset.NewIntSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(3).Add(4).Add(5)
-        s3 := s1.Diff(s2)
-        gtest.Assert(s3.Contains(1), true)
-        gtest.Assert(s3.Contains(2), true)
-        gtest.Assert(s3.Contains(3), false)
-        gtest.Assert(s3.Contains(4), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Diff(s2)
+		gtest.Assert(s3.Contains(1), true)
+		gtest.Assert(s3.Contains(2), true)
+		gtest.Assert(s3.Contains(3), false)
+		gtest.Assert(s3.Contains(4), false)
+	})
 }
 
 func TestIntSet_Intersect(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewIntSet()
-        s2 := gset.NewIntSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(3).Add(4).Add(5)
-        s3 := s1.Intersect(s2)
-        gtest.Assert(s3.Contains(1), false)
-        gtest.Assert(s3.Contains(2), false)
-        gtest.Assert(s3.Contains(3), true)
-        gtest.Assert(s3.Contains(4), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Intersect(s2)
+		gtest.Assert(s3.Contains(1), false)
+		gtest.Assert(s3.Contains(2), false)
+		gtest.Assert(s3.Contains(3), true)
+		gtest.Assert(s3.Contains(4), false)
+	})
 }
 
 func TestIntSet_Complement(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewIntSet()
-        s2 := gset.NewIntSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(3).Add(4).Add(5)
-        s3 := s1.Complement(s2)
-        gtest.Assert(s3.Contains(1), false)
-        gtest.Assert(s3.Contains(2), false)
-        gtest.Assert(s3.Contains(4), true)
-        gtest.Assert(s3.Contains(5), true)
-    })
-}
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Complement(s2)
+		gtest.Assert(s3.Contains(1), false)
+		gtest.Assert(s3.Contains(2), false)
+		gtest.Assert(s3.Contains(4), true)
+		gtest.Assert(s3.Contains(5), true)
+	})
+}
+
+func TestIntSet_Size(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet(true)
+		s1.Add(1).Add(2).Add(3)
+		gtest.Assert(s1.Size(), 3)
+
+	})
+
+}
+
+func TestIntSet_Merge(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Merge(s2)
+		gtest.Assert(s3.Contains(1), true)
+		gtest.Assert(s3.Contains(5), true)
+		gtest.Assert(s3.Contains(6), false)
+	})
+}
+
+func TestIntSet_Join(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s3 := s1.Join(",")
+		gtest.Assert(strings.Contains(s3, "3"), true)
+
+	})
+}
+
+func TestIntSet_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s2 := gset.NewIntSet()
+		s2.Add(5).Add(6).Add(7)
+		gtest.Assert(s2.Sum(), 18)
+
+	})
+
+}
+
+func TestIntSet_Pop(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s1.Add(4).Add(2).Add(3)
+		gtest.AssertIN(s1.Pop(1), []int{4, 2, 3})
+		gtest.AssertIN(s1.Pop(5), []int{4, 2, 3})
+		gtest.Assert(s1.Size(), 3)
+	})
+}

g/container/gset/gset_z_unit_string_test.go

@@ -9,152 +9,248 @@
 package gset_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/container/gset"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/container/gset"
+	"github.com/gogf/gf/g/test/gtest"
+	"strings"
+	"testing"
 )
 
 func TestStringSet_Basic(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewStringSet()
-        s.Add("1").Add("1").Add("2")
-        s.Add([]string{"3","4"}...)
-        gtest.Assert(s.Size(), 4)
-        gtest.AssertIN("1", s.Slice())
-        gtest.AssertIN("2", s.Slice())
-        gtest.AssertIN("3", s.Slice())
-        gtest.AssertIN("4", s.Slice())
-        gtest.AssertNI("0", s.Slice())
-        gtest.Assert(s.Contains("4"), true)
-        gtest.Assert(s.Contains("5"), false)
-        s.Remove("1")
-        gtest.Assert(s.Size(), 3)
-        s.Clear()
-        gtest.Assert(s.Size(), 0)
-    })
+	gtest.Case(t, func() {
+		s := gset.NewStringSet()
+		s.Add("1").Add("1").Add("2")
+		s.Add([]string{"3", "4"}...)
+		gtest.Assert(s.Size(), 4)
+		gtest.AssertIN("1", s.Slice())
+		gtest.AssertIN("2", s.Slice())
+		gtest.AssertIN("3", s.Slice())
+		gtest.AssertIN("4", s.Slice())
+		gtest.AssertNI("0", s.Slice())
+		gtest.Assert(s.Contains("4"), true)
+		gtest.Assert(s.Contains("5"), false)
+		s.Remove("1")
+		gtest.Assert(s.Size(), 3)
+		s.Clear()
+		gtest.Assert(s.Size(), 0)
+	})
 }
 
 func TestStringSet_Iterator(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewStringSet()
-        s.Add("1").Add("2").Add("3")
-        gtest.Assert(s.Size(), 3)
+	gtest.Case(t, func() {
+		s := gset.NewStringSet()
+		s.Add("1").Add("2").Add("3")
+		gtest.Assert(s.Size(), 3)
 
-        a1 := garray.New()
-        a2 := garray.New()
-        s.Iterator(func(v string) bool {
-            a1.Append("1")
-            return false
-        })
-        s.Iterator(func(v string) bool {
-            a2.Append("1")
-            return true
-        })
-        gtest.Assert(a1.Len(), 1)
-        gtest.Assert(a2.Len(), 3)
-    })
+		a1 := garray.New()
+		a2 := garray.New()
+		s.Iterator(func(v string) bool {
+			a1.Append("1")
+			return false
+		})
+		s.Iterator(func(v string) bool {
+			a2.Append("1")
+			return true
+		})
+		gtest.Assert(a1.Len(), 1)
+		gtest.Assert(a2.Len(), 3)
+	})
 }
 
 func TestStringSet_LockFunc(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewStringSet()
-        s.Add("1").Add("2").Add("3")
-        gtest.Assert(s.Size(), 3)
-        s.LockFunc(func(m map[string]struct{}) {
-            delete(m, "1")
-        })
-        gtest.Assert(s.Size(), 2)
-        s.RLockFunc(func(m map[string]struct{}) {
-            gtest.Assert(m, map[string]struct{}{
-                "3" : struct{}{},
-                "2" : struct{}{},
-            })
-        })
-    })
+	gtest.Case(t, func() {
+		s := gset.NewStringSet()
+		s.Add("1").Add("2").Add("3")
+		gtest.Assert(s.Size(), 3)
+		s.LockFunc(func(m map[string]struct{}) {
+			delete(m, "1")
+		})
+		gtest.Assert(s.Size(), 2)
+		s.RLockFunc(func(m map[string]struct{}) {
+			gtest.Assert(m, map[string]struct{}{
+				"3": struct{}{},
+				"2": struct{}{},
+			})
+		})
+	})
 }
 
 func TestStringSet_Equal(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewStringSet()
-        s2 := gset.NewStringSet()
-        s3 := gset.NewStringSet()
-        s1.Add("1").Add("2").Add("3")
-        s2.Add("1").Add("2").Add("3")
-        s3.Add("1").Add("2").Add("3").Add("4")
-        gtest.Assert(s1.Equal(s2), true)
-        gtest.Assert(s1.Equal(s3), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s3 := gset.NewStringSet()
+		s1.Add("1").Add("2").Add("3")
+		s2.Add("1").Add("2").Add("3")
+		s3.Add("1").Add("2").Add("3").Add("4")
+		gtest.Assert(s1.Equal(s2), true)
+		gtest.Assert(s1.Equal(s3), false)
+	})
 }
 
 func TestStringSet_IsSubsetOf(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewStringSet()
-        s2 := gset.NewStringSet()
-        s3 := gset.NewStringSet()
-        s1.Add("1").Add("2")
-        s2.Add("1").Add("2").Add("3")
-        s3.Add("1").Add("2").Add("3").Add("4")
-        gtest.Assert(s1.IsSubsetOf(s2), true)
-        gtest.Assert(s2.IsSubsetOf(s3), true)
-        gtest.Assert(s1.IsSubsetOf(s3), true)
-        gtest.Assert(s2.IsSubsetOf(s1), false)
-        gtest.Assert(s3.IsSubsetOf(s2), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s3 := gset.NewStringSet()
+		s1.Add("1").Add("2")
+		s2.Add("1").Add("2").Add("3")
+		s3.Add("1").Add("2").Add("3").Add("4")
+		gtest.Assert(s1.IsSubsetOf(s2), true)
+		gtest.Assert(s2.IsSubsetOf(s3), true)
+		gtest.Assert(s1.IsSubsetOf(s3), true)
+		gtest.Assert(s2.IsSubsetOf(s1), false)
+		gtest.Assert(s3.IsSubsetOf(s2), false)
+	})
 }
 
 func TestStringSet_Union(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewStringSet()
-        s2 := gset.NewStringSet()
-        s1.Add("1").Add("2")
-        s2.Add("3").Add("4")
-        s3 := s1.Union(s2)
-        gtest.Assert(s3.Contains("1"), true)
-        gtest.Assert(s3.Contains("2"), true)
-        gtest.Assert(s3.Contains("3"), true)
-        gtest.Assert(s3.Contains("4"), true)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s1.Add("1").Add("2")
+		s2.Add("3").Add("4")
+		s3 := s1.Union(s2)
+		gtest.Assert(s3.Contains("1"), true)
+		gtest.Assert(s3.Contains("2"), true)
+		gtest.Assert(s3.Contains("3"), true)
+		gtest.Assert(s3.Contains("4"), true)
+	})
 }
 
 func TestStringSet_Diff(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewStringSet()
-        s2 := gset.NewStringSet()
-        s1.Add("1").Add("2").Add("3")
-        s2.Add("3").Add("4").Add("5")
-        s3 := s1.Diff(s2)
-        gtest.Assert(s3.Contains("1"), true)
-        gtest.Assert(s3.Contains("2"), true)
-        gtest.Assert(s3.Contains("3"), false)
-        gtest.Assert(s3.Contains("4"), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s1.Add("1").Add("2").Add("3")
+		s2.Add("3").Add("4").Add("5")
+		s3 := s1.Diff(s2)
+		gtest.Assert(s3.Contains("1"), true)
+		gtest.Assert(s3.Contains("2"), true)
+		gtest.Assert(s3.Contains("3"), false)
+		gtest.Assert(s3.Contains("4"), false)
+	})
 }
 
 func TestStringSet_Intersect(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewStringSet()
-        s2 := gset.NewStringSet()
-        s1.Add("1").Add("2").Add("3")
-        s2.Add("3").Add("4").Add("5")
-        s3 := s1.Intersect(s2)
-        gtest.Assert(s3.Contains("1"), false)
-        gtest.Assert(s3.Contains("2"), false)
-        gtest.Assert(s3.Contains("3"), true)
-        gtest.Assert(s3.Contains("4"), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s1.Add("1").Add("2").Add("3")
+		s2.Add("3").Add("4").Add("5")
+		s3 := s1.Intersect(s2)
+		gtest.Assert(s3.Contains("1"), false)
+		gtest.Assert(s3.Contains("2"), false)
+		gtest.Assert(s3.Contains("3"), true)
+		gtest.Assert(s3.Contains("4"), false)
+	})
 }
 
 func TestStringSet_Complement(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewStringSet()
-        s2 := gset.NewStringSet()
-        s1.Add("1").Add("2").Add("3")
-        s2.Add("3").Add("4").Add("5")
-        s3 := s1.Complement(s2)
-        gtest.Assert(s3.Contains("1"), false)
-        gtest.Assert(s3.Contains("2"), false)
-        gtest.Assert(s3.Contains("4"), true)
-        gtest.Assert(s3.Contains("5"), true)
-    })
-}
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s1.Add("1").Add("2").Add("3")
+		s2.Add("3").Add("4").Add("5")
+		s3 := s1.Complement(s2)
+		gtest.Assert(s3.Contains("1"), false)
+		gtest.Assert(s3.Contains("2"), false)
+		gtest.Assert(s3.Contains("4"), true)
+		gtest.Assert(s3.Contains("5"), true)
+	})
+}
+
+func TestNewIntSetFrom(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSetFrom([]int{1, 2, 3, 4})
+		s2 := gset.NewIntSetFrom([]int{5, 6, 7, 8})
+		gtest.Assert(s1.Contains(3), true)
+		gtest.Assert(s1.Contains(5), false)
+		gtest.Assert(s2.Contains(3), false)
+		gtest.Assert(s2.Contains(5), true)
+	})
+}
+
+func TestStringSet_Merge(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s1.Add("1").Add("2").Add("3")
+		s2.Add("3").Add("4").Add("5")
+		s3 := s1.Merge(s2)
+		gtest.Assert(s3.Contains("1"), true)
+		gtest.Assert(s3.Contains("6"), false)
+		gtest.Assert(s3.Contains("4"), true)
+		gtest.Assert(s3.Contains("5"), true)
+	})
+}
+
+func TestNewStringSetFrom(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		gtest.Assert(s1.Contains("b"), true)
+		gtest.Assert(s1.Contains("d"), false)
+	})
+}
+
+func TestStringSet_Join(t *testing.T) {
+	s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+	str1 := s1.Join(",")
+	gtest.Assert(strings.Contains(str1, "b"), true)
+	gtest.Assert(strings.Contains(str1, "d"), false)
+}
+
+func TestStringSet_String(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		str1 := s1.String()
+		gtest.Assert(strings.Contains(str1, "b"), true)
+		gtest.Assert(strings.Contains(str1, "d"), false)
+	})
+
+}
+
+func TestStringSet_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		s2 := gset.NewIntSetFrom([]int{2, 3, 4}, true)
+		gtest.Assert(s1.Sum(), 0)
+		gtest.Assert(s2.Sum(), 9)
+	})
+}
+
+func TestStringSet_Size(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		gtest.Assert(s1.Size(), 3)
+
+	})
+}
+
+func TestStringSet_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		s1 = s1.Remove("b")
+		gtest.Assert(s1.Contains("b"), false)
+		gtest.Assert(s1.Contains("c"), true)
+	})
+}
+
+func TestStringSet_Pop(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		str1 := s1.Pop(1)
+		gtest.Assert(strings.Contains("a,b,c", str1), true)
+	})
+}
+
+func TestStringSet_Pops(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		strs1 := s1.Pops(2)
+		gtest.AssertIN(strs1, []string{"a", "b", "c"})
+		gtest.Assert(len(strs1), 2)
+		str2 := s1.Pops(7)
+		gtest.AssertIN(str2, []string{"a", "b", "c"})
+	})
+}

g/container/gset/gset_z_unit_test.go

@@ -9,152 +9,260 @@
 package gset_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/container/gset"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/container/gset"
+	"github.com/gogf/gf/g/test/gtest"
+	"strings"
+
+	"testing"
 )
 
+func TestSet_New(t *testing.T) {
+	gtest.Case(t, func() {
+		s := gset.New()
+		s.Add(1).Add(1).Add(2)
+		s.Add([]interface{}{3, 4}...)
+		gtest.Assert(s.Size(), 4)
+		gtest.AssertIN(1, s.Slice())
+		gtest.AssertIN(2, s.Slice())
+		gtest.AssertIN(3, s.Slice())
+		gtest.AssertIN(4, s.Slice())
+		gtest.AssertNI(0, s.Slice())
+		gtest.Assert(s.Contains(4), true)
+		gtest.Assert(s.Contains(5), false)
+		s.Remove(1)
+		gtest.Assert(s.Size(), 3)
+		s.Clear()
+		gtest.Assert(s.Size(), 0)
+	})
+}
+
 func TestSet_Basic(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewSet()
-        s.Add(1).Add(1).Add(2)
-        s.Add([]interface{}{3,4}...)
-        gtest.Assert(s.Size(), 4)
-        gtest.AssertIN(1, s.Slice())
-        gtest.AssertIN(2, s.Slice())
-        gtest.AssertIN(3, s.Slice())
-        gtest.AssertIN(4, s.Slice())
-        gtest.AssertNI(0, s.Slice())
-        gtest.Assert(s.Contains(4), true)
-        gtest.Assert(s.Contains(5), false)
-        s.Remove(1)
-        gtest.Assert(s.Size(), 3)
-        s.Clear()
-        gtest.Assert(s.Size(), 0)
-    })
+	gtest.Case(t, func() {
+		s := gset.NewSet()
+		s.Add(1).Add(1).Add(2)
+		s.Add([]interface{}{3, 4}...)
+		gtest.Assert(s.Size(), 4)
+		gtest.AssertIN(1, s.Slice())
+		gtest.AssertIN(2, s.Slice())
+		gtest.AssertIN(3, s.Slice())
+		gtest.AssertIN(4, s.Slice())
+		gtest.AssertNI(0, s.Slice())
+		gtest.Assert(s.Contains(4), true)
+		gtest.Assert(s.Contains(5), false)
+		s.Remove(1)
+		gtest.Assert(s.Size(), 3)
+		s.Clear()
+		gtest.Assert(s.Size(), 0)
+	})
 }
 
 func TestSet_Iterator(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewSet()
-        s.Add(1).Add(2).Add(3)
-        gtest.Assert(s.Size(), 3)
+	gtest.Case(t, func() {
+		s := gset.NewSet()
+		s.Add(1).Add(2).Add(3)
+		gtest.Assert(s.Size(), 3)
 
-        a1 := garray.New()
-        a2 := garray.New()
-        s.Iterator(func(v interface{}) bool {
-            a1.Append(1)
-            return false
-        })
-        s.Iterator(func(v interface{}) bool {
-            a2.Append(1)
-            return true
-        })
-        gtest.Assert(a1.Len(), 1)
-        gtest.Assert(a2.Len(), 3)
-    })
+		a1 := garray.New()
+		a2 := garray.New()
+		s.Iterator(func(v interface{}) bool {
+			a1.Append(1)
+			return false
+		})
+		s.Iterator(func(v interface{}) bool {
+			a2.Append(1)
+			return true
+		})
+		gtest.Assert(a1.Len(), 1)
+		gtest.Assert(a2.Len(), 3)
+	})
 }
 
 func TestSet_LockFunc(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewSet()
-        s.Add(1).Add(2).Add(3)
-        gtest.Assert(s.Size(), 3)
-        s.LockFunc(func(m map[interface{}]struct{}) {
-            delete(m, 1)
-        })
-        gtest.Assert(s.Size(), 2)
-        s.RLockFunc(func(m map[interface{}]struct{}) {
-            gtest.Assert(m, map[interface{}]struct{}{
-                3 : struct{}{},
-                2 : struct{}{},
-            })
-        })
-    })
+	gtest.Case(t, func() {
+		s := gset.NewSet()
+		s.Add(1).Add(2).Add(3)
+		gtest.Assert(s.Size(), 3)
+		s.LockFunc(func(m map[interface{}]struct{}) {
+			delete(m, 1)
+		})
+		gtest.Assert(s.Size(), 2)
+		s.RLockFunc(func(m map[interface{}]struct{}) {
+			gtest.Assert(m, map[interface{}]struct{}{
+				3: struct{}{},
+				2: struct{}{},
+			})
+		})
+	})
 }
 
 func TestSet_Equal(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewSet()
-        s2 := gset.NewSet()
-        s3 := gset.NewSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(1).Add(2).Add(3)
-        s3.Add(1).Add(2).Add(3).Add(4)
-        gtest.Assert(s1.Equal(s2), true)
-        gtest.Assert(s1.Equal(s3), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s3 := gset.NewSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(1).Add(2).Add(3)
+		s3.Add(1).Add(2).Add(3).Add(4)
+		gtest.Assert(s1.Equal(s2), true)
+		gtest.Assert(s1.Equal(s3), false)
+	})
 }
 
 func TestSet_IsSubsetOf(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewSet()
-        s2 := gset.NewSet()
-        s3 := gset.NewSet()
-        s1.Add(1).Add(2)
-        s2.Add(1).Add(2).Add(3)
-        s3.Add(1).Add(2).Add(3).Add(4)
-        gtest.Assert(s1.IsSubsetOf(s2), true)
-        gtest.Assert(s2.IsSubsetOf(s3), true)
-        gtest.Assert(s1.IsSubsetOf(s3), true)
-        gtest.Assert(s2.IsSubsetOf(s1), false)
-        gtest.Assert(s3.IsSubsetOf(s2), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s3 := gset.NewSet()
+		s1.Add(1).Add(2)
+		s2.Add(1).Add(2).Add(3)
+		s3.Add(1).Add(2).Add(3).Add(4)
+		gtest.Assert(s1.IsSubsetOf(s2), true)
+		gtest.Assert(s2.IsSubsetOf(s3), true)
+		gtest.Assert(s1.IsSubsetOf(s3), true)
+		gtest.Assert(s2.IsSubsetOf(s1), false)
+		gtest.Assert(s3.IsSubsetOf(s2), false)
+	})
 }
 
 func TestSet_Union(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewSet()
-        s2 := gset.NewSet()
-        s1.Add(1).Add(2)
-        s2.Add(3).Add(4)
-        s3 := s1.Union(s2)
-        gtest.Assert(s3.Contains(1), true)
-        gtest.Assert(s3.Contains(2), true)
-        gtest.Assert(s3.Contains(3), true)
-        gtest.Assert(s3.Contains(4), true)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s1.Add(1).Add(2)
+		s2.Add(3).Add(4)
+		s3 := s1.Union(s2)
+		gtest.Assert(s3.Contains(1), true)
+		gtest.Assert(s3.Contains(2), true)
+		gtest.Assert(s3.Contains(3), true)
+		gtest.Assert(s3.Contains(4), true)
+	})
 }
 
 func TestSet_Diff(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewSet()
-        s2 := gset.NewSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(3).Add(4).Add(5)
-        s3 := s1.Diff(s2)
-        gtest.Assert(s3.Contains(1), true)
-        gtest.Assert(s3.Contains(2), true)
-        gtest.Assert(s3.Contains(3), false)
-        gtest.Assert(s3.Contains(4), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Diff(s2)
+		gtest.Assert(s3.Contains(1), true)
+		gtest.Assert(s3.Contains(2), true)
+		gtest.Assert(s3.Contains(3), false)
+		gtest.Assert(s3.Contains(4), false)
+	})
 }
 
 func TestSet_Intersect(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewSet()
-        s2 := gset.NewSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(3).Add(4).Add(5)
-        s3 := s1.Intersect(s2)
-        gtest.Assert(s3.Contains(1), false)
-        gtest.Assert(s3.Contains(2), false)
-        gtest.Assert(s3.Contains(3), true)
-        gtest.Assert(s3.Contains(4), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Intersect(s2)
+		gtest.Assert(s3.Contains(1), false)
+		gtest.Assert(s3.Contains(2), false)
+		gtest.Assert(s3.Contains(3), true)
+		gtest.Assert(s3.Contains(4), false)
+	})
 }
 
 func TestSet_Complement(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewSet()
-        s2 := gset.NewSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(3).Add(4).Add(5)
-        s3 := s1.Complement(s2)
-        gtest.Assert(s3.Contains(1), false)
-        gtest.Assert(s3.Contains(2), false)
-        gtest.Assert(s3.Contains(4), true)
-        gtest.Assert(s3.Contains(5), true)
-    })
-}
+	gtest.Case(t, func() {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Complement(s2)
+		gtest.Assert(s3.Contains(1), false)
+		gtest.Assert(s3.Contains(2), false)
+		gtest.Assert(s3.Contains(4), true)
+		gtest.Assert(s3.Contains(5), true)
+	})
+}
+
+func TestNewFrom(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewFrom("a")
+		s2 := gset.NewFrom("b", false)
+		s3 := gset.NewFrom(3, true)
+		s4 := gset.NewFrom([]string{"s1", "s2"}, true)
+		gtest.Assert(s1.Contains("a"), true)
+		gtest.Assert(s2.Contains("b"), true)
+		gtest.Assert(s3.Contains(3), true)
+		gtest.Assert(s4.Contains("s1"), true)
+		gtest.Assert(s4.Contains("s3"), false)
+
+	})
+}
+
+func TestNew(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New()
+		s1.Add("a").Add(2)
+		s2 := gset.New(true)
+		s2.Add("b").Add(3)
+		gtest.Assert(s1.Contains("a"), true)
+
+	})
+}
+
+func TestSet_Join(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New(true)
+		s1.Add("a").Add("a1").Add("b").Add("c")
+		str1 := s1.Join(",")
+		gtest.Assert(strings.Contains(str1, "a1"), true)
+
+	})
+}
+
+func TestSet_String(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New(true)
+		s1.Add("a").Add("a2").Add("b").Add("c")
+		str1 := s1.String()
+		gtest.Assert(strings.Contains(str1, "a2"), true)
+
+	})
+}
+
+func TestSet_Merge(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New(true)
+		s2 := gset.New(true)
+		s1.Add("a").Add("a2").Add("b").Add("c")
+		s2.Add("b").Add("b1").Add("e").Add("f")
+		ss := s1.Merge(s2)
+		gtest.Assert(ss.Contains("a2"), true)
+		gtest.Assert(ss.Contains("b1"), true)
+
+	})
+}
+
+func TestSet_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New(true)
+		s1.Add(1).Add(2).Add(3).Add(4)
+		gtest.Assert(s1.Sum(), int(10))
+
+	})
+}
+
+func TestSet_Pop(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New(true)
+		s1.Add(1).Add(2).Add(3).Add(4)
+		gtest.AssertIN(s1.Pop(1), []int{1, 2, 3, 4})
+	})
+}
+
+func TestSet_Pops(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New(true)
+		s1.Add(1).Add(2).Add(3).Add(4)
+		gtest.AssertIN(s1.Pops(1), []int{1, 2, 3, 4})
+		gtest.AssertIN(s1.Pops(6), []int{1, 2, 3, 4})
+		gtest.Assert(len(s1.Pops(2)), 2)
+	})
+}

g/container/gtree/gtree_avltree.go

@@ -29,8 +29,8 @@ type AVLTreeNode struct {
 	b        int8
 }
 
-// NewAVLTree instantiates an AVL tree with the custom comparator.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// NewAVLTree instantiates an AVL tree with the custom key comparator.
+// The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
 func NewAVLTree(comparator func(v1, v2 interface{}) int, unsafe...bool) *AVLTree {
 	return &AVLTree{
@@ -39,8 +39,8 @@ func NewAVLTree(comparator func(v1, v2 interface{}) int, unsafe...bool) *AVLTree
 	}
 }
 
-// NewAVLTreeFrom instantiates an AVL tree with the custom comparator and data map.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// NewAVLTreeFrom instantiates an AVL tree with the custom key comparator and data map.
+// The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
 func NewAVLTreeFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, unsafe...bool) *AVLTree {
 	tree := NewAVLTree(comparator, unsafe...)
@@ -222,7 +222,7 @@ func (tree *AVLTree) Contains(key interface{}) bool {
 	return ok
 }
 
-// Remove remove the node from the tree by key.
+// Remove removes the node from the tree by key.
 // Key should adhere to the comparator's type assertion, otherwise method panics.
 func (tree *AVLTree) Remove(key interface{}) (value interface{}) {
 	tree.mu.Lock()
@@ -306,7 +306,7 @@ func (tree *AVLTree) Right() *AVLTreeNode {
 	return node
 }
 
-// Floor Finds floor node of the input key, return the floor node or nil if no ceiling is found.
+// Floor Finds floor node of the input key, return the floor node or nil if no floor node is found.
 // Second return parameter is true if floor was found, otherwise false.
 //
 // Floor node is defined as the largest node that is smaller than or equal to the given node.
@@ -317,16 +317,15 @@ func (tree *AVLTree) Right() *AVLTreeNode {
 func (tree *AVLTree) Floor(key interface{}) (floor *AVLTreeNode, found bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
-	found = false
 	n := tree.root
 	for n != nil {
 		c := tree.comparator(key, n.Key)
 		switch {
-		case c == 0: return n, true
-		case c  < 0: n = n.children[0]
-		case c  > 0:
-			floor, found = n, true
-			n = n.children[1]
+			case c == 0: return n, true
+			case c  < 0: n = n.children[0]
+			case c  > 0:
+				floor, found = n, true
+				n = n.children[1]
 		}
 	}
 	if found {
@@ -335,7 +334,7 @@ func (tree *AVLTree) Floor(key interface{}) (floor *AVLTreeNode, found bool) {
 	return nil, false
 }
 
-// Ceiling finds ceiling node of the input key, return the ceiling node or nil if no ceiling is found.
+// Ceiling finds ceiling node of the input key, return the ceiling node or nil if no ceiling node is found.
 // Second return parameter is true if ceiling was found, otherwise false.
 //
 // Ceiling node is defined as the smallest node that is larger than or equal to the given node.
@@ -343,10 +342,9 @@ func (tree *AVLTree) Floor(key interface{}) (floor *AVLTreeNode, found bool) {
 // all nodes in the tree is smaller than the given node.
 //
 // Key should adhere to the comparator's type assertion, otherwise method panics.
-func (tree *AVLTree) Ceiling(key interface{}) (floor *AVLTreeNode, found bool) {
+func (tree *AVLTree) Ceiling(key interface{}) (ceiling *AVLTreeNode, found bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
-	found = false
 	n := tree.root
 	for n != nil {
 		c := tree.comparator(key, n.Key)
@@ -354,7 +352,7 @@ func (tree *AVLTree) Ceiling(key interface{}) (floor *AVLTreeNode, found bool) {
 			case c == 0: return n, true
 			case c  > 0: n = n.children[1]
 			case c  < 0:
-				floor, found = n, true
+				ceiling, found = n, true
 				n = n.children[0]
 		}
 	}
@@ -514,7 +512,7 @@ func (tree *AVLTree) remove(key interface{}, qp **AVLTreeNode) (value interface{
 	if fix {
 		return value, removeFix(int8(-c), qp)
 	}
-	return nil, false
+	return value, false
 }
 
 func removeMin(qp **AVLTreeNode, minKey *interface{}, minVal *interface{}) bool {

g/container/gtree/gtree_btree.go

@@ -37,7 +37,7 @@ type BTreeEntry struct {
 }
 
 // NewBTree instantiates a B-tree with <m> (maximum number of children) and a custom key comparator.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
 // Note that the <m> must be greater or equal than 3, or else it panics.
 func NewBTree(m int, comparator func(v1, v2 interface{}) int, unsafe...bool) *BTree {
@@ -52,7 +52,7 @@ func NewBTree(m int, comparator func(v1, v2 interface{}) int, unsafe...bool) *BT
 }
 
 // NewBTreeFrom instantiates a B-tree with <m> (maximum number of children), a custom key comparator and data map.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
 func NewBTreeFrom(m int, comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, unsafe...bool) *BTree {
 	tree := NewBTree(m, comparator, unsafe...)
@@ -503,9 +503,9 @@ func (tree *BTree) isLeaf(node *BTreeNode) bool {
 	return len(node.Children) == 0
 }
 
-func (tree *BTree) isFull(node *BTreeNode) bool {
-	return len(node.Entries) == tree.maxEntries()
-}
+//func (tree *BTree) isFull(node *BTreeNode) bool {
+//	return len(node.Entries) == tree.maxEntries()
+//}
 
 func (tree *BTree) shouldSplit(node *BTreeNode) bool {
 	return len(node.Entries) > tree.maxEntries()

g/container/gtree/gtree_redblacktree.go

@@ -36,8 +36,8 @@ type RedBlackTreeNode struct {
 	parent *RedBlackTreeNode
 }
 
-// NewRedBlackTree instantiates a red-black tree with the custom comparator.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// NewRedBlackTree instantiates a red-black tree with the custom key comparator.
+// The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
 func NewRedBlackTree(comparator func(v1, v2 interface{}) int, unsafe...bool) *RedBlackTree {
 	return &RedBlackTree {
@@ -46,8 +46,8 @@ func NewRedBlackTree(comparator func(v1, v2 interface{}) int, unsafe...bool) *Re
 	}
 }
 
-// NewRedBlackTreeFrom instantiates a red-black tree with the custom comparator and <data> map.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// NewRedBlackTreeFrom instantiates a red-black tree with the custom key comparator and <data> map.
+// The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
 func NewRedBlackTreeFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, unsafe...bool) *RedBlackTree {
 	tree := NewRedBlackTree(comparator, unsafe...)
@@ -393,60 +393,56 @@ func (tree *RedBlackTree) rightNode() *RedBlackTreeNode {
 	return p
 }
 
-// Floor Finds floor node of the input <key>, return the floor node or nil if no floor is found.
+// Floor Finds floor node of the input key, return the floor node or nil if no floor node is found.
+// Second return parameter is true if floor was found, otherwise false.
 //
 // Floor node is defined as the largest node that its key is smaller than or equal to the given <key>.
 // A floor node may not be found, either because the tree is empty, or because
 // all nodes in the tree are larger than the given node.
-func (tree *RedBlackTree) Floor(key interface{}) (floor *RedBlackTreeNode) {
+func (tree *RedBlackTree) Floor(key interface{}) (floor *RedBlackTreeNode, found bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
-	found := false
-	node  := tree.root
-	for node != nil {
-		compare := tree.comparator(key, node.Key)
+	n := tree.root
+	for n != nil {
+		compare := tree.comparator(key, n.Key)
 		switch {
-			case compare == 0:
-				return node
-			case compare < 0:
-				node = node.left
-			case compare > 0:
-				floor, found = node, true
-				node         = node.right
+			case compare == 0: return n, true
+			case compare  < 0: n = n.left
+			case compare  > 0:
+				floor, found = n, true
+				n            = n.right
 		}
 	}
 	if found {
-		return floor
+		return
 	}
-	return nil
+	return nil, false
 }
 
-// Ceiling finds ceiling node of the input <key>, return the ceiling node or nil if no ceiling is found.
+// Ceiling finds ceiling node of the input key, return the ceiling node or nil if no ceiling node is found.
+// Second return parameter is true if ceiling was found, otherwise false.
 //
 // Ceiling node is defined as the smallest node that its key is larger than or equal to the given <key>.
 // A ceiling node may not be found, either because the tree is empty, or because
 // all nodes in the tree are smaller than the given node.
-func (tree *RedBlackTree) Ceiling(key interface{}) (ceiling *RedBlackTreeNode) {
+func (tree *RedBlackTree) Ceiling(key interface{}) (ceiling *RedBlackTreeNode, found bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
-	found := false
-	node  := tree.root
-	for node != nil {
-		compare := tree.comparator(key, node.Key)
+	n := tree.root
+	for n != nil {
+		compare := tree.comparator(key, n.Key)
 		switch {
-			case compare == 0:
-				return node
-			case compare < 0:
-				ceiling, found = node, true
-				node           = node.left
-			case compare > 0:
-				node = node.right
+			case compare == 0: return n, true
+			case compare  > 0: n = n.right
+			case compare  < 0:
+				ceiling, found = n, true
+				n              = n.left
 		}
 	}
 	if found {
-		return ceiling
+		return
 	}
-	return nil
+	return nil, false
 }
 
 // Iterator is alias of IteratorAsc.

g/container/gtype/gtype_z_unit_test.go

@@ -0,0 +1,291 @@
+package gtype_test
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/gogf/gf/g/container/gtype"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+type Temp struct {
+	Name string
+	Age  int
+}
+
+func Test_Bool(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewBool(true)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(false), true)
+		gtest.AssertEQ(iClone.Val(), false)
+
+		i1 := gtype.NewBool(false)
+		iClone1 := i1.Clone()
+		gtest.AssertEQ(iClone1.Set(true), false)
+		gtest.AssertEQ(iClone1.Val(), true)
+
+		//空参测试
+		i2 := gtype.NewBool()
+		gtest.AssertEQ(i2.Val(), false)
+	})
+}
+
+func Test_Byte(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 127
+		i := gtype.NewByte(byte(0))
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(byte(1)), byte(0))
+		gtest.AssertEQ(iClone.Val(), byte(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(byte(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewByte()
+		gtest.AssertEQ(i1.Val(), byte(0))
+	})
+}
+
+func Test_Bytes(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewBytes([]byte("abc"))
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set([]byte("123")), []byte("abc"))
+		gtest.AssertEQ(iClone.Val(), []byte("123"))
+
+		//空参测试
+		i1 := gtype.NewBytes()
+		gtest.AssertEQ(i1.Val(), nil)
+	})
+}
+
+func Test_String(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewString("abc")
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set("123"), "abc")
+		gtest.AssertEQ(iClone.Val(), "123")
+
+		//空参测试
+		i1 := gtype.NewString()
+		gtest.AssertEQ(i1.Val(), "")
+	})
+}
+
+func Test_Interface(t *testing.T) {
+	gtest.Case(t, func() {
+		t := Temp{Name: "gf", Age: 18}
+		t1 := Temp{Name: "gf", Age: 19}
+		i := gtype.New(t)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(t1), t)
+		gtest.AssertEQ(iClone.Val().(Temp), t1)
+
+		//空参测试
+		i1 := gtype.New()
+		gtest.AssertEQ(i1.Val(), nil)
+	})
+}
+
+func Test_Float32(t *testing.T) {
+	gtest.Case(t, func() {
+		//var wg sync.WaitGroup
+		//addTimes := 100
+		i := gtype.NewFloat32(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(0.1), float32(0))
+		gtest.AssertEQ(iClone.Val(), float32(0.1))
+		// for index := 0; index < addTimes; index++ {
+		// 	wg.Add(1)
+		// 	go func() {
+		// 	defer wg.Done()
+		// 	i.Add(0.2)
+		// 	fmt.Println(i.Val())
+		// 	}()
+		// }
+		// wg.Wait()
+		// gtest.AssertEQ(100.0, i.Val())
+
+		//空参测试
+		i1 := gtype.NewFloat32()
+		gtest.AssertEQ(i1.Val(), float32(0))
+	})
+}
+
+func Test_Float64(t *testing.T) {
+	gtest.Case(t, func() {
+		//var wg sync.WaitGroup
+		//addTimes := 100
+		i := gtype.NewFloat64(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(0.1), float64(0))
+		gtest.AssertEQ(iClone.Val(), float64(0.1))
+		// for index := 0; index < addTimes; index++ {
+		// 	wg.Add(1)
+		// 	go func() {
+		// 	defer wg.Done()
+		// 	i.Add(0.1)
+		// 	fmt.Println(i.Val())
+		// 	}()
+		// }
+		// wg.Wait()
+		// gtest.AssertEQ(100.0, i.Val())
+
+		//空参测试
+		i1 := gtype.NewFloat64()
+		gtest.AssertEQ(i1.Val(), float64(0))
+	})
+}
+
+func Test_Int(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewInt(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), 0)
+		gtest.AssertEQ(iClone.Val(), 1)
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(addTimes, i.Val())
+
+		//空参测试
+		i1 := gtype.NewInt()
+		gtest.AssertEQ(i1.Val(), 0)
+	})
+}
+
+func Test_Int32(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewInt32(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), int32(0))
+		gtest.AssertEQ(iClone.Val(), int32(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(int32(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewInt32()
+		gtest.AssertEQ(i1.Val(), int32(0))
+	})
+}
+
+func Test_Int64(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewInt64(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), int64(0))
+		gtest.AssertEQ(iClone.Val(), int64(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(int64(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewInt64()
+		gtest.AssertEQ(i1.Val(), int64(0))
+	})
+}
+
+func Test_Uint(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewUint(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), uint(0))
+		gtest.AssertEQ(iClone.Val(), uint(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(uint(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewUint()
+		gtest.AssertEQ(i1.Val(), uint(0))
+	})
+}
+
+func Test_Uint32(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewUint32(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), uint32(0))
+		gtest.AssertEQ(iClone.Val(), uint32(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(uint32(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewUint32()
+		gtest.AssertEQ(i1.Val(), uint32(0))
+	})
+}
+
+func Test_Uint64(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewUint64(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), uint64(0))
+		gtest.AssertEQ(iClone.Val(), uint64(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(uint64(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewUint64()
+		gtest.AssertEQ(i1.Val(), uint64(0))
+	})
+}

g/container/gvar/gvar.go

@@ -20,7 +20,7 @@ type Var struct {
 }
 
 // New returns a new Var with given <value>.
-// The param <unsafe> used to specify whether using Var in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using Var in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func New(value interface{}, unsafe...bool) *Var {
     v := &Var{}
@@ -59,7 +59,7 @@ func (v *Var) Interface() interface{} {
 }
 
 // Time converts and returns <v> as time.Time.
-// The param <format> specifies the format of the time string using gtime,
+// The parameter <format> specifies the format of the time string using gtime,
 // eg: Y-m-d H:i:s.
 func (v *Var) Time(format...string) time.Time {
     return gconv.Time(v.Val(), format...)
@@ -72,15 +72,15 @@ func (v *Var) Duration() time.Duration {
 }
 
 // GTime converts and returns <v> as *gtime.Time.
-// The param <format> specifies the format of the time string using gtime,
+// The parameter <format> specifies the format of the time string using gtime,
 // eg: Y-m-d H:i:s.
 func (v *Var) GTime(format...string) *gtime.Time {
     return gconv.GTime(v.Val(), format...)
 }
 
 // Struct maps value of <v> to <objPointer>.
-// The param <objPointer> should be a pointer to a struct instance.
-// The param <mapping> is used to specify the key-to-attribute mapping rules.
+// The parameter <objPointer> should be a pointer to a struct instance.
+// The parameter <mapping> is used to specify the key-to-attribute mapping rules.
 func (v *Var) Struct(pointer interface{}, mapping...map[string]string) error {
     return gconv.Struct(v.Val(), pointer, mapping...)
 }

g/crypto/gaes/gaes_test.go

@@ -9,6 +9,7 @@
 package gaes_test
 
 import (
+	"github.com/gogf/gf/g/encoding/gbase64"
 	"testing"
 
 	"github.com/gogf/gf/g/crypto/gaes"
@@ -16,52 +17,111 @@ import (
 )
 
 var (
-	content = []byte("pibigstar")
+	content          = []byte("pibigstar")
+	content_16, _    = gbase64.Decode("v1jqsGHId/H8onlVHR8Vaw==")
+	content_24, _    = gbase64.Decode("0TXOaj5KMoLhNWmJ3lxY1A==")
+	content_32, _    = gbase64.Decode("qM/Waw1kkWhrwzek24rCSA==")
+	content_16_iv, _ = gbase64.Decode("DqQUXiHgW/XFb6Qs98+hrA==")
+	content_32_iv, _ = gbase64.Decode("ZuLgAOii+lrD5KJoQ7yQ8Q==")
 	// iv 长度必须等于blockSize，只能为16
-	iv     = []byte("Hello My GoFrame")
-	key_16 = []byte("1234567891234567")
-	key_24 = []byte("123456789123456789123456")
-	key_32 = []byte("12345678912345678912345678912345")
-	keys   = []byte("12345678912345678912345678912346")
+	iv         = []byte("Hello My GoFrame")
+	key_16     = []byte("1234567891234567")
+	key_17     = []byte("12345678912345670")
+	key_24     = []byte("123456789123456789123456")
+	key_32     = []byte("12345678912345678912345678912345")
+	keys       = []byte("12345678912345678912345678912346")
+	key_err    = []byte("1234")
+	key_32_err = []byte("1234567891234567891234567891234 ")
 )
 
 func TestEncrypt(t *testing.T) {
 	gtest.Case(t, func() {
-		_, err := gaes.Encrypt(content, key_16)
+		data, err := gaes.Encrypt(content, key_16)
 		gtest.Assert(err, nil)
-		_, err = gaes.Encrypt(content, key_24)
+		gtest.Assert(data, []byte(content_16))
+		data, err = gaes.Encrypt(content, key_24)
 		gtest.Assert(err, nil)
-		_, err = gaes.Encrypt(content, key_32)
+		gtest.Assert(data, []byte(content_24))
+		data, err = gaes.Encrypt(content, key_32)
 		gtest.Assert(err, nil)
-		_, err = gaes.Encrypt(content, key_16, iv)
+		gtest.Assert(data, []byte(content_32))
+		data, err = gaes.Encrypt(content, key_16, iv)
 		gtest.Assert(err, nil)
+		gtest.Assert(data, []byte(content_16_iv))
+		data, err = gaes.Encrypt(content, key_32, iv)
+		gtest.Assert(err, nil)
+		gtest.Assert(data, []byte(content_32_iv))
 	})
 }
 
 func TestDecrypt(t *testing.T) {
 	gtest.Case(t, func() {
-		encrypt, err := gaes.Encrypt(content, key_16)
-		decrypt, err := gaes.Decrypt(encrypt, key_16)
+		decrypt, err := gaes.Decrypt([]byte(content_16), key_16)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
+		gtest.Assert(decrypt, content)
 
-		encrypt, err = gaes.Encrypt(content, key_24)
-		decrypt, err = gaes.Decrypt(encrypt, key_24)
+		decrypt, err = gaes.Decrypt([]byte(content_24), key_24)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
+		gtest.Assert(decrypt, content)
 
-		encrypt, err = gaes.Encrypt(content, key_32)
-		decrypt, err = gaes.Decrypt(encrypt, key_32)
+		decrypt, err = gaes.Decrypt([]byte(content_32), key_32)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
+		gtest.Assert(decrypt, content)
 
-		encrypt, err = gaes.Encrypt(content, key_32, iv)
-		decrypt, err = gaes.Decrypt(encrypt, key_32, iv)
+		decrypt, err = gaes.Decrypt([]byte(content_16_iv), key_16, iv)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
+		gtest.Assert(decrypt, content)
 
-		encrypt, err = gaes.Encrypt(content, key_32, iv)
-		decrypt, err = gaes.Decrypt(encrypt, keys, iv)
+		decrypt, err = gaes.Decrypt([]byte(content_32_iv), key_32, iv)
+		gtest.Assert(err, nil)
+		gtest.Assert(decrypt, content)
+
+		decrypt, err = gaes.Decrypt([]byte(content_32_iv), keys, iv)
 		gtest.Assert(err, "invalid padding")
 	})
 }
+
+func TestEncryptErr(t *testing.T) {
+	gtest.Case(t, func() {
+		// encrypt key error
+		_, err := gaes.Encrypt(content, key_err)
+		gtest.AssertNE(err, nil)
+	})
+}
+
+func TestDecryptErr(t *testing.T) {
+	gtest.Case(t, func() {
+		// decrypt key error
+		encrypt, err := gaes.Encrypt(content, key_16)
+		_, err = gaes.Decrypt(encrypt, key_err)
+		gtest.AssertNE(err, nil)
+
+		// decrypt content too short error
+		_, err = gaes.Decrypt([]byte("test"), key_16)
+		gtest.AssertNE(err, nil)
+
+		// decrypt content size error
+		_, err = gaes.Decrypt(key_17, key_16)
+		gtest.AssertNE(err, nil)
+	})
+}
+
+func TestPKCS5UnPaddingErr(t *testing.T) {
+	gtest.Case(t, func() {
+		// PKCS5UnPadding blockSize zero
+		_, err := gaes.PKCS5UnPadding(content, 0)
+		gtest.AssertNE(err, nil)
+
+		// PKCS5UnPadding src len zero
+		_, err = gaes.PKCS5UnPadding([]byte(""), 16)
+		gtest.AssertNE(err, nil)
+
+		// PKCS5UnPadding src len > blockSize
+		_, err = gaes.PKCS5UnPadding(key_17, 16)
+		gtest.AssertNE(err, nil)
+
+		// PKCS5UnPadding src len > blockSize
+		_, err = gaes.PKCS5UnPadding(key_32_err, 32)
+		gtest.AssertNE(err, nil)
+	})
+}

g/crypto/gcrc32/gcrc32_test.go

@@ -9,13 +9,14 @@
 package gcrc32_test
 
 import (
+	"github.com/gogf/gf/g/crypto/gmd5"
 	"testing"
 
 	"github.com/gogf/gf/g/crypto/gcrc32"
 	"github.com/gogf/gf/g/test/gtest"
 )
 
-func TestEncrypt(t *testing.T) {
+func TestEncryptString(t *testing.T) {
 	gtest.Case(t, func() {
 		s := "pibigstar"
 		result := 693191136
@@ -25,3 +26,19 @@ func TestEncrypt(t *testing.T) {
 		gtest.AssertEQ(int(encrypt2), result)
 	})
 }
+
+func TestEncrypt(t *testing.T) {
+	gtest.Case(t, func() {
+		s := "pibigstar"
+		result := 693191136
+		encrypt1 := gcrc32.Encrypt(s)
+		encrypt2 := gcrc32.Encrypt([]byte(s))
+		gtest.AssertEQ(int(encrypt1), result)
+		gtest.AssertEQ(int(encrypt2), result)
+
+		strmd5 := gmd5.Encrypt(s)
+		test1 := gcrc32.Encrypt(strmd5)
+		test2 := gcrc32.Encrypt([]byte(strmd5))
+		gtest.AssertEQ(test2, test1)
+	})
+}

g/database/gdb/gdb.go

@@ -162,7 +162,7 @@ var (
 )
 
 // New creates ORM DB object with global configurations.
-// The param <name> specifies the configuration group name,
+// The parameter <name> specifies the configuration group name,
 // which is DEFAULT_GROUP_NAME in default.
 func New(name ...string) (db DB, err error) {
 	group := configs.defaultGroup
@@ -210,7 +210,7 @@ func New(name ...string) (db DB, err error) {
 }
 
 // Instance returns an instance for DB operations.
-// The param <name> specifies the configuration group name,
+// The parameter <name> specifies the configuration group name,
 // which is DEFAULT_GROUP_NAME in default.
 func Instance(name ...string) (db DB, err error) {
     group := configs.defaultGroup

g/database/gredis/gredis_unit_test.go

@@ -7,133 +7,203 @@
 package gredis_test
 
 import (
-    "github.com/gogf/gf/g/database/gredis"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
-    "time"
+	"github.com/gogf/gf/g/database/gredis"
+	"github.com/gogf/gf/g/test/gtest"
+	redis2 "github.com/gogf/gf/third/github.com/gomodule/redigo/redis"
+	"testing"
+	"time"
 )
 
 var (
-    config = gredis.Config{
-        Host : "127.0.0.1",
-        Port : 6379,
-        Db   : 1,
-    }
+	config = gredis.Config{
+		Host: "127.0.0.1",
+		Port: 6379,
+		Db:   1,
+	}
 )
 
 func Test_NewClose(t *testing.T) {
-    gtest.Case(t, func() {
-        redis := gredis.New(config)
-        gtest.AssertNE(redis, nil)
-        err := redis.Close()
-        gtest.Assert(err, nil)
-    })
+	gtest.Case(t, func() {
+		redis := gredis.New(config)
+		gtest.AssertNE(redis, nil)
+		err := redis.Close()
+		gtest.Assert(err, nil)
+	})
 }
 
 func Test_Do(t *testing.T) {
-    gtest.Case(t, func() {
-        redis := gredis.New(config)
-        defer redis.Close()
-        _, err := redis.Do("SET", "k", "v")
-        gtest.Assert(err, nil)
+	gtest.Case(t, func() {
+		redis := gredis.New(config)
+		defer redis.Close()
+		_, err := redis.Do("SET", "k", "v")
+		gtest.Assert(err, nil)
 
-        r, err := redis.Do("GET", "k")
-        gtest.Assert(err, nil)
-        gtest.Assert(r, []byte("v"))
+		r, err := redis.Do("GET", "k")
+		gtest.Assert(err, nil)
+		gtest.Assert(r, []byte("v"))
 
-        _, err  = redis.Do("DEL", "k")
-        gtest.Assert(err, nil)
-        r, err  = redis.Do("GET", "k")
-        gtest.Assert(err, nil)
-        gtest.Assert(r, nil)
-    })
+		_, err = redis.Do("DEL", "k")
+		gtest.Assert(err, nil)
+		r, err = redis.Do("GET", "k")
+		gtest.Assert(err, nil)
+		gtest.Assert(r, nil)
+	})
 }
 
 func Test_Send(t *testing.T) {
-    gtest.Case(t, func() {
-        redis := gredis.New(config)
-        defer redis.Close()
-        err := redis.Send("SET", "k", "v")
-        gtest.Assert(err, nil)
+	gtest.Case(t, func() {
+		redis := gredis.New(config)
+		defer redis.Close()
+		err := redis.Send("SET", "k", "v")
+		gtest.Assert(err, nil)
 
-        r, err := redis.Do("GET", "k")
-        gtest.Assert(err, nil)
-        gtest.Assert(r,   []byte("v"))
-    })
+		r, err := redis.Do("GET", "k")
+		gtest.Assert(err, nil)
+		gtest.Assert(r, []byte("v"))
+	})
 }
 
 func Test_Stats(t *testing.T) {
-    gtest.Case(t, func() {
-        redis := gredis.New(config)
-        defer redis.Close()
-        redis.SetMaxIdle(2)
-        redis.SetMaxActive(100)
-        redis.SetIdleTimeout(500*time.Millisecond)
-        redis.SetMaxConnLifetime(500*time.Millisecond)
+	gtest.Case(t, func() {
+		redis := gredis.New(config)
+		defer redis.Close()
+		redis.SetMaxIdle(2)
+		redis.SetMaxActive(100)
+		redis.SetIdleTimeout(500 * time.Millisecond)
+		redis.SetMaxConnLifetime(500 * time.Millisecond)
 
-        array := make([]*gredis.Conn, 0)
-        for i := 0; i < 10; i++ {
-            array = append(array, redis.Conn())
-        }
-        stats := redis.Stats()
-        gtest.Assert(stats.ActiveCount, 10)
-        gtest.Assert(stats.IdleCount,    0)
-        for i := 0; i < 10; i++ {
-            array[i].Close()
-        }
-        stats  = redis.Stats()
-        gtest.Assert(stats.ActiveCount,  2)
-        gtest.Assert(stats.IdleCount,    2)
-        //time.Sleep(3000*time.Millisecond)
-        //stats  = redis.Stats()
-        //fmt.Println(stats)
-        //gtest.Assert(stats.ActiveCount,  0)
-        //gtest.Assert(stats.IdleCount,    0)
-    })
+		array := make([]*gredis.Conn, 0)
+		for i := 0; i < 10; i++ {
+			array = append(array, redis.Conn())
+		}
+		stats := redis.Stats()
+		gtest.Assert(stats.ActiveCount, 10)
+		gtest.Assert(stats.IdleCount, 0)
+		for i := 0; i < 10; i++ {
+			array[i].Close()
+		}
+		stats = redis.Stats()
+		gtest.Assert(stats.ActiveCount, 2)
+		gtest.Assert(stats.IdleCount, 2)
+		//time.Sleep(3000*time.Millisecond)
+		//stats  = redis.Stats()
+		//fmt.Println(stats)
+		//gtest.Assert(stats.ActiveCount,  0)
+		//gtest.Assert(stats.IdleCount,    0)
+	})
 }
 
 func Test_Conn(t *testing.T) {
-    gtest.Case(t, func() {
-        redis := gredis.New(config)
-        defer redis.Close()
-        conn := redis.Conn()
-        defer conn.Close()
+	gtest.Case(t, func() {
+		redis := gredis.New(config)
+		defer redis.Close()
+		conn := redis.Conn()
+		defer conn.Close()
 
+		r, err := conn.Do("GET", "k")
+		gtest.Assert(err, nil)
+		gtest.Assert(r, []byte("v"))
 
-        r, err := conn.Do("GET", "k")
-        gtest.Assert(err, nil)
-        gtest.Assert(r,   []byte("v"))
-
-        _, err  = conn.Do("DEL", "k")
-        gtest.Assert(err, nil)
-        r, err  = conn.Do("GET", "k")
-        gtest.Assert(err, nil)
-        gtest.Assert(r, nil)
-    })
+		_, err = conn.Do("DEL", "k")
+		gtest.Assert(err, nil)
+		r, err = conn.Do("GET", "k")
+		gtest.Assert(err, nil)
+		gtest.Assert(r, nil)
+	})
 }
 
 func Test_Instance(t *testing.T) {
-    gtest.Case(t, func() {
-        group := "my-test"
-        gredis.SetConfig(config, group)
-        defer gredis.RemoveConfig(group)
-        redis := gredis.Instance(group)
-        defer redis.Close()
+	gtest.Case(t, func() {
+		group := "my-test"
+		gredis.SetConfig(config, group)
+		defer gredis.RemoveConfig(group)
+		redis := gredis.Instance(group)
+		defer redis.Close()
 
-        conn := redis.Conn()
-        defer conn.Close()
+		conn := redis.Conn()
+		defer conn.Close()
 
-        _, err := conn.Do("SET", "k", "v")
-        gtest.Assert(err, nil)
+		_, err := conn.Do("SET", "k", "v")
+		gtest.Assert(err, nil)
 
-        r, err := conn.Do("GET", "k")
-        gtest.Assert(err, nil)
-        gtest.Assert(r,   []byte("v"))
+		r, err := conn.Do("GET", "k")
+		gtest.Assert(err, nil)
+		gtest.Assert(r, []byte("v"))
 
-        _, err  = conn.Do("DEL", "k")
-        gtest.Assert(err, nil)
-        r, err  = conn.Do("GET", "k")
-        gtest.Assert(err, nil)
-        gtest.Assert(r, nil)
-    })
+		_, err = conn.Do("DEL", "k")
+		gtest.Assert(err, nil)
+		r, err = conn.Do("GET", "k")
+		gtest.Assert(err, nil)
+		gtest.Assert(r, nil)
+	})
+}
+
+func Test_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		config1 := gredis.Config{
+			Host: "127.0.0.2",
+			Port: 6379,
+			Db:   1,
+		}
+		redis := gredis.New(config1)
+		_, err := redis.Do("info")
+		gtest.AssertNE(err, nil)
+
+		config1 = gredis.Config{
+			Host: "127.0.0.1",
+			Port: 6379,
+			Db:   1,
+			Pass: "666666",
+		}
+		redis = gredis.New(config1)
+		_, err = redis.Do("info")
+		gtest.AssertNE(err, nil)
+
+		config1 = gredis.Config{
+			Host: "127.0.0.1",
+			Port: 6379,
+			Db:   100,
+		}
+		redis = gredis.New(config1)
+		_, err = redis.Do("info")
+		gtest.AssertNE(err, nil)
+
+		redis = gredis.Instance("gf")
+		gtest.Assert(redis == nil, true)
+		gredis.ClearConfig()
+
+		redis = gredis.New(config)
+		defer redis.Close()
+		_, err = redis.DoVar("SET", "k", "v")
+		gtest.Assert(err, nil)
+
+		v, err := redis.DoVar("GET", "k")
+		gtest.Assert(err, nil)
+		gtest.Assert(v.String(), "v")
+
+		conn := redis.GetConn()
+		_, err = conn.DoVar("SET", "k", "v")
+		gtest.Assert(err, nil)
+
+		//v, err = conn.ReceiveVar()
+		//gtest.Assert(err, nil)
+		//gtest.Assert(v.String(), "v")
+
+		psc := redis2.PubSubConn{Conn: conn}
+		psc.Subscribe("gf")
+		redis.DoVar("PUBLISH", "gf", "gf test")
+		go func() {
+			for {
+				v, _ := conn.ReceiveVar()
+				switch obj := v.Val().(type) {
+				case redis2.Message:
+					gtest.Assert(string(obj.Data), "gf test")
+				case redis2.Subscription:
+
+				}
+			}
+		}()
+
+		time.Sleep(time.Second)
+	})
 }

g/encoding/gcharset/gcharset.go

@@ -1,55 +1,110 @@
-// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+// Copyright 2018-2019 gf Author(https://github.com/gogf/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://github.com/gogf/gf.
-// @author wenzi1
-// @date   20180604
 
-// Package gcharset provides converting string to requested character encoding.
+// Package charset implements character-set conversion functionality.
 //
-// 字符集转换方法,
-// 使用mahonia实现的字符集转换方法，支持的字符集包括常见的utf8/UTF-16/UTF-16LE/macintosh/big5/gbk/gb18030,支持的全量字符集可以参考mahonia包
+// Supported Character Set:
+//
+// Chinese : GBK/GB18030/GB2312/Big5
+//
+// Japanese: EUCJP/ISO2022JP/ShiftJIS
+//
+// Korean  : EUCKR
+//
+// Unicode : UTF-8/UTF-16/UTF-16BE/UTF-16LE
+//
+// Other   : macintosh/IBM*/Windows*/ISO-*
 package gcharset
 
 import (
-	"github.com/gogf/gf/third/github.com/axgle/mahonia"
+	"bytes"
 	"errors"
 	"fmt"
+	"github.com/gogf/gf/third/golang.org/x/text/encoding"
+	"github.com/gogf/gf/third/golang.org/x/text/encoding/ianaindex"
+	"github.com/gogf/gf/third/golang.org/x/text/transform"
+	"io/ioutil"
 )
 
+var (
+	// Alias for charsets.
+	charsetAlias = map[string]string {
+		"HZGB2312" : "HZ-GB-2312",
+		"hzgb2312" : "HZ-GB-2312",
+		"GB2312"   : "HZ-GB-2312",
+		"gb2312"   : "HZ-GB-2312",
+	}
+)
 
-// 2个字符集之间的转换
+// Supported returns whether charset <charset> is supported.
+func Supported(charset string) bool {
+	return getEncoding(charset) != nil
+}
+
+// Convert converts <src> charset encoding from <srcCharset> to <dstCharset>,
+// and returns the converted string.
+// It returns <src> as <dst> if it fails converting.
 func Convert(dstCharset string, srcCharset string, src string) (dst string, err error) {
-	s := mahonia.GetCharset(srcCharset)
-	if 	s == nil {
-		return "", errors.New(fmt.Sprintf("not support charset:%s", srcCharset))
+	if dstCharset == srcCharset {
+		return src, nil
 	}
-
-	d := mahonia.GetCharset(dstCharset)
-	if d == nil {
-		return "", errors.New(fmt.Sprintf("not support charset:%s", dstCharset))
+	dst = src
+	// Converting <src> to UTF-8.
+	if srcCharset != "UTF-8" {
+		if e := getEncoding(srcCharset); e != nil {
+			tmp, err := ioutil.ReadAll(
+				transform.NewReader(bytes.NewReader([]byte(src)), e.NewDecoder()),
+			)
+			if err != nil {
+				return "", fmt.Errorf("%s to utf8 failed. %v", srcCharset, err)
+			}
+			src = string(tmp)
+		} else {
+			return dst, errors.New(fmt.Sprintf("unsupport srcCharset: %s", srcCharset))
+		}
 	}
-	
-	srctmp := src
-	if s.Name != "UTF-8" {
-		srctmp = s.NewDecoder().ConvertString(srctmp)
+	// Do the converting from UTF-8 to <dstCharset>.
+	if dstCharset != "UTF-8" {
+		if e := getEncoding(dstCharset); e != nil {
+			tmp, err := ioutil.ReadAll(
+				transform.NewReader(bytes.NewReader([]byte(src)), e.NewEncoder()),
+			)
+			if err != nil {
+				return "", fmt.Errorf("utf to %s failed. %v", dstCharset, err)
+			}
+			dst = string(tmp)
+		} else {
+			return dst, errors.New(fmt.Sprintf("unsupport dstCharset: %s", dstCharset))
+		}
+	} else {
+		dst = src
 	}
-	
-	dst = srctmp
-	if d.Name != "UTF-8" {
-		dst = d.NewEncoder().ConvertString(dst)
-	}
-	
 	return dst, nil
 }
 
-// 指定字符集转UTF8
-func ToUTF8(charset string, src string) (dst string, err error) {
-	return Convert("UTF-8", charset, src)
+// ToUTF8 converts <src> charset encoding from <srcCharset> to UTF-8 ,
+// and returns the converted string.
+func ToUTF8(srcCharset string, src string) (dst string, err error) {
+	return Convert("UTF-8", srcCharset, src)
 }
 
-// UTF8转指定字符集
-func UTF8To(charset string, src string) (dst string, err error) {
-	return Convert(charset, "UTF-8", src)
+// UTF8To converts <src> charset encoding from UTF-8 to <dstCharset>,
+// and returns the converted string.
+func UTF8To(dstCharset string, src string) (dst string, err error) {
+	return Convert(dstCharset, "UTF-8", src)
+}
+
+// getEncoding returns the encoding.Encoding interface object for <charset>.
+// It returns nil if <charset> is not supported.
+func getEncoding(charset string) encoding.Encoding {
+	if c, ok := charsetAlias[charset]; ok {
+		charset = c
+	}
+	if e, err := ianaindex.MIB.Encoding(charset); err == nil && e != nil {
+		return e
+	}
+	return nil
 }

g/encoding/gcharset/gcharset_test.go

@@ -8,22 +8,23 @@ package gcharset_test
 
 import (
 	"github.com/gogf/gf/g/encoding/gcharset"
+	"github.com/gogf/gf/g/test/gtest"
 	"testing"
 )
 
 var testData = []struct {
 	utf8, other, otherEncoding string
 }{
-	{"Résumé", "Résumé", "utf8"},
-	{"Résumé", "R\xe9sum\xe9", "latin-1"},
+	{"Résumé", "Résumé", "utf-8"},
+	//{"Résumé", "R\xe9sum\xe9", "latin-1"},
 	{"これは漢字です。", "S0\x8c0o0\"oW[g0Y0\x020", "UTF-16LE"},
 	{"これは漢字です。", "0S0\x8c0oo\"[W0g0Y0\x02", "UTF-16BE"},
 	{"これは漢字です。", "\xfe\xff0S0\x8c0oo\"[W0g0Y0\x02", "UTF-16"},
 	{"𝄢𝄞𝄪𝄫", "\xfe\xff\xd8\x34\xdd\x22\xd8\x34\xdd\x1e\xd8\x34\xdd\x2a\xd8\x34\xdd\x2b", "UTF-16"},
-	{"Hello, world", "Hello, world", "ASCII"},
+	//{"Hello, world", "Hello, world", "ASCII"},
 	{"Gdańsk", "Gda\xf1sk", "ISO-8859-2"},
 	{"Ââ Čč Đđ Ŋŋ Õõ Šš Žž Åå Ää", "\xc2\xe2 \xc8\xe8 \xa9\xb9 \xaf\xbf \xd5\xf5 \xaa\xba \xac\xbc \xc5\xe5 \xc4\xe4", "ISO-8859-10"},
-	{"สำหรับ", "\xca\xd3\xcb\xc3\u047a", "ISO-8859-11"},
+	//{"สำหรับ", "\xca\xd3\xcb\xc3\u047a", "ISO-8859-11"},
 	{"latviešu", "latvie\xf0u", "ISO-8859-13"},
 	{"Seònaid", "Se\xf2naid", "ISO-8859-14"},
 	{"€1 is cheap", "\xa41 is cheap", "ISO-8859-15"},
@@ -49,9 +50,12 @@ var testData = []struct {
 	{"Hello 常用國字標準字體表", "Hello \xb1`\xa5\u03b0\xea\xa6r\xbc\u0437\u01e6r\xc5\xe9\xaa\xed", "big5"},
 	{"Hello 常用國字標準字體表", "Hello \xb3\xa3\xd3\xc3\x87\xf8\xd7\xd6\x98\xcb\x9c\xca\xd7\xd6\xf3\x77\xb1\xed", "gbk"},
 	{"Hello 常用國字標準字體表", "Hello \xb3\xa3\xd3\xc3\x87\xf8\xd7\xd6\x98\xcb\x9c\xca\xd7\xd6\xf3\x77\xb1\xed", "gb18030"},
+	{"花间一壶酒，独酌无相亲。", "~{;(<dR;:x>F#,6@WCN^O`GW!#", "GB2312"},
+	{"花间一壶酒，独酌无相亲。", "~{;(<dR;:x>F#,6@WCN^O`GW!#", "HZGB2312"},
 	{"עִבְרִית", "\x81\x30\xfb\x30\x81\x30\xf6\x34\x81\x30\xf9\x33\x81\x30\xf6\x30\x81\x30\xfb\x36\x81\x30\xf6\x34\x81\x30\xfa\x31\x81\x30\xfb\x38", "gb18030"},
 	{"㧯", "\x82\x31\x89\x38", "gb18030"},
-	{"これは漢字です。", "\x82\xb1\x82\xea\x82\xcd\x8a\xbf\x8e\x9a\x82\xc5\x82\xb7\x81B", "SJIS"},
+	{"㧯", "㧯", "UTF-8"},
+	//{"これは漢字です。", "\x82\xb1\x82\xea\x82\xcd\x8a\xbf\x8e\x9a\x82\xc5\x82\xb7\x81B", "SJIS"},
 	{"これは漢字です。", "\xa4\xb3\xa4\xec\xa4\u03f4\xc1\xbb\xfa\xa4\u01e4\xb9\xa1\xa3", "EUC-JP"},
 }
 
@@ -63,14 +67,43 @@ func TestDecode(t *testing.T) {
 			t.Errorf("Could not create decoder for %v", err)
 			continue
 		}
-		
+
+		if str != data.utf8 {
+			t.Errorf("Unexpected value: %#v (expected %#v) %v", str, data.utf8, data.otherEncoding)
+		}
+	}
+}
+
+func TestUTF8To(t *testing.T) {
+	for _, data := range testData {
+		str := ""
+		str, err := gcharset.UTF8To(data.otherEncoding, data.utf8)
+		if err != nil {
+			t.Errorf("Could not create decoder for %v", err)
+			continue
+		}
+
+		if str != data.other {
+			t.Errorf("Unexpected value: %#v (expected %#v) %v", str, data.other, data.otherEncoding)
+		}
+	}
+}
+
+func TestToUTF8(t *testing.T) {
+	for _, data := range testData {
+		str := ""
+		str, err := gcharset.ToUTF8(data.otherEncoding, data.other)
+		if err != nil {
+			t.Errorf("Could not create decoder for %v", err)
+			continue
+		}
+
 		if str != data.utf8 {
 			t.Errorf("Unexpected value: %#v (expected %#v)", str, data.utf8)
 		}
 	}
 }
 
-
 func TestEncode(t *testing.T) {
 	for _, data := range testData {
 		str := ""
@@ -101,4 +134,32 @@ func TestConvert(t *testing.T) {
 	if str != dst {
 		t.Errorf("unexpected value:%#v (expected %#v)", str, dst)
 	}
-}
+}
+
+func TestConvertErr(t *testing.T) {
+	gtest.Case(t, func() {
+		srcCharset := "big5"
+		dstCharset := "gbk"
+		src        := "Hello \xb1`\xa5\u03b0\xea\xa6r\xbc\u0437\u01e6r\xc5\xe9\xaa\xed"
+
+		s1, e1 := gcharset.Convert(srcCharset, srcCharset, src)
+		gtest.Assert(e1, nil)
+		gtest.Assert(s1, src)
+
+
+		s2, e2 := gcharset.Convert(dstCharset, "no this charset", src)
+		gtest.AssertNE(e2, nil)
+		gtest.Assert(s2, src)
+
+		s3, e3 := gcharset.Convert("no this charset", srcCharset, src)
+		gtest.AssertNE(e3, nil)
+		gtest.Assert(s3, src)
+	})
+}
+
+func TestSupported(t *testing.T) {
+	gtest.Case(t, func() {
+		gtest.Assert(gcharset.Supported("UTF-8"), true)
+		gtest.Assert(gcharset.Supported("UTF-80"), false)
+	})
+}

g/encoding/gcompress/gcompress.go

@@ -5,8 +5,6 @@
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package gcompress provides kinds of compression algorithms for binary/bytes data.
-//
-// 数据压缩/解压.
 package gcompress
 
 import (
@@ -16,19 +14,19 @@ import (
     "io"
 )
 
-// 进行zlib压缩
+// Zlib compresses <data> with zlib algorithm.
 func Zlib(data []byte) []byte {
     if data == nil || len(data) < 13 {
         return data
     }
     var in bytes.Buffer
-    w := zlib.NewWriter(&in)
-    w.Write(data)
-    w.Close()
+    w   := zlib.NewWriter(&in)
+    _, _ = w.Write(data)
+    _    = w.Close()
     return in.Bytes()
 }
 
-// 进行zlib解压缩
+// UnZlib decompresses <data> with zlib algorithm.
 func UnZlib(data []byte) []byte {
     if data == nil || len(data) < 13 {
         return data
@@ -39,32 +37,32 @@ func UnZlib(data []byte) []byte {
     if err != nil {
         return nil
     }
-    io.Copy(&out, r)
+    _, _ = io.Copy(&out, r)
     return out.Bytes()
 }
 
-//做gzip解压缩
-func UnGzip(data []byte) []byte {
-    var buf bytes.Buffer
-	content := bytes.NewReader(data)
-	zipdata, err := gzip.NewReader(content)
-	if err != nil {
-		return nil
-	}
-	io.Copy(&buf, zipdata)
-	zipdata.Close()
-	return buf.Bytes()
-}
-
-//做gzip压缩
+// Gzip compresses <data> with gzip algorithm.
 func Gzip(data []byte) []byte {
-    var buf bytes.Buffer
-	zip := gzip.NewWriter(&buf)
+	var buf bytes.Buffer
+	zip    := gzip.NewWriter(&buf)
 	_, err := zip.Write(data)
 	if err != nil {
 		return nil
 	}
-	zip.Close()
-
+	_ = zip.Close()
 	return buf.Bytes()
-}
+}
+
+// UnGzip decompresses <data> with gzip algorithm.
+func UnGzip(data []byte) []byte {
+    var buf bytes.Buffer
+	content      := bytes.NewReader(data)
+	zipData, err := gzip.NewReader(content)
+	if err != nil {
+		return nil
+	}
+	_, _ = io.Copy(&buf, zipData)
+	_    = zipData.Close()
+	return buf.Bytes()
+}
+

g/encoding/gcompress/gcompress_test.go

@@ -3,6 +3,7 @@
 // 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://github.com/gogf/gf.
+
 package gcompress_test
 
 import (
@@ -18,6 +19,11 @@ func TestZlib(t *testing.T) {
 		gtest.Assert(gcompress.Zlib([]byte(src)), dst)
 
 		gtest.Assert(gcompress.UnZlib(dst), []byte(src))
+
+		gtest.Assert(gcompress.Zlib(nil), nil)
+		gtest.Assert(gcompress.UnZlib(nil), nil)
+
+		gtest.Assert(gcompress.UnZlib(dst[1:]), nil)
 	})
 
 }
@@ -36,7 +42,10 @@ func TestGzip(t *testing.T) {
 		0x00, 0x00,
 	}
 
-	gtest.Assert(gcompress.Gzip([]byte(src)), gzip)
+	arr := []byte(src)
+	gtest.Assert(gcompress.Gzip(arr), gzip)
 
-	gtest.Assert(gcompress.UnGzip(gzip), []byte(src))
+	gtest.Assert(gcompress.UnGzip(gzip), arr)
+
+	gtest.Assert(gcompress.UnGzip(gzip[1:]), nil)
 }

g/encoding/ghash/ghash.go

@@ -5,15 +5,13 @@
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package ghash provides some popular hash functions(uint32/uint64) in go.
-//
-// 常用的hash函数.
 package ghash
 
 
 // BKDR Hash Function
 func BKDRHash(str []byte) uint32 {
-    var seed uint32 = 131; // 31 131 1313 13131 131313 etc..
-    var hash uint32 = 0;
+    var seed uint32 = 131 // 31 131 1313 13131 131313 etc..
+    var hash uint32 = 0
     for i := 0; i < len(str); i++ {
         hash = hash * seed + uint32(str[i])
     }
@@ -22,8 +20,8 @@ func BKDRHash(str []byte) uint32 {
 
 // BKDR Hash Function 64
 func BKDRHash64(str []byte) uint64 {
-    var seed uint64 = 131; // 31 131 1313 13131 131313 etc..
-    var hash uint64 = 0;
+    var seed uint64 = 131 // 31 131 1313 13131 131313 etc..
+    var hash uint64 = 0
     for i := 0; i < len(str); i++ {
         hash = hash * seed + uint64(str[i])
     }
@@ -32,78 +30,78 @@ func BKDRHash64(str []byte) uint64 {
 
 // SDBM Hash
 func SDBMHash(str []byte) uint32 {
-    var hash uint32 = 0;
+    var hash uint32 = 0
     for i := 0; i < len(str); i++ {
         // equivalent to: hash = 65599*hash + uint32(str[i]);
-        hash = uint32(str[i]) + (hash << 6) + (hash << 16) - hash;
+        hash = uint32(str[i]) + (hash << 6) + (hash << 16) - hash
     }
     return hash
 }
 
 // SDBM Hash 64
 func SDBMHash64(str []byte) uint64 {
-    var hash uint64 = 0;
+    var hash uint64 = 0
     for i := 0; i < len(str); i++ {
-        // equivalent to: hash = 65599*hash + uint32(str[i]);
-        hash = uint64(str[i]) + (hash << 6) + (hash << 16) - hash;
+        // equivalent to: hash = 65599*hash + uint32(str[i])
+        hash = uint64(str[i]) + (hash << 6) + (hash << 16) - hash
     }
     return hash
 }
 
 // RS Hash Function
 func RSHash(str []byte) uint32 {
-    var b uint32 = 378551;
-    var a uint32 = 63689;
-    var hash uint32 = 0;
+    var b    uint32 = 378551
+    var a    uint32 = 63689
+    var hash uint32 = 0
     for i := 0; i < len(str); i++ {
-        hash = hash * a + uint32(str[i]);
-        a *= b;
+        hash = hash * a + uint32(str[i])
+        a   *= b
     }
     return hash
 }
 
 // RS Hash Function 64
 func RSHash64(str []byte) uint64 {
-    var b    uint64 = 378551;
-    var a    uint64 = 63689;
-    var hash uint64 = 0;
+    var b    uint64 = 378551
+    var a    uint64 = 63689
+    var hash uint64 = 0
     for i := 0; i < len(str); i++ {
-        hash = hash * a + uint64(str[i]);
-        a *= b;
+        hash = hash * a + uint64(str[i])
+        a   *= b;
     }
     return hash
 }
 
 // JS Hash Function
 func JSHash(str []byte) uint32 {
-    var hash uint32 = 1315423911;
+    var hash uint32 = 1315423911
     for i := 0; i < len(str); i++ {
-        hash ^= ((hash << 5) + uint32(str[i]) + (hash >> 2));
+        hash ^= (hash << 5) + uint32(str[i]) + (hash >> 2)
     }
     return hash
 }
 
 // JS Hash Function 64
 func JSHash64(str []byte) uint64 {
-    var hash uint64 = 1315423911;
+    var hash uint64 = 1315423911
     for i := 0; i < len(str); i++ {
-        hash ^= ((hash << 5) + uint64(str[i]) + (hash >> 2));
+        hash ^= (hash << 5) + uint64(str[i]) + (hash >> 2)
     }
     return hash
 }
 
 // P. J. Weinberger Hash Function
 func PJWHash(str []byte) uint32 {
-    var BitsInUnignedInt uint32 = (4 * 8);
-    var ThreeQuarters    uint32 = ((BitsInUnignedInt  * 3) / 4);
-    var OneEighth        uint32 = (BitsInUnignedInt / 8);
-    var HighBits         uint32 = (0xFFFFFFFF) << (BitsInUnignedInt - OneEighth);
-    var hash uint32             = 0;
-    var test uint32             = 0;
+    var BitsInUnignedInt uint32 = 4 * 8
+    var ThreeQuarters    uint32 = (BitsInUnignedInt  * 3) / 4
+    var OneEighth        uint32 = BitsInUnignedInt / 8
+    var HighBits         uint32 = (0xFFFFFFFF) << (BitsInUnignedInt - OneEighth)
+    var hash uint32             = 0
+    var test uint32             = 0
     for i := 0; i < len(str); i++ {
-        hash = (hash << OneEighth) + uint32(str[i]);
+        hash = (hash << OneEighth) + uint32(str[i])
         if test = hash & HighBits; test != 0 {
-            hash = ((hash ^ (test >> ThreeQuarters)) & (^HighBits + 1));
+            hash = (hash ^ (test >> ThreeQuarters)) & (^HighBits + 1)
         }
     }
     return hash
@@ -111,16 +109,16 @@ func PJWHash(str []byte) uint32 {
 
 // P. J. Weinberger Hash Function 64
 func PJWHash64(str []byte) uint64 {
-    var BitsInUnignedInt uint64 = (4 * 8);
-    var ThreeQuarters    uint64 = ((BitsInUnignedInt  * 3) / 4);
-    var OneEighth        uint64 = (BitsInUnignedInt / 8);
-    var HighBits         uint64 = (0xFFFFFFFFFFFFFFFF) << (BitsInUnignedInt - OneEighth);
-    var hash             uint64 = 0;
-    var test             uint64 = 0;
+    var BitsInUnignedInt uint64 = 4 * 8
+    var ThreeQuarters    uint64 = (BitsInUnignedInt  * 3) / 4
+    var OneEighth        uint64 = BitsInUnignedInt / 8
+    var HighBits         uint64 = (0xFFFFFFFFFFFFFFFF) << (BitsInUnignedInt - OneEighth)
+    var hash             uint64 = 0
+    var test             uint64 = 0
     for i := 0; i < len(str); i++ {
-        hash = (hash << OneEighth) + uint64(str[i]);
+        hash = (hash << OneEighth) + uint64(str[i])
         if test = hash & HighBits; test != 0 {
-            hash = ((hash ^ (test >> ThreeQuarters)) & (^HighBits + 1));
+            hash = (hash ^ (test >> ThreeQuarters)) & (^HighBits + 1)
         }
     }
     return hash
@@ -128,13 +126,13 @@ func PJWHash64(str []byte) uint64 {
 
 // ELF Hash Function
 func ELFHash(str []byte) uint32 {
-    var hash uint32 = 0;
-    var x    uint32 = 0;
+    var hash uint32 = 0
+    var x    uint32 = 0
     for i := 0; i < len(str); i++ {
-        hash = (hash << 4) + uint32(str[i]);
+        hash = (hash << 4) + uint32(str[i])
         if x = hash & 0xF0000000; x != 0 {
-            hash ^= (x >> 24);
-            hash &= ^x + 1;
+            hash ^= x >> 24
+            hash &= ^x + 1
         }
     }
     return hash
@@ -142,13 +140,13 @@ func ELFHash(str []byte) uint32 {
 
 // ELF Hash Function 64
 func ELFHash64(str []byte) uint64 {
-    var hash uint64 = 0;
-    var x    uint64 = 0;
+    var hash uint64 = 0
+    var x    uint64 = 0
     for i := 0; i < len(str); i++ {
-        hash = (hash << 4) + uint64(str[i]);
+        hash = (hash << 4) + uint64(str[i])
         if x = hash & 0xF000000000000000; x != 0 {
-            hash ^= (x >> 24);
-            hash &= ^x + 1;
+            hash ^= x >> 24
+            hash &= ^x + 1
         }
     }
     return hash
@@ -156,30 +154,30 @@ func ELFHash64(str []byte) uint64 {
 
 // DJB Hash Function
 func DJBHash(str []byte) uint32 {
-    var hash uint32 = 5381;
+    var hash uint32 = 5381
     for i := 0; i < len(str); i++ {
-        hash += (hash << 5) + uint32(str[i]);
+        hash += (hash << 5) + uint32(str[i])
     }
     return hash
 }
 
 // DJB Hash Function 64
 func DJBHash64(str []byte) uint64 {
-    var hash uint64 = 5381;
+    var hash uint64 = 5381
     for i := 0; i < len(str); i++ {
-        hash += (hash << 5) + uint64(str[i]);
+        hash += (hash << 5) + uint64(str[i])
     }
     return hash
 }
 
 // AP Hash Function
 func APHash(str []byte) uint32 {
-    var hash uint32 = 0;
+    var hash uint32 = 0
     for i := 0; i < len(str); i++ {
-        if ((i & 1) == 0) {
-            hash ^= ((hash << 7) ^ uint32(str[i]) ^ (hash >> 3));
+        if (i & 1) == 0 {
+            hash ^= (hash << 7) ^ uint32(str[i]) ^ (hash >> 3)
         } else {
-            hash ^= (^((hash << 11) ^ uint32(str[i]) ^ (hash >> 5)) + 1);
+            hash ^= ^((hash << 11) ^ uint32(str[i]) ^ (hash >> 5)) + 1
         }
     }
     return hash
@@ -187,12 +185,12 @@ func APHash(str []byte) uint32 {
 
 // AP Hash Function 64
 func APHash64(str []byte) uint64 {
-    var hash uint64 = 0;
+    var hash uint64 = 0
     for i := 0; i < len(str); i++ {
-        if ((i & 1) == 0) {
-            hash ^= ((hash << 7) ^ uint64(str[i]) ^ (hash >> 3));
+        if (i & 1) == 0 {
+            hash ^= (hash << 7) ^ uint64(str[i]) ^ (hash >> 3)
         } else {
-            hash ^= (^((hash << 11) ^ uint64(str[i]) ^ (hash >> 5)) + 1);
+            hash ^= ^((hash << 11) ^ uint64(str[i]) ^ (hash >> 5)) + 1
         }
     }
     return hash

g/encoding/ghash/ghash_z_unit_basic_test.go

@@ -0,0 +1,140 @@
+package ghash_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/g/encoding/ghash"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+var (
+	strBasic = []byte("This is the test string for hash.")
+)
+
+func Test_BKDRHash(t *testing.T) {
+	var x uint32 = 200645773
+	gtest.Case(t, func() {
+		j := ghash.BKDRHash(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_BKDRHash64(t *testing.T) {
+	var x uint64 = 4214762819217104013
+	gtest.Case(t, func() {
+		j := ghash.BKDRHash64(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_SDBMHash(t *testing.T) {
+	var x uint32 = 1069170245
+	gtest.Case(t, func() {
+		j := ghash.SDBMHash(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_SDBMHash64(t *testing.T) {
+	var x uint64 = 9881052176572890693
+	gtest.Case(t, func() {
+		j := ghash.SDBMHash64(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_RSHash(t *testing.T) {
+	var x uint32 = 1944033799
+	gtest.Case(t, func() {
+		j := ghash.RSHash(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_RSHash64(t *testing.T) {
+	var x uint64 = 13439708950444349959
+	gtest.Case(t, func() {
+		j := ghash.RSHash64(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_JSHash(t *testing.T) {
+	var x uint32 = 498688898
+	gtest.Case(t, func() {
+		j := ghash.JSHash(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_JSHash64(t *testing.T) {
+	var x uint64 = 13410163655098759877
+	gtest.Case(t, func() {
+		j := ghash.JSHash64(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_PJWHash(t *testing.T) {
+	var x uint32 = 7244206
+	gtest.Case(t, func() {
+		j := ghash.PJWHash(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_PJWHash64(t *testing.T) {
+	var x uint64 = 31150
+	gtest.Case(t, func() {
+		j := ghash.PJWHash64(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_ELFHash(t *testing.T) {
+	var x uint32 = 7244206
+	gtest.Case(t, func() {
+		j := ghash.ELFHash(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_ELFHash64(t *testing.T) {
+	var x uint64 = 31150
+	gtest.Case(t, func() {
+		j := ghash.ELFHash64(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_DJBHash(t *testing.T) {
+	var x uint32 = 959862602
+	gtest.Case(t, func() {
+		j := ghash.DJBHash(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_DJBHash64(t *testing.T) {
+	var x uint64 = 2519720351310960458
+	gtest.Case(t, func() {
+		j := ghash.DJBHash64(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_APHash(t *testing.T) {
+	var x uint32 = 3998202516
+	gtest.Case(t, func() {
+		j := ghash.APHash(strBasic)
+		gtest.Assert(j, x)
+	})
+}
+
+func Test_APHash64(t *testing.T) {
+	var x uint64 = 2531023058543352243
+	gtest.Case(t, func() {
+		j := ghash.APHash64(strBasic)
+		gtest.Assert(j, x)
+	})
+}

g/encoding/gjson/gjson.go

@@ -108,7 +108,11 @@ func (j *Json) setValue(pattern string, value interface{}, removed bool) error {
                     if len((*pointer).([]interface{})) > valn {
                         if removed && value == nil {
                             // 删除数据元素
-                            j.setPointerWithValue(pparent, array[i - 1], append((*pointer).([]interface{})[ : valn], (*pointer).([]interface{})[valn + 1 : ]...))
+                            if pparent == nil {
+	                            *pointer = append((*pointer).([]interface{})[ : valn], (*pointer).([]interface{})[valn + 1 : ]...)
+                            } else {
+	                            j.setPointerWithValue(pparent, array[i - 1], append((*pointer).([]interface{})[ : valn], (*pointer).([]interface{})[valn + 1 : ]...))
+                            }
                         } else {
                             (*pointer).([]interface{})[valn] = value
                         }

g/encoding/gjson/gjson_z_unit_basic_test.go

@@ -7,221 +7,221 @@
 package gjson_test
 
 import (
-    "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/encoding/gjson"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/encoding/gjson"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
 )
 
 func Test_New(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j := gjson.New(data)
-        gtest.Assert(j.Get("n"), "123456789")
-        gtest.Assert(j.Get("m"), g.Map{"k" : "v"})
-        gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j := gjson.New(data)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+	})
 }
 
 func Test_NewUnsafe(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j := gjson.NewUnsafe(data)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j := gjson.NewUnsafe(data)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
 }
 
 func Test_Valid(t *testing.T) {
-    data1 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    data2 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]`)
-    gtest.Case(t, func() {
-        gtest.Assert(gjson.Valid(data1), true)
-        gtest.Assert(gjson.Valid(data2), false)
-    })
+	data1 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	data2 := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]`)
+	gtest.Case(t, func() {
+		gtest.Assert(gjson.Valid(data1), true)
+		gtest.Assert(gjson.Valid(data2), false)
+	})
 }
 
 func Test_Encode(t *testing.T) {
-    value := g.Slice{1, 2, 3}
-    gtest.Case(t, func() {
-        b, err := gjson.Encode(value)
-        gtest.Assert(err, nil)
-        gtest.Assert(b,   []byte(`[1,2,3]`))
-    })
+	value := g.Slice{1, 2, 3}
+	gtest.Case(t, func() {
+		b, err := gjson.Encode(value)
+		gtest.Assert(err, nil)
+		gtest.Assert(b, []byte(`[1,2,3]`))
+	})
 }
 
 func Test_Decode(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        v, err := gjson.Decode(data)
-        gtest.Assert(err, nil)
-        gtest.Assert(v, g.Map{
-            "n" : 123456789,
-            "a" : g.Slice{1, 2, 3},
-            "m" : g.Map{
-                "k" : "v",
-            },
-        })
-    })
-    gtest.Case(t, func() {
-        var v interface{}
-        err := gjson.DecodeTo(data, &v)
-        gtest.Assert(err, nil)
-        gtest.Assert(v, g.Map{
-            "n" : 123456789,
-            "a" : g.Slice{1, 2, 3},
-            "m" : g.Map{
-                "k" : "v",
-            },
-        })
-    })
-    gtest.Case(t, func() {
-        j, err := gjson.DecodeToJson(data)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		v, err := gjson.Decode(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(v, g.Map{
+			"n": 123456789,
+			"a": g.Slice{1, 2, 3},
+			"m": g.Map{
+				"k": "v",
+			},
+		})
+	})
+	gtest.Case(t, func() {
+		var v interface{}
+		err := gjson.DecodeTo(data, &v)
+		gtest.Assert(err, nil)
+		gtest.Assert(v, g.Map{
+			"n": 123456789,
+			"a": g.Slice{1, 2, 3},
+			"m": g.Map{
+				"k": "v",
+			},
+		})
+	})
+	gtest.Case(t, func() {
+		j, err := gjson.DecodeToJson(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
 }
 
 func Test_SplitChar(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j, err := gjson.DecodeToJson(data)
-        j.SetSplitChar(byte('#'))
-        gtest.Assert(err, nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m#k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a#1"), 2)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j, err := gjson.DecodeToJson(data)
+		j.SetSplitChar(byte('#'))
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m#k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a#1"), 2)
+	})
 }
 
 func Test_ViolenceCheck(t *testing.T) {
-    data := []byte(`{"m":{"a":[1,2,3], "v1.v2":"4"}}`)
-    gtest.Case(t, func() {
-        j, err := gjson.DecodeToJson(data)
-        gtest.Assert(err, nil)
-        gtest.Assert(j.Get("m.a.2"),   3)
-        gtest.Assert(j.Get("m.v1.v2"), nil)
-        j.SetViolenceCheck(true)
-        gtest.Assert(j.Get("m.v1.v2"), 4)
-    })
+	data := []byte(`{"m":{"a":[1,2,3], "v1.v2":"4"}}`)
+	gtest.Case(t, func() {
+		j, err := gjson.DecodeToJson(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("m.a.2"), 3)
+		gtest.Assert(j.Get("m.v1.v2"), nil)
+		j.SetViolenceCheck(true)
+		gtest.Assert(j.Get("m.v1.v2"), 4)
+	})
 }
 
 func Test_GetToVar(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        var m map[string]string
-        var n int
-        var a []int
-        j, err := gjson.DecodeToJson(data)
-        gtest.Assert(err, nil)
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		var m map[string]string
+		var n int
+		var a []int
+		j, err := gjson.DecodeToJson(data)
+		gtest.Assert(err, nil)
 
-        j.GetToVar("n", &n)
-        j.GetToVar("m", &m)
-        j.GetToVar("a", &a)
+		j.GetToVar("n", &n)
+		j.GetToVar("m", &m)
+		j.GetToVar("a", &a)
 
-        gtest.Assert(n, "123456789")
-        gtest.Assert(m, g.Map{"k" : "v"})
-        gtest.Assert(a, g.Slice{1, 2, 3})
-    })
+		gtest.Assert(n, "123456789")
+		gtest.Assert(m, g.Map{"k": "v"})
+		gtest.Assert(a, g.Slice{1, 2, 3})
+	})
 }
 
 func Test_GetMap(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j, err := gjson.DecodeToJson(data)
-        gtest.Assert(err, nil)
-        gtest.Assert(j.GetMap("n"), nil)
-        gtest.Assert(j.GetMap("m"), g.Map{"k" : "v"})
-        gtest.Assert(j.GetMap("a"), nil)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j, err := gjson.DecodeToJson(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.GetMap("n"), nil)
+		gtest.Assert(j.GetMap("m"), g.Map{"k": "v"})
+		gtest.Assert(j.GetMap("a"), nil)
+	})
 }
 
 func Test_GetJson(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j, err := gjson.DecodeToJson(data)
-        gtest.Assert(err, nil)
-        j2 := j.GetJson("m")
-        gtest.AssertNE(j2, nil)
-        gtest.Assert(j2.Get("k"), "v")
-        gtest.Assert(j2.Get("a"), nil)
-        gtest.Assert(j2.Get("n"), nil)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j, err := gjson.DecodeToJson(data)
+		gtest.Assert(err, nil)
+		j2 := j.GetJson("m")
+		gtest.AssertNE(j2, nil)
+		gtest.Assert(j2.Get("k"), "v")
+		gtest.Assert(j2.Get("a"), nil)
+		gtest.Assert(j2.Get("n"), nil)
+	})
 }
 
 func Test_GetArray(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j, err := gjson.DecodeToJson(data)
-        gtest.Assert(err, nil)
-        gtest.Assert(j.GetArray("n"), g.Array{123456789})
-        gtest.Assert(j.GetArray("m"), g.Array{g.Map{"k":"v"}})
-        gtest.Assert(j.GetArray("a"), g.Array{1,2,3})
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j, err := gjson.DecodeToJson(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.GetArray("n"), g.Array{123456789})
+		gtest.Assert(j.GetArray("m"), g.Array{g.Map{"k": "v"}})
+		gtest.Assert(j.GetArray("a"), g.Array{1, 2, 3})
+	})
 }
 
 func Test_GetString(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j, err := gjson.DecodeToJson(data)
-        gtest.Assert(err, nil)
-        gtest.AssertEQ(j.GetString("n"), "123456789")
-        gtest.AssertEQ(j.GetString("m"), `{"k":"v"}`)
-        gtest.AssertEQ(j.GetString("a"), `[1,2,3]`)
-        gtest.AssertEQ(j.GetString("i"), "")
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j, err := gjson.DecodeToJson(data)
+		gtest.Assert(err, nil)
+		gtest.AssertEQ(j.GetString("n"), "123456789")
+		gtest.AssertEQ(j.GetString("m"), `{"k":"v"}`)
+		gtest.AssertEQ(j.GetString("a"), `[1,2,3]`)
+		gtest.AssertEQ(j.GetString("i"), "")
+	})
 }
 
 func Test_GetStrings(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j, err := gjson.DecodeToJson(data)
-        gtest.Assert(err, nil)
-        gtest.AssertEQ(j.GetStrings("n"), g.SliceStr{"123456789"})
-        gtest.AssertEQ(j.GetStrings("m"), g.SliceStr{`{"k":"v"}`})
-        gtest.AssertEQ(j.GetStrings("a"), g.SliceStr{"1", "2", "3"})
-        gtest.AssertEQ(j.GetStrings("i"), nil)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j, err := gjson.DecodeToJson(data)
+		gtest.Assert(err, nil)
+		gtest.AssertEQ(j.GetStrings("n"), g.SliceStr{"123456789"})
+		gtest.AssertEQ(j.GetStrings("m"), g.SliceStr{`{"k":"v"}`})
+		gtest.AssertEQ(j.GetStrings("a"), g.SliceStr{"1", "2", "3"})
+		gtest.AssertEQ(j.GetStrings("i"), nil)
+	})
 }
 
 func Test_GetInterfaces(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j, err := gjson.DecodeToJson(data)
-        gtest.Assert(err, nil)
-        gtest.AssertEQ(j.GetInterfaces("n"), g.Array{123456789})
-        gtest.AssertEQ(j.GetInterfaces("m"), g.Array{g.Map{"k":"v"}})
-        gtest.AssertEQ(j.GetInterfaces("a"), g.Array{1,2,3})
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j, err := gjson.DecodeToJson(data)
+		gtest.Assert(err, nil)
+		gtest.AssertEQ(j.GetInterfaces("n"), g.Array{123456789})
+		gtest.AssertEQ(j.GetInterfaces("m"), g.Array{g.Map{"k": "v"}})
+		gtest.AssertEQ(j.GetInterfaces("a"), g.Array{1, 2, 3})
+	})
 }
 
 func Test_Len(t *testing.T) {
-    gtest.Case(t, func() {
-        p := gjson.New(nil)
-        p.Append("a", 1)
-        p.Append("a", 2)
-        gtest.Assert(p.Len("a"), 2)
-    })
-    gtest.Case(t, func() {
-        p := gjson.New(nil)
-        p.Append("a.b", 1)
-        p.Append("a.c", 2)
-        gtest.Assert(p.Len("a"), 2)
-    })
-    gtest.Case(t, func() {
-        p := gjson.New(nil)
-        p.Set("a", 1)
-        gtest.Assert(p.Len("a"), -1)
-    })
+	gtest.Case(t, func() {
+		p := gjson.New(nil)
+		p.Append("a", 1)
+		p.Append("a", 2)
+		gtest.Assert(p.Len("a"), 2)
+	})
+	gtest.Case(t, func() {
+		p := gjson.New(nil)
+		p.Append("a.b", 1)
+		p.Append("a.c", 2)
+		gtest.Assert(p.Len("a"), 2)
+	})
+	gtest.Case(t, func() {
+		p := gjson.New(nil)
+		p.Set("a", 1)
+		gtest.Assert(p.Len("a"), -1)
+	})
 }
 
 func Test_Append(t *testing.T) {
@@ -236,8 +236,8 @@ func Test_Append(t *testing.T) {
 		p.Append("a.b", 1)
 		p.Append("a.c", 2)
 		gtest.Assert(p.Get("a"), g.Map{
-			"b" : g.Slice{1},
-			"c" : g.Slice{2},
+			"b": g.Slice{1},
+			"c": g.Slice{2},
 		})
 	})
 	gtest.Case(t, func() {
@@ -282,21 +282,180 @@ func TestJson_Default(t *testing.T) {
 		gtest.AssertEQ(j.GetUint64("no", 100), uint64(100))
 		gtest.AssertEQ(j.GetFloat32("no", 123.456), float32(123.456))
 		gtest.AssertEQ(j.GetFloat64("no", 123.456), float64(123.456))
-		gtest.AssertEQ(j.GetArray("no", g.Slice{1,2,3}), g.Slice{1,2,3})
-		gtest.AssertEQ(j.GetInts("no", g.Slice{1,2,3}), g.SliceInt{1,2,3})
-		gtest.AssertEQ(j.GetFloats("no", g.Slice{1,2,3}), []float64{1,2,3})
-		gtest.AssertEQ(j.GetMap("no", g.Map{"k":"v"}), g.Map{"k":"v"})
+		gtest.AssertEQ(j.GetArray("no", g.Slice{1, 2, 3}), g.Slice{1, 2, 3})
+		gtest.AssertEQ(j.GetInts("no", g.Slice{1, 2, 3}), g.SliceInt{1, 2, 3})
+		gtest.AssertEQ(j.GetFloats("no", g.Slice{1, 2, 3}), []float64{1, 2, 3})
+		gtest.AssertEQ(j.GetMap("no", g.Map{"k": "v"}), g.Map{"k": "v"})
 		gtest.AssertEQ(j.GetVar("no", 123.456).Float64(), float64(123.456))
-		gtest.AssertEQ(j.GetJson("no", g.Map{"k":"v"}).Get("k"), "v")
+		gtest.AssertEQ(j.GetJson("no", g.Map{"k": "v"}).Get("k"), "v")
 		gtest.AssertEQ(j.GetJsons("no", g.Slice{
-			g.Map{"k1":"v1"},
-			g.Map{"k2":"v2"},
-			g.Map{"k3":"v3"},
+			g.Map{"k1": "v1"},
+			g.Map{"k2": "v2"},
+			g.Map{"k3": "v3"},
 		})[0].Get("k1"), "v1")
 		gtest.AssertEQ(j.GetJsonMap("no", g.Map{
-			"m1" : g.Map{"k1":"v1"},
-			"m2" : g.Map{"k2":"v2"},
+			"m1": g.Map{"k1": "v1"},
+			"m2": g.Map{"k2": "v2"},
 		})["m2"].Get("k2"), "v2")
 	})
 }
 
+func Test_Convert(t *testing.T) {
+	gtest.Case(t, func() {
+		j := gjson.New(`{"name":"gf"}`)
+		arr, err := j.ToXml()
+		gtest.Assert(err, nil)
+		gtest.Assert(string(arr), "<name>gf</name>")
+		arr, err = j.ToXmlIndent()
+		gtest.Assert(err, nil)
+		gtest.Assert(string(arr), "<name>gf</name>")
+		str, err := j.ToXmlString()
+		gtest.Assert(err, nil)
+		gtest.Assert(str, "<name>gf</name>")
+		str, err = j.ToXmlIndentString()
+		gtest.Assert(err, nil)
+		gtest.Assert(str, "<name>gf</name>")
+
+		arr, err = j.ToJsonIndent()
+		gtest.Assert(err, nil)
+		gtest.Assert(string(arr), "{\n\t\"name\": \"gf\"\n}")
+		str, err = j.ToJsonIndentString()
+		gtest.Assert(err, nil)
+		gtest.Assert(string(arr), "{\n\t\"name\": \"gf\"\n}")
+
+		arr, err = j.ToYaml()
+		gtest.Assert(err, nil)
+		gtest.Assert(string(arr), "name: gf\n")
+		str, err = j.ToYamlString()
+		gtest.Assert(err, nil)
+		gtest.Assert(string(arr), "name: gf\n")
+
+		arr, err = j.ToToml()
+		gtest.Assert(err, nil)
+		gtest.Assert(string(arr), "name = \"gf\"\n")
+		str, err = j.ToTomlString()
+		gtest.Assert(err, nil)
+		gtest.Assert(string(arr), "name = \"gf\"\n")
+	})
+}
+
+func Test_Convert2(t *testing.T) {
+	gtest.Case(t, func() {
+		name := struct {
+			Name string
+		}{}
+		j := gjson.New(`{"name":"gf","time":"2019-06-12"}`)
+		gtest.Assert(j.Value().(g.Map)["name"], "gf")
+		gtest.Assert(j.GetMap("name1"), nil)
+		gtest.Assert(j.GetJson("name1"), nil)
+		gtest.Assert(j.GetJsons("name1"), nil)
+		gtest.Assert(j.GetJsonMap("name1"), nil)
+		gtest.Assert(j.Contains("name1"), false)
+		gtest.Assert(j.GetToVar("name1", &name) == nil, true)
+		gtest.Assert(j.GetToVar("name", &name) == nil, false)
+		gtest.Assert(j.Len("name1"), -1)
+		gtest.Assert(j.GetTime("time").Format("2006-01-02"), "2019-06-12")
+		gtest.Assert(j.GetGTime("time").Format("Y-m-d"), "2019-06-12")
+		gtest.Assert(j.GetDuration("time").String(), "0s")
+
+		err := j.ToStruct(&name)
+		gtest.Assert(err, nil)
+		gtest.Assert(name.Name, "gf")
+		err = j.Dump()
+		gtest.Assert(err, nil)
+
+		j = gjson.New(`{"person":{"name":"gf"}}`)
+		err = j.GetToStruct("person", &name)
+		gtest.Assert(err, nil)
+		gtest.Assert(name.Name, "gf")
+
+		j = gjson.New(`{"name":"gf""}`)
+		err = j.Dump()
+		gtest.Assert(err, nil)
+
+		j = gjson.New(`[1,2,3]`)
+		gtest.Assert(len(j.ToArray()), 3)
+	})
+}
+
+func Test_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		j := gjson.New(`{"name":"gf","time":"2019-06-12"}`)
+		j.SetViolenceCheck(true)
+		gtest.Assert(j.Get("").(g.Map)["name"], "gf")
+		gtest.Assert(j.Get("").(g.Map)["name1"], nil)
+		j.SetViolenceCheck(false)
+		gtest.Assert(j.Get("").(g.Map)["name"], "gf")
+
+		err := j.Set("name", "gf1")
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("name"), "gf1")
+
+		j = gjson.New(`[1,2,3]`)
+		err = j.Set("\"0\".1", 11)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("1"), 11)
+
+		j = gjson.New(`[1,2,3]`)
+		err = j.Set("11111111111111111111111", 11)
+		gtest.AssertNE(err, nil)
+
+		j   = gjson.New(`[1,2,3]`)
+		err = j.Remove("1")
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("0"), 1)
+
+		j = gjson.New(`[1,2,3]`)
+		err = j.Remove("3")
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("0"), 1)
+
+		j = gjson.New(`[1,2,3]`)
+		err = j.Remove("0.3")
+		gtest.Assert(err, nil)
+		gtest.Assert(len(j.Get("0").([]interface{})), 3)
+
+		j = gjson.New(`[1,2,3]`)
+		err = j.Remove("0.a")
+		gtest.Assert(err, nil)
+		gtest.Assert(len(j.Get("0").(g.Map)), 0)
+
+		name := struct {
+			Name string
+		}{Name: "gf"}
+		j = gjson.New(name)
+		gtest.Assert(j.Get("Name"), "gf")
+		err = j.Remove("Name")
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("Name"), nil)
+
+		err = j.Set("Name", "gf1")
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("Name"), "gf1")
+
+		j = gjson.New(nil)
+		err = j.Remove("Name")
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("Name"), nil)
+
+		j = gjson.New(name)
+		gtest.Assert(j.Get("Name"), "gf")
+		err = j.Set("Name1", g.Map{"Name": "gf1"})
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("Name1").(g.Map)["Name"], "gf1")
+		err = j.Set("Name2", g.Slice{1, 2, 3})
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("Name2").(g.Slice)[0], 1)
+		err = j.Set("Name3", name)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("Name3").(g.Map)["Name"], "gf")
+		err = j.Set("Name4", &name)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("Name4").(g.Map)["Name"], "gf")
+		arr := [3]int{1, 2, 3}
+		err = j.Set("Name5", arr)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("Name5").(g.Array)[0], 1)
+
+	})
+}

g/encoding/gjson/gjson_z_unit_load_test.go

@@ -7,66 +7,65 @@
 package gjson_test
 
 import (
-    "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/encoding/gjson"
-    "github.com/gogf/gf/g/os/gfile"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/encoding/gjson"
+	"github.com/gogf/gf/g/os/gfile"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
 )
 
-
 func Test_Load_JSON(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    // JSON
-    gtest.Case(t, func() {
-        j, err := gjson.LoadContent(data)
-        gtest.Assert(err,        nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
-    // JSON
-    gtest.Case(t, func() {
-        path := "test.json"
-        gfile.PutBinContents(path, data)
-        defer gfile.Remove(path)
-        j, err := gjson.Load(path)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	// JSON
+	gtest.Case(t, func() {
+		j, err := gjson.LoadContent(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
+	// JSON
+	gtest.Case(t, func() {
+		path := "test.json"
+		gfile.PutBinContents(path, data)
+		defer gfile.Remove(path)
+		j, err := gjson.Load(path)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
 }
 
 func Test_Load_XML(t *testing.T) {
-    data := []byte(`<doc><a>1</a><a>2</a><a>3</a><m><k>v</k></m><n>123456789</n></doc>`)
-    // XML
-    gtest.Case(t, func() {
-        j, err := gjson.LoadContent(data)
-        gtest.Assert(err, nil)
-        gtest.Assert(j.Get("doc.n"),   "123456789")
-        gtest.Assert(j.Get("doc.m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("doc.m.k"), "v")
-        gtest.Assert(j.Get("doc.a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("doc.a.1"), 2)
-    })
-    // XML
-    gtest.Case(t, func() {
-        path := "test.xml"
-        gfile.PutBinContents(path, data)
-        defer gfile.Remove(path)
-        j, err := gjson.Load(path)
-        gtest.Assert(err, nil)
-        gtest.Assert(j.Get("doc.n"),   "123456789")
-        gtest.Assert(j.Get("doc.m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("doc.m.k"), "v")
-        gtest.Assert(j.Get("doc.a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("doc.a.1"), 2)
-    })
+	data := []byte(`<doc><a>1</a><a>2</a><a>3</a><m><k>v</k></m><n>123456789</n></doc>`)
+	// XML
+	gtest.Case(t, func() {
+		j, err := gjson.LoadContent(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("doc.n"), "123456789")
+		gtest.Assert(j.Get("doc.m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("doc.m.k"), "v")
+		gtest.Assert(j.Get("doc.a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("doc.a.1"), 2)
+	})
+	// XML
+	gtest.Case(t, func() {
+		path := "test.xml"
+		gfile.PutBinContents(path, data)
+		defer gfile.Remove(path)
+		j, err := gjson.Load(path)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("doc.n"), "123456789")
+		gtest.Assert(j.Get("doc.m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("doc.m.k"), "v")
+		gtest.Assert(j.Get("doc.a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("doc.a.1"), 2)
+	})
 
 	// XML
 	gtest.Case(t, func() {
@@ -82,13 +81,13 @@ func Test_Load_XML(t *testing.T) {
 	</Output>`
 		j, err := gjson.LoadContent(xml)
 		gtest.Assert(err, nil)
-		gtest.Assert(j.Get("Output.ipageIndex"),    "2")
+		gtest.Assert(j.Get("Output.ipageIndex"), "2")
 		gtest.Assert(j.Get("Output.itotalRecords"), "GF框架")
 	})
 }
 
 func Test_Load_YAML1(t *testing.T) {
-    data := []byte(`
+	data := []byte(`
 a:
 - 1
 - 2
@@ -97,78 +96,102 @@ m:
  k: v
 "n": 123456789
     `)
-    // YAML
-    gtest.Case(t, func() {
-        j, err := gjson.LoadContent(data)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
-    // YAML
-    gtest.Case(t, func() {
-        path := "test.yaml"
-        gfile.PutBinContents(path, data)
-        defer gfile.Remove(path)
-        j, err := gjson.Load(path)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
+	// YAML
+	gtest.Case(t, func() {
+		j, err := gjson.LoadContent(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
+	// YAML
+	gtest.Case(t, func() {
+		path := "test.yaml"
+		gfile.PutBinContents(path, data)
+		defer gfile.Remove(path)
+		j, err := gjson.Load(path)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
 }
 
 func Test_Load_YAML2(t *testing.T) {
-    data := []byte("i : 123456789")
-    gtest.Case(t, func() {
-        j, err := gjson.LoadContent(data)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("i"),   "123456789")
-    })
+	data := []byte("i : 123456789")
+	gtest.Case(t, func() {
+		j, err := gjson.LoadContent(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("i"), "123456789")
+	})
 }
 
 func Test_Load_TOML1(t *testing.T) {
-    data := []byte(`
+	data := []byte(`
 a = ["1", "2", "3"]
 n = "123456789"
 
 [m]
   k = "v"
 `)
-    // TOML
-    gtest.Case(t, func() {
-        j, err := gjson.LoadContent(data)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
-    // TOML
-    gtest.Case(t, func() {
-        path := "test.toml"
-        gfile.PutBinContents(path, data)
-        defer gfile.Remove(path)
-        j, err := gjson.Load(path)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
+	// TOML
+	gtest.Case(t, func() {
+		j, err := gjson.LoadContent(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
+	// TOML
+	gtest.Case(t, func() {
+		path := "test.toml"
+		gfile.PutBinContents(path, data)
+		defer gfile.Remove(path)
+		j, err := gjson.Load(path)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
 }
 
 func Test_Load_TOML2(t *testing.T) {
-    data := []byte("i=123456789")
-    gtest.Case(t, func() {
-        j, err := gjson.LoadContent(data)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("i"),   "123456789")
-    })
+	data := []byte("i=123456789")
+	gtest.Case(t, func() {
+		j, err := gjson.LoadContent(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("i"), "123456789")
+	})
+}
+
+func Test_Load_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		j := gjson.NewUnsafe()
+		gtest.Assert(j.Value(), nil)
+		_, err := gjson.Decode(nil)
+		gtest.AssertNE(err, nil)
+		_, err = gjson.DecodeToJson(nil)
+		gtest.AssertNE(err, nil)
+		j, err = gjson.LoadContent(nil)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Value(), nil)
+
+		j, err = gjson.LoadContent(`{"name": "gf"}`)
+		gtest.Assert(err, nil)
+
+		j, err = gjson.LoadContent(`{"name": "gf"""}`)
+		gtest.AssertNE(err, nil)
+
+		j = gjson.New(&g.Map{"name": "gf"})
+		gtest.Assert(j.GetString("name"), "gf")
+
+	})
 }

g/encoding/gparser/gparser_unit_basic_test.go

@@ -7,202 +7,314 @@
 package gparser_test
 
 import (
-    "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/encoding/gparser"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/encoding/gparser"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
 )
 
 func Test_New(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j := gparser.New(data)
-        gtest.Assert(j.Get("n"), "123456789")
-        gtest.Assert(j.Get("m"), g.Map{"k" : "v"})
-        gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j := gparser.New(data)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		v := j.Value().(g.Map)
+		gtest.Assert(v["n"], 123456789)
+	})
 }
 
 func Test_NewUnsafe(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j := gparser.NewUnsafe(data)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j := gparser.NewUnsafe(data)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
 }
 
 func Test_Encode(t *testing.T) {
-    value := g.Slice{1, 2, 3}
-    gtest.Case(t, func() {
-        b, err := gparser.VarToJson(value)
-        gtest.Assert(err, nil)
-        gtest.Assert(b,   []byte(`[1,2,3]`))
-    })
+	value := g.Slice{1, 2, 3}
+	gtest.Case(t, func() {
+		b, err := gparser.VarToJson(value)
+		gtest.Assert(err, nil)
+		gtest.Assert(b, []byte(`[1,2,3]`))
+	})
 }
 
 func Test_Decode(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j := gparser.New(data)
-        gtest.AssertNE(j,          nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j := gparser.New(data)
+		gtest.AssertNE(j, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
 }
 
 func Test_SplitChar(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j := gparser.New(data)
-        j.SetSplitChar(byte('#'))
-        gtest.AssertNE(j, nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m#k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a#1"), 2)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j := gparser.New(data)
+		j.SetSplitChar(byte('#'))
+		gtest.AssertNE(j, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m#k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a#1"), 2)
+	})
 }
 
 func Test_ViolenceCheck(t *testing.T) {
-    data := []byte(`{"m":{"a":[1,2,3], "v1.v2":"4"}}`)
-    gtest.Case(t, func() {
-        j := gparser.New(data)
-        gtest.AssertNE(j, nil)
-        gtest.Assert(j.Get("m.a.2"),   3)
-        gtest.Assert(j.Get("m.v1.v2"), nil)
-        j.SetViolenceCheck(true)
-        gtest.Assert(j.Get("m.v1.v2"), 4)
-    })
+	data := []byte(`{"m":{"a":[1,2,3], "v1.v2":"4"}}`)
+	gtest.Case(t, func() {
+		j := gparser.New(data)
+		gtest.AssertNE(j, nil)
+		gtest.Assert(j.Get("m.a.2"), 3)
+		gtest.Assert(j.Get("m.v1.v2"), nil)
+		j.SetViolenceCheck(true)
+		gtest.Assert(j.Get("m.v1.v2"), 4)
+	})
 }
 
 func Test_GetToVar(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        var m map[string]string
-        var n int
-        var a []int
-        j := gparser.New(data)
-        gtest.AssertNE(j, nil)
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		var m map[string]string
+		var n int
+		var a []int
+		j := gparser.New(data)
+		gtest.AssertNE(j, nil)
 
-        j.GetToVar("n", &n)
-        j.GetToVar("m", &m)
-        j.GetToVar("a", &a)
+		j.GetToVar("n", &n)
+		j.GetToVar("m", &m)
+		j.GetToVar("a", &a)
 
-        gtest.Assert(n, "123456789")
-        gtest.Assert(m, g.Map{"k" : "v"})
-        gtest.Assert(a, g.Slice{1, 2, 3})
-    })
+		gtest.Assert(n, "123456789")
+		gtest.Assert(m, g.Map{"k": "v"})
+		gtest.Assert(a, g.Slice{1, 2, 3})
+	})
 }
 
 func Test_GetMap(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j := gparser.New(data)
-        gtest.AssertNE(j, nil)
-        gtest.Assert(j.GetMap("n"), nil)
-        gtest.Assert(j.GetMap("m"), g.Map{"k" : "v"})
-        gtest.Assert(j.GetMap("a"), nil)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j := gparser.New(data)
+		gtest.AssertNE(j, nil)
+		gtest.Assert(j.GetMap("n"), nil)
+		gtest.Assert(j.GetMap("m"), g.Map{"k": "v"})
+		gtest.Assert(j.GetMap("a"), nil)
+	})
 }
 
 func Test_GetArray(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j := gparser.New(data)
-        gtest.AssertNE(j, nil)
-        gtest.Assert(j.GetArray("n"), g.Array{123456789})
-        gtest.Assert(j.GetArray("m"), g.Array{g.Map{"k":"v"}})
-        gtest.Assert(j.GetArray("a"), g.Array{1,2,3})
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j := gparser.New(data)
+		gtest.AssertNE(j, nil)
+		gtest.Assert(j.GetArray("n"), g.Array{123456789})
+		gtest.Assert(j.GetArray("m"), g.Array{g.Map{"k": "v"}})
+		gtest.Assert(j.GetArray("a"), g.Array{1, 2, 3})
+	})
 }
 
 func Test_GetString(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j := gparser.New(data)
-        gtest.AssertNE(j, nil)
-        gtest.AssertEQ(j.GetString("n"), "123456789")
-        gtest.AssertEQ(j.GetString("m"), `{"k":"v"}`)
-        gtest.AssertEQ(j.GetString("a"), `[1,2,3]`)
-        gtest.AssertEQ(j.GetString("i"), "")
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j := gparser.New(data)
+		gtest.AssertNE(j, nil)
+		gtest.AssertEQ(j.GetString("n"), "123456789")
+		gtest.AssertEQ(j.GetString("m"), `{"k":"v"}`)
+		gtest.AssertEQ(j.GetString("a"), `[1,2,3]`)
+		gtest.AssertEQ(j.GetString("i"), "")
+	})
 }
 
 func Test_GetStrings(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j := gparser.New(data)
-        gtest.AssertNE(j, nil)
-        gtest.AssertEQ(j.GetStrings("n"), g.SliceStr{"123456789"})
-        gtest.AssertEQ(j.GetStrings("m"), g.SliceStr{`{"k":"v"}`})
-        gtest.AssertEQ(j.GetStrings("a"), g.SliceStr{"1", "2", "3"})
-        gtest.AssertEQ(j.GetStrings("i"), nil)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j := gparser.New(data)
+		gtest.AssertNE(j, nil)
+		gtest.AssertEQ(j.GetStrings("n"), g.SliceStr{"123456789"})
+		gtest.AssertEQ(j.GetStrings("m"), g.SliceStr{`{"k":"v"}`})
+		gtest.AssertEQ(j.GetStrings("a"), g.SliceStr{"1", "2", "3"})
+		gtest.AssertEQ(j.GetStrings("i"), nil)
+	})
 }
 
 func Test_GetInterfaces(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    gtest.Case(t, func() {
-        j := gparser.New(data)
-        gtest.AssertNE(j, nil)
-        gtest.AssertEQ(j.GetInterfaces("n"), g.Array{123456789})
-        gtest.AssertEQ(j.GetInterfaces("m"), g.Array{g.Map{"k":"v"}})
-        gtest.AssertEQ(j.GetInterfaces("a"), g.Array{1,2,3})
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	gtest.Case(t, func() {
+		j := gparser.New(data)
+		gtest.AssertNE(j, nil)
+		gtest.AssertEQ(j.GetInterfaces("n"), g.Array{123456789})
+		gtest.AssertEQ(j.GetInterfaces("m"), g.Array{g.Map{"k": "v"}})
+		gtest.AssertEQ(j.GetInterfaces("a"), g.Array{1, 2, 3})
+	})
 }
 
 func Test_Len(t *testing.T) {
-    gtest.Case(t, func() {
-        p := gparser.New(nil)
-        p.Append("a", 1)
-        p.Append("a", 2)
-        gtest.Assert(p.Len("a"), 2)
-    })
-    gtest.Case(t, func() {
-        p := gparser.New(nil)
-        p.Append("a.b", 1)
-        p.Append("a.c", 2)
-        gtest.Assert(p.Len("a"), 2)
-    })
-    gtest.Case(t, func() {
-        p := gparser.New(nil)
-        p.Set("a", 1)
-        gtest.Assert(p.Len("a"), -1)
-    })
+	gtest.Case(t, func() {
+		p := gparser.New(nil)
+		p.Append("a", 1)
+		p.Append("a", 2)
+		gtest.Assert(p.Len("a"), 2)
+	})
+	gtest.Case(t, func() {
+		p := gparser.New(nil)
+		p.Append("a.b", 1)
+		p.Append("a.c", 2)
+		gtest.Assert(p.Len("a"), 2)
+	})
+	gtest.Case(t, func() {
+		p := gparser.New(nil)
+		p.Set("a", 1)
+		gtest.Assert(p.Len("a"), -1)
+	})
 }
 
 func Test_Append(t *testing.T) {
-    gtest.Case(t, func() {
-        p := gparser.New(nil)
-        p.Append("a", 1)
-        p.Append("a", 2)
-        gtest.Assert(p.Get("a"), g.Slice{1, 2})
-    })
-    gtest.Case(t, func() {
-        p := gparser.New(nil)
-        p.Append("a.b", 1)
-        p.Append("a.c", 2)
-        gtest.Assert(p.Get("a"), g.Map{
-            "b" : g.Slice{1},
-            "c" : g.Slice{2},
-        })
-    })
-    gtest.Case(t, func() {
-        p := gparser.New(nil)
-        p.Set("a", 1)
-        err := p.Append("a", 2)
-        gtest.AssertNE(err, nil)
-        gtest.Assert(p.Get("a"), 1)
-    })
+	gtest.Case(t, func() {
+		p := gparser.New(nil)
+		p.Append("a", 1)
+		p.Append("a", 2)
+		gtest.Assert(p.Get("a"), g.Slice{1, 2})
+	})
+	gtest.Case(t, func() {
+		p := gparser.New(nil)
+		p.Append("a.b", 1)
+		p.Append("a.c", 2)
+		gtest.Assert(p.Get("a"), g.Map{
+			"b": g.Slice{1},
+			"c": g.Slice{2},
+		})
+	})
+	gtest.Case(t, func() {
+		p := gparser.New(nil)
+		p.Set("a", 1)
+		err := p.Append("a", 2)
+		gtest.AssertNE(err, nil)
+		gtest.Assert(p.Get("a"), 1)
+	})
 }
 
+func Test_Convert(t *testing.T) {
+	gtest.Case(t, func() {
+		p := gparser.New(`{"name":"gf","bool":true,"int":1,"float":1,"ints":[1,2],"floats":[1,2],"time":"2019-06-12","person": {"name": "gf"}}`)
+		gtest.Assert(p.GetVar("name").String(), "gf")
+		gtest.Assert(p.GetString("name"), "gf")
+		gtest.Assert(p.GetBool("bool"), true)
+		gtest.Assert(p.GetInt("int"), 1)
+		gtest.Assert(p.GetInt8("int"), 1)
+		gtest.Assert(p.GetInt16("int"), 1)
+		gtest.Assert(p.GetInt32("int"), 1)
+		gtest.Assert(p.GetInt64("int"), 1)
+		gtest.Assert(p.GetUint("int"), 1)
+		gtest.Assert(p.GetUint8("int"), 1)
+		gtest.Assert(p.GetUint16("int"), 1)
+		gtest.Assert(p.GetUint32("int"), 1)
+		gtest.Assert(p.GetUint64("int"), 1)
+		gtest.Assert(p.GetInts("ints")[0], 1)
+		gtest.Assert(p.GetFloat32("float"), 1)
+		gtest.Assert(p.GetFloat64("float"), 1)
+		gtest.Assert(p.GetFloats("floats")[0], 1)
+		gtest.Assert(p.GetTime("time").Format("2006-01-02"), "2019-06-12")
+		gtest.Assert(p.GetGTime("time").Format("Y-m-d"), "2019-06-12")
+		gtest.Assert(p.GetDuration("time").String(), "0s")
+		name := struct {
+			Name string
+		}{}
+		err := p.GetToStruct("person", &name)
+		gtest.Assert(err, nil)
+		gtest.Assert(name.Name, "gf")
+		gtest.Assert(p.ToMap()["name"], "gf")
+		err = p.ToStruct(&name)
+		gtest.Assert(err, nil)
+		gtest.Assert(name.Name, "gf")
+		p.Dump()
 
+		p = gparser.New(`[0,1,2]`)
+		gtest.Assert(p.ToArray()[0], 0)
 
+		err = gparser.VarToStruct(`{"name":"gf"}`, &name)
+		gtest.Assert(err, nil)
+		gtest.Assert(name.Name, "gf")
+	})
+}
+
+func Test_Convert2(t *testing.T) {
+	gtest.Case(t, func() {
+		xmlArr := []byte{60, 114, 111, 111, 116, 47, 62}
+		p := gparser.New(`<root></root>`)
+		arr, err := p.ToXml("root")
+		gtest.Assert(err, nil)
+		gtest.Assert(arr, xmlArr)
+		arr, err = gparser.VarToXml(`<root></root>`, "root")
+		gtest.Assert(err, nil)
+		gtest.Assert(arr, xmlArr)
+
+		arr, err = p.ToXmlIndent("root")
+		gtest.Assert(err, nil)
+		gtest.Assert(arr, xmlArr)
+		arr, err = gparser.VarToXmlIndent(`<root></root>`, "root")
+		gtest.Assert(err, nil)
+		gtest.Assert(arr, xmlArr)
+
+		p = gparser.New(`{"name":"gf"}`)
+		str, err := p.ToJsonString()
+		gtest.Assert(err, nil)
+		gtest.Assert(str, `{"name":"gf"}`)
+		str, err = gparser.VarToJsonString(`{"name":"gf"}`)
+		gtest.Assert(err, nil)
+		gtest.Assert(str, `{"name":"gf"}`)
+
+		jsonIndentArr := []byte{123, 10, 9, 34, 110, 97, 109, 101, 34, 58, 32, 34, 103, 102, 34, 10, 125}
+		arr, err = p.ToJsonIndent()
+		gtest.Assert(err, nil)
+		gtest.Assert(arr, jsonIndentArr)
+		arr, err = gparser.VarToJsonIndent(`{"name":"gf"}`)
+		gtest.Assert(err, nil)
+		gtest.Assert(arr, jsonIndentArr)
+
+		str, err = p.ToJsonIndentString()
+		gtest.Assert(err, nil)
+		gtest.Assert(str, "{\n\t\"name\": \"gf\"\n}")
+		str, err = gparser.VarToJsonIndentString(`{"name":"gf"}`)
+		gtest.Assert(err, nil)
+		gtest.Assert(str, "{\n\t\"name\": \"gf\"\n}")
+
+		yamlArr := []byte{124, 50, 10, 10, 32, 32, 110, 97, 109, 101, 58, 103, 102, 10}
+		p = gparser.New(`
+name:gf
+`)
+		arr, err = p.ToYaml()
+		gtest.Assert(err, nil)
+		gtest.Assert(arr, yamlArr)
+		arr, err = gparser.VarToYaml(`
+name:gf
+`)
+		gtest.Assert(err, nil)
+		gtest.Assert(arr, yamlArr)
+
+		tomlArr := []byte{110, 97, 109, 101, 32, 61, 32, 34, 103, 102, 34, 10}
+		p = gparser.New(`
+name= "gf"
+`)
+		arr, err = p.ToToml()
+		gtest.Assert(err, nil)
+		gtest.Assert(arr, tomlArr)
+		arr, err = gparser.VarToToml(`
+name= "gf"
+`)
+		gtest.Assert(err, nil)
+		gtest.Assert(arr, tomlArr)
+	})
+}

g/encoding/gparser/gparser_unit_load_test.go

@@ -11,62 +11,62 @@ import (
 	"github.com/gogf/gf/g/encoding/gparser"
 	"github.com/gogf/gf/g/os/gfile"
 	"github.com/gogf/gf/g/test/gtest"
+	"io/ioutil"
 	"testing"
 )
 
-
 func Test_Load_JSON(t *testing.T) {
-    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
-    // JSON
-    gtest.Case(t, func() {
-        j, err := gparser.LoadContent(data)
-        gtest.Assert(err,        nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
-    // JSON
-    gtest.Case(t, func() {
-        path := "test.json"
-        gfile.PutBinContents(path, data)
-        defer gfile.Remove(path)
-        j, err := gparser.Load(path)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
+	data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+	// JSON
+	gtest.Case(t, func() {
+		j, err := gparser.LoadContent(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
+	// JSON
+	gtest.Case(t, func() {
+		path := "test.json"
+		gfile.PutBinContents(path, data)
+		defer gfile.Remove(path)
+		j, err := gparser.Load(path)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
 }
 
 func Test_Load_XML(t *testing.T) {
-    data := []byte(`<doc><a>1</a><a>2</a><a>3</a><m><k>v</k></m><n>123456789</n></doc>`)
-    // XML
-    gtest.Case(t, func() {
-        j, err := gparser.LoadContent(data)
-        gtest.Assert(err, nil)
-        gtest.Assert(j.Get("doc.n"),   "123456789")
-        gtest.Assert(j.Get("doc.m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("doc.m.k"), "v")
-        gtest.Assert(j.Get("doc.a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("doc.a.1"), 2)
-    })
-    // XML
-    gtest.Case(t, func() {
-        path := "test.xml"
-        gfile.PutBinContents(path, data)
-        defer gfile.Remove(path)
-        j, err := gparser.Load(path)
-        gtest.Assert(err, nil)
-        gtest.Assert(j.Get("doc.n"),   "123456789")
-        gtest.Assert(j.Get("doc.m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("doc.m.k"), "v")
-        gtest.Assert(j.Get("doc.a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("doc.a.1"), 2)
-    })
+	data := []byte(`<doc><a>1</a><a>2</a><a>3</a><m><k>v</k></m><n>123456789</n></doc>`)
+	// XML
+	gtest.Case(t, func() {
+		j, err := gparser.LoadContent(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("doc.n"), "123456789")
+		gtest.Assert(j.Get("doc.m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("doc.m.k"), "v")
+		gtest.Assert(j.Get("doc.a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("doc.a.1"), 2)
+	})
+	// XML
+	gtest.Case(t, func() {
+		path := "test.xml"
+		gfile.PutBinContents(path, data)
+		defer gfile.Remove(path)
+		j, err := gparser.Load(path)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("doc.n"), "123456789")
+		gtest.Assert(j.Get("doc.m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("doc.m.k"), "v")
+		gtest.Assert(j.Get("doc.a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("doc.a.1"), 2)
+	})
 
 	// XML
 	gtest.Case(t, func() {
@@ -82,13 +82,13 @@ func Test_Load_XML(t *testing.T) {
 	</Output>`
 		j, err := gparser.LoadContent(xml)
 		gtest.Assert(err, nil)
-		gtest.Assert(j.Get("Output.ipageIndex"),    "2")
+		gtest.Assert(j.Get("Output.ipageIndex"), "2")
 		gtest.Assert(j.Get("Output.itotalRecords"), "GF框架")
 	})
 }
 
 func Test_Load_YAML1(t *testing.T) {
-    data := []byte(`
+	data := []byte(`
 a:
 - 1
 - 2
@@ -97,78 +97,93 @@ m:
  k: v
 "n": 123456789
     `)
-    // YAML
-    gtest.Case(t, func() {
-        j, err := gparser.LoadContent(data)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
-    // YAML
-    gtest.Case(t, func() {
-        path := "test.yaml"
-        gfile.PutBinContents(path, data)
-        defer gfile.Remove(path)
-        j, err := gparser.Load(path)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
+	// YAML
+	gtest.Case(t, func() {
+		j, err := gparser.LoadContent(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
+	// YAML
+	gtest.Case(t, func() {
+		path := "test.yaml"
+		gfile.PutBinContents(path, data)
+		defer gfile.Remove(path)
+		j, err := gparser.Load(path)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
 }
 
 func Test_Load_YAML2(t *testing.T) {
-    data := []byte("i : 123456789")
-    gtest.Case(t, func() {
-        j, err := gparser.LoadContent(data)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("i"),   "123456789")
-    })
+	data := []byte("i : 123456789")
+	gtest.Case(t, func() {
+		j, err := gparser.LoadContent(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("i"), "123456789")
+	})
 }
 
 func Test_Load_TOML1(t *testing.T) {
-    data := []byte(`
+	data := []byte(`
 a = ["1", "2", "3"]
 n = "123456789"
 
 [m]
   k = "v"
 `)
-    // TOML
-    gtest.Case(t, func() {
-        j, err := gparser.LoadContent(data)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
-    // TOML
-    gtest.Case(t, func() {
-        path := "test.toml"
-        gfile.PutBinContents(path, data)
-        defer gfile.Remove(path)
-        j, err := gparser.Load(path)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("n"),   "123456789")
-        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
-        gtest.Assert(j.Get("m.k"), "v")
-        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
-        gtest.Assert(j.Get("a.1"), 2)
-    })
+	// TOML
+	gtest.Case(t, func() {
+		j, err := gparser.LoadContent(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
+	// TOML
+	gtest.Case(t, func() {
+		path := "test.toml"
+		gfile.PutBinContents(path, data)
+		defer gfile.Remove(path)
+		j, err := gparser.Load(path)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("n"), "123456789")
+		gtest.Assert(j.Get("m"), g.Map{"k": "v"})
+		gtest.Assert(j.Get("m.k"), "v")
+		gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+		gtest.Assert(j.Get("a.1"), 2)
+	})
 }
 
 func Test_Load_TOML2(t *testing.T) {
-    data := []byte("i=123456789")
-    gtest.Case(t, func() {
-        j, err := gparser.LoadContent(data)
-        gtest.Assert(err,          nil)
-        gtest.Assert(j.Get("i"),   "123456789")
-    })
+	data := []byte("i=123456789")
+	gtest.Case(t, func() {
+		j, err := gparser.LoadContent(data)
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("i"), "123456789")
+	})
+}
+
+func Test_Load_Nil(t *testing.T) {
+	gtest.Case(t, func() {
+		p := gparser.NewUnsafe()
+		gtest.Assert(p.Value(), nil)
+		file := "test22222.json"
+		filePath := gfile.Pwd() + gfile.Separator + file
+		ioutil.WriteFile(filePath, []byte("{"), 0644)
+		defer gfile.Remove(filePath)
+		_, err := gparser.Load(file)
+		gtest.AssertNE(err, nil)
+		_, err = gparser.LoadContent("{")
+		gtest.AssertNE(err, nil)
+	})
 }

g/encoding/gxml/gxml.go

@@ -9,8 +9,8 @@ package gxml
 
 import (
 	"fmt"
+	"github.com/gogf/gf/g/encoding/gcharset"
 	"github.com/gogf/gf/g/text/gregex"
-	"github.com/gogf/gf/third/github.com/axgle/mahonia"
 	"github.com/gogf/gf/third/github.com/clbanning/mxj"
 	"strings"
 )
@@ -60,16 +60,17 @@ func convert(xml []byte) (res []byte, err error) {
 	if len(matchStr) == 2 {
 		xmlEncode = matchStr[1]
 	}
-	s := mahonia.GetCharset(xmlEncode)
-	if s == nil {
-		return nil, fmt.Errorf("not support charset:%s\n", xmlEncode)
-	}
-	res, err = gregex.Replace(patten, []byte(""), xml)
+	xmlEncode = strings.ToUpper(xmlEncode)
+	res, err  = gregex.Replace(patten, []byte(""), xml)
 	if err != nil {
 		return nil, err
 	}
-	if !strings.EqualFold(s.Name, "UTF-8") {
-		res = []byte(s.NewDecoder().ConvertString(string(res)))
+	if xmlEncode != "UTF-8" && xmlEncode != "UTF8" {
+		dst, err := gcharset.Convert("UTF-8", xmlEncode, string(res))
+		if err != nil {
+			return nil, err
+		}
+		res = []byte(dst)
 	}
 	return res, nil
 }

g/encoding/gxml/gxml_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/gogf/gf/g/encoding/gcharset"
 	"github.com/gogf/gf/g/encoding/gparser"
 	"github.com/gogf/gf/g/encoding/gxml"
+	"github.com/gogf/gf/g/test/gtest"
 	"strings"
 	"testing"
 )
@@ -23,6 +24,12 @@ var testData = []struct {
 	{"Hello 常用國字標準字體表", "Hello \xb3\xa3\xd3\xc3\x87\xf8\xd7\xd6\x98\xcb\x9c\xca\xd7\xd6\xf3\x77\xb1\xed", "gb18030"},
 }
 
+var testErrData = []struct {
+	utf8, other, otherEncoding string
+}{
+	{"Hello 常用國字標準字體表", "Hello \xb3\xa3\xd3\xc3\x87\xf8\xd7\xd6\x98\xcb\x9c\xca\xd7\xd6\xf3\x77\xb1\xed", "gbk"},
+}
+
 func buildXml(charset string, str string) (string, string) {
 	head := `<?xml version="1.0" encoding="UTF-8"?>`
 	srcXml := strings.Replace(head, "UTF-8", charset, -1)
@@ -112,7 +119,7 @@ func Test_Encode(t *testing.T) {
 	if err != nil {
 		t.Errorf("encode error.")
 	}
-	t.Logf("%s\n", string(xmlStr))
+	//t.Logf("%s\n", string(xmlStr))
 
 	res := `<root><bool>true</bool><float>100.92</float><int>123</int><string>hello world</string></root>`
 	if string(xmlStr) != res {
@@ -130,11 +137,45 @@ func Test_EncodeIndent(t *testing.T) {
 	}
 	m["root"] = interface{}(v)
 
-	xmlStr, err := gxml.EncodeWithIndent(m, "xml")
+	_, err := gxml.EncodeWithIndent(m, "xml")
 	if err != nil {
 		t.Errorf("encodeWithIndent error.")
 	}
 
-	t.Logf("%s\n", string(xmlStr))
+	//t.Logf("%s\n", string(xmlStr))
 
 }
+
+func TestErrXml(t *testing.T) {
+	for _, v := range testErrData {
+		srcXml, dstXml := buildXml(v.otherEncoding, v.utf8)
+		if len(srcXml) == 0 && len(dstXml) == 0 {
+			t.Errorf("build xml string error. srcEncoding:%s, src:%s, utf8:%s", v.otherEncoding, v.other, v.utf8)
+		}
+
+		srcXml = strings.Replace(srcXml, "gbk", "XXX", -1)
+		_, err := gxml.ToJson([]byte(srcXml))
+		if err == nil {
+			t.Errorf("srcXml to json should be failed. %s", srcXml)
+		}
+
+	}
+}
+
+func TestErrCase(t *testing.T) {
+	gtest.Case(t, func() {
+		errXml := `<root><bool>true</bool><float>100.92</float><int>123</int><string>hello world</string>`
+		_, err := gxml.ToJson([]byte(errXml))
+		if err == nil {
+			t.Errorf("unexpected value: nil")
+		}
+	})
+
+	gtest.Case(t, func() {
+		errXml := `<root><bool>true</bool><float>100.92</float><int>123</int><string>hello world</string>`
+		_, err := gxml.Decode([]byte(errXml))
+		if err == nil {
+			t.Errorf("unexpected value: nil")
+		}
+	})
+}

g/frame/gins/gins.go

@@ -61,13 +61,13 @@ func SetIfNotExist(key string, value interface{}) bool {
 }
 
 // View returns an instance of View with default settings.
-// The param <name> is the name for the instance.
+// The parameter <name> is the name for the instance.
 func View(name ...string) *gview.View {
 	return gview.Instance(name ...)
 }
 
 // Config returns an instance of View with default settings.
-// The param <name> is the name for the instance.
+// The parameter <name> is the name for the instance.
 func Config(name ...string) *gcfg.Config {
     return gcfg.Instance(name ...)
 }

g/g_object.go

@@ -47,7 +47,7 @@ func Database(name...string) gdb.DB {
     return gins.Database(name...)
 }
 
-// Alias of Database. See Database.
+// DB is alias of Database. See Database.
 func DB(name...string) gdb.DB {
     return gins.Database(name...)
 }

g/internal/cmdenv/cmdenv.go

@@ -4,6 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
+// Package cmdenv provides access to certain variable for both command options and environment.
 package cmdenv
 
 import (
@@ -18,7 +19,12 @@ var (
 	cmdOptions = make(map[string]string)
 )
 
-func init() {
+func init()  {
+	doInit()
+}
+
+// doInit does the initialization for this package.
+func doInit() {
 	reg := regexp.MustCompile(`\-\-{0,1}(.+?)=(.+)`)
 	for i := 0; i < len(os.Args); i++ {
 		result := reg.FindStringSubmatch(os.Args[i])
@@ -28,10 +34,13 @@ func init() {
 	}
 }
 
-// 获取指定名称的命令行参数，当不存在时获取环境变量参数，皆不存在时，返回给定的默认值。
-// 规则:
-// 1、命令行参数以小写字母格式，使用: gf.包名.变量名 传递；
-// 2、环境变量参数以大写字母格式，使用: GF_包名_变量名 传递；
+// Get returns the command line argument of the specified <key>.
+// If the argument does not exist, then it returns the environment variable with specified <key>.
+// It returns the default value <def> if none of them exists.
+//
+// Fetching Rules:
+// 1. Command line arguments are in lowercase format, eg: gf.<package name>.<variable name>;
+// 2. Environment arguments are in uppercase format, eg: GF_<package name>_<variable name>；
 func Get(key string, def...interface{}) *gvar.Var {
     value := interface{}(nil)
     if len(def) > 0 {

g/internal/cmdenv/cmdenv_test.go

@@ -0,0 +1,29 @@
+// Copyright 2017 gf Author(https://github.com/gogf/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://github.com/gogf/gf.
+
+// go test *.go -bench=".*" -benchmem
+
+package cmdenv
+
+import (
+	"github.com/gogf/gf/g/test/gtest"
+	"os"
+	"testing"
+)
+
+func Test_Get(t *testing.T) {
+	os.Args = []string{"--gf.test.value1=111"}
+	os.Setenv("GF_TEST_VALUE1", "222")
+	os.Setenv("GF_TEST_VALUE2", "333")
+	doInit()
+	gtest.Case(t, func() {
+		gtest.Assert(Get("gf.test.value1").String(),    "111")
+		gtest.Assert(Get("gf.test.value2").String(),    "333")
+		gtest.Assert(Get("gf.test.value3").String(),    "")
+		gtest.Assert(Get("gf.test.value3", 1).String(), "1")
+	})
+}
+

g/internal/empty/empty.go

@@ -4,15 +4,16 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
+// Package empty provides checks for empty variables.
 package empty
 
 import (
 	"reflect"
 )
 
-// 判断给定的变量是否为空。
-// 整型为0, 布尔为false, slice/map长度为0, 其他为nil的情况，都为空。
-// 为空时返回true，否则返回false。
+// IsEmpty checks whether given <value> empty.
+// It returns true if <value> is in: 0, nil, false, "", len(slice/map/chan) == 0.
+// Or else it returns true.
 func IsEmpty(value interface{}) bool {
     if value == nil {
         return true

g/internal/mutex/mutex.go

@@ -4,11 +4,11 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
+// Package mutex provides switch for sync.Mutex for concurrent safe feature.
 package mutex
 
 import "sync"
 
-// Mutex的封装，支持对并发安全开启/关闭的控制。
 type Mutex struct {
     sync.Mutex
     safe bool

g/internal/rwmutex/rwmutex.go

@@ -4,6 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
+// Package rwmutex provides switch for sync.RWMutex for concurrent safe feature.
 package rwmutex
 
 import "sync"

g/net/gtcp/gtcp_server.go

@@ -45,7 +45,7 @@ func GetServer(name...interface{}) *Server {
 }
 
 // NewServer creates and returns a new normal TCP server.
-// The param <name> is optional, which is used to specify the instance name of the server.
+// The parameter <name> is optional, which is used to specify the instance name of the server.
 func NewServer(address string, handler func (*Conn), name...string) *Server {
     s := &Server{
     	address : address,
@@ -58,7 +58,7 @@ func NewServer(address string, handler func (*Conn), name...string) *Server {
 }
 
 // NewServerTLS creates and returns a new TCP server with TLS support.
-// The param <name> is optional, which is used to specify the instance name of the server.
+// The parameter <name> is optional, which is used to specify the instance name of the server.
 func NewServerTLS(address string, tlsConfig *tls.Config, handler func (*Conn), name...string) *Server {
 	s := NewServer(address, handler, name...)
 	s.SetTLSConfig(tlsConfig)
@@ -66,7 +66,7 @@ func NewServerTLS(address string, tlsConfig *tls.Config, handler func (*Conn), n
 }
 
 // NewServerKeyCrt creates and returns a new TCP server with TLS support.
-// The param <name> is optional, which is used to specify the instance name of the server.
+// The parameter <name> is optional, which is used to specify the instance name of the server.
 func NewServerKeyCrt(address, crtFile, keyFile string, handler func (*Conn), name...string) *Server {
 	s := NewServer(address, handler, name...)
 	if err := s.SetTLSKeyCrt(crtFile, keyFile); err != nil {

g/os/gcache/gcache.go

@@ -7,81 +7,100 @@
 // Package gcache provides high performance and concurrent-safe in-memory cache for process.
 package gcache
 
-// 全局缓存管理对象
+// Default cache object.
 var cache = New()
 
-// (使用全局KV缓存对象)设置kv缓存键值对，过期时间单位为**毫秒**
+
+// Set sets cache with <key>-<value> pair, which is expired after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
 func Set(key interface{}, value interface{}, expire int)  {
     cache.Set(key, value, expire)
 }
 
-// 当键名不存在时写入，并返回true；否则返回false。
-// 常用来做对并发性要求不高的内存锁。
+// SetIfNotExist sets cache with <key>-<value> pair if <key> does not exist in the cache,
+// which is expired after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
 func SetIfNotExist(key interface{}, value interface{}, expire int) bool {
     return cache.SetIfNotExist(key, value, expire)
 }
 
-// (使用全局KV缓存对象)批量设置kv缓存键值对，过期时间单位为**毫秒**
+// Sets batch sets cache with key-value pairs by <data>, which is expired after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
 func Sets(data map[interface{}]interface{}, expire int)  {
     cache.Sets(data, expire)
 }
 
-// (使用全局KV缓存对象)获取指定键名的值
+// Get returns the value of <key>.
+// It returns nil if it does not exist or its value is nil.
 func Get(key interface{}) interface{} {
     return cache.Get(key)
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
+// GetOrSet returns the value of <key>,
+// or sets <key>-<value> pair and returns <value> if <key> does not exist in the cache.
+// The key-value pair expires after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
 func GetOrSet(key interface{}, value interface{}, expire int) interface{} {
     return cache.GetOrSet(key, value, expire)
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+
+// GetOrSetFunc returns the value of <key>,
+// or sets <key> with result of function <f> and returns its result
+// if <key> does not exist in the cache.
+// The key-value pair expires after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
 func GetOrSetFunc(key interface{}, f func() interface{}, expire int) interface{} {
     return cache.GetOrSetFunc(key, f, expire)
 }
 
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
+// GetOrSetFuncLock returns the value of <key>,
+// or sets <key> with result of function <f> and returns its result
+// if <key> does not exist in the cache.
+// The key-value pair expires after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
+//
+// Note that the function <f> is executed within writing mutex lock.
 func GetOrSetFuncLock(key interface{}, f func() interface{}, expire int) interface{} {
     return cache.GetOrSetFuncLock(key, f, expire)
 }
 
-// 是否存在指定的键名，true表示存在，false表示不存在。
+// Contains returns true if <key> exists in the cache, or else returns false.
 func Contains(key interface{}) bool {
     return cache.Contains(key)
 }
 
-// (使用全局KV缓存对象)删除指定键值对
+// Remove deletes the <key> in the cache, and returns its value.
 func Remove(key interface{}) interface{} {
     return cache.Remove(key)
 }
 
-// (使用全局KV缓存对象)批量删除指定键值对
+// Removes deletes <keys> in the cache.
 func Removes(keys []interface{}) {
     cache.Removes(keys)
 }
 
-// 返回缓存的所有数据键值对(不包含已过期数据)
+// Data returns a copy of all key-value pairs in the cache as map type.
 func Data() map[interface{}]interface{} {
     return cache.Data()
 }
 
-// 获得所有的键名，组成数组返回
+// Keys returns all keys in the cache as slice.
 func Keys() []interface{} {
     return cache.Keys()
 }
 
-// 获得所有的键名，组成字符串数组返回
+// KeyStrings returns all keys in the cache as string slice.
 func KeyStrings() []string {
     return cache.KeyStrings()
 }
 
-// 获得所有的值，组成数组返回
+// Values returns all values in the cache as slice.
 func Values() []interface{} {
     return cache.Values()
 }
 
-// 获得缓存对象的键值对数量
+// Size returns the size of the cache.
 func Size() int {
     return cache.Size()
 }

g/os/gcache/gcache_cache.go

@@ -13,13 +13,12 @@ import (
     "unsafe"
 )
 
-// 缓存对象。
-// 底层只有一个缓存对象，如果需要提高并发性能，可新增缓存对象无锁哈希表，用键名做固定分区。
+// Cache struct.
 type Cache struct {
     *memCache
 }
 
-// Cache对象按照缓存键名首字母做了分组
+// New creates and returns a new cache object.
 func New(lruCap...int) *Cache {
     c := &Cache {
         memCache : newMemCache(lruCap...),
@@ -28,10 +27,10 @@ func New(lruCap...int) *Cache {
     return c
 }
 
-// 清空缓存中的所有数据
+// Clear clears all data of the cache.
 func (c *Cache) Clear() {
-    // 使用原子操作替换缓存对象
+	// atomic swap to ensure atomicity.
     old := atomic.SwapPointer((*unsafe.Pointer)(unsafe.Pointer(&c.memCache)), unsafe.Pointer(newMemCache()))
-    // 关闭旧的缓存对象
+    // close the old cache object.
     (*memCache)(old).Close()
 }

g/os/gcache/gcache_mem_cache.go

@@ -18,41 +18,46 @@ import (
 )
 
 
-// 缓存对象
+// Internal cache object.
 type memCache struct {
     dataMu       sync.RWMutex
     expireTimeMu sync.RWMutex
     expireSetMu  sync.RWMutex
 
-    cap          int                            // 控制缓存池大小，超过大小则按照LRU算法进行缓存过期处理(默认为0表示不进行限制)
-    data         map[interface{}]memCacheItem   // 缓存数据(所有的缓存数据存放哈希表)
-    expireTimes  map[interface{}]int64          // 键名对应的分组过期时间(用于相同键名过期时间快速更新)，键值为1秒级时间戳
-    expireSets   map[int64]*gset.Set            // 分组过期时间对应的键名列表(用于自动过期快速删除)，键值为1秒级时间戳
+	// <cap> limits the size of the cache pool.
+	// If the size of the cache exceeds the <cap>,
+	// the cache expiration process is performed according to the LRU algorithm.
+	// It is 0 in default which means no limits.
+    cap          int
+    data         map[interface{}]memCacheItem // Underlying cache data which is stored in a hash table.
+    expireTimes  map[interface{}]int64        // Expiring key mapping to its timestamp, which is used for quick indexing and deleting.
+    expireSets   map[int64]*gset.Set          // Expiring timestamp mapping to its key set, which is used for quick indexing and deleting.
 
-    lru          *memCacheLru                   // LRU缓存限制(只有限定cap池大小时才启用)
-    lruGetList   *glist.List                    // Get操作的LRU记录
-    eventList    *glist.List                    // 异步处理队列
-    closed       *gtype.Bool                    // 关闭事件通知
+    lru          *memCacheLru                 // LRU object, which is enabled when <cap> > 0.
+    lruGetList   *glist.List                  // LRU history according with Get function.
+    eventList    *glist.List                  // Asynchronous event list for internal data synchronization.
+    closed       *gtype.Bool                  // Is this cache closed or not.
 }
 
-// 缓存数据项
+// Internal cache item.
 type memCacheItem struct {
-    v interface{} // 键值
-    e int64       // 过期时间
+    v interface{} // Value.
+    e int64       // Expire time in milliseconds.
 }
 
-// 异步队列数据项
+// Internal event item.
 type memCacheEvent struct {
-    k interface{} // 键名
-    e int64       // 过期时间
+    k interface{} // Key.
+    e int64       // Expire time in milliseconds.
 }
 
 const (
-    // 当数据不过期时，默认设置的过期属性值，相当于：math.MaxInt64/1000000
+    // Default expire time for no expiring items.
+    // It equals to math.MaxInt64/1000000.
     gDEFAULT_MAX_EXPIRE = 9223372036854
 )
 
-// 创建底层的缓存对象
+// newMemCache creates and returns a new memory cache object.
 func newMemCache(lruCap...int) *memCache {
     c := &memCache {
         lruGetList  : glist.New(),
@@ -69,12 +74,12 @@ func newMemCache(lruCap...int) *memCache {
     return c
 }
 
-// 计算过期缓存的键名(将毫秒换算成秒的整数毫秒，按照1秒进行分组)
+// makeExpireKey groups the <expire> in milliseconds to its according seconds.
 func (c *memCache) makeExpireKey(expire int64) int64 {
     return int64(math.Ceil(float64(expire/1000) + 1)*1000)
 }
 
-// 获取一个过期键名存放Set, 如果没有则返回nil
+// getExpireSet returns the expire set for given <expire> in seconds.
 func (c *memCache) getExpireSet(expire int64) (expireSet *gset.Set) {
     c.expireSetMu.RLock()
     expireSet, _ = c.expireSets[expire]
@@ -82,23 +87,24 @@ func (c *memCache) getExpireSet(expire int64) (expireSet *gset.Set) {
     return
 }
 
-// 获取或者创建一个过期键名存放Set(由于是异步单线程执行，因此不会出现创建set时的覆盖问题)
+// getOrNewExpireSet returns the expire set for given <expire> in seconds.
+// It creates and returns a new set for <expire> if it does not exist.
 func (c *memCache) getOrNewExpireSet(expire int64) (expireSet *gset.Set) {
     if expireSet = c.getExpireSet(expire); expireSet == nil {
-        expireSet = gset.New()
-        c.expireSetMu.Lock()
-        // 写锁二次检索确认
-        if es, ok := c.expireSets[expire]; ok {
-            expireSet = es
-        } else {
-            c.expireSets[expire] = expireSet
-        }
+	    expireSet = gset.New()
+	    c.expireSetMu.Lock()
+	    if es, ok := c.expireSets[expire]; ok {
+		    expireSet = es
+	    } else {
+		    c.expireSets[expire] = expireSet
+	    }
         c.expireSetMu.Unlock()
     }
     return
 }
 
-// 设置kv缓存键值对，过期时间单位为毫秒，expire<=0表示不过期
+// Set sets cache with <key>-<value> pair, which is expired after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
 func (c *memCache) Set(key interface{}, value interface{}, expire int) {
     expireTime := c.getInternalExpire(expire)
     c.dataMu.Lock()
@@ -107,8 +113,12 @@ func (c *memCache) Set(key interface{}, value interface{}, expire int) {
     c.eventList.PushBack(&memCacheEvent{k : key, e : expireTime})
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// doSetWithLockCheck sets cache with <key>-<value> pair if <key> does not exist in the cache,
+// which is expired after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
+//
+// It doubly checks the <key> whether exists in the cache using mutex writing lock
+// before setting it to the cache.
 func (c *memCache) doSetWithLockCheck(key interface{}, value interface{}, expire int) interface{} {
     expireTimestamp := c.getInternalExpire(expire)
     c.dataMu.Lock()
@@ -128,7 +138,7 @@ func (c *memCache) doSetWithLockCheck(key interface{}, value interface{}, expire
     return value
 }
 
-// 根据给定expire参数计算内部使用的expire过期时间
+// getInternalExpire returns the expire time with given expire duration in milliseconds.
 func (c *memCache) getInternalExpire(expire int) int64 {
     if expire != 0 {
         return gtime.Millisecond() + int64(expire)
@@ -137,7 +147,9 @@ func (c *memCache) getInternalExpire(expire int) int64 {
     }
 }
 
-// 当键名不存在时写入，并返回true；否则返回false。
+// SetIfNotExist sets cache with <key>-<value> pair if <key> does not exist in the cache,
+// which is expired after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
 func (c *memCache) SetIfNotExist(key interface{}, value interface{}, expire int) bool {
     if !c.Contains(key) {
         c.doSetWithLockCheck(key, value, expire)
@@ -146,7 +158,8 @@ func (c *memCache) SetIfNotExist(key interface{}, value interface{}, expire int)
     return false
 }
 
-// 批量设置
+// Sets batch sets cache with key-value pairs by <data>, which is expired after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
 func (c *memCache) Sets(data map[interface{}]interface{}, expire int) {
     expireTime := c.getInternalExpire(expire)
     for k, v := range data {
@@ -157,13 +170,14 @@ func (c *memCache) Sets(data map[interface{}]interface{}, expire int) {
     }
 }
 
-// 获取指定键名的值
+// Get returns the value of <key>.
+// It returns nil if it does not exist or its value is nil.
 func (c *memCache) Get(key interface{}) interface{} {
     c.dataMu.RLock()
     item, ok := c.data[key]
     c.dataMu.RUnlock()
     if ok && !item.IsExpired() {
-        // 增加LRU(Least Recently Used)操作记录
+        // Adding to LRU history if LRU feature is enbaled.
         if c.cap > 0 {
             c.lruGetList.PushBack(key)
         }
@@ -172,7 +186,10 @@ func (c *memCache) Get(key interface{}) interface{} {
     return nil
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
+// GetOrSet returns the value of <key>,
+// or sets <key>-<value> pair and returns <value> if <key> does not exist in the cache.
+// The key-value pair expires after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
 func (c *memCache) GetOrSet(key interface{}, value interface{}, expire int) interface{} {
     if v := c.Get(key); v == nil {
         return c.doSetWithLockCheck(key, value, expire)
@@ -181,17 +198,26 @@ func (c *memCache) GetOrSet(key interface{}, value interface{}, expire int) inte
     }
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// GetOrSetFunc returns the value of <key>,
+// or sets <key> with result of function <f> and returns its result
+// if <key> does not exist in the cache.
+// The key-value pair expires after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
 func (c *memCache) GetOrSetFunc(key interface{}, f func() interface{}, expire int) interface{} {
     if v := c.Get(key); v == nil {
-        // 可能存在多个goroutine被阻塞在这里，f可能是并发运行
         return c.doSetWithLockCheck(key, f(), expire)
     } else {
         return v
     }
 }
 
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
+// GetOrSetFuncLock returns the value of <key>,
+// or sets <key> with result of function <f> and returns its result
+// if <key> does not exist in the cache.
+// The key-value pair expires after <expire> milliseconds.
+// If <expire> <=0 means it does not expire.
+//
+// Note that the function <f> is executed within writing mutex lock.
 func (c *memCache) GetOrSetFuncLock(key interface{}, f func() interface{}, expire int) interface{} {
     if v := c.Get(key); v == nil {
         return c.doSetWithLockCheck(key, f, expire)
@@ -200,12 +226,12 @@ func (c *memCache) GetOrSetFuncLock(key interface{}, f func() interface{}, expir
     }
 }
 
-// 是否存在指定的键名，true表示存在，false表示不存在。
+// Contains returns true if <key> exists in the cache, or else returns false.
 func (c *memCache) Contains(key interface{}) bool {
     return c.Get(key) != nil
 }
 
-// 删除指定键值对，并返回被删除的键值
+// Remove deletes the <key> in the cache, and returns its value.
 func (c *memCache) Remove(key interface{}) (value interface{}) {
     c.dataMu.RLock()
     item, ok := c.data[key]
@@ -220,14 +246,14 @@ func (c *memCache) Remove(key interface{}) (value interface{}) {
     return
 }
 
-// 批量删除键值对，并返回被删除的键值对数据
+// Removes deletes <keys> in the cache.
 func (c *memCache) Removes(keys []interface{}) {
     for _, key := range keys {
         c.Remove(key)
     }
 }
 
-// 返回缓存的所有数据键值对(不包含已过期数据)
+// Data returns a copy of all key-value pairs in the cache as map type.
 func (c *memCache) Data() map[interface{}]interface{} {
     m := make(map[interface{}]interface{})
     c.dataMu.RLock()
@@ -240,7 +266,7 @@ func (c *memCache) Data() map[interface{}]interface{} {
     return m
 }
 
-// 获得所有的键名，组成数组返回
+// Keys returns all keys in the cache as slice.
 func (c *memCache) Keys() []interface{} {
     keys := make([]interface{}, 0)
     c.dataMu.RLock()
@@ -253,12 +279,12 @@ func (c *memCache) Keys() []interface{} {
     return keys
 }
 
-// 获得所有的键名，组成字符串数组返回
+// KeyStrings returns all keys in the cache as string slice.
 func (c *memCache) KeyStrings() []string {
     return gconv.Strings(c.Keys())
 }
 
-// 获得所有的值，组成数组返回
+// Values returns all values in the cache as slice.
 func (c *memCache) Values() []interface{} {
     values := make([]interface{}, 0)
     c.dataMu.RLock()
@@ -271,7 +297,7 @@ func (c *memCache) Values() []interface{} {
     return values
 }
 
-// 获得缓存对象的键值对数量
+// Size returns the size of the cache.
 func (c *memCache) Size() (size int) {
     c.dataMu.RLock()
     size = len(c.data)
@@ -279,7 +305,7 @@ func (c *memCache) Size() (size int) {
     return
 }
 
-// 删除缓存对象
+// Close closes the cache.
 func (c *memCache) Close()  {
     if c.cap > 0 {
         c.lru.Close()
@@ -287,9 +313,10 @@ func (c *memCache) Close()  {
     c.closed.Set(true)
 }
 
-// 数据异步任务循环:
-// 1、将事件列表中的数据异步处理，并同步结果到expireTimes和expireSets属性中；
-// 2、清理过期键值对数据；
+// Asynchronous task loop:
+// 1. asynchronously process the data in the event list,
+//    and synchronize the results to the <expireTimes> and <expireSets> properties.
+// 2. clean up the expired key-value pair data.
 func (c *memCache) syncEventAndClearExpired() {
     event         := (*memCacheEvent)(nil)
     oldExpireTime := int64(0)
@@ -299,7 +326,7 @@ func (c *memCache) syncEventAndClearExpired() {
         return
     }
     // ========================
-    // 数据同步处理
+    // Data Synchronization.
     // ========================
     for {
         v := c.eventList.PopFront()
@@ -307,28 +334,28 @@ func (c *memCache) syncEventAndClearExpired() {
             break
         }
         event = v.(*memCacheEvent)
-        // 获得旧的过期时间分组
+        // Fetching the old expire set.
         c.expireTimeMu.RLock()
         oldExpireTime = c.expireTimes[event.k]
         c.expireTimeMu.RUnlock()
-        // 计算新的过期时间分组
+        // Calculating the new expire set.
         newExpireTime = c.makeExpireKey(event.e)
         if newExpireTime != oldExpireTime {
             c.getOrNewExpireSet(newExpireTime).Add(event.k)
             if oldExpireTime != 0 {
                 c.getOrNewExpireSet(oldExpireTime).Remove(event.k)
             }
-            // 重新设置对应键名的过期时间
+            // Updating the expire time for <event.k>.
             c.expireTimeMu.Lock()
             c.expireTimes[event.k] = newExpireTime
             c.expireTimeMu.Unlock()
         }
-        // 写入操作也会增加到LRU(Least Recently Used)操作记录
+        // Adding the key the LRU history by writing operations.
         if c.cap > 0 {
             c.lru.Push(event.k)
         }
     }
-    // 异步处理读取操作的LRU列表
+    // Processing expired keys from LRU.
     if c.cap > 0 && c.lruGetList.Len() > 0 {
         for {
             if v := c.lruGetList.PopFront(); v != nil {
@@ -339,18 +366,18 @@ func (c *memCache) syncEventAndClearExpired() {
         }
     }
     // ========================
-    // 缓存过期处理
+    // Data Cleaning up.
     // ========================
     ek := c.makeExpireKey(gtime.Millisecond())
     eks := []int64{ek - 1000, ek - 2000, ek - 3000, ek - 4000, ek - 5000}
     for _, expireTime := range eks {
         if expireSet := c.getExpireSet(expireTime); expireSet != nil {
-            // 遍历Set，执行数据过期删除
+            // Iterating the set to delete all keys in it.
             expireSet.Iterator(func(key interface{}) bool {
                 c.clearByKey(key)
                 return true
             })
-            // Set数据处理完之后删除该Set
+            // Deleting the set after all of its keys are deleted.
             c.expireSetMu.Lock()
             delete(c.expireSets, expireTime)
             c.expireSetMu.Unlock()
@@ -358,22 +385,22 @@ func (c *memCache) syncEventAndClearExpired() {
     }
 }
 
-// 删除对应键名的缓存数据
+// clearByKey deletes the key-value pair with given <key>.
+// The parameter <force> specifies whether doing this deleting forcely.
 func (c *memCache) clearByKey(key interface{}, force...bool) {
-    // 删除缓存数据
     c.dataMu.Lock()
-    // 删除核对，真正的过期才删除
+    // Doubly check before really deleting it from cache.
     if item, ok := c.data[key]; (ok && item.IsExpired()) || (len(force) > 0 && force[0]) {
         delete(c.data, key)
     }
     c.dataMu.Unlock()
 
-    // 删除异步处理数据项
+    // Deleting its expire time from <expireTimes>.
     c.expireTimeMu.Lock()
     delete(c.expireTimes, key)
     c.expireTimeMu.Unlock()
 
-    // 删除LRU管理对象中指定键名
+    // Deleting it from LRU.
     if c.cap > 0 {
         c.lru.Remove(key)
     }

g/os/gcache/gcache_mem_cache_item.go

@@ -8,9 +8,10 @@ package gcache
 
 import "github.com/gogf/gf/g/os/gtime"
 
-// 判断缓存项是否已过期
+// IsExpired checks whether <item> is expired.
 func (item *memCacheItem) IsExpired() bool {
-    // 注意这里应当包含等于，试想一下缓存时间只有最小粒度为1毫秒的情况
+    // Note that it should use greater than or equal judgement here
+    // imagining that the cache time is only 1 millisecond.
     if item.e >= gtime.Millisecond() {
         return false
     }

g/os/gcache/gcache_mem_cache_lru.go

@@ -7,24 +7,24 @@
 package gcache
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/glist"
-    "github.com/gogf/gf/g/container/gmap"
-    "github.com/gogf/gf/g/container/gtype"
-    "github.com/gogf/gf/g/os/gtimer"
-    "time"
+	"github.com/gogf/gf/g/container/glist"
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/container/gtype"
+	"github.com/gogf/gf/g/os/gtimer"
+	"time"
 )
 
-// LRU算法实现对象，底层双向链表使用了标准库的list.List
+// LRU cache object.
+// It uses list.List from stdlib for its underlying doubly linked list.
 type memCacheLru struct {
-    cache     *memCache     // 所属Cache对象
-    data      *gmap.Map     // 记录键名与链表中的位置项指针
-    list      *glist.List   // 键名历史记录链表
-    rawList   *glist.List   // 事件列表
-    closed    *gtype.Bool   // 是否关闭
+    cache     *memCache     // Parent cache object.
+    data      *gmap.Map     // Key mapping to the item of the list.
+    list      *glist.List   // Key list.
+    rawList   *glist.List   // History for key adding.
+    closed    *gtype.Bool   // Closed or not.
 }
 
-// 创建LRU管理对象
+// newMemCacheLru creates and returns a new LRU object.
 func newMemCacheLru(cache *memCache) *memCacheLru {
     lru := &memCacheLru {
         cache     : cache,
@@ -37,12 +37,12 @@ func newMemCacheLru(cache *memCache) *memCacheLru {
     return lru
 }
 
-// 关闭LRU对象
+// Close closes the LRU object.
 func (lru *memCacheLru) Close() {
     lru.closed.Set(true)
 }
 
-// 删除指定数据项
+// Remove deletes the <key> FROM <lru>.
 func (lru *memCacheLru) Remove(key interface{}) {
     if v := lru.data.Get(key); v != nil {
         lru.data.Remove(key)
@@ -50,17 +50,17 @@ func (lru *memCacheLru) Remove(key interface{}) {
     }
 }
 
-// 当前LRU数据大小
+// Size returns the size of <lru>.
 func (lru *memCacheLru) Size() int {
     return lru.data.Size()
 }
 
-// 添加LRU数据项
+// Push pushes <key> to the tail of <lru>.
 func (lru *memCacheLru) Push(key interface{}) {
     lru.rawList.PushBack(key)
 }
 
-// 从链表尾删除LRU数据项，并返回对应数据
+// Pop deletes and returns the key from tail of <lru>.
 func (lru *memCacheLru) Pop() interface{} {
     if v := lru.list.PopBack(); v != nil {
         lru.data.Remove(v)
@@ -69,34 +69,36 @@ func (lru *memCacheLru) Pop() interface{} {
     return nil
 }
 
-// 从链表头打印LRU链表值
-func (lru *memCacheLru) Print() {
-    for _, v := range lru.list.FrontAll() {
-        fmt.Printf("%v ", v)
-    }
-    fmt.Println()
-}
+// Print is used for test only.
+//func (lru *memCacheLru) Print() {
+//    for _, v := range lru.list.FrontAll() {
+//        fmt.Printf("%v ", v)
+//    }
+//    fmt.Println()
+//}
 
-// 异步执行协程，将queue中的数据同步到list中
+// SyncAndClear synchronizes the keys from <rawList> to <list> and <data>
+// using Least Recently Used algorithm.
 func (lru *memCacheLru) SyncAndClear() {
     if lru.closed.Val() {
         gtimer.Exit()
         return
     }
-    // 数据同步
+    // Data synchronization.
     for {
         if v := lru.rawList.PopFront(); v != nil {
-            // 删除对应链表项
+            // Deleting the key from list.
             if v := lru.data.Get(v); v != nil {
                 lru.list.Remove(v.(*glist.Element))
             }
-            // 将数据插入到链表头，并记录对应的链表项到哈希表中，便于检索
+	        // Pushing key to the head of the list
+	        // and setting its list item to hash table for quick indexing.
             lru.data.Set(v, lru.list.PushFront(v))
         } else {
             break
         }
     }
-    // 数据清理
+    // Data cleaning up.
     for i := lru.Size() - lru.cache.cap; i > 0; i-- {
         if s := lru.Pop(); s != nil {
             lru.cache.clearByKey(s, true)

g/os/gcache/gcache_z_unit_1_test.go

@@ -9,57 +9,265 @@
 package gcache_test
 
 import (
-    "github.com/gogf/gf/g/os/gcache"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
-    "time"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/container/gset"
+	"github.com/gogf/gf/g/os/gcache"
+	"github.com/gogf/gf/g/os/grpool"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+	"time"
 )
 
+//clear 用于清除全局缓存，因gcache api 暂未暴露 Clear 方法
+//暂定所有测试用例key的集合为1,2,3，避免不同测试用例间因全局cache共享带来的问题，每个测试用例在测试gcache.XXX之前，先调用clear()
+func clear() {
+	gcache.Removes(g.Slice{1, 2, 3})
+}
+
 func TestCache_Set(t *testing.T) {
-    gtest.Case(t, func() {
-        cache := gcache.New()
-        cache.Set(1, 11, 0)
-        gtest.Assert(cache.Get(1), 11)
-    })
+	gtest.Case(t, func() {
+		cache := gcache.New()
+		cache.Set(1, 11, 0)
+		gtest.Assert(cache.Get(1), 11)
+		gtest.Assert(cache.Contains(1), true)
+
+		clear()
+		gcache.Set(1, 11, 0)
+		gtest.Assert(gcache.Get(1), 11)
+		gtest.Assert(gcache.Contains(1), true)
+	})
 }
 
 func TestCache_Set_Expire(t *testing.T) {
-    gtest.Case(t, func() {
-        cache := gcache.New()
-        cache.Set(2, 22, 100)
-        gtest.Assert(cache.Get(2), 22)
-        time.Sleep(200*time.Millisecond)
-        gtest.Assert(cache.Get(2), nil)
-        time.Sleep(3*time.Second)
-        gtest.Assert(cache.Size(), 0)
-    })
+	gtest.Case(t, func() {
+		cache := gcache.New()
+		cache.Set(2, 22, 100)
+		gtest.Assert(cache.Get(2), 22)
+		time.Sleep(200 * time.Millisecond)
+		gtest.Assert(cache.Get(2), nil)
+		time.Sleep(3 * time.Second)
+		gtest.Assert(cache.Size(), 0)
+		cache.Close()
+	})
 }
 
 func TestCache_Keys_Values(t *testing.T) {
-    gtest.Case(t, func() {
-        cache := gcache.New()
-        for i := 0; i < 10; i++ {
-            cache.Set(i, i*10, 0)
-        }
-        gtest.Assert(len(cache.Keys()), 10)
-        gtest.Assert(len(cache.Values()), 10)
-        gtest.AssertIN(0, cache.Keys())
-        gtest.AssertIN(90, cache.Values())
-    })
+	gtest.Case(t, func() {
+		cache := gcache.New()
+		for i := 0; i < 10; i++ {
+			cache.Set(i, i*10, 0)
+		}
+		gtest.Assert(len(cache.Keys()), 10)
+		gtest.Assert(len(cache.Values()), 10)
+		gtest.AssertIN(0, cache.Keys())
+		gtest.AssertIN(90, cache.Values())
+	})
 }
 
 func TestCache_LRU(t *testing.T) {
-    gtest.Case(t, func() {
-        cache := gcache.New(2)
-        for i := 0; i < 10; i++ {
-            cache.Set(i, i, 0)
-        }
+	gtest.Case(t, func() {
+		cache := gcache.New(2)
+		for i := 0; i < 10; i++ {
+			cache.Set(i, i, 0)
+		}
+		gtest.Assert(cache.Size(), 10)
+		gtest.Assert(cache.Get(6), 6)
+		time.Sleep(4 * time.Second)
+		gtest.Assert(cache.Size(), 2)
+		gtest.Assert(cache.Get(6), 6)
+		gtest.Assert(cache.Get(1), nil)
+		cache.Close()
+	})
+}
 
-        gtest.Assert(cache.Size(), 10)
-        gtest.Assert(cache.Get(6), 6)
-        time.Sleep(4*time.Second)
-        gtest.Assert(cache.Size(), 2)
-        gtest.Assert(cache.Get(6), 6)
-        gtest.Assert(cache.Get(1), nil)
-    })
-}
+func TestCache_LRU_expire(t *testing.T) {
+	gtest.Case(t, func() {
+		cache := gcache.New(2)
+		cache.Set(1, nil, 1000)
+		gtest.Assert(cache.Size(), 1)
+		gtest.Assert(cache.Get(1), nil)
+	})
+}
+
+func TestCache_SetIfNotExist(t *testing.T) {
+	gtest.Case(t, func() {
+		cache := gcache.New()
+		cache.SetIfNotExist(1, 11, 0)
+		gtest.Assert(cache.Get(1), 11)
+		cache.SetIfNotExist(1, 22, 0)
+		gtest.Assert(cache.Get(1), 11)
+		cache.SetIfNotExist(2, 22, 0)
+		gtest.Assert(cache.Get(2), 22)
+
+		clear()
+		gcache.SetIfNotExist(1, 11, 0)
+		gtest.Assert(gcache.Get(1), 11)
+		gcache.SetIfNotExist(1, 22, 0)
+		gtest.Assert(gcache.Get(1), 11)
+	})
+}
+
+func TestCache_Sets(t *testing.T) {
+	gtest.Case(t, func() {
+		cache := gcache.New()
+		cache.Sets(g.MapAnyAny{1: 11, 2: 22}, 0)
+		gtest.Assert(cache.Get(1), 11)
+
+		clear()
+		gcache.Sets(g.MapAnyAny{1: 11, 2: 22}, 0)
+		gtest.Assert(gcache.Get(1), 11)
+	})
+}
+
+func TestCache_GetOrSet(t *testing.T) {
+	gtest.Case(t, func() {
+		cache := gcache.New()
+		cache.GetOrSet(1, 11, 0)
+		gtest.Assert(cache.Get(1), 11)
+		cache.GetOrSet(1, 111, 0)
+		gtest.Assert(cache.Get(1), 11)
+
+		clear()
+		gcache.GetOrSet(1, 11, 0)
+		gtest.Assert(gcache.Get(1), 11)
+		gcache.GetOrSet(1, 111, 0)
+		gtest.Assert(gcache.Get(1), 11)
+	})
+}
+
+func TestCache_GetOrSetFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		cache := gcache.New()
+		cache.GetOrSetFunc(1, func() interface{} {
+			return 11
+		}, 0)
+		gtest.Assert(cache.Get(1), 11)
+		cache.GetOrSetFunc(1, func() interface{} {
+			return 111
+		}, 0)
+		gtest.Assert(cache.Get(1), 11)
+
+		clear()
+		gcache.GetOrSetFunc(1, func() interface{} {
+			return 11
+		}, 0)
+		gtest.Assert(gcache.Get(1), 11)
+		gcache.GetOrSetFunc(1, func() interface{} {
+			return 111
+		}, 0)
+		gtest.Assert(gcache.Get(1), 11)
+	})
+}
+
+func TestCache_GetOrSetFuncLock(t *testing.T) {
+	gtest.Case(t, func() {
+		cache := gcache.New()
+		cache.GetOrSetFuncLock(1, func() interface{} {
+			return 11
+		}, 0)
+		gtest.Assert(cache.Get(1), 11)
+		cache.GetOrSetFuncLock(1, func() interface{} {
+			return 111
+		}, 0)
+		gtest.Assert(cache.Get(1), 11)
+
+		clear()
+		gcache.GetOrSetFuncLock(1, func() interface{} {
+			return 11
+		}, 0)
+		gtest.Assert(gcache.Get(1), 11)
+		gcache.GetOrSetFuncLock(1, func() interface{} {
+			return 111
+		}, 0)
+		gtest.Assert(gcache.Get(1), 11)
+	})
+}
+
+func TestCache_Clear(t *testing.T) {
+	gtest.Case(t, func() {
+		cache := gcache.New()
+		cache.Sets(g.MapAnyAny{1: 11, 2: 22}, 0)
+		cache.Clear()
+		gtest.Assert(cache.Size(), 0)
+	})
+}
+
+func TestCache_SetConcurrency(t *testing.T) {
+	gtest.Case(t, func() {
+		cache := gcache.New()
+		pool := grpool.New(4)
+		go func() {
+			for {
+				pool.Add(func() {
+					cache.SetIfNotExist(1, 11, 10)
+				})
+			}
+		}()
+		select {
+		case <-time.After(2 * time.Second):
+			t.Log("first part end")
+		}
+
+		go func() {
+			for {
+				pool.Add(func() {
+					cache.SetIfNotExist(1, nil, 10)
+				})
+			}
+		}()
+		select {
+		case <-time.After(2 * time.Second):
+			t.Log("second part end")
+		}
+	})
+}
+
+func TestCache_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		{
+			cache := gcache.New()
+			cache.Sets(g.MapAnyAny{1: 11, 2: 22}, 0)
+			gtest.Assert(cache.Contains(1), true)
+			gtest.Assert(cache.Get(1), 11)
+			data := cache.Data()
+			gtest.Assert(data[1], 11)
+			gtest.Assert(data[2], 22)
+			gtest.Assert(data[3], nil)
+			gtest.Assert(cache.Size(), 2)
+			keys := cache.Keys()
+			gtest.Assert(gset.NewFrom(g.Slice{1, 2}).Equal(gset.NewFrom(keys)), true)
+			keyStrs := cache.KeyStrings()
+			gtest.Assert(gset.NewFrom(g.Slice{"1", "2"}).Equal(gset.NewFrom(keyStrs)), true)
+			values := cache.Values()
+			gtest.Assert(gset.NewFrom(g.Slice{11, 22}).Equal(gset.NewFrom(values)), true)
+			removeData1 := cache.Remove(1)
+			gtest.Assert(removeData1, 11)
+			gtest.Assert(cache.Size(), 1)
+			cache.Removes(g.Slice{2})
+			gtest.Assert(cache.Size(), 0)
+		}
+
+		clear()
+		{
+			gcache.Sets(g.MapAnyAny{1: 11, 2: 22}, 0)
+			gtest.Assert(gcache.Contains(1), true)
+			gtest.Assert(gcache.Get(1), 11)
+			data := gcache.Data()
+			gtest.Assert(data[1], 11)
+			gtest.Assert(data[2], 22)
+			gtest.Assert(data[3], nil)
+			gtest.Assert(gcache.Size(), 2)
+			keys := gcache.Keys()
+			gtest.Assert(gset.NewFrom(g.Slice{1, 2}).Equal(gset.NewFrom(keys)), true)
+			keyStrs := gcache.KeyStrings()
+			gtest.Assert(gset.NewFrom(g.Slice{"1", "2"}).Equal(gset.NewFrom(keyStrs)), true)
+			values := gcache.Values()
+			gtest.Assert(gset.NewFrom(g.Slice{11, 22}).Equal(gset.NewFrom(values)), true)
+			removeData1 := gcache.Remove(1)
+			gtest.Assert(removeData1, 11)
+			gtest.Assert(gcache.Size(), 1)
+			gcache.Removes(g.Slice{2})
+			gtest.Assert(gcache.Size(), 0)
+		}
+	})
+}

g/os/gcfg/gcfg.go

@@ -40,7 +40,7 @@ type Config struct {
 }
 
 // New returns a new configuration management object.
-// The param <file> specifies the default configuration file name for reading.
+// The parameter <file> specifies the default configuration file name for reading.
 func New(file...string) *Config {
     name := DEFAULT_CONFIG_FILE
     if len(file) > 0 {
@@ -57,7 +57,9 @@ func New(file...string) *Config {
 		if gfile.Exists(envPath) {
 			_ = c.SetPath(envPath)
 		} else {
-			glog.Errorf("Configuration directory path does not exist: %s", envPath)
+			if errorPrint() {
+				glog.Errorf("Configuration directory path does not exist: %s", envPath)
+			}
 		}
 	} else {
 		// Dir path of working dir.
@@ -97,13 +99,15 @@ func (c *Config) filePath(file...string) (path string) {
         } else {
             buffer.WriteString(fmt.Sprintf("[gcfg] cannot find config file \"%s\" with no path set/add", name))
         }
-        glog.Error(buffer.String())
+	    if errorPrint() {
+		    glog.Error(buffer.String())
+	    }
     }
     return path
 }
 
 // SetPath sets the configuration directory path for file search.
-// The param <path> can be absolute or relative path,
+// The parameter <path> can be absolute or relative path,
 // but absolute path is strongly recommended.
 func (c *Config) SetPath(path string) error {
     // Absolute path.
@@ -133,13 +137,17 @@ func (c *Config) SetPath(path string) error {
             buffer.WriteString(fmt.Sprintf(`[gcfg] SetPath failed: path "%s" does not exist`, path))
         }
         err := errors.New(buffer.String())
-        glog.Error(err)
+	    if errorPrint() {
+		    glog.Error(err)
+	    }
         return err
     }
     // Should be a directory.
     if !gfile.IsDir(realPath) {
         err := errors.New(fmt.Sprintf(`[gcfg] SetPath failed: path "%s" should be directory type`, path))
-        glog.Error(err)
+	    if errorPrint() {
+		    glog.Error(err)
+	    }
         return err
     }
     // Repeated path check.
@@ -191,12 +199,16 @@ func (c *Config) AddPath(path string) error {
             buffer.WriteString(fmt.Sprintf(`[gcfg] AddPath failed: path "%s" does not exist`, path))
         }
         err := errors.New(buffer.String())
-        glog.Error(err)
+	    if errorPrint() {
+		    glog.Error(err)
+	    }
         return err
     }
     if !gfile.IsDir(realPath) {
         err := errors.New(fmt.Sprintf(`[gcfg] AddPath failed: path "%s" should be directory type`, path))
-        glog.Error(err)
+	    if errorPrint() {
+	    	glog.Error(err)
+	    }
         return err
     }
     // Repeated path check.
@@ -269,17 +281,19 @@ func (c *Config) getJson(file...string) *gjson.Json {
             // Add monitor for this configuration file,
             // any changes of this file will refresh its cache in Config object.
             if filePath != "" {
-                gfsnotify.Add(filePath, func(event *gfsnotify.Event) {
+                _, _ = gfsnotify.Add(filePath, func(event *gfsnotify.Event) {
                     c.jsons.Remove(name)
                 })
             }
             return j
         } else {
-            if filePath != "" {
-                glog.Criticalf(`[gcfg] Load config file "%s" failed: %s`, filePath, err.Error())
-            } else {
-                glog.Criticalf(`[gcfg] Load configuration failed: %s`, err.Error())
-            }
+	        if errorPrint() {
+		        if filePath != "" {
+			        glog.Criticalf(`[gcfg] Load config file "%s" failed: %s`, filePath, err.Error())
+		        } else {
+			        glog.Criticalf(`[gcfg] Load configuration failed: %s`, err.Error())
+		        }
+	        }
         }
         return nil
     })

g/os/gcfg/gcfg_error.go

@@ -0,0 +1,22 @@
+// Copyright 2019 gf Author(https://github.com/gogf/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://github.com/gogf/gf.
+
+package gcfg
+
+import (
+	"github.com/gogf/gf/g/internal/cmdenv"
+)
+
+const (
+	// gERROR_PRINT_KEY is used to specify the key controlling error printing to stdout.
+	// This error is designed not to be returned by functions.
+	gERROR_PRINT_KEY = "gf.gcfg.errorprint"
+)
+
+// errorPrint checks whether printing error to stdout.
+func errorPrint() bool {
+	return cmdenv.Get(gERROR_PRINT_KEY, true).Bool()
+}

g/os/gcfg/gcfg_instance.go

@@ -20,7 +20,7 @@ var (
 )
 
 // Instance returns an instance of Config with default settings.
-// The param <name> is the name for the instance.
+// The parameter <name> is the name for the instance.
 func Instance(name...string) *Config {
 	key := DEFAULT_GROUP_NAME
 	if len(name) > 0 {

g/os/gcfg/gcfg_z_unit_test.go

@@ -9,14 +9,22 @@
 package gcfg_test
 
 import (
-    "github.com/gogf/gf/g/os/gcfg"
-    "github.com/gogf/gf/g/os/gfile"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/encoding/gjson"
+	"github.com/gogf/gf/g/os/gcfg"
+	"github.com/gogf/gf/g/os/gfile"
+	"github.com/gogf/gf/g/test/gtest"
+	"io/ioutil"
+	"os"
+	"testing"
 )
 
+func init() {
+	os.Setenv("GF_GCFG_ERRORPRINT", "false")
+}
+
 func Test_Basic(t *testing.T) {
-    config := `
+	config := `
 v1    = 1
 v2    = "true"
 v3    = "off"
@@ -26,58 +34,58 @@ array = [1,2,3]
     disk  = "127.0.0.1:6379,0"
     cache = "127.0.0.1:6379,1"
 `
-    gtest.Case(t, func() {
-        path := gcfg.DEFAULT_CONFIG_FILE
-        err  := gfile.PutContents(path, config)
-        gtest.Assert(err, nil)
-        defer gfile.Remove(path)
+	gtest.Case(t, func() {
+		path := gcfg.DEFAULT_CONFIG_FILE
+		err := gfile.PutContents(path, config)
+		gtest.Assert(err, nil)
+		defer gfile.Remove(path)
 
-        c := gcfg.New()
-        gtest.Assert(c.Get("v1"),           1)
-        gtest.AssertEQ(c.GetInt("v1"),      1)
-        gtest.AssertEQ(c.GetInt8("v1"),     int8(1))
-        gtest.AssertEQ(c.GetInt16("v1"),    int16(1))
-        gtest.AssertEQ(c.GetInt32("v1"),    int32(1))
-        gtest.AssertEQ(c.GetInt64("v1"),    int64(1))
-        gtest.AssertEQ(c.GetUint("v1"),     uint(1))
-        gtest.AssertEQ(c.GetUint8("v1"),    uint8(1))
-        gtest.AssertEQ(c.GetUint16("v1"),   uint16(1))
-        gtest.AssertEQ(c.GetUint32("v1"),   uint32(1))
-        gtest.AssertEQ(c.GetUint64("v1"),   uint64(1))
+		c := gcfg.New()
+		gtest.Assert(c.Get("v1"), 1)
+		gtest.AssertEQ(c.GetInt("v1"), 1)
+		gtest.AssertEQ(c.GetInt8("v1"), int8(1))
+		gtest.AssertEQ(c.GetInt16("v1"), int16(1))
+		gtest.AssertEQ(c.GetInt32("v1"), int32(1))
+		gtest.AssertEQ(c.GetInt64("v1"), int64(1))
+		gtest.AssertEQ(c.GetUint("v1"), uint(1))
+		gtest.AssertEQ(c.GetUint8("v1"), uint8(1))
+		gtest.AssertEQ(c.GetUint16("v1"), uint16(1))
+		gtest.AssertEQ(c.GetUint32("v1"), uint32(1))
+		gtest.AssertEQ(c.GetUint64("v1"), uint64(1))
 
-        gtest.AssertEQ(c.GetVar("v1").String(), "1")
-        gtest.AssertEQ(c.GetVar("v1").Bool(),   true)
-        gtest.AssertEQ(c.GetVar("v2").String(), "true")
-        gtest.AssertEQ(c.GetVar("v2").Bool(),   true)
+		gtest.AssertEQ(c.GetVar("v1").String(), "1")
+		gtest.AssertEQ(c.GetVar("v1").Bool(), true)
+		gtest.AssertEQ(c.GetVar("v2").String(), "true")
+		gtest.AssertEQ(c.GetVar("v2").Bool(), true)
 
-        gtest.AssertEQ(c.GetString("v1"),  "1")
-        gtest.AssertEQ(c.GetFloat32("v4"), float32(1.23))
-        gtest.AssertEQ(c.GetFloat64("v4"), float64(1.23))
-        gtest.AssertEQ(c.GetString("v2"),  "true")
-        gtest.AssertEQ(c.GetBool("v2"),    true)
-        gtest.AssertEQ(c.GetBool("v3"),    false)
+		gtest.AssertEQ(c.GetString("v1"), "1")
+		gtest.AssertEQ(c.GetFloat32("v4"), float32(1.23))
+		gtest.AssertEQ(c.GetFloat64("v4"), float64(1.23))
+		gtest.AssertEQ(c.GetString("v2"), "true")
+		gtest.AssertEQ(c.GetBool("v2"), true)
+		gtest.AssertEQ(c.GetBool("v3"), false)
 
-        gtest.AssertEQ(c.Contains("v1"),    true)
-        gtest.AssertEQ(c.Contains("v2"),    true)
-        gtest.AssertEQ(c.Contains("v3"),    true)
-        gtest.AssertEQ(c.Contains("v4"),    true)
-        gtest.AssertEQ(c.Contains("v5"),    false)
+		gtest.AssertEQ(c.Contains("v1"), true)
+		gtest.AssertEQ(c.Contains("v2"), true)
+		gtest.AssertEQ(c.Contains("v3"), true)
+		gtest.AssertEQ(c.Contains("v4"), true)
+		gtest.AssertEQ(c.Contains("v5"), false)
 
-        gtest.AssertEQ(c.GetInts("array"),        []int{1,2,3})
-        gtest.AssertEQ(c.GetStrings("array"),     []string{"1","2","3"})
-        gtest.AssertEQ(c.GetArray("array"),       []interface{}{"1","2","3"})
-        gtest.AssertEQ(c.GetInterfaces("array"),  []interface{}{"1","2","3"})
-        gtest.AssertEQ(c.GetMap("redis"),         map[string]interface{}{
-            "disk"  : "127.0.0.1:6379,0",
-            "cache" : "127.0.0.1:6379,1",
-        })
-        gtest.AssertEQ(c.FilePath(),    gfile.Pwd() + gfile.Separator + path)
+		gtest.AssertEQ(c.GetInts("array"), []int{1, 2, 3})
+		gtest.AssertEQ(c.GetStrings("array"), []string{"1", "2", "3"})
+		gtest.AssertEQ(c.GetArray("array"), []interface{}{"1", "2", "3"})
+		gtest.AssertEQ(c.GetInterfaces("array"), []interface{}{"1", "2", "3"})
+		gtest.AssertEQ(c.GetMap("redis"), map[string]interface{}{
+			"disk":  "127.0.0.1:6379,0",
+			"cache": "127.0.0.1:6379,1",
+		})
+		gtest.AssertEQ(c.FilePath(), gfile.Pwd()+gfile.Separator+path)
 
-    })
+	})
 }
 
 func Test_Content(t *testing.T) {
-    content := `
+	content := `
 v1    = 1
 v2    = "true"
 v3    = "off"
@@ -87,54 +95,54 @@ array = [1,2,3]
     disk  = "127.0.0.1:6379,0"
     cache = "127.0.0.1:6379,1"
 `
-    gcfg.SetContent(content)
-    defer gcfg.ClearContent()
+	gcfg.SetContent(content)
+	defer gcfg.ClearContent()
 
-    gtest.Case(t, func() {
-        c := gcfg.New()
-        gtest.Assert(c.Get("v1"),           1)
-        gtest.AssertEQ(c.GetInt("v1"),      1)
-        gtest.AssertEQ(c.GetInt8("v1"),     int8(1))
-        gtest.AssertEQ(c.GetInt16("v1"),    int16(1))
-        gtest.AssertEQ(c.GetInt32("v1"),    int32(1))
-        gtest.AssertEQ(c.GetInt64("v1"),    int64(1))
-        gtest.AssertEQ(c.GetUint("v1"),     uint(1))
-        gtest.AssertEQ(c.GetUint8("v1"),    uint8(1))
-        gtest.AssertEQ(c.GetUint16("v1"),   uint16(1))
-        gtest.AssertEQ(c.GetUint32("v1"),   uint32(1))
-        gtest.AssertEQ(c.GetUint64("v1"),   uint64(1))
+	gtest.Case(t, func() {
+		c := gcfg.New()
+		gtest.Assert(c.Get("v1"), 1)
+		gtest.AssertEQ(c.GetInt("v1"), 1)
+		gtest.AssertEQ(c.GetInt8("v1"), int8(1))
+		gtest.AssertEQ(c.GetInt16("v1"), int16(1))
+		gtest.AssertEQ(c.GetInt32("v1"), int32(1))
+		gtest.AssertEQ(c.GetInt64("v1"), int64(1))
+		gtest.AssertEQ(c.GetUint("v1"), uint(1))
+		gtest.AssertEQ(c.GetUint8("v1"), uint8(1))
+		gtest.AssertEQ(c.GetUint16("v1"), uint16(1))
+		gtest.AssertEQ(c.GetUint32("v1"), uint32(1))
+		gtest.AssertEQ(c.GetUint64("v1"), uint64(1))
 
-        gtest.AssertEQ(c.GetVar("v1").String(), "1")
-        gtest.AssertEQ(c.GetVar("v1").Bool(),   true)
-        gtest.AssertEQ(c.GetVar("v2").String(), "true")
-        gtest.AssertEQ(c.GetVar("v2").Bool(),   true)
+		gtest.AssertEQ(c.GetVar("v1").String(), "1")
+		gtest.AssertEQ(c.GetVar("v1").Bool(), true)
+		gtest.AssertEQ(c.GetVar("v2").String(), "true")
+		gtest.AssertEQ(c.GetVar("v2").Bool(), true)
 
-        gtest.AssertEQ(c.GetString("v1"),  "1")
-        gtest.AssertEQ(c.GetFloat32("v4"), float32(1.23))
-        gtest.AssertEQ(c.GetFloat64("v4"), float64(1.23))
-        gtest.AssertEQ(c.GetString("v2"),  "true")
-        gtest.AssertEQ(c.GetBool("v2"),    true)
-        gtest.AssertEQ(c.GetBool("v3"),    false)
+		gtest.AssertEQ(c.GetString("v1"), "1")
+		gtest.AssertEQ(c.GetFloat32("v4"), float32(1.23))
+		gtest.AssertEQ(c.GetFloat64("v4"), float64(1.23))
+		gtest.AssertEQ(c.GetString("v2"), "true")
+		gtest.AssertEQ(c.GetBool("v2"), true)
+		gtest.AssertEQ(c.GetBool("v3"), false)
 
-        gtest.AssertEQ(c.Contains("v1"),    true)
-        gtest.AssertEQ(c.Contains("v2"),    true)
-        gtest.AssertEQ(c.Contains("v3"),    true)
-        gtest.AssertEQ(c.Contains("v4"),    true)
-        gtest.AssertEQ(c.Contains("v5"),    false)
+		gtest.AssertEQ(c.Contains("v1"), true)
+		gtest.AssertEQ(c.Contains("v2"), true)
+		gtest.AssertEQ(c.Contains("v3"), true)
+		gtest.AssertEQ(c.Contains("v4"), true)
+		gtest.AssertEQ(c.Contains("v5"), false)
 
-        gtest.AssertEQ(c.GetInts("array"),        []int{1,2,3})
-        gtest.AssertEQ(c.GetStrings("array"),     []string{"1","2","3"})
-        gtest.AssertEQ(c.GetArray("array"),       []interface{}{"1","2","3"})
-        gtest.AssertEQ(c.GetInterfaces("array"),  []interface{}{"1","2","3"})
-        gtest.AssertEQ(c.GetMap("redis"),         map[string]interface{}{
-            "disk"  : "127.0.0.1:6379,0",
-            "cache" : "127.0.0.1:6379,1",
-        })
-    })
+		gtest.AssertEQ(c.GetInts("array"), []int{1, 2, 3})
+		gtest.AssertEQ(c.GetStrings("array"), []string{"1", "2", "3"})
+		gtest.AssertEQ(c.GetArray("array"), []interface{}{"1", "2", "3"})
+		gtest.AssertEQ(c.GetInterfaces("array"), []interface{}{"1", "2", "3"})
+		gtest.AssertEQ(c.GetMap("redis"), map[string]interface{}{
+			"disk":  "127.0.0.1:6379,0",
+			"cache": "127.0.0.1:6379,1",
+		})
+	})
 }
 
 func Test_SetFileName(t *testing.T) {
-    config := `
+	config := `
 {
 	"array": [
 		1,
@@ -151,59 +159,59 @@ func Test_SetFileName(t *testing.T) {
 	"v4": "1.234"
 }
 `
-    gtest.Case(t, func() {
-        path := "config.json"
-        err  := gfile.PutContents(path, config)
-        gtest.Assert(err, nil)
-        defer gfile.Remove(path)
+	gtest.Case(t, func() {
+		path := "config.json"
+		err := gfile.PutContents(path, config)
+		gtest.Assert(err, nil)
+		defer gfile.Remove(path)
 
-        c := gcfg.New()
-        c.SetFileName(path)
-        gtest.Assert(c.Get("v1"),           1)
-        gtest.AssertEQ(c.GetInt("v1"),      1)
-        gtest.AssertEQ(c.GetInt8("v1"),     int8(1))
-        gtest.AssertEQ(c.GetInt16("v1"),    int16(1))
-        gtest.AssertEQ(c.GetInt32("v1"),    int32(1))
-        gtest.AssertEQ(c.GetInt64("v1"),    int64(1))
-        gtest.AssertEQ(c.GetUint("v1"),     uint(1))
-        gtest.AssertEQ(c.GetUint8("v1"),    uint8(1))
-        gtest.AssertEQ(c.GetUint16("v1"),   uint16(1))
-        gtest.AssertEQ(c.GetUint32("v1"),   uint32(1))
-        gtest.AssertEQ(c.GetUint64("v1"),   uint64(1))
+		c := gcfg.New()
+		c.SetFileName(path)
+		gtest.Assert(c.Get("v1"), 1)
+		gtest.AssertEQ(c.GetInt("v1"), 1)
+		gtest.AssertEQ(c.GetInt8("v1"), int8(1))
+		gtest.AssertEQ(c.GetInt16("v1"), int16(1))
+		gtest.AssertEQ(c.GetInt32("v1"), int32(1))
+		gtest.AssertEQ(c.GetInt64("v1"), int64(1))
+		gtest.AssertEQ(c.GetUint("v1"), uint(1))
+		gtest.AssertEQ(c.GetUint8("v1"), uint8(1))
+		gtest.AssertEQ(c.GetUint16("v1"), uint16(1))
+		gtest.AssertEQ(c.GetUint32("v1"), uint32(1))
+		gtest.AssertEQ(c.GetUint64("v1"), uint64(1))
 
-        gtest.AssertEQ(c.GetVar("v1").String(), "1")
-        gtest.AssertEQ(c.GetVar("v1").Bool(),   true)
-        gtest.AssertEQ(c.GetVar("v2").String(), "true")
-        gtest.AssertEQ(c.GetVar("v2").Bool(),   true)
+		gtest.AssertEQ(c.GetVar("v1").String(), "1")
+		gtest.AssertEQ(c.GetVar("v1").Bool(), true)
+		gtest.AssertEQ(c.GetVar("v2").String(), "true")
+		gtest.AssertEQ(c.GetVar("v2").Bool(), true)
 
-        gtest.AssertEQ(c.GetString("v1"),  "1")
-        gtest.AssertEQ(c.GetFloat32("v4"), float32(1.234))
-        gtest.AssertEQ(c.GetFloat64("v4"), float64(1.234))
-        gtest.AssertEQ(c.GetString("v2"),  "true")
-        gtest.AssertEQ(c.GetBool("v2"),    true)
-        gtest.AssertEQ(c.GetBool("v3"),    false)
+		gtest.AssertEQ(c.GetString("v1"), "1")
+		gtest.AssertEQ(c.GetFloat32("v4"), float32(1.234))
+		gtest.AssertEQ(c.GetFloat64("v4"), float64(1.234))
+		gtest.AssertEQ(c.GetString("v2"), "true")
+		gtest.AssertEQ(c.GetBool("v2"), true)
+		gtest.AssertEQ(c.GetBool("v3"), false)
 
-        gtest.AssertEQ(c.Contains("v1"),    true)
-        gtest.AssertEQ(c.Contains("v2"),    true)
-        gtest.AssertEQ(c.Contains("v3"),    true)
-        gtest.AssertEQ(c.Contains("v4"),    true)
-        gtest.AssertEQ(c.Contains("v5"),    false)
+		gtest.AssertEQ(c.Contains("v1"), true)
+		gtest.AssertEQ(c.Contains("v2"), true)
+		gtest.AssertEQ(c.Contains("v3"), true)
+		gtest.AssertEQ(c.Contains("v4"), true)
+		gtest.AssertEQ(c.Contains("v5"), false)
 
-        gtest.AssertEQ(c.GetInts("array"),        []int{1,2,3})
-        gtest.AssertEQ(c.GetStrings("array"),     []string{"1","2","3"})
-        gtest.AssertEQ(c.GetArray("array"),       []interface{}{"1","2","3"})
-        gtest.AssertEQ(c.GetInterfaces("array"),  []interface{}{"1","2","3"})
-        gtest.AssertEQ(c.GetMap("redis"),         map[string]interface{}{
-            "disk"  : "127.0.0.1:6379,0",
-            "cache" : "127.0.0.1:6379,1",
-        })
-        gtest.AssertEQ(c.FilePath(),    gfile.Pwd() + gfile.Separator + path)
+		gtest.AssertEQ(c.GetInts("array"), []int{1, 2, 3})
+		gtest.AssertEQ(c.GetStrings("array"), []string{"1", "2", "3"})
+		gtest.AssertEQ(c.GetArray("array"), []interface{}{"1", "2", "3"})
+		gtest.AssertEQ(c.GetInterfaces("array"), []interface{}{"1", "2", "3"})
+		gtest.AssertEQ(c.GetMap("redis"), map[string]interface{}{
+			"disk":  "127.0.0.1:6379,0",
+			"cache": "127.0.0.1:6379,1",
+		})
+		gtest.AssertEQ(c.FilePath(), gfile.Pwd()+gfile.Separator+path)
 
-    })
+	})
 }
 
 func Test_Instance(t *testing.T) {
-    config := `
+	config := `
 {
 	"array": [
 		1,
@@ -220,52 +228,183 @@ func Test_Instance(t *testing.T) {
 	"v4": "1.234"
 }
 `
-    gtest.Case(t, func() {
-        path := gcfg.DEFAULT_CONFIG_FILE
-        err  := gfile.PutContents(path, config)
-        gtest.Assert(err, nil)
-        defer gfile.Remove(path)
+	gtest.Case(t, func() {
+		path := gcfg.DEFAULT_CONFIG_FILE
+		err := gfile.PutContents(path, config)
+		gtest.Assert(err, nil)
+		defer gfile.Remove(path)
 
-        c := gcfg.Instance()
-        gtest.Assert(c.Get("v1"),           1)
-        gtest.AssertEQ(c.GetInt("v1"),      1)
-        gtest.AssertEQ(c.GetInt8("v1"),     int8(1))
-        gtest.AssertEQ(c.GetInt16("v1"),    int16(1))
-        gtest.AssertEQ(c.GetInt32("v1"),    int32(1))
-        gtest.AssertEQ(c.GetInt64("v1"),    int64(1))
-        gtest.AssertEQ(c.GetUint("v1"),     uint(1))
-        gtest.AssertEQ(c.GetUint8("v1"),    uint8(1))
-        gtest.AssertEQ(c.GetUint16("v1"),   uint16(1))
-        gtest.AssertEQ(c.GetUint32("v1"),   uint32(1))
-        gtest.AssertEQ(c.GetUint64("v1"),   uint64(1))
+		c := gcfg.Instance()
+		gtest.Assert(c.Get("v1"), 1)
+		gtest.AssertEQ(c.GetInt("v1"), 1)
+		gtest.AssertEQ(c.GetInt8("v1"), int8(1))
+		gtest.AssertEQ(c.GetInt16("v1"), int16(1))
+		gtest.AssertEQ(c.GetInt32("v1"), int32(1))
+		gtest.AssertEQ(c.GetInt64("v1"), int64(1))
+		gtest.AssertEQ(c.GetUint("v1"), uint(1))
+		gtest.AssertEQ(c.GetUint8("v1"), uint8(1))
+		gtest.AssertEQ(c.GetUint16("v1"), uint16(1))
+		gtest.AssertEQ(c.GetUint32("v1"), uint32(1))
+		gtest.AssertEQ(c.GetUint64("v1"), uint64(1))
 
-        gtest.AssertEQ(c.GetVar("v1").String(), "1")
-        gtest.AssertEQ(c.GetVar("v1").Bool(),   true)
-        gtest.AssertEQ(c.GetVar("v2").String(), "true")
-        gtest.AssertEQ(c.GetVar("v2").Bool(),   true)
+		gtest.AssertEQ(c.GetVar("v1").String(), "1")
+		gtest.AssertEQ(c.GetVar("v1").Bool(), true)
+		gtest.AssertEQ(c.GetVar("v2").String(), "true")
+		gtest.AssertEQ(c.GetVar("v2").Bool(), true)
 
-        gtest.AssertEQ(c.GetString("v1"),  "1")
-        gtest.AssertEQ(c.GetFloat32("v4"), float32(1.234))
-        gtest.AssertEQ(c.GetFloat64("v4"), float64(1.234))
-        gtest.AssertEQ(c.GetString("v2"),  "true")
-        gtest.AssertEQ(c.GetBool("v2"),    true)
-        gtest.AssertEQ(c.GetBool("v3"),    false)
+		gtest.AssertEQ(c.GetString("v1"), "1")
+		gtest.AssertEQ(c.GetFloat32("v4"), float32(1.234))
+		gtest.AssertEQ(c.GetFloat64("v4"), float64(1.234))
+		gtest.AssertEQ(c.GetString("v2"), "true")
+		gtest.AssertEQ(c.GetBool("v2"), true)
+		gtest.AssertEQ(c.GetBool("v3"), false)
 
-        gtest.AssertEQ(c.Contains("v1"),    true)
-        gtest.AssertEQ(c.Contains("v2"),    true)
-        gtest.AssertEQ(c.Contains("v3"),    true)
-        gtest.AssertEQ(c.Contains("v4"),    true)
-        gtest.AssertEQ(c.Contains("v5"),    false)
+		gtest.AssertEQ(c.Contains("v1"), true)
+		gtest.AssertEQ(c.Contains("v2"), true)
+		gtest.AssertEQ(c.Contains("v3"), true)
+		gtest.AssertEQ(c.Contains("v4"), true)
+		gtest.AssertEQ(c.Contains("v5"), false)
 
-        gtest.AssertEQ(c.GetInts("array"),        []int{1,2,3})
-        gtest.AssertEQ(c.GetStrings("array"),     []string{"1","2","3"})
-        gtest.AssertEQ(c.GetArray("array"),       []interface{}{"1","2","3"})
-        gtest.AssertEQ(c.GetInterfaces("array"),  []interface{}{"1","2","3"})
-        gtest.AssertEQ(c.GetMap("redis"),         map[string]interface{}{
-            "disk"  : "127.0.0.1:6379,0",
-            "cache" : "127.0.0.1:6379,1",
-        })
-        gtest.AssertEQ(c.FilePath(),    gfile.Pwd() + gfile.Separator + path)
+		gtest.AssertEQ(c.GetInts("array"), []int{1, 2, 3})
+		gtest.AssertEQ(c.GetStrings("array"), []string{"1", "2", "3"})
+		gtest.AssertEQ(c.GetArray("array"), []interface{}{"1", "2", "3"})
+		gtest.AssertEQ(c.GetInterfaces("array"), []interface{}{"1", "2", "3"})
+		gtest.AssertEQ(c.GetMap("redis"), map[string]interface{}{
+			"disk":  "127.0.0.1:6379,0",
+			"cache": "127.0.0.1:6379,1",
+		})
+		gtest.AssertEQ(c.FilePath(), gfile.Pwd()+gfile.Separator+path)
 
-    })
-}
+	})
+}
+
+func TestCfg_New(t *testing.T) {
+	gtest.Case(t, func() {
+		os.Setenv("GF_GCFG_PATH", "config")
+		c := gcfg.New("config.yml")
+		gtest.Assert(c.Get("name"), nil)
+		gtest.Assert(c.GetFileName(), "config.yml")
+
+		configPath := gfile.Pwd() + gfile.Separator + "config"
+		gfile.Mkdir(configPath)
+		defer gfile.Remove(configPath)
+		c = gcfg.New("config.yml")
+		gtest.Assert(c.Get("name"), nil)
+
+		os.Unsetenv("GF_GCFG_PATH")
+		c = gcfg.New("config.yml")
+		gtest.Assert(c.Get("name"), nil)
+	})
+}
+
+func TestCfg_SetPath(t *testing.T) {
+	gtest.Case(t, func() {
+		c := gcfg.New("config.yml")
+		err := c.SetPath("tmp")
+		gtest.AssertNE(err, nil)
+		err = c.SetPath("gcfg.go")
+		gtest.AssertNE(err, nil)
+		gtest.Assert(c.Get("name"), nil)
+	})
+}
+
+func TestCfg_SetViolenceCheck(t *testing.T) {
+	gtest.Case(t, func() {
+		c := gcfg.New("config.yml")
+		c.SetViolenceCheck(true)
+		gtest.Assert(c.Get("name"), nil)
+	})
+}
+
+func TestCfg_AddPath(t *testing.T) {
+	gtest.Case(t, func() {
+		c := gcfg.New("config.yml")
+		err := c.AddPath("tmp")
+		gtest.AssertNE(err, nil)
+		err = c.AddPath("gcfg.go")
+		gtest.AssertNE(err, nil)
+		gtest.Assert(c.Get("name"), nil)
+	})
+}
+
+func TestCfg_FilePath(t *testing.T) {
+	gtest.Case(t, func() {
+		c := gcfg.New("config.yml")
+		path := c.FilePath("tmp")
+		gtest.Assert(path, "")
+		path = c.GetFilePath("tmp")
+		gtest.Assert(path, "")
+	})
+}
+
+func TestCfg_Get(t *testing.T) {
+	gtest.Case(t, func() {
+		configPath := gfile.Pwd() + gfile.Separator + "config"
+		gfile.Mkdir(configPath)
+		defer gfile.Remove(configPath)
+		ioutil.WriteFile(configPath+gfile.Separator+"config.yml", []byte("wrong config"), 0644)
+		c := gcfg.New("config.yml")
+		gtest.Assert(c.Get("name"), nil)
+		gtest.Assert(c.GetVar("name").Val(), nil)
+		gtest.Assert(c.Contains("name"), false)
+		gtest.Assert(c.GetMap("name"), nil)
+		gtest.Assert(c.GetArray("name"), nil)
+		gtest.Assert(c.GetString("name"), "")
+		gtest.Assert(c.GetStrings("name"), nil)
+		gtest.Assert(c.GetInterfaces("name"), nil)
+		gtest.Assert(c.GetBool("name"), false)
+		gtest.Assert(c.GetFloat32("name"), 0)
+		gtest.Assert(c.GetFloat64("name"), 0)
+		gtest.Assert(c.GetFloats("name"), nil)
+		gtest.Assert(c.GetInt("name"), 0)
+		gtest.Assert(c.GetInt8("name"), 0)
+		gtest.Assert(c.GetInt16("name"), 0)
+		gtest.Assert(c.GetInt32("name"), 0)
+		gtest.Assert(c.GetInt64("name"), 0)
+		gtest.Assert(c.GetInts("name"), nil)
+		gtest.Assert(c.GetUint("name"), 0)
+		gtest.Assert(c.GetUint8("name"), 0)
+		gtest.Assert(c.GetUint16("name"), 0)
+		gtest.Assert(c.GetUint32("name"), 0)
+		gtest.Assert(c.GetUint64("name"), 0)
+		gtest.Assert(c.GetTime("name").Format("2006-01-02"), "0001-01-01")
+		gtest.Assert(c.GetGTime("name"), nil)
+		gtest.Assert(c.GetDuration("name").String(), "0s")
+		name := struct {
+			Name string
+		}{}
+		gtest.Assert(c.GetToStruct("name", &name) == nil, false)
+
+		c.Reload()
+		c.Clear()
+
+		arr, _ := gjson.Encode(g.Map{"name": "gf", "time": "2019-06-12", "person": g.Map{"name": "gf"}, "floats": g.Slice{1, 2, 3}})
+		ioutil.WriteFile(configPath+gfile.Separator+"config.yml", arr, 0644)
+		gtest.Assert(c.GetTime("time").Format("2006-01-02"), "2019-06-12")
+		gtest.Assert(c.GetGTime("time").Format("Y-m-d"), "2019-06-12")
+		gtest.Assert(c.GetDuration("time").String(), "0s")
+		//t.Log(c.GetString("person"))
+		err := c.GetToStruct("person", &name)
+		gtest.Assert(err, nil)
+		gtest.Assert(name.Name, "gf")
+		gtest.Assert(c.GetFloats("floats") == nil, false)
+	})
+}
+
+func TestCfg_Instance(t *testing.T) {
+	gtest.Case(t, func() {
+		gtest.Assert(gcfg.Instance("gf") != nil, true)
+	})
+}
+
+func TestCfg_Config(t *testing.T) {
+	gtest.Case(t, func() {
+		gcfg.SetContent("gf", "config.yml")
+		gtest.Assert(gcfg.GetContent("config.yml"), "gf")
+		gcfg.SetContent("gf1", "config.yml")
+		gtest.Assert(gcfg.GetContent("config.yml"), "gf1")
+		gcfg.RemoveConfig("config.yml")
+		gcfg.ClearContent()
+		gtest.Assert(gcfg.GetContent("name"), "")
+	})
+}

g/os/gcmd/gcmd.go

@@ -24,13 +24,19 @@ type gCmdOption struct {
 	options map[string]string
 }
 
-var Value = &gCmdValue{}                 // Console values.
-var Option = &gCmdOption{}               // Console options.
+var Value      = &gCmdValue{}            // Console values.
+var Option     = &gCmdOption{}           // Console options.
 var cmdFuncMap = make(map[string]func()) // Registered callback functions.
 
 func init() {
-	reg := regexp.MustCompile(`\-\-{0,1}(.+?)=(.+)`)
+	doInit()
+}
+
+// doInit does the initialization for this package.
+func doInit() {
+	Value.values   = Value.values[:0]
 	Option.options = make(map[string]string)
+	reg := regexp.MustCompile(`\-\-{0,1}(.+?)=(.+)`)
 	for i := 0; i < len(os.Args); i++ {
 		result := reg.FindStringSubmatch(os.Args[i])
 		if len(result) > 1 {

g/os/gcmd/gcmd_z_unit_test.go

@@ -0,0 +1,28 @@
+// Copyright 2017 gf Author(https://github.com/gogf/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://github.com/gogf/gf.
+
+// go test *.go -bench=".*" -benchmem
+
+package gcmd
+
+import (
+	"github.com/gogf/gf/g/test/gtest"
+	"os"
+	"testing"
+)
+
+
+func Test_ValueAndOption(t *testing.T) {
+	os.Args = []string{"v1", "v2", "--o1=111", "-o2=222"}
+	doInit()
+	gtest.Case(t, func() {
+		gtest.Assert(Value.GetAll(), []string{"v1", "v2"})
+		gtest.Assert(Value.Get(0), "v1")
+		gtest.Assert(Value.Get(1), "v2")
+		gtest.Assert(Value.Get(2), "")
+	})
+}
+

g/os/genv/genv.go

@@ -5,29 +5,33 @@
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package genv provides operations for environment variables of system.
-// 
-// 环境变量管理
 package genv
 
 import "os"
 
+// All returns a copy of strings representing the environment,
+// in the form "key=value".
 func All() []string {
     return os.Environ()
 }
 
-// 获取环境变量，并可以指定当环境变量不存在时的默认值
-func Get(k string, def...string) string {
-    v, ok := os.LookupEnv(k)
+// Get returns the value of the environment variable named by the <key>.
+// It returns given <def> if the variable does not exist in the environment.
+func Get(key string, def...string) string {
+    v, ok := os.LookupEnv(key)
     if !ok && len(def) > 0 {
         return def[0]
     }
     return v
 }
 
-func Set(k, v string) error {
-    return os.Setenv(k, v)
+// Set sets the value of the environment variable named by the <key>.
+// It returns an error, if any.
+func Set(key, value string) error {
+    return os.Setenv(key, value)
 }
 
-func Remove(k string) error {
-    return os.Unsetenv(k)
+// Remove deletes a single environment variable.
+func Remove(key string) error {
+    return os.Unsetenv(key)
 }

g/os/genv/genv_test.go

@@ -0,0 +1,43 @@
+package genv_test
+
+import (
+	"github.com/gogf/gf/g/os/genv"
+	"github.com/gogf/gf/g/test/gtest"
+	"os"
+	"testing"
+)
+
+func Test_Genv_All(t *testing.T) {
+	gtest.Case(t, func() {
+		gtest.Assert(os.Environ(), genv.All())
+	})
+}
+
+func Test_Genv_Get(t *testing.T) {
+	gtest.Case(t, func() {
+		key := "TEST_GET_ENV"
+		err := os.Setenv(key, "TEST")
+		gtest.Assert(err, nil)
+		gtest.AssertEQ(genv.Get(key), "TEST")
+	})
+}
+
+func Test_Genv_Set(t *testing.T) {
+	gtest.Case(t, func() {
+		key := "TEST_SET_ENV"
+		err := genv.Set(key, "TEST")
+		gtest.Assert(err, nil)
+		gtest.AssertEQ(os.Getenv(key), "TEST")
+	})
+}
+
+func Test_Genv_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		key := "TEST_REMOVE_ENV"
+		err := os.Setenv(key, "TEST")
+		gtest.Assert(err, nil)
+		err = genv.Remove(key)
+		gtest.Assert(err, nil)
+		gtest.AssertEQ(os.Getenv(key), "")
+	})
+}

g/os/gfcache/gfcache.go

@@ -5,8 +5,6 @@
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package gfcache provides reading and caching for file contents.
-// 
-// 文件缓存.
 package gfcache
 
 import (
@@ -17,21 +15,25 @@ import (
 )
 
 const (
-    // 默认的缓存超时时间(60秒)
+    // Default expire time for file content caching in seconds.
     gDEFAULT_CACHE_EXPIRE = 60
 )
 
 var (
-    // 默认的缓存时间(秒)
+    // Default expire time for file content caching in seconds.
     cacheExpire = cmdenv.Get("gf.gfcache.expire", gDEFAULT_CACHE_EXPIRE).Int()*1000
 )
 
-// 获得文件内容 string，expire参数为缓存过期时间，单位为秒。
+// GetContents returns string content of given file by <path> from cache.
+// If there's no content in the cache, it will read it from disk file specified by <path>.
+// The parameter <expire> specifies the caching time for this file content in seconds.
 func GetContents(path string, expire...int) string {
     return string(GetBinContents(path, expire...))
 }
 
-// 获得文件内容 []byte，expire参数为缓存过期时间，单位为秒。
+// GetBinContents returns []byte content of given file by <path> from cache.
+// If there's no content in the cache, it will read it from disk file specified by <path>.
+// The parameter <expire> specifies the caching time for this file content in seconds.
 func GetBinContents(path string, expire...int) []byte {
     k := cacheKey(path)
     e := cacheExpire
@@ -41,8 +43,9 @@ func GetBinContents(path string, expire...int) []byte {
     r := gcache.GetOrSetFuncLock(k, func() interface{} {
         b := gfile.GetBinContents(path)
         if b != nil {
-            // 添加文件监控，如果文件有任何变化，立即清空缓存
-            gfsnotify.Add(path, func(event *gfsnotify.Event) {
+            // Adding this <path> to gfsnotify,
+            // it will clear its cache if there's any changes of the file.
+            _, _ = gfsnotify.Add(path, func(event *gfsnotify.Event) {
                 gcache.Remove(k)
                 gfsnotify.Exit()
             })

g/os/gfile/gfile.go

@@ -425,8 +425,7 @@ func MainPkgPath() string {
         		continue
 	        }
         	// separator of <file> '/' will be converted to Separator.
-        	path = Dir(file)
-        	for path[len(path) - 1] != os.PathSeparator {
+        	for path = Dir(file); len(path) > 1 && Exists(path) && path[len(path) - 1] != os.PathSeparator; {
         		files, _ := ScanDir(path, "*.go")
         		for _, v := range files {
 			        if gregex.IsMatchString(`package\s+main`, GetContents(v)) {

g/os/gfile/gfile_search.go

@@ -22,6 +22,7 @@ func Search(name string, prioritySearchPaths...string) (realPath string, err err
     if realPath != "" {
         return
     }
+    // TODO move search paths to internal package variable.
     // Search paths array.
     array := garray.NewStringArray(true)
     array.Append(prioritySearchPaths...)

g/os/gflock/gflock.go

@@ -4,9 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-// Package gflock implements a thread-safe sync.Locker interface for file locking.
-// 
-// 文件锁.
+// Package gflock implements a concurrent-safe sync.Locker interface for file locking.
 package gflock
 
 import (
@@ -15,17 +13,18 @@ import (
     "github.com/gogf/gf/g/os/gfile"
 )
 
-// 文件锁
+// File locker.
 type Locker struct {
     mu    sync.RWMutex // 用于外部接口调用的互斥锁(阻塞机制)
     flock *flock.Flock // 底层文件锁对象
 }
 
-// 创建文件锁
+// New creates and returns a new file locker with given <file>.
+// The parameter <file> usually is a absolute file path.
 func New(file string) *Locker {
     dir := gfile.TempDir() + gfile.Separator + "gflock"
     if !gfile.Exists(dir) {
-        gfile.Mkdir(dir)
+        _ = gfile.Mkdir(dir)
     }
     path := dir + gfile.Separator + file
     lock := flock.NewFlock(path)
@@ -34,16 +33,18 @@ func New(file string) *Locker {
     }
 }
 
+// Path returns the file path of the locker.
 func (l *Locker) Path() string {
     return l.flock.Path()
 }
 
-// 当前文件锁是否处于锁定状态(Lock)
+// IsLocked returns whether the locker is locked.
 func (l *Locker) IsLocked() bool {
     return l.flock.Locked()
 }
 
-// 尝试Lock文件，如果失败立即返回
+// TryLock tries get the writing lock of the locker.
+// It returns true if success, or else returns false immediately.
 func (l *Locker) TryLock() bool {
     ok, _ := l.flock.TryLock()
     if ok {
@@ -52,7 +53,8 @@ func (l *Locker) TryLock() bool {
     return ok
 }
 
-// 尝试RLock文件，如果失败立即返回
+// TryRLock tries get the reading lock of the locker.
+// It returns true if success, or else returns false immediately.
 func (l *Locker) TryRLock() bool {
     ok, _ := l.flock.TryRLock()
     if ok {
@@ -61,22 +63,26 @@ func (l *Locker) TryRLock() bool {
     return ok
 }
 
-func (l *Locker) Lock() {
+func (l *Locker) Lock() (err error) {
     l.mu.Lock()
-    l.flock.Lock()
+    err = l.flock.Lock()
+    return
 }
 
-func (l *Locker) UnLock() {
-    l.flock.Unlock()
+func (l *Locker) UnLock() (err error) {
+    err = l.flock.Unlock()
     l.mu.Unlock()
+    return
 }
 
-func (l *Locker) RLock() {
+func (l *Locker) RLock() (err error) {
     l.mu.RLock()
-    l.flock.RLock()
+    err = l.flock.RLock()
+    return
 }
 
-func (l *Locker) RUnlock() {
-    l.flock.Unlock()
+func (l *Locker) RUnlock() (err error) {
+    err = l.flock.Unlock()
     l.mu.RUnlock()
+    return
 }

g/os/gfpool/gfpool.go

@@ -93,7 +93,7 @@ func newFilePool(p *Pool, path string, flag int, perm os.FileMode, expire int) *
             path   : path,
         }, nil
     }, func(i interface{}) {
-        i.(*File).File.Close()
+        _ = i.(*File).File.Close()
     })
     return pool
 }
@@ -136,7 +136,7 @@ func (p *Pool) File() (*File, error) {
         // 优先使用 !p.inited.Val() 原子读取操作判断，保证判断操作的效率；
         // p.inited.Set(true) == false 使用原子写入操作，保证该操作的原子性；
         if !p.inited.Val() && p.inited.Set(true) == false {
-            gfsnotify.Add(f.path, func(event *gfsnotify.Event) {
+            _, _ = gfsnotify.Add(f.path, func(event *gfsnotify.Event) {
                 // 如果文件被删除或者重命名，立即重建指针池
                 if event.IsRemove() || event.IsRename() {
                     // 原有的指针都不要了

g/os/glog/glog.go

@@ -3,8 +3,6 @@
 // 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://github.com/gogf/gf.
-//
-// @author john, zseeker
 
 // Package glog implements powerful and easy-to-use levelled logging functionality.
 package glog

g/os/glog/glog_api.go

@@ -7,13 +7,13 @@
 package glog
 
 // Print prints <v> with newline using fmt.Sprintln.
-// The param <v> can be multiple variables.
+// The parameter <v> can be multiple variables.
 func Print(v ...interface{}) {
     logger.Print(v ...)
 }
 
 // Printf prints <v> with format <format> using fmt.Sprintf.
-// The param <v> can be multiple variables.
+// The parameter <v> can be multiple variables.
 func Printf(format string, v ...interface{}) {
     logger.Printf(format, v ...)
 }

g/os/glog/glog_chaining.go

@@ -10,6 +10,11 @@ import (
 	"io"
 )
 
+// Expose returns the default logger of glog.
+func Expose() *Logger {
+	return logger
+}
+
 // To is a chaining function, 
 // which redirects current logging content output to the sepecified <writer>.
 func To(writer io.Writer) *Logger {
@@ -69,7 +74,7 @@ func Header(enabled...bool) *Logger {
 
 // Line is a chaining function,
 // which enables/disables printing its caller file along with its line number.
-// The param <long> specified whether print the long absolute file path, eg: /a/b/c/d.go:23.
+// The parameter <long> specified whether print the long absolute file path, eg: /a/b/c/d.go:23.
 func Line(long...bool) *Logger {
 	return logger.Line(long...)
 }

g/os/glog/glog_logger_api.go

@@ -12,13 +12,13 @@ import (
 )
 
 // Print prints <v> with newline using fmt.Sprintln.
-// The param <v> can be multiple variables.
+// The parameter <v> can be multiple variables.
 func (l *Logger) Print(v...interface{}) {
     l.printStd("", v...)
 }
 
 // Printf prints <v> with format <format> using fmt.Sprintf.
-// The param <v> can be multiple variables.
+// The parameter <v> can be multiple variables.
 func (l *Logger) Printf(format string, v...interface{}) {
     l.printStd(l.format(format, v...))
 }

g/os/glog/glog_logger_chaining.go

@@ -157,7 +157,7 @@ func (l *Logger) Header(enabled...bool) *Logger {
 
 // Line is a chaining function,
 // which enables/disables printing its caller file path along with its line number.
-// The param <long> specified whether print the long absolute file path, eg: /a/b/c/d.go:23,
+// The parameter <long> specified whether print the long absolute file path, eg: /a/b/c/d.go:23,
 // or else short one: d.go:23.
 func (l *Logger) Line(long...bool) *Logger {
 	logger := (*Logger)(nil)

g/os/glog/glog_logger_writer.go

@@ -6,9 +6,11 @@
 
 package glog
 
+import "bytes"
+
 // Write implements the io.Writer interface.
 // It just prints the content using Print.
 func (l *Logger) Write(p []byte) (n int, err error) {
-	l.Header(false).Print(string(p))
+	l.Header(false).Print(string(bytes.TrimRight(p, "\r\n")))
 	return len(p), nil
 }

g/os/grpool/grpool.go

@@ -24,7 +24,7 @@ type Pool struct {
 var pool = New()
 
 // New creates and returns a new goroutine pool object.
-// The param <limit> is used to limit the max goroutine count,
+// The parameter <limit> is used to limit the max goroutine count,
 // which is not limited in default.
 func New(limit...int) *Pool {
     p := &Pool {

g/os/gspath/gspath_cache.go

@@ -19,9 +19,9 @@ import (
 
 // 递归添加目录下的文件
 func (sp *SPath) updateCacheByPath(path string) {
-    if sp.cache == nil {
-        return
-    }
+	if sp.cache == nil {
+		return
+	}
     sp.addToCache(path, path)
 }
 
@@ -58,9 +58,6 @@ func (sp *SPath) parseCacheValue(value string) (filePath string, isDir bool) {
 
 // 添加path到缓存中(递归)
 func (sp *SPath) addToCache(filePath, rootPath string) {
-    if sp.cache == nil {
-        return
-    }
     // 首先添加自身
     idDir := gfile.IsDir(filePath)
     sp.cache.SetIfNotExist(sp.nameFromPath(filePath, rootPath), sp.makeCacheValue(filePath, idDir))
@@ -83,7 +80,7 @@ func (sp *SPath) addMonitorByPath(path string) {
     if sp.cache == nil {
         return
     }
-    gfsnotify.Add(path, func(event *gfsnotify.Event) {
+    _, _ = gfsnotify.Add(path, func(event *gfsnotify.Event) {
         //glog.Debug(event.String())
         switch {
             case event.IsRemove():
@@ -105,5 +102,5 @@ func (sp *SPath) removeMonitorByPath(path string) {
     if sp.cache == nil {
         return
     }
-    gfsnotify.Remove(path)
+    _ = gfsnotify.Remove(path)
 }

g/os/gspath/gspath_unit_test.go

@@ -0,0 +1,101 @@
+package gspath_test
+
+import (
+	"github.com/gogf/gf/g/os/gfile"
+	"github.com/gogf/gf/g/os/gspath"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+
+func TestSPath_Api(t *testing.T) {
+	gtest.Case(t, func() {
+		pwd := gfile.Pwd()
+		root := pwd + gfile.Separator
+		gfile.Create(root + "gf_tmp" + gfile.Separator + "gf.txt")
+		defer gfile.Remove(root + "gf_tmp")
+		fp, isDir := gspath.Search(root, "gf_tmp")
+		gtest.Assert(fp, root+"gf_tmp")
+		gtest.Assert(isDir, true)
+		fp, isDir = gspath.Search(root, "gf_tmp", "gf.txt")
+		gtest.Assert(fp, root+"gf_tmp"+gfile.Separator+"gf.txt")
+		gtest.Assert(isDir, false)
+
+		fp, isDir = gspath.SearchWithCache(root, "gf_tmp")
+		gtest.Assert(fp, root+"gf_tmp")
+		gtest.Assert(isDir, true)
+		fp, isDir = gspath.SearchWithCache(root, "gf_tmp", "gf.txt")
+		gtest.Assert(fp, root+"gf_tmp"+gfile.Separator+"gf.txt")
+		gtest.Assert(isDir, false)
+	})
+}
+
+func TestSPath_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		pwd := gfile.Pwd()
+		root := pwd + gfile.Separator
+		gfile.Create(root + "gf_tmp" + gfile.Separator + "gf.txt")
+		defer gfile.Remove(root + "gf_tmp")
+		gsp := gspath.New(root, false)
+		realPath, err := gsp.Add(root + "gf_tmp")
+		gtest.Assert(err, nil)
+		gtest.Assert(realPath, root+"gf_tmp")
+		realPath, err = gsp.Add("gf_tmp1")
+		gtest.Assert(err != nil, true)
+		gtest.Assert(realPath, "")
+		realPath, err = gsp.Add(root + "gf_tmp" + gfile.Separator + "gf.txt")
+		gtest.Assert(err != nil, true)
+		gtest.Assert(realPath, "")
+		gsp.Remove("gf_tmp1")
+		gtest.Assert(gsp.Size(), 2)
+		gtest.Assert(len(gsp.Paths()), 2)
+		gtest.Assert(len(gsp.AllPaths()), 0)
+		realPath, err = gsp.Set(root + "gf_tmp1")
+		gtest.Assert(err != nil, true)
+		gtest.Assert(realPath, "")
+		realPath, err = gsp.Set(root + "gf_tmp" + gfile.Separator + "gf.txt")
+		gtest.Assert(err != nil, true)
+		gtest.Assert(realPath, "")
+		gsp.Set(root)
+		fp, isDir := gsp.Search("gf_tmp")
+		gtest.Assert(fp, root+"gf_tmp")
+		gtest.Assert(isDir, true)
+		fp, isDir = gsp.Search("gf_tmp", "gf.txt")
+		gtest.Assert(fp, root+"gf_tmp"+gfile.Separator+"gf.txt")
+		gtest.Assert(isDir, false)
+		fp, isDir = gsp.Search("/", "gf.txt")
+		gtest.Assert(fp, root+gfile.Separator)
+		gtest.Assert(isDir, true)
+
+		gsp = gspath.New(root, true)
+		realPath, err = gsp.Add(root + "gf_tmp")
+		gtest.Assert(err, nil)
+		gtest.Assert(realPath, root+"gf_tmp")
+
+		gfile.Mkdir(root + "gf_tmp1")
+		gfile.Rename(root+"gf_tmp1", root+"gf_tmp2")
+		gfile.Rename(root+"gf_tmp2", root+"gf_tmp1")
+		defer gfile.Remove(root + "gf_tmp1")
+		realPath, err = gsp.Add("gf_tmp1")
+		gtest.Assert(err != nil, false)
+		gtest.Assert(realPath, root+"gf_tmp1")
+		realPath, err = gsp.Add("gf_tmp3")
+		gtest.Assert(err != nil, true)
+		gtest.Assert(realPath, "")
+		gsp.Remove(root + "gf_tmp")
+		gsp.Remove(root + "gf_tmp1")
+		gsp.Remove(root + "gf_tmp3")
+		gtest.Assert(gsp.Size(), 3)
+		gtest.Assert(len(gsp.Paths()), 3)
+		gsp.AllPaths()
+		gsp.Set(root)
+		fp, isDir = gsp.Search("gf_tmp")
+		gtest.Assert(fp, root+"gf_tmp")
+		gtest.Assert(isDir, true)
+		fp, isDir = gsp.Search("gf_tmp", "gf.txt")
+		gtest.Assert(fp, root+"gf_tmp"+gfile.Separator+"gf.txt")
+		gtest.Assert(isDir, false)
+		fp, isDir = gsp.Search("/", "gf.txt")
+		gtest.Assert(fp, pwd)
+		gtest.Assert(isDir, true)
+	})
+}

g/os/gview/gview.go

@@ -69,7 +69,9 @@ func New(path...string) *View {
             if gfile.Exists(envPath) {
 	            view.SetPath(envPath)
             } else {
-                glog.Errorf("Template directory path does not exist: %s", envPath)
+	            if errorPrint() {
+	            	glog.Errorf("Template directory path does not exist: %s", envPath)
+	            }
             }
         } else {
             // Dir path of working dir.
@@ -117,7 +119,7 @@ func New(path...string) *View {
 }
 
 // SetPath sets the template directory path for template file search.
-// The param <path> can be absolute or relative path, but absolute path is suggested.
+// The parameter <path> can be absolute or relative path, but absolute path is suggested.
 func (view *View) SetPath(path string) error {
 	// Absolute path.
     realPath := gfile.RealPath(path)
@@ -146,13 +148,17 @@ func (view *View) SetPath(path string) error {
             buffer.WriteString(fmt.Sprintf(`[gview] SetPath failed: path "%s" does not exist`, path))
         }
         err := errors.New(buffer.String())
-        glog.Error(err)
+	    if errorPrint() {
+	    	glog.Error(err)
+	    }
         return err
     }
 	// Should be a directory.
     if !gfile.IsDir(realPath) {
         err := errors.New(fmt.Sprintf(`[gview] SetPath failed: path "%s" should be directory type`, path))
-        glog.Error(err)
+	    if errorPrint() {
+	    	glog.Error(err)
+	    }
         return err
     }
 	// Repeated path check.
@@ -194,13 +200,17 @@ func (view *View) AddPath(path string) error {
             buffer.WriteString(fmt.Sprintf(`[gview] AddPath failed: path "%s" does not exist`, path))
         }
         err := errors.New(buffer.String())
-        glog.Error(err)
+	    if errorPrint() {
+	    	glog.Error(err)
+	    }
         return err
     }
     // realPath should be type of folder.
     if !gfile.IsDir(realPath) {
         err := errors.New(fmt.Sprintf(`[gview] AddPath failed: path "%s" should be directory type`, path))
-        glog.Error(err)
+	    if errorPrint() {
+	    	glog.Error(err)
+	    }
         return err
     }
 	// Repeated path check.

g/os/gview/gview_doparse.go

@@ -11,6 +11,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/encoding/ghash"
 	"github.com/gogf/gf/g/os/gfcache"
 	"github.com/gogf/gf/g/os/gfile"
 	"github.com/gogf/gf/g/os/gfsnotify"
@@ -18,6 +19,7 @@ import (
 	"github.com/gogf/gf/g/os/gmlock"
 	"github.com/gogf/gf/g/os/gspath"
 	"github.com/gogf/gf/g/text/gstr"
+	"github.com/gogf/gf/g/util/gconv"
 	"text/template"
 )
 
@@ -28,6 +30,7 @@ const (
 
 var (
 	// Templates cache map for template folder.
+	// TODO Note that there's no expiring logic for this map.
 	templates = gmap.NewStrAnyMap()
 )
 
@@ -88,7 +91,9 @@ func (view *View) searchFile(file string) (path string, folder string, err error
 		} else {
 			buffer.WriteString(fmt.Sprintf("[gview] cannot find template file \"%s\" with no path set/add", file))
 		}
-		glog.Error(buffer.String())
+		if errorPrint() {
+			glog.Error(buffer.String())
+		}
 		err = errors.New(fmt.Sprintf(`template file "%s" not found`, file))
 	}
 	return
@@ -160,7 +165,8 @@ func (view *View) ParseContent(content string, params...Params) (string, error)
 		return template.New(gCONTENT_TEMPLATE_NAME).Delims(view.delimiters[0], view.delimiters[1]).Funcs(view.funcMap)
 	}).(*template.Template)
 	// Using memory lock to ensure concurrent safety for content parsing.
-	gmlock.LockFunc("gview-parsing:content", func() {
+	hash := gconv.String(ghash.DJBHash64([]byte(content)))
+	gmlock.LockFunc("gview-parsing-content:" + hash, func() {
 		tpl, err = tpl.Parse(content)
 	})
 	if err != nil {

g/os/gview/gview_error.go

@@ -0,0 +1,22 @@
+// Copyright 2019 gf Author(https://github.com/gogf/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://github.com/gogf/gf.
+
+package gview
+
+import (
+	"github.com/gogf/gf/g/internal/cmdenv"
+)
+
+const (
+	// gERROR_PRINT_KEY is used to specify the key controlling error printing to stdout.
+	// This error is designed not to be returned by functions.
+	gERROR_PRINT_KEY = "gf.gview.errorprint"
+)
+
+// errorPrint checks whether printing error to stdout.
+func errorPrint() bool {
+	return cmdenv.Get(gERROR_PRINT_KEY, true).Bool()
+}

g/os/gview/gview_instance.go

@@ -18,7 +18,7 @@ var (
 )
 
 // Instance returns an instance of View with default settings.
-// The param <name> is the name for the instance.
+// The parameter <name> is the name for the instance.
 func Instance(name ...string) *View {
 	key := DEFAULT_INSTANCE_NAME
 	if len(name) > 0 {

g/os/gview/gview_unit_test.go

@@ -0,0 +1,240 @@
+package gview_test
+
+import (
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/os/gfile"
+	"github.com/gogf/gf/g/os/gview"
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/text/gstr"
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func init() {
+	os.Setenv("GF_GVIEW_ERRORPRINT", "false")
+}
+
+func TestView_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		str := `hello {{.name}},version:{{.version}};hello {{GetName}},version:{{GetVersion}};{{.other}}`
+		pwd := gfile.Pwd()
+		view := gview.New()
+		view.SetDelimiters("{{", "}}")
+		view.AddPath(pwd)
+		view.SetPath(pwd)
+		view.Assign("name", "gf")
+		view.Assigns(g.Map{"version": "1.7.0"})
+		view.BindFunc("GetName", func() string { return "gf" })
+		view.BindFuncMap(gview.FuncMap{"GetVersion": func() string { return "1.7.0" }})
+		result, err := view.ParseContent(str, g.Map{"other": "that's all"})
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, "hello gf,version:1.7.0;hello gf,version:1.7.0;that's all")
+
+		//测试api方法
+		str = `hello {{.name}}`
+		result, err = gview.ParseContent(str, g.Map{"name": "gf"})
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, "hello gf")
+
+		//测试instance方法
+		result, err = gview.Instance().ParseContent(str, g.Map{"name": "gf"})
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, "hello gf")
+	})
+}
+
+func TestView_Func(t *testing.T) {
+	gtest.Case(t, func() {
+		str := `{{eq 1 1}};{{eq 1 2}};{{eq "A" "B"}}`
+		result, err := gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `true;false;false`)
+
+		str = `{{ne 1 2}};{{ne 1 1}};{{ne "A" "B"}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `true;false;true`)
+
+		str = `{{lt 1 2}};{{lt 1 1}};{{lt 1 0}};{{lt "A" "B"}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `true;false;false;true`)
+
+		str = `{{le 1 2}};{{le 1 1}};{{le 1 0}};{{le "A" "B"}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `true;true;false;true`)
+
+		str = `{{gt 1 2}};{{gt 1 1}};{{gt 1 0}};{{gt "A" "B"}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `false;false;true;false`)
+
+		str = `{{ge 1 2}};{{ge 1 1}};{{ge 1 0}};{{ge "A" "B"}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `false;true;true;false`)
+
+		str = `{{"<div>测试</div>"|text}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `测试`)
+
+		str = `{{"<div>测试</div>"|html}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `&lt;div&gt;测试&lt;/div&gt;`)
+
+		str = `{{"<div>测试</div>"|htmlencode}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `&lt;div&gt;测试&lt;/div&gt;`)
+
+		str = `{{"&lt;div&gt;测试&lt;/div&gt;"|htmldecode}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `<div>测试</div>`)
+
+		str = `{{"https://goframe.org"|url}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `https%3A%2F%2Fgoframe.org`)
+
+		str = `{{"https://goframe.org"|urlencode}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `https%3A%2F%2Fgoframe.org`)
+
+		str = `{{"https%3A%2F%2Fgoframe.org"|urldecode}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `https://goframe.org`)
+		str = `{{"https%3NA%2F%2Fgoframe.org"|urldecode}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(gstr.Contains(result, "invalid URL escape"), true)
+
+		str = `{{1540822968 | date "Y-m-d"}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `2018-10-29`)
+		str = `{{date "Y-m-d"}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+
+		str = `{{"我是中国人" | substr 2 -1}};{{"我是中国人" | substr 2  2}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `中国人;中国`)
+
+		str = `{{"我是中国人" | strlimit 2  "..."}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `我是...`)
+
+		str = `{{compare "A" "B"}};{{compare "1" "2"}};{{compare 2 1}};{{compare 1 1}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `-1;-1;1;0`)
+
+		str = `{{"热爱GF热爱生活" | hidestr 20  "*"}};{{"热爱GF热爱生活" | hidestr 50  "*"}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `热爱GF*爱生活;热爱****生活`)
+
+		str = `{{"热爱GF热爱生活" | highlight "GF" "red"}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `热爱<span style="color:red;">GF</span>热爱生活`)
+
+		str = `{{"gf" | toupper}};{{"GF" | tolower}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `GF;gf`)
+
+		str = `{{"Go\nFrame" | nl2br}}`
+		view := gview.New()
+		result, err = view.ParseContent(str)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `Go<br>Frame`)
+	})
+}
+
+func TestView_FuncInclude(t *testing.T) {
+	gtest.Case(t, func() {
+		header := `<h1>HEADER</h1>`
+		main := `<h1>hello gf</h1>`
+		footer := `<h1>FOOTER</h1>`
+		layout := `{{include "header.html" .}}
+{{include "main.html" .}}
+{{include "footer.html" .}}`
+		templatePath := gfile.Pwd() + gfile.Separator + "template"
+		gfile.Mkdir(templatePath)
+		defer gfile.Remove(templatePath)
+		//headerFile, _ := gfile.Create(templatePath + gfile.Separator + "header.html")
+		err := ioutil.WriteFile(templatePath+gfile.Separator+"header.html", []byte(header), 0644)
+		if err != nil {
+			t.Error(err)
+		}
+		ioutil.WriteFile(templatePath+gfile.Separator+"main.html", []byte(main), 0644)
+		ioutil.WriteFile(templatePath+gfile.Separator+"footer.html", []byte(footer), 0644)
+		ioutil.WriteFile(templatePath+gfile.Separator+"layout.html", []byte(layout), 0644)
+		view := gview.New(templatePath)
+		result, err := view.Parse("notfound.html")
+		gtest.Assert(err != nil, true)
+		gtest.Assert(result, ``)
+		result, err = view.Parse("layout.html")
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `<h1>HEADER</h1>
+<h1>hello gf</h1>
+<h1>FOOTER</h1>`)
+		notfoundPath := templatePath + gfile.Separator + "template" + gfile.Separator + "notfound.html"
+		gfile.Mkdir(templatePath + gfile.Separator + "template")
+		gfile.Create(notfoundPath)
+		ioutil.WriteFile(notfoundPath, []byte("notfound"), 0644)
+		result, err = view.Parse("notfound.html")
+		gtest.Assert(err != nil, true)
+		gtest.Assert(result, ``)
+	})
+}
+
+func TestView_SetPath(t *testing.T) {
+	gtest.Case(t, func() {
+		view := gview.Instance("addpath")
+		err := view.AddPath("tmp")
+		gtest.AssertNE(err, nil)
+
+		err = view.AddPath("gview.go")
+		gtest.AssertNE(err, nil)
+
+		os.Setenv("GF_GVIEW_PATH", "tmp")
+		view = gview.Instance("setpath")
+		err = view.SetPath("tmp")
+		gtest.AssertNE(err, nil)
+
+		err = view.SetPath("gview.go")
+		gtest.AssertNE(err, nil)
+
+		view = gview.New(gfile.Pwd())
+		err = view.SetPath("tmp")
+		gtest.AssertNE(err, nil)
+
+		err = view.SetPath("gview.go")
+		gtest.AssertNE(err, nil)
+
+		os.Setenv("GF_GVIEW_PATH", "template")
+		gfile.Mkdir(gfile.Pwd() + gfile.Separator + "template")
+		view = gview.New()
+	})
+}
+
+func TestView_ParseContent(t *testing.T) {
+	gtest.Case(t, func() {
+		str := `{{.name}}`
+		view := gview.New()
+		result, err := view.ParseContent(str, g.Map{"name": func() {}})
+		gtest.Assert(err != nil, true)
+		gtest.Assert(result, ``)
+	})
+}