Merge branch 'master' into qiangg_comment

2026-07-08 22:40:30 +08:00 · 2019-06-10 23:09:32 +08:00
parent f98db6d21c ad8ece68c6
commit 5aa8ce1c6b
7 changed files with 338 additions and 149 deletions
--- 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)
-    })
-}
+	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)
+	})
+}
--- 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,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)
+	})
+}
--- a/g/crypto/gcrc32/gcrc32_test.go
+++ b/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)
+	})
+}
--- a/g/os/genv/genv_test.go
+++ b/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), "")
+	})
+}
--- 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)) {
--- 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)

 	})
 }
--- a/go.mod
+++ b/go.mod
@ -1 +1,2 @@
-module github.com/gogf/gf
+module github.com/gogf/gf
+