From 3a7268677424514fa09e05c55c8c77499c2402a3 Mon Sep 17 00:00:00 2001
From: zhangbiao <zhangbiao@channelsoft.com>
Date: Mon, 10 Jun 2019 15:05:11 +0800
Subject: [PATCH 01/18] add gcrc test

---
 g/crypto/gcrc32/gcrc32_test.go | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/g/crypto/gcrc32/gcrc32_test.go b/g/crypto/gcrc32/gcrc32_test.go
index 32f9a3094..27c301fbc 100644
--- a/g/crypto/gcrc32/gcrc32_test.go
+++ b/g/crypto/gcrc32/gcrc32_test.go
@@ -15,7 +15,7 @@ import (
 	"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 +25,14 @@ 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)
+	})
+}

From d5d14b7efc73153d8ac17553c813d3be69961143 Mon Sep 17 00:00:00 2001
From: zdl <381897429@qq.com>
Date: Mon, 10 Jun 2019 15:49:43 +0800
Subject: [PATCH 02/18] test gset TestSet_New

---
 g/container/gset/gset_z_unit_test.go | 262 ++++++++++++++-------------
 1 file changed, 141 insertions(+), 121 deletions(-)

diff --git a/g/container/gset/gset_z_unit_test.go b/g/container/gset/gset_z_unit_test.go
index a0901a070..9ee7c192e 100644
--- a/g/container/gset/gset_z_unit_test.go
+++ b/g/container/gset/gset_z_unit_test.go
@@ -9,152 +9,172 @@
 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"
+	"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)
-    })
-}
\ No newline at end of file
+	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)
+	})
+}

From 6814372a891b699ecdd0085768dfd223f612a6cd Mon Sep 17 00:00:00 2001
From: zhangbiao <zhangbiao@channelsoft.com>
Date: Mon, 10 Jun 2019 15:55:43 +0800
Subject: [PATCH 03/18] add gcrc test2

---
 g/crypto/gcrc32/gcrc32_test.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/g/crypto/gcrc32/gcrc32_test.go b/g/crypto/gcrc32/gcrc32_test.go
index 27c301fbc..7a67d1c41 100644
--- a/g/crypto/gcrc32/gcrc32_test.go
+++ b/g/crypto/gcrc32/gcrc32_test.go
@@ -9,6 +9,7 @@
 package gcrc32_test
 
 import (
+	"github.com/gogf/gf/g/crypto/gmd5"
 	"testing"
 
 	"github.com/gogf/gf/g/crypto/gcrc32"
@@ -34,5 +35,10 @@ func TestEncrypt(t *testing.T) {
 		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)
 	})
 }

From 501c3680d931bb998950662196c48b2de8315e3d Mon Sep 17 00:00:00 2001
From: zhangbiao <zhangbiao@channelsoft.com>
Date: Mon, 10 Jun 2019 17:26:32 +0800
Subject: [PATCH 04/18] add gaes test

---
 g/crypto/gaes/gaes_test.go | 58 ++++++++++++++++++++++++++++++++++----
 1 file changed, 53 insertions(+), 5 deletions(-)

diff --git a/g/crypto/gaes/gaes_test.go b/g/crypto/gaes/gaes_test.go
index fbae75d9c..1a3fb24da 100644
--- a/g/crypto/gaes/gaes_test.go
+++ b/g/crypto/gaes/gaes_test.go
@@ -18,11 +18,14 @@ import (
 var (
 	content = []byte("pibigstar")
 	// 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) {
@@ -38,6 +41,51 @@ func TestEncrypt(t *testing.T) {
 	})
 }
 
+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)
+	})
+}
+
 func TestDecrypt(t *testing.T) {
 	gtest.Case(t, func() {
 		encrypt, err := gaes.Encrypt(content, key_16)

From 334cd7ad515ec4c553bd3acc5cfa21e1ddedd8df Mon Sep 17 00:00:00 2001
From: zhangbiao <zhangbiao@channelsoft.com>
Date: Mon, 10 Jun 2019 18:59:42 +0800
Subject: [PATCH 05/18] add gregex test

---
 g/text/gregex/gregex_z_unit_test.go | 49 +++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/g/text/gregex/gregex_z_unit_test.go b/g/text/gregex/gregex_z_unit_test.go
index 64ce85489..bd2556b3b 100644
--- a/g/text/gregex/gregex_z_unit_test.go
+++ b/g/text/gregex/gregex_z_unit_test.go
@@ -15,6 +15,10 @@ import (
 	"testing"
 )
 
+var (
+	PatternErr = `([\d+`
+)
+
 func Test_Quote(t *testing.T) {
 	gtest.Case(t, func() {
 		s1 := `[foo]` //`\[foo\]`
@@ -40,6 +44,8 @@ func Test_IsMatch(t *testing.T) {
 		gtest.Assert(gregex.IsMatch(pattern, s1), false)
 		s1 = []byte(`sfs:`)
 		gtest.Assert(gregex.IsMatch(pattern, s1), false)
+		// error pattern
+		gtest.Assert(gregex.IsMatch(PatternErr, s1), false)
 	})
 }
 
@@ -52,6 +58,8 @@ func Test_IsMatchString(t *testing.T) {
 		gtest.Assert(gregex.IsMatchString(pattern, s1), false)
 		s1 = `sfs:`
 		gtest.Assert(gregex.IsMatchString(pattern, s1), false)
+		// error pattern
+		gtest.Assert(gregex.IsMatchString(PatternErr, s1), false)
 	})
 }
 
@@ -68,6 +76,9 @@ func Test_Match(t *testing.T) {
 		if string(subs[1]) != "aab" {
 			t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1], "aab")
 		}
+		// error pattern
+		_, err = gregex.Match(PatternErr, []byte(s))
+		gtest.AssertNE(err, nil)
 	})
 }
 
@@ -84,6 +95,9 @@ func Test_MatchString(t *testing.T) {
 		if string(subs[1]) != "aab" {
 			t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1], "aab")
 		}
+		// error pattern
+		_, err = gregex.MatchString(PatternErr, s)
+		gtest.AssertNE(err, nil)
 	})
 }
 
@@ -108,6 +122,9 @@ func Test_MatchAll(t *testing.T) {
 		if string(subs[1][1]) != "aab" {
 			t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1][1], "aab")
 		}
+		// error pattern
+		_, err = gregex.MatchAll(PatternErr, []byte(s))
+		gtest.AssertNE(err, nil)
 	})
 }
 
@@ -131,6 +148,9 @@ func Test_MatchAllString(t *testing.T) {
 		if string(subs[1][1]) != "aab" {
 			t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1][1], "aab")
 		}
+		// error pattern
+		_, err = gregex.MatchAllString(PatternErr, s)
+		gtest.AssertNE(err, nil)
 	})
 }
 
@@ -146,6 +166,9 @@ func Test_Replace(t *testing.T) {
 		if string(replacedStr) != wanted {
 			t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted)
 		}
+		// error pattern
+		_, err = gregex.Replace(PatternErr, []byte(replace), []byte(s))
+		gtest.AssertNE(err, nil)
 	})
 }
 
@@ -161,6 +184,9 @@ func Test_ReplaceString(t *testing.T) {
 		if replacedStr != wanted {
 			t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted)
 		}
+		// error pattern
+		_, err = gregex.ReplaceString(PatternErr, replace, s)
+		gtest.AssertNE(err, nil)
 	})
 }
 
@@ -182,6 +208,11 @@ func Test_ReplaceFun(t *testing.T) {
 		if string(replacedStr) != wanted {
 			t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted)
 		}
+		// error pattern
+		_, err = gregex.ReplaceFunc(PatternErr, []byte(s), func(s []byte) []byte {
+			return []byte("")
+		})
+		gtest.AssertNE(err, nil)
 	})
 }
 
@@ -209,6 +240,11 @@ func Test_ReplaceFuncMatch(t *testing.T) {
 		})
 		gtest.Assert(e3, nil)
 		gtest.Assert(s3, []byte("7890"))
+		// error pattern
+		_, err := gregex.ReplaceFuncMatch(PatternErr, s, func(match [][]byte) []byte {
+			return match[3]
+		})
+		gtest.AssertNE(err, nil)
 	})
 }
 
@@ -230,6 +266,11 @@ func Test_ReplaceStringFunc(t *testing.T) {
 		if replacedStr != wanted {
 			t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted)
 		}
+		// error pattern
+		_, err = gregex.ReplaceStringFunc(PatternErr, s, func(s string) string {
+			return ""
+		})
+		gtest.AssertNE(err, nil)
 	})
 }
 
@@ -257,6 +298,11 @@ func Test_ReplaceStringFuncMatch(t *testing.T) {
 		})
 		gtest.Assert(e3, nil)
 		gtest.Assert(s3, "7890")
+		// error pattern
+		_, err := gregex.ReplaceStringFuncMatch(PatternErr, s, func(match []string) string {
+			return ""
+		})
+		gtest.AssertNE(err, nil)
 	})
 }
 
@@ -288,6 +334,9 @@ func Test_Split(t *testing.T) {
 		if items[0] != s {
 			t.Fatalf("regex:%s,Split(%q) want %q", re, s, item0)
 		}
+		// error pattern
+		items = gregex.Split(PatternErr, s)
+		gtest.AssertEQ(items, nil)
 
 	})
 }

From 59ae6217cddf7c589ad80b3b6a29129de32f414a Mon Sep 17 00:00:00 2001
From: zhangbiao <zhangbiao@channelsoft.com>
Date: Mon, 10 Jun 2019 19:37:02 +0800
Subject: [PATCH 06/18] add gaes test3: add encrypt assert content

---
 g/crypto/gaes/gaes_test.go | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/g/crypto/gaes/gaes_test.go b/g/crypto/gaes/gaes_test.go
index 1a3fb24da..36f0101a7 100644
--- a/g/crypto/gaes/gaes_test.go
+++ b/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,7 +17,11 @@ 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==")
 	// iv 长度必须等于blockSize，只能为16
 	iv         = []byte("Hello My GoFrame")
 	key_16     = []byte("1234567891234567")
@@ -30,14 +35,18 @@ var (
 
 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(string(data), content_16)
+		data, err = gaes.Encrypt(content, key_24)
 		gtest.Assert(err, nil)
-		_, err = gaes.Encrypt(content, key_32)
+		gtest.Assert(string(data), content_24)
+		data, err = gaes.Encrypt(content, key_32)
 		gtest.Assert(err, nil)
-		_, err = gaes.Encrypt(content, key_16, iv)
+		gtest.Assert(string(data), content_32)
+		data, err = gaes.Encrypt(content, key_16, iv)
 		gtest.Assert(err, nil)
+		gtest.Assert(string(data), content_16_iv)
 	})
 }
 

From b0b6871bbb581cc8b2e526b979a7f38f50da5a21 Mon Sep 17 00:00:00 2001
From: zdl <381897429@qq.com>
Date: Mon, 10 Jun 2019 19:50:45 +0800
Subject: [PATCH 07/18] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20genv=20=E6=B5=8B?=
 =?UTF-8?q?=E8=AF=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 g/os/genv/genv_test.go | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 g/os/genv/genv_test.go

diff --git a/g/os/genv/genv_test.go b/g/os/genv/genv_test.go
new file mode 100644
index 000000000..e4b64062f
--- /dev/null
+++ b/g/os/genv/genv_test.go
@@ -0,0 +1,36 @@
+package genv_test
+
+import (
+	"github.com/gogf/gf/g/os/genv"
+	"github.com/gogf/gf/g/test/gtest"
+	"os"
+	"testing"
+	"time"
+)
+
+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() {
+		gtest.AssertEQ("keke", genv.Get("LLL"+time.Now().String(), "keke"))
+		gtest.AssertEQ("", genv.Get("LLL"+time.Now().String()))
+	})
+}
+
+func Test_Genv_Set(t *testing.T) {
+	gtest.Case(t, func() {
+		err := genv.Set("LLL", "keke")
+		gtest.Assert(err, nil)
+	})
+}
+
+func Test_Genv_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		err := genv.Remove("LLL")
+		gtest.Assert(err, nil)
+	})
+}

From be6f522cf3c911a718948c185fe0453f4f8e0a52 Mon Sep 17 00:00:00 2001
From: zhangbiao <zhangbiao@channelsoft.com>
Date: Mon, 10 Jun 2019 19:53:07 +0800
Subject: [PATCH 08/18] add gaes test4:optimize Encrypt Decrypt test

---
 g/crypto/gaes/gaes_test.go | 59 ++++++++++++++++++++------------------
 1 file changed, 31 insertions(+), 28 deletions(-)

diff --git a/g/crypto/gaes/gaes_test.go b/g/crypto/gaes/gaes_test.go
index 36f0101a7..9805dda4a 100644
--- a/g/crypto/gaes/gaes_test.go
+++ b/g/crypto/gaes/gaes_test.go
@@ -22,6 +22,7 @@ var (
 	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")
@@ -47,6 +48,36 @@ func TestEncrypt(t *testing.T) {
 		data, err = gaes.Encrypt(content, key_16, iv)
 		gtest.Assert(err, nil)
 		gtest.Assert(string(data), content_16_iv)
+		data, err = gaes.Encrypt(content, key_32, iv)
+		gtest.Assert(err, nil)
+		gtest.Assert(string(data), content_32_iv)
+	})
+}
+
+func TestDecrypt(t *testing.T) {
+	gtest.Case(t, func() {
+		decrypt, err := gaes.Decrypt([]byte(content_16), key_16)
+		gtest.Assert(err, nil)
+		gtest.Assert(string(decrypt), string(content))
+
+		decrypt, err = gaes.Decrypt([]byte(content_24), key_24)
+		gtest.Assert(err, nil)
+		gtest.Assert(string(decrypt), string(content))
+
+		decrypt, err = gaes.Decrypt([]byte(content_32), key_32)
+		gtest.Assert(err, nil)
+		gtest.Assert(string(decrypt), string(content))
+
+		decrypt, err = gaes.Decrypt([]byte(content_16_iv), key_16, iv)
+		gtest.Assert(err, nil)
+		gtest.Assert(string(decrypt), string(content))
+
+		decrypt, err = gaes.Decrypt([]byte(content_32_iv), key_32, iv)
+		gtest.Assert(err, nil)
+		gtest.Assert(string(decrypt), string(content))
+
+		decrypt, err = gaes.Decrypt([]byte(content_32_iv), keys, iv)
+		gtest.Assert(err, "invalid padding")
 	})
 }
 
@@ -94,31 +125,3 @@ func TestPKCS5UnPaddingErr(t *testing.T) {
 		gtest.AssertNE(err, nil)
 	})
 }
-
-func TestDecrypt(t *testing.T) {
-	gtest.Case(t, func() {
-		encrypt, err := gaes.Encrypt(content, key_16)
-		decrypt, err := gaes.Decrypt(encrypt, key_16)
-		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
-
-		encrypt, err = gaes.Encrypt(content, key_24)
-		decrypt, err = gaes.Decrypt(encrypt, key_24)
-		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
-
-		encrypt, err = gaes.Encrypt(content, key_32)
-		decrypt, err = gaes.Decrypt(encrypt, key_32)
-		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
-
-		encrypt, err = gaes.Encrypt(content, key_32, iv)
-		decrypt, err = gaes.Decrypt(encrypt, key_32, iv)
-		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
-
-		encrypt, err = gaes.Encrypt(content, key_32, iv)
-		decrypt, err = gaes.Decrypt(encrypt, keys, iv)
-		gtest.Assert(err, "invalid padding")
-	})
-}

From 3320d12994242ecea5cc7b7c362acdd40da31902 Mon Sep 17 00:00:00 2001
From: piaohao <buhao@jinbaozheng.com>
Date: Mon, 10 Jun 2019 19:58:00 +0800
Subject: [PATCH 09/18] =?UTF-8?q?gcache=E6=B5=8B=E8=AF=95=E7=94=A8?=
 =?UTF-8?q?=E4=BE=8B=E5=AE=8C=E5=96=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 g/os/gcache/gcache_z_unit_1_test.go | 290 ++++++++++++++++++++++++----
 1 file changed, 249 insertions(+), 41 deletions(-)

diff --git a/g/os/gcache/gcache_z_unit_1_test.go b/g/os/gcache/gcache_z_unit_1_test.go
index 4f0590a66..0cd6ea07c 100644
--- a/g/os/gcache/gcache_z_unit_1_test.go
+++ b/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)
-    })
-}
\ No newline at end of file
+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)
+		}
+	})
+}

From e479c41667fceecfe486937ec0016dfa2154be7f Mon Sep 17 00:00:00 2001
From: zdl <381897429@qq.com>
Date: Mon, 10 Jun 2019 20:24:11 +0800
Subject: [PATCH 10/18] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20genv=20=E6=B5=8B?=
 =?UTF-8?q?=E8=AF=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 g/os/genv/genv_test.go | 17 ++++++++++++-----
 go.mod                 |  4 +++-
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/g/os/genv/genv_test.go b/g/os/genv/genv_test.go
index e4b64062f..c67063d1c 100644
--- a/g/os/genv/genv_test.go
+++ b/g/os/genv/genv_test.go
@@ -5,7 +5,6 @@ import (
 	"github.com/gogf/gf/g/test/gtest"
 	"os"
 	"testing"
-	"time"
 )
 
 func Test_Genv_All(t *testing.T) {
@@ -16,21 +15,29 @@ func Test_Genv_All(t *testing.T) {
 
 func Test_Genv_Get(t *testing.T) {
 	gtest.Case(t, func() {
-		gtest.AssertEQ("keke", genv.Get("LLL"+time.Now().String(), "keke"))
-		gtest.AssertEQ("", genv.Get("LLL"+time.Now().String()))
+		key := "TEST_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() {
-		err := genv.Set("LLL", "keke")
+		key := "TEST_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() {
-		err := genv.Remove("LLL")
+		key := "TEST_ENV"
+		err := os.Setenv(key, "TEST")
 		gtest.Assert(err, nil)
+		err = genv.Remove(key)
+		gtest.Assert(err, nil)
+		gtest.AssertEQ(os.Getenv(key), "")
 	})
 }
diff --git a/go.mod b/go.mod
index fd3232e72..081d99cd0 100644
--- a/go.mod
+++ b/go.mod
@@ -1 +1,3 @@
-module github.com/gogf/gf
\ No newline at end of file
+module github.com/gogf/gf
+
+go 1.12

From ffd78d76e1d65040c3572aba37a7a428e65eae94 Mon Sep 17 00:00:00 2001
From: zdl <381897429@qq.com>
Date: Mon, 10 Jun 2019 20:44:30 +0800
Subject: [PATCH 11/18] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20genv=20=E6=B5=8B?=
 =?UTF-8?q?=E8=AF=95=201?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 g/os/genv/genv_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/g/os/genv/genv_test.go b/g/os/genv/genv_test.go
index c67063d1c..9f9a894e4 100644
--- a/g/os/genv/genv_test.go
+++ b/g/os/genv/genv_test.go
@@ -15,7 +15,7 @@ func Test_Genv_All(t *testing.T) {
 
 func Test_Genv_Get(t *testing.T) {
 	gtest.Case(t, func() {
-		key := "TEST_ENV"
+		key := "TEST_GET_ENV"
 		err := os.Setenv(key, "TEST")
 		gtest.Assert(err, nil)
 		gtest.AssertEQ(genv.Get(key), "TEST")
@@ -24,7 +24,7 @@ func Test_Genv_Get(t *testing.T) {
 
 func Test_Genv_Set(t *testing.T) {
 	gtest.Case(t, func() {
-		key := "TEST_ENV"
+		key := "TEST_SET_ENV"
 		err := genv.Set(key, "TEST")
 		gtest.Assert(err, nil)
 		gtest.AssertEQ(os.Getenv(key), "TEST")
@@ -33,7 +33,7 @@ func Test_Genv_Set(t *testing.T) {
 
 func Test_Genv_Remove(t *testing.T) {
 	gtest.Case(t, func() {
-		key := "TEST_ENV"
+		key := "TEST_REMOVE_ENV"
 		err := os.Setenv(key, "TEST")
 		gtest.Assert(err, nil)
 		err = genv.Remove(key)

From c695dfd92e9a23e8be8eb58c009413d0b236d4de Mon Sep 17 00:00:00 2001
From: zdl <381897429@qq.com>
Date: Mon, 10 Jun 2019 20:52:06 +0800
Subject: [PATCH 12/18] delete go version

---
 go.mod | 1 -
 1 file changed, 1 deletion(-)

diff --git a/go.mod b/go.mod
index 081d99cd0..28729e4f6 100644
--- a/go.mod
+++ b/go.mod
@@ -1,3 +1,2 @@
 module github.com/gogf/gf
 
-go 1.12

From 13eb1150a5d5c3c4d62607cd3c1d40ae288e4b32 Mon Sep 17 00:00:00 2001
From: John <john@johng.cn>
Date: Mon, 10 Jun 2019 21:32:40 +0800
Subject: [PATCH 13/18] fix issue in gfile.MainPkgPath

---
 g/os/gfile/gfile.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/g/os/gfile/gfile.go b/g/os/gfile/gfile.go
index e55e156f4..e658a869b 100644
--- a/g/os/gfile/gfile.go
+++ b/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)) {

From 46d46afaafe3a513682a985633c2ddc7963222c6 Mon Sep 17 00:00:00 2001
From: "zcool321@sina.com" <1234qwer>
Date: Mon, 10 Jun 2019 22:42:46 +0800
Subject: [PATCH 14/18] add gaes test:update assert type

---
 g/crypto/gaes/gaes_test.go | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/g/crypto/gaes/gaes_test.go b/g/crypto/gaes/gaes_test.go
index 9805dda4a..57f307a6e 100644
--- a/g/crypto/gaes/gaes_test.go
+++ b/g/crypto/gaes/gaes_test.go
@@ -38,19 +38,19 @@ func TestEncrypt(t *testing.T) {
 	gtest.Case(t, func() {
 		data, err := gaes.Encrypt(content, key_16)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(data), content_16)
+		gtest.Assert(data, []byte(content_16))
 		data, err = gaes.Encrypt(content, key_24)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(data), content_24)
+		gtest.Assert(data, []byte(content_24))
 		data, err = gaes.Encrypt(content, key_32)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(data), content_32)
+		gtest.Assert(data, []byte(content_32))
 		data, err = gaes.Encrypt(content, key_16, iv)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(data), content_16_iv)
+		gtest.Assert(data, []byte(content_16_iv))
 		data, err = gaes.Encrypt(content, key_32, iv)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(data), content_32_iv)
+		gtest.Assert(data, []byte(content_32_iv))
 	})
 }
 
@@ -58,23 +58,23 @@ func TestDecrypt(t *testing.T) {
 	gtest.Case(t, func() {
 		decrypt, err := gaes.Decrypt([]byte(content_16), key_16)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
+		gtest.Assert(decrypt, content)
 
 		decrypt, err = gaes.Decrypt([]byte(content_24), key_24)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
+		gtest.Assert(decrypt, content)
 
 		decrypt, err = gaes.Decrypt([]byte(content_32), key_32)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
+		gtest.Assert(decrypt, content)
 
 		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)
 
 		decrypt, err = gaes.Decrypt([]byte(content_32_iv), key_32, iv)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
+		gtest.Assert(decrypt, content)
 
 		decrypt, err = gaes.Decrypt([]byte(content_32_iv), keys, iv)
 		gtest.Assert(err, "invalid padding")

From c034d2529997967297fa27dff643261c888732f4 Mon Sep 17 00:00:00 2001
From: piaohao <buhao@jinbaozheng.com>
Date: Tue, 11 Jun 2019 17:24:26 +0800
Subject: [PATCH 15/18] =?UTF-8?q?gspath=E6=A8=A1=E5=9D=97=E5=8F=8Agview?=
 =?UTF-8?q?=E6=A8=A1=E5=9D=97=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B=E7=BC=96?=
 =?UTF-8?q?=E5=86=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 g/os/gspath/gspath_unit_test.go | 101 ++++++++++++++
 g/os/gview/gview_unit_test.go   | 240 ++++++++++++++++++++++++++++++++
 2 files changed, 341 insertions(+)
 create mode 100644 g/os/gspath/gspath_unit_test.go
 create mode 100644 g/os/gview/gview_unit_test.go

diff --git a/g/os/gspath/gspath_unit_test.go b/g/os/gspath/gspath_unit_test.go
new file mode 100644
index 000000000..9f08d6c0a
--- /dev/null
+++ b/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)
+	})
+}
diff --git a/g/os/gview/gview_unit_test.go b/g/os/gview/gview_unit_test.go
new file mode 100644
index 000000000..6c910059a
--- /dev/null
+++ b/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 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"}};{{"1540822968" | date "Y-m-d H:i:s"}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `2018-10-29;2018-10-29 22:22:48`)
+		str = `{{1540822968 | date "Y-m-d"}};{{"1540822968" | date "Y-m-d H:i:s"}}`
+		result, err = gview.ParseContent(str, nil)
+		gtest.Assert(err != nil, false)
+		gtest.Assert(result, `2018-10-29;2018-10-29 22:22:48`)
+		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.Assert(err == nil, false)
+
+		err = view.AddPath("gview.go")
+		gtest.Assert(err == nil, false)
+
+		os.Setenv("GF_GVIEW_PATH", "tmp")
+		view = gview.Instance("setpath")
+		err = view.SetPath("tmp")
+		gtest.Assert(err == nil, false)
+
+		err = view.SetPath("gview.go")
+		gtest.Assert(err == nil, false)
+
+		view = gview.New(gfile.Pwd())
+		err = view.SetPath("tmp")
+		gtest.Assert(err == nil, false)
+
+		err = view.SetPath("gview.go")
+		gtest.Assert(err == nil, false)
+
+		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, ``)
+	})
+}

From 1f670a1ab214d0b30473cd7f2d54377d89822d5e Mon Sep 17 00:00:00 2001
From: piaohao <buhao@jinbaozheng.com>
Date: Tue, 11 Jun 2019 17:49:05 +0800
Subject: [PATCH 16/18] =?UTF-8?q?gspath=E6=A8=A1=E5=9D=97=E5=8F=8Agview?=
 =?UTF-8?q?=E6=A8=A1=E5=9D=97=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B=E7=BC=96?=
 =?UTF-8?q?=E5=86=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 g/os/gview/gview_unit_test.go | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/g/os/gview/gview_unit_test.go b/g/os/gview/gview_unit_test.go
index 6c910059a..b1c7f01a7 100644
--- a/g/os/gview/gview_unit_test.go
+++ b/g/os/gview/gview_unit_test.go
@@ -111,14 +111,10 @@ func TestView_Func(t *testing.T) {
 		gtest.Assert(err != nil, false)
 		gtest.Assert(gstr.Contains(result, "invalid URL escape"), true)
 
-		str = `{{1540822968 | date "Y-m-d"}};{{"1540822968" | date "Y-m-d H:i:s"}}`
+		str = `{{1540822968 | date "Y-m-d"}}`
 		result, err = gview.ParseContent(str, nil)
 		gtest.Assert(err != nil, false)
-		gtest.Assert(result, `2018-10-29;2018-10-29 22:22:48`)
-		str = `{{1540822968 | date "Y-m-d"}};{{"1540822968" | date "Y-m-d H:i:s"}}`
-		result, err = gview.ParseContent(str, nil)
-		gtest.Assert(err != nil, false)
-		gtest.Assert(result, `2018-10-29;2018-10-29 22:22:48`)
+		gtest.Assert(result, `2018-10-29`)
 		str = `{{date "Y-m-d"}}`
 		result, err = gview.ParseContent(str, nil)
 		gtest.Assert(err != nil, false)

From fccac049807dc9d3bb586f875dbf13e3a85f885d Mon Sep 17 00:00:00 2001
From: John <john@johng.cn>
Date: Tue, 11 Jun 2019 21:19:32 +0800
Subject: [PATCH 17/18] donator updates

---
 DONATOR.MD | 1 +
 1 file changed, 1 insertion(+)

diff --git a/DONATOR.MD b/DONATOR.MD
index 892de6304..741ff45d0 100644
--- a/DONATOR.MD
+++ b/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
 

From 6e7d08fbfbf6b47ed55f2ea252a0a479e32f0e4b Mon Sep 17 00:00:00 2001
From: John <john@johng.cn>
Date: Wed, 12 Jun 2019 10:11:54 +0800
Subject: [PATCH 18/18] fix issue in garray.Search

---
 g/container/garray/garray_sorted_int.go       | 10 ++++++++--
 g/container/garray/garray_sorted_interface.go | 10 ++++++++--
 g/container/garray/garray_sorted_string.go    | 10 ++++++++--
 geg/other/test.go                             |  9 +++++----
 4 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/g/container/garray/garray_sorted_int.go b/g/container/garray/garray_sorted_int.go
index 9288a0702..f2fd289e7 100644
--- a/g/container/garray/garray_sorted_int.go
+++ b/g/container/garray/garray_sorted_int.go
@@ -286,11 +286,17 @@ func (a *SortedIntArray) Contains(value int) bool {
 // 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
diff --git a/g/container/garray/garray_sorted_interface.go b/g/container/garray/garray_sorted_interface.go
index c392fc468..25d0a7f17 100644
--- a/g/container/garray/garray_sorted_interface.go
+++ b/g/container/garray/garray_sorted_interface.go
@@ -287,11 +287,17 @@ func (a *SortedArray) Contains(value interface{}) bool {
 // 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
diff --git a/g/container/garray/garray_sorted_string.go b/g/container/garray/garray_sorted_string.go
index 28e7a2fa0..1fa4fe6ec 100644
--- a/g/container/garray/garray_sorted_string.go
+++ b/g/container/garray/garray_sorted_string.go
@@ -281,11 +281,17 @@ func (a *SortedStringArray) Contains(value string) bool {
 // 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
diff --git a/geg/other/test.go b/geg/other/test.go
index 9f3000841..c2217cd37 100644
--- a/geg/other/test.go
+++ b/geg/other/test.go
@@ -1,11 +1,12 @@
 package main
 
 import (
-	"fmt"
-	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/test/gtest"
 )
 
 func main() {
-	fmt.Println(gtime.Now().Format("U"))
-	fmt.Println(gtime.Second())
+	a2 := []int{1}
+	array2 := garray.NewSortedIntArrayFrom(a2)
+	gtest.Assert(array2.Search(2),-1)
 }
\ No newline at end of file