diff --git a/g/util/gvalid/gvalid_unit_basic_all_test.go b/g/util/gvalid/gvalid_unit_basic_all_test.go
index dcd9e2c90..10731887a 100755
--- a/g/util/gvalid/gvalid_unit_basic_all_test.go
+++ b/g/util/gvalid/gvalid_unit_basic_all_test.go
@@ -1,867 +1,867 @@
-// 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.
-
-package gvalid_test
-
-import (
-	"testing"
-
-	"github.com/gogf/gf/g"
-	"github.com/gogf/gf/g/test/gtest"
-	"github.com/gogf/gf/g/util/gvalid"
-)
-
-func Test_Check(t *testing.T) {
-
-	gtest.Case(t, func() {
-		rule := "abc:6,16"
-		val1 := 0
-		val2 := 7
-		val3 := 20
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.AssertNE(err3, nil)
-	})
-}
-
-func Test_Required(t *testing.T) {
-	if m := gvalid.Check("1", "required", nil); m != nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("", "required", nil); m == nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("", "required-if:id,1,age,18", nil, map[string]interface{}{"id": 1, "age": 19}); m == nil {
-		t.Error("Required校验失败")
-	}
-	if m := gvalid.Check("", "required-if:id,1,age,18", nil, map[string]interface{}{"id": 2, "age": 19}); m != nil {
-		t.Error("Required校验失败")
-	}
-}
-
-func Test_RequiredIf(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "required-if:100,200"
-		val1 := ""
-		val2 := "100"
-		val3 := "200"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(err3, nil)
-	})
-}
-
-func Test_RequiredUnless(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "required-unless:100,200"
-		val1 := ""
-		val2 := "100"
-		val3 := "200"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(err3, nil)
-	})
-}
-
-func Test_RequiredWith(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "required-with:id,name"
-		val1 := ""
-		params1 := g.Map{
-			"age": 18,
-		}
-		params2 := g.Map{
-			"id": 100,
-		}
-		params3 := g.Map{
-			"id":   100,
-			"name": "john",
-		}
-		err1 := gvalid.Check(val1, rule, nil, params1)
-		err2 := gvalid.Check(val1, rule, nil, params2)
-		err3 := gvalid.Check(val1, rule, nil, params3)
-		gtest.Assert(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.AssertNE(err3, nil)
-	})
-}
-
-func Test_RequiredWithAll(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "required-with-all:id,name"
-		val1 := ""
-		params1 := g.Map{
-			"age": 18,
-		}
-		params2 := g.Map{
-			"id": 100,
-		}
-		params3 := g.Map{
-			"id":   100,
-			"name": "john",
-		}
-		err1 := gvalid.Check(val1, rule, nil, params1)
-		err2 := gvalid.Check(val1, rule, nil, params2)
-		err3 := gvalid.Check(val1, rule, nil, params3)
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.AssertNE(err3, nil)
-	})
-}
-
-func Test_RequiredWithOut(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "required-without:id,name"
-		val1 := ""
-		params1 := g.Map{
-			"age": 18,
-		}
-		params2 := g.Map{
-			"id": 100,
-		}
-		params3 := g.Map{
-			"id":   100,
-			"name": "john",
-		}
-		err1 := gvalid.Check(val1, rule, nil, params1)
-		err2 := gvalid.Check(val1, rule, nil, params2)
-		err3 := gvalid.Check(val1, rule, nil, params3)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-	})
-}
-
-func Test_RequiredWithOutAll(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "required-without-all:id,name"
-		val1 := ""
-		params1 := g.Map{
-			"age": 18,
-		}
-		params2 := g.Map{
-			"id": 100,
-		}
-		params3 := g.Map{
-			"id":   100,
-			"name": "john",
-		}
-		err1 := gvalid.Check(val1, rule, nil, params1)
-		err2 := gvalid.Check(val1, rule, nil, params2)
-		err3 := gvalid.Check(val1, rule, nil, params3)
-		gtest.AssertNE(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(err3, nil)
-	})
-}
-
-func Test_Date(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "date"
-		val1 := "2010"
-		val2 := "201011"
-		val3 := "20101101"
-		val4 := "2010-11-01"
-		val5 := "2010.11.01"
-		val6 := "2010/11/01"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		err6 := gvalid.Check(val6, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-		gtest.Assert(err6, nil)
-	})
-}
-
-func Test_DateFormat(t *testing.T) {
-	gtest.Case(t, func() {
-		val1 := "2010"
-		val2 := "201011"
-		val3 := "2010.11"
-		val4 := "201011-01"
-		val5 := "2010~11~01"
-		val6 := "2010-11~01"
-		err1 := gvalid.Check(val1, "date-format:Y", nil)
-		err2 := gvalid.Check(val2, "date-format:Ym", nil)
-		err3 := gvalid.Check(val3, "date-format:Y.m", nil)
-		err4 := gvalid.Check(val4, "date-format:Ym-d", nil)
-		err5 := gvalid.Check(val5, "date-format:Y~m~d", nil)
-		err6 := gvalid.Check(val6, "date-format:Y~m~d", nil)
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-		gtest.AssertNE(err6, nil)
-	})
-}
-
-func Test_Email(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "email"
-		value1 := "m@johngcn"
-		value2 := "m@www@johngcn"
-		value3 := "m-m_m@mail.johng.cn"
-		value4 := "m.m-m@johng.cn"
-		err1 := gvalid.Check(value1, rule, nil)
-		err2 := gvalid.Check(value2, rule, nil)
-		err3 := gvalid.Check(value3, rule, nil)
-		err4 := gvalid.Check(value4, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-	})
-}
-
-func Test_Phone(t *testing.T) {
-	gtest.Case(t, func() {
-		err1 := gvalid.Check("1361990897", "phone", nil)
-		err2 := gvalid.Check("13619908979", "phone", nil)
-		err3 := gvalid.Check("16719908979", "phone", nil)
-		err4 := gvalid.Check("19719908989", "phone", nil)
-		gtest.AssertNE(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-	})
-}
-
-func Test_Telephone(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "telephone"
-		val1 := "869265"
-		val2 := "028-869265"
-		val3 := "86292651"
-		val4 := "028-8692651"
-		val5 := "0830-8692651"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-	})
-}
-
-func Test_Passport(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "passport"
-		val1 := "123456"
-		val2 := "a12345-6"
-		val3 := "aaaaa"
-		val4 := "aaaaaa"
-		val5 := "a123_456"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.AssertNE(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-	})
-}
-
-func Test_Password(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "password"
-		val1 := "12345"
-		val2 := "aaaaa"
-		val3 := "a12345-6"
-		val4 := ">,/;'[09-"
-		val5 := "a123_456"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-	})
-}
-
-func Test_Password2(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "password2"
-		val1 := "12345"
-		val2 := "Naaaa"
-		val3 := "a12345-6"
-		val4 := ">,/;'[09-"
-		val5 := "a123_456"
-		val6 := "Nant1986"
-		val7 := "Nant1986!"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		err6 := gvalid.Check(val6, rule, nil)
-		err7 := gvalid.Check(val7, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.AssertNE(err3, nil)
-		gtest.AssertNE(err4, nil)
-		gtest.AssertNE(err5, nil)
-		gtest.Assert(err6, nil)
-		gtest.Assert(err7, nil)
-	})
-}
-
-func Test_Password3(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "password3"
-		val1 := "12345"
-		val2 := "Naaaa"
-		val3 := "a12345-6"
-		val4 := ">,/;'[09-"
-		val5 := "a123_456"
-		val6 := "Nant1986"
-		val7 := "Nant1986!"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		err6 := gvalid.Check(val6, rule, nil)
-		err7 := gvalid.Check(val7, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.AssertNE(err3, nil)
-		gtest.AssertNE(err4, nil)
-		gtest.AssertNE(err5, nil)
-		gtest.AssertNE(err6, nil)
-		gtest.Assert(err7, nil)
-	})
-}
-
-func Test_Postcode(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "postcode"
-		val1 := "12345"
-		val2 := "610036"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.Assert(err2, nil)
-	})
-}
-
-func Test_IDNumber(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "id-number"
-		val1 := "11111111111111"
-		val2 := "1111111111111111"
-		val3 := "311128500121201"
-		val4 := "510521198607185367"
-		val5 := "51052119860718536x"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-	})
-}
-
-func Test_QQ(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "qq"
-		val1 := "100"
-		val2 := "1"
-		val3 := "10000"
-		val4 := "38996181"
-		val5 := "389961817"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-	})
-}
-
-func Test_Ip(t *testing.T) {
-	if m := gvalid.Check("10.0.0.1", "ip", nil); m != nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("10.0.0.1", "ipv4", nil); m != nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("0.0.0.0", "ipv4", nil); m != nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("1920.0.0.0", "ipv4", nil); m == nil {
-		t.Error("ipv4校验失败")
-	}
-	if m := gvalid.Check("1920.0.0.0", "ip", nil); m == nil {
-		t.Error("ipv4校验失败")
-	}
-	if m := gvalid.Check("fe80::5484:7aff:fefe:9799", "ipv6", nil); m != nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("fe80::5484:7aff:fefe:9799123", "ipv6", nil); m == nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("fe80::5484:7aff:fefe:9799", "ip", nil); m != nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("fe80::5484:7aff:fefe:9799123", "ip", nil); m == nil {
-		t.Error(m)
-	}
-}
-
-func Test_IPv4(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "ipv4"
-		val1 := "0.0.0"
-		val2 := "0.0.0.0"
-		val3 := "1.1.1.1"
-		val4 := "255.255.255.0"
-		val5 := "127.0.0.1"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-	})
-}
-
-func Test_IPv6(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "ipv6"
-		val1 := "192.168.1.1"
-		val2 := "CDCD:910A:2222:5498:8475:1111:3900:2020"
-		val3 := "1030::C9B4:FF12:48AA:1A2B"
-		val4 := "2000:0:0:0:0:0:0:1"
-		val5 := "0000:0000:0000:0000:0000:ffff:c0a8:5909"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-	})
-}
-
-func Test_MAC(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "mac"
-		val1 := "192.168.1.1"
-		val2 := "44-45-53-54-00-00"
-		val3 := "01:00:5e:00:00:00"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(err3, nil)
-	})
-}
-
-func Test_URL(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "url"
-		val1 := "127.0.0.1"
-		val2 := "https://www.baidu.com"
-		val3 := "http://127.0.0.1"
-		val4 := "file:///tmp/test.txt"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-	})
-}
-
-func Test_Domain(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "domain"
-		val1 := "localhost"
-		val2 := "baidu.com"
-		val3 := "www.baidu.com"
-		val4 := "jn.np"
-		val5 := "www.jn.np"
-		val6 := "w.www.jn.np"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		err6 := gvalid.Check(val6, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-		gtest.Assert(err6, nil)
-	})
-}
-
-func Test_Length(t *testing.T) {
-	rule := "length:6,16"
-	if m := gvalid.Check("123456", rule, nil); m != nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("12345", rule, nil); m == nil {
-		t.Error("长度校验失败")
-	}
-}
-
-func Test_MinLength(t *testing.T) {
-	rule := "min-length:6"
-	msgs := map[string]string{
-		"min-length": "地址长度至少为:min位",
-	}
-	if m := gvalid.Check("123456", rule, nil); m != nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("12345", rule, nil); m == nil {
-		t.Error("长度校验失败")
-	}
-	if m := gvalid.Check("12345", rule, msgs); m == nil {
-		t.Error("长度校验失败")
-	}
-
-	rule2 := "min-length:abc"
-	if m := gvalid.Check("123456", rule2, nil); m == nil {
-		t.Error("长度校验失败")
-	}
-}
-
-func Test_MaxLength(t *testing.T) {
-	rule := "max-length:6"
-	msgs := map[string]string{
-		"max-length": "地址长度至大为:max位",
-	}
-	if m := gvalid.Check("12345", rule, nil); m != nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("1234567", rule, nil); m == nil {
-		t.Error("长度校验失败")
-	}
-	if m := gvalid.Check("1234567", rule, msgs); m == nil {
-		t.Error("长度校验失败")
-	}
-
-	rule2 := "max-length:abc"
-	if m := gvalid.Check("123456", rule2, nil); m == nil {
-		t.Error("长度校验失败")
-	}
-}
-
-func Test_Between(t *testing.T) {
-	rule := "between:6.01, 10.01"
-	if m := gvalid.Check(10, rule, nil); m != nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check(10.02, rule, nil); m == nil {
-		t.Error("大小范围校验失败")
-	}
-	if m := gvalid.Check("a", rule, nil); m == nil {
-		t.Error("大小范围校验失败")
-	}
-}
-
-func Test_Min(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "min:100"
-		val1 := "1"
-		val2 := "99"
-		val3 := "100"
-		val4 := "1000"
-		val5 := "a"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.AssertNE(err5, nil)
-
-		rule2 := "min:a"
-		err6 := gvalid.Check(val1, rule2, nil)
-		gtest.AssertNE(err6, nil)
-	})
-}
-
-func Test_Max(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "max:100"
-		val1 := "1"
-		val2 := "99"
-		val3 := "100"
-		val4 := "1000"
-		val5 := "a"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.AssertNE(err4, nil)
-		gtest.AssertNE(err5, nil)
-
-		rule2 := "max:a"
-		err6 := gvalid.Check(val1, rule2, nil)
-		gtest.AssertNE(err6, nil)
-	})
-}
-
-func Test_Json(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "json"
-		val1 := ""
-		val2 := "."
-		val3 := "{}"
-		val4 := "[]"
-		val5 := "[1,2,3,4]"
-		val6 := `{"list":[1,2,3,4]}`
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		err6 := gvalid.Check(val6, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-		gtest.Assert(err6, nil)
-	})
-}
-
-func Test_Integer(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "integer"
-		val1 := ""
-		val2 := "1.0"
-		val3 := "001"
-		val4 := "1"
-		val5 := "100"
-		val6 := `999999999`
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		err6 := gvalid.Check(val6, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-		gtest.Assert(err6, nil)
-	})
-}
-
-func Test_Float(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "float"
-		val1 := ""
-		val2 := "a"
-		val3 := "1"
-		val4 := "1.0"
-		val5 := "1.1"
-		val6 := `0.1`
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		err6 := gvalid.Check(val6, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-		gtest.Assert(err6, nil)
-	})
-}
-
-func Test_Boolean(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "boolean"
-		val1 := "a"
-		val2 := "-"
-		val3 := ""
-		val4 := "1"
-		val5 := "true"
-		val6 := `off`
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		err5 := gvalid.Check(val5, rule, nil)
-		err6 := gvalid.Check(val6, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-		gtest.Assert(err5, nil)
-		gtest.Assert(err6, nil)
-	})
-}
-
-func Test_Same(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "same:id"
-		val1 := "100"
-		params1 := g.Map{
-			"age": 18,
-		}
-		params2 := g.Map{
-			"id": 100,
-		}
-		params3 := g.Map{
-			"id":   100,
-			"name": "john",
-		}
-		err1 := gvalid.Check(val1, rule, nil, params1)
-		err2 := gvalid.Check(val1, rule, nil, params2)
-		err3 := gvalid.Check(val1, rule, nil, params3)
-		gtest.AssertNE(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(err3, nil)
-	})
-}
-
-func Test_Different(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "different:id"
-		val1 := "100"
-		params1 := g.Map{
-			"age": 18,
-		}
-		params2 := g.Map{
-			"id": 100,
-		}
-		params3 := g.Map{
-			"id":   100,
-			"name": "john",
-		}
-		err1 := gvalid.Check(val1, rule, nil, params1)
-		err2 := gvalid.Check(val1, rule, nil, params2)
-		err3 := gvalid.Check(val1, rule, nil, params3)
-		gtest.Assert(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.AssertNE(err3, nil)
-	})
-}
-
-func Test_In(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "in:100,200"
-		val1 := ""
-		val2 := "1"
-		val3 := "100"
-		val4 := "200"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-		gtest.Assert(err4, nil)
-	})
-}
-
-func Test_NotIn(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "not-in:100,200"
-		val1 := ""
-		val2 := "1"
-		val3 := "100"
-		val4 := "200"
-		err1 := gvalid.Check(val1, rule, nil)
-		err2 := gvalid.Check(val2, rule, nil)
-		err3 := gvalid.Check(val3, rule, nil)
-		err4 := gvalid.Check(val4, rule, nil)
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.AssertNE(err3, nil)
-		gtest.AssertNE(err4, nil)
-	})
-}
-
-func Test_Regex1(t *testing.T) {
-	rule := `regex:\d{6}|\D{6}|length:6,16`
-	if m := gvalid.Check("123456", rule, nil); m != nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("abcde6", rule, nil); m == nil {
-		t.Error("校验失败")
-	}
-}
-
-func Test_Regex2(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := `required|min-length:6|regex:^data:image\/(jpeg|png);base64,`
-		str1 := ""
-		str2 := "data"
-		str3 := "data:image/jpeg;base64,/9jrbattq22r"
-		err1 := gvalid.Check(str1, rule, nil)
-		err2 := gvalid.Check(str2, rule, nil)
-		err3 := gvalid.Check(str3, rule, nil)
-		gtest.AssertNE(err1, nil)
-		gtest.AssertNE(err2, nil)
-		gtest.Assert(err3, nil)
-
-		gtest.AssertNE(err1.Map()["required"], nil)
-		gtest.AssertNE(err2.Map()["min-length"], nil)
-	})
-}
+// 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.
+
+package gvalid_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/util/gvalid"
+)
+
+func Test_Check(t *testing.T) {
+
+	gtest.Case(t, func() {
+		rule := "abc:6,16"
+		val1 := 0
+		val2 := 7
+		val3 := 20
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.AssertNE(err3, nil)
+	})
+}
+
+func Test_Required(t *testing.T) {
+	if m := gvalid.Check("1", "required", nil); m != nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check("", "required", nil); m == nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check("", "required-if:id,1,age,18", nil, map[string]interface{}{"id": 1, "age": 19}); m == nil {
+		t.Error("Required校验失败")
+	}
+	if m := gvalid.Check("", "required-if:id,1,age,18", nil, map[string]interface{}{"id": 2, "age": 19}); m != nil {
+		t.Error("Required校验失败")
+	}
+}
+
+func Test_RequiredIf(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "required-if:100,200"
+		val1 := ""
+		val2 := "100"
+		val3 := "200"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(err3, nil)
+	})
+}
+
+func Test_RequiredUnless(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "required-unless:100,200"
+		val1 := ""
+		val2 := "100"
+		val3 := "200"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(err3, nil)
+	})
+}
+
+func Test_RequiredWith(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "required-with:id,name"
+		val1 := ""
+		params1 := g.Map{
+			"age": 18,
+		}
+		params2 := g.Map{
+			"id": 100,
+		}
+		params3 := g.Map{
+			"id":   100,
+			"name": "john",
+		}
+		err1 := gvalid.Check(val1, rule, nil, params1)
+		err2 := gvalid.Check(val1, rule, nil, params2)
+		err3 := gvalid.Check(val1, rule, nil, params3)
+		gtest.Assert(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.AssertNE(err3, nil)
+	})
+}
+
+func Test_RequiredWithAll(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "required-with-all:id,name"
+		val1 := ""
+		params1 := g.Map{
+			"age": 18,
+		}
+		params2 := g.Map{
+			"id": 100,
+		}
+		params3 := g.Map{
+			"id":   100,
+			"name": "john",
+		}
+		err1 := gvalid.Check(val1, rule, nil, params1)
+		err2 := gvalid.Check(val1, rule, nil, params2)
+		err3 := gvalid.Check(val1, rule, nil, params3)
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.AssertNE(err3, nil)
+	})
+}
+
+func Test_RequiredWithOut(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "required-without:id,name"
+		val1 := ""
+		params1 := g.Map{
+			"age": 18,
+		}
+		params2 := g.Map{
+			"id": 100,
+		}
+		params3 := g.Map{
+			"id":   100,
+			"name": "john",
+		}
+		err1 := gvalid.Check(val1, rule, nil, params1)
+		err2 := gvalid.Check(val1, rule, nil, params2)
+		err3 := gvalid.Check(val1, rule, nil, params3)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+	})
+}
+
+func Test_RequiredWithOutAll(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "required-without-all:id,name"
+		val1 := ""
+		params1 := g.Map{
+			"age": 18,
+		}
+		params2 := g.Map{
+			"id": 100,
+		}
+		params3 := g.Map{
+			"id":   100,
+			"name": "john",
+		}
+		err1 := gvalid.Check(val1, rule, nil, params1)
+		err2 := gvalid.Check(val1, rule, nil, params2)
+		err3 := gvalid.Check(val1, rule, nil, params3)
+		gtest.AssertNE(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(err3, nil)
+	})
+}
+
+func Test_Date(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "date"
+		val1 := "2010"
+		val2 := "201011"
+		val3 := "20101101"
+		val4 := "2010-11-01"
+		val5 := "2010.11.01"
+		val6 := "2010/11/01"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		err6 := gvalid.Check(val6, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+		gtest.Assert(err6, nil)
+	})
+}
+
+func Test_DateFormat(t *testing.T) {
+	gtest.Case(t, func() {
+		val1 := "2010"
+		val2 := "201011"
+		val3 := "2010.11"
+		val4 := "201011-01"
+		val5 := "2010~11~01"
+		val6 := "2010-11~01"
+		err1 := gvalid.Check(val1, "date-format:Y", nil)
+		err2 := gvalid.Check(val2, "date-format:Ym", nil)
+		err3 := gvalid.Check(val3, "date-format:Y.m", nil)
+		err4 := gvalid.Check(val4, "date-format:Ym-d", nil)
+		err5 := gvalid.Check(val5, "date-format:Y~m~d", nil)
+		err6 := gvalid.Check(val6, "date-format:Y~m~d", nil)
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+		gtest.AssertNE(err6, nil)
+	})
+}
+
+func Test_Email(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "email"
+		value1 := "m@johngcn"
+		value2 := "m@www@johngcn"
+		value3 := "m-m_m@mail.johng.cn"
+		value4 := "m.m-m@johng.cn"
+		err1 := gvalid.Check(value1, rule, nil)
+		err2 := gvalid.Check(value2, rule, nil)
+		err3 := gvalid.Check(value3, rule, nil)
+		err4 := gvalid.Check(value4, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+	})
+}
+
+func Test_Phone(t *testing.T) {
+	gtest.Case(t, func() {
+		err1 := gvalid.Check("1361990897", "phone", nil)
+		err2 := gvalid.Check("13619908979", "phone", nil)
+		err3 := gvalid.Check("16719908979", "phone", nil)
+		err4 := gvalid.Check("19719908989", "phone", nil)
+		gtest.AssertNE(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+	})
+}
+
+func Test_Telephone(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "telephone"
+		val1 := "869265"
+		val2 := "028-869265"
+		val3 := "86292651"
+		val4 := "028-8692651"
+		val5 := "0830-8692651"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+	})
+}
+
+func Test_Passport(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "passport"
+		val1 := "123456"
+		val2 := "a12345-6"
+		val3 := "aaaaa"
+		val4 := "aaaaaa"
+		val5 := "a123_456"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.AssertNE(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+	})
+}
+
+func Test_Password(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "password"
+		val1 := "12345"
+		val2 := "aaaaa"
+		val3 := "a12345-6"
+		val4 := ">,/;'[09-"
+		val5 := "a123_456"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+	})
+}
+
+func Test_Password2(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "password2"
+		val1 := "12345"
+		val2 := "Naaaa"
+		val3 := "a12345-6"
+		val4 := ">,/;'[09-"
+		val5 := "a123_456"
+		val6 := "Nant1986"
+		val7 := "Nant1986!"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		err6 := gvalid.Check(val6, rule, nil)
+		err7 := gvalid.Check(val7, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.AssertNE(err3, nil)
+		gtest.AssertNE(err4, nil)
+		gtest.AssertNE(err5, nil)
+		gtest.Assert(err6, nil)
+		gtest.Assert(err7, nil)
+	})
+}
+
+func Test_Password3(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "password3"
+		val1 := "12345"
+		val2 := "Naaaa"
+		val3 := "a12345-6"
+		val4 := ">,/;'[09-"
+		val5 := "a123_456"
+		val6 := "Nant1986"
+		val7 := "Nant1986!"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		err6 := gvalid.Check(val6, rule, nil)
+		err7 := gvalid.Check(val7, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.AssertNE(err3, nil)
+		gtest.AssertNE(err4, nil)
+		gtest.AssertNE(err5, nil)
+		gtest.AssertNE(err6, nil)
+		gtest.Assert(err7, nil)
+	})
+}
+
+func Test_Postcode(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "postcode"
+		val1 := "12345"
+		val2 := "610036"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.Assert(err2, nil)
+	})
+}
+
+func Test_IDNumber(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "id-number"
+		val1 := "11111111111111"
+		val2 := "1111111111111111"
+		val3 := "311128500121201"
+		val4 := "510521198607185367"
+		val5 := "51052119860718536x"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+	})
+}
+
+func Test_QQ(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "qq"
+		val1 := "100"
+		val2 := "1"
+		val3 := "10000"
+		val4 := "38996181"
+		val5 := "389961817"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+	})
+}
+
+func Test_Ip(t *testing.T) {
+	if m := gvalid.Check("10.0.0.1", "ip", nil); m != nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check("10.0.0.1", "ipv4", nil); m != nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check("0.0.0.0", "ipv4", nil); m != nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check("1920.0.0.0", "ipv4", nil); m == nil {
+		t.Error("ipv4校验失败")
+	}
+	if m := gvalid.Check("1920.0.0.0", "ip", nil); m == nil {
+		t.Error("ipv4校验失败")
+	}
+	if m := gvalid.Check("fe80::5484:7aff:fefe:9799", "ipv6", nil); m != nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check("fe80::5484:7aff:fefe:9799123", "ipv6", nil); m == nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check("fe80::5484:7aff:fefe:9799", "ip", nil); m != nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check("fe80::5484:7aff:fefe:9799123", "ip", nil); m == nil {
+		t.Error(m)
+	}
+}
+
+func Test_IPv4(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "ipv4"
+		val1 := "0.0.0"
+		val2 := "0.0.0.0"
+		val3 := "1.1.1.1"
+		val4 := "255.255.255.0"
+		val5 := "127.0.0.1"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+	})
+}
+
+func Test_IPv6(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "ipv6"
+		val1 := "192.168.1.1"
+		val2 := "CDCD:910A:2222:5498:8475:1111:3900:2020"
+		val3 := "1030::C9B4:FF12:48AA:1A2B"
+		val4 := "2000:0:0:0:0:0:0:1"
+		val5 := "0000:0000:0000:0000:0000:ffff:c0a8:5909"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+	})
+}
+
+func Test_MAC(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "mac"
+		val1 := "192.168.1.1"
+		val2 := "44-45-53-54-00-00"
+		val3 := "01:00:5e:00:00:00"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(err3, nil)
+	})
+}
+
+func Test_URL(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "url"
+		val1 := "127.0.0.1"
+		val2 := "https://www.baidu.com"
+		val3 := "http://127.0.0.1"
+		val4 := "file:///tmp/test.txt"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+	})
+}
+
+func Test_Domain(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "domain"
+		val1 := "localhost"
+		val2 := "baidu.com"
+		val3 := "www.baidu.com"
+		val4 := "jn.np"
+		val5 := "www.jn.np"
+		val6 := "w.www.jn.np"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		err6 := gvalid.Check(val6, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+		gtest.Assert(err6, nil)
+	})
+}
+
+func Test_Length(t *testing.T) {
+	rule := "length:6,16"
+	if m := gvalid.Check("123456", rule, nil); m != nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check("12345", rule, nil); m == nil {
+		t.Error("长度校验失败")
+	}
+}
+
+func Test_MinLength(t *testing.T) {
+	rule := "min-length:6"
+	msgs := map[string]string{
+		"min-length": "地址长度至少为:min位",
+	}
+	if m := gvalid.Check("123456", rule, nil); m != nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check("12345", rule, nil); m == nil {
+		t.Error("长度校验失败")
+	}
+	if m := gvalid.Check("12345", rule, msgs); m == nil {
+		t.Error("长度校验失败")
+	}
+
+	rule2 := "min-length:abc"
+	if m := gvalid.Check("123456", rule2, nil); m == nil {
+		t.Error("长度校验失败")
+	}
+}
+
+func Test_MaxLength(t *testing.T) {
+	rule := "max-length:6"
+	msgs := map[string]string{
+		"max-length": "地址长度至大为:max位",
+	}
+	if m := gvalid.Check("12345", rule, nil); m != nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check("1234567", rule, nil); m == nil {
+		t.Error("长度校验失败")
+	}
+	if m := gvalid.Check("1234567", rule, msgs); m == nil {
+		t.Error("长度校验失败")
+	}
+
+	rule2 := "max-length:abc"
+	if m := gvalid.Check("123456", rule2, nil); m == nil {
+		t.Error("长度校验失败")
+	}
+}
+
+func Test_Between(t *testing.T) {
+	rule := "between:6.01, 10.01"
+	if m := gvalid.Check(10, rule, nil); m != nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check(10.02, rule, nil); m == nil {
+		t.Error("大小范围校验失败")
+	}
+	if m := gvalid.Check("a", rule, nil); m == nil {
+		t.Error("大小范围校验失败")
+	}
+}
+
+func Test_Min(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "min:100"
+		val1 := "1"
+		val2 := "99"
+		val3 := "100"
+		val4 := "1000"
+		val5 := "a"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.AssertNE(err5, nil)
+
+		rule2 := "min:a"
+		err6 := gvalid.Check(val1, rule2, nil)
+		gtest.AssertNE(err6, nil)
+	})
+}
+
+func Test_Max(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "max:100"
+		val1 := "1"
+		val2 := "99"
+		val3 := "100"
+		val4 := "1000"
+		val5 := "a"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.AssertNE(err4, nil)
+		gtest.AssertNE(err5, nil)
+
+		rule2 := "max:a"
+		err6 := gvalid.Check(val1, rule2, nil)
+		gtest.AssertNE(err6, nil)
+	})
+}
+
+func Test_Json(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "json"
+		val1 := ""
+		val2 := "."
+		val3 := "{}"
+		val4 := "[]"
+		val5 := "[1,2,3,4]"
+		val6 := `{"list":[1,2,3,4]}`
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		err6 := gvalid.Check(val6, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+		gtest.Assert(err6, nil)
+	})
+}
+
+func Test_Integer(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "integer"
+		val1 := ""
+		val2 := "1.0"
+		val3 := "001"
+		val4 := "1"
+		val5 := "100"
+		val6 := `999999999`
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		err6 := gvalid.Check(val6, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+		gtest.Assert(err6, nil)
+	})
+}
+
+func Test_Float(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "float"
+		val1 := ""
+		val2 := "a"
+		val3 := "1"
+		val4 := "1.0"
+		val5 := "1.1"
+		val6 := `0.1`
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		err6 := gvalid.Check(val6, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+		gtest.Assert(err6, nil)
+	})
+}
+
+func Test_Boolean(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "boolean"
+		val1 := "a"
+		val2 := "-"
+		val3 := ""
+		val4 := "1"
+		val5 := "true"
+		val6 := `off`
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		err5 := gvalid.Check(val5, rule, nil)
+		err6 := gvalid.Check(val6, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+		gtest.Assert(err5, nil)
+		gtest.Assert(err6, nil)
+	})
+}
+
+func Test_Same(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "same:id"
+		val1 := "100"
+		params1 := g.Map{
+			"age": 18,
+		}
+		params2 := g.Map{
+			"id": 100,
+		}
+		params3 := g.Map{
+			"id":   100,
+			"name": "john",
+		}
+		err1 := gvalid.Check(val1, rule, nil, params1)
+		err2 := gvalid.Check(val1, rule, nil, params2)
+		err3 := gvalid.Check(val1, rule, nil, params3)
+		gtest.AssertNE(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(err3, nil)
+	})
+}
+
+func Test_Different(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "different:id"
+		val1 := "100"
+		params1 := g.Map{
+			"age": 18,
+		}
+		params2 := g.Map{
+			"id": 100,
+		}
+		params3 := g.Map{
+			"id":   100,
+			"name": "john",
+		}
+		err1 := gvalid.Check(val1, rule, nil, params1)
+		err2 := gvalid.Check(val1, rule, nil, params2)
+		err3 := gvalid.Check(val1, rule, nil, params3)
+		gtest.Assert(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.AssertNE(err3, nil)
+	})
+}
+
+func Test_In(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "in:100,200"
+		val1 := ""
+		val2 := "1"
+		val3 := "100"
+		val4 := "200"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+		gtest.Assert(err4, nil)
+	})
+}
+
+func Test_NotIn(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := "not-in:100,200"
+		val1 := ""
+		val2 := "1"
+		val3 := "100"
+		val4 := "200"
+		err1 := gvalid.Check(val1, rule, nil)
+		err2 := gvalid.Check(val2, rule, nil)
+		err3 := gvalid.Check(val3, rule, nil)
+		err4 := gvalid.Check(val4, rule, nil)
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.AssertNE(err3, nil)
+		gtest.AssertNE(err4, nil)
+	})
+}
+
+func Test_Regex1(t *testing.T) {
+	rule := `regex:\d{6}|\D{6}|length:6,16`
+	if m := gvalid.Check("123456", rule, nil); m != nil {
+		t.Error(m)
+	}
+	if m := gvalid.Check("abcde6", rule, nil); m == nil {
+		t.Error("校验失败")
+	}
+}
+
+func Test_Regex2(t *testing.T) {
+	gtest.Case(t, func() {
+		rule := `required|min-length:6|regex:^data:image\/(jpeg|png);base64,`
+		str1 := ""
+		str2 := "data"
+		str3 := "data:image/jpeg;base64,/9jrbattq22r"
+		err1 := gvalid.Check(str1, rule, nil)
+		err2 := gvalid.Check(str2, rule, nil)
+		err3 := gvalid.Check(str3, rule, nil)
+		gtest.AssertNE(err1, nil)
+		gtest.AssertNE(err2, nil)
+		gtest.Assert(err3, nil)
+
+		gtest.AssertNE(err1.Map()["required"], nil)
+		gtest.AssertNE(err2.Map()["min-length"], nil)
+	})
+}
diff --git a/g/util/gvalid/gvalid_unit_checkmap_test.go b/g/util/gvalid/gvalid_unit_checkmap_test.go
index 009d72bc3..05b519d94 100755
--- a/g/util/gvalid/gvalid_unit_checkmap_test.go
+++ b/g/util/gvalid/gvalid_unit_checkmap_test.go
@@ -1,182 +1,182 @@
-// 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 gvalid_test
-
-import (
-	"testing"
-
-	"github.com/gogf/gf/g/test/gtest"
-	"github.com/gogf/gf/g/util/gvalid"
-)
-
-func Test_CheckMap(t *testing.T) {
-
-	var params interface{}
-	if m := gvalid.CheckMap(params, nil, nil); m == nil {
-		t.Error("CheckMap校验失败")
-	}
-
-	kvmap := map[string]interface{}{
-		"id":   "0",
-		"name": "john",
-	}
-	rules := map[string]string{
-		"id":   "required|between:1,100",
-		"name": "required|length:6,16",
-	}
-	msgs := gvalid.CustomMsg{
-		"id": "ID不能为空|ID范围应当为:min到:max",
-		"name": map[string]string{
-			"required": "名称不能为空",
-			"length":   "名称长度为:min到:max个字符",
-		},
-	}
-	if m := gvalid.CheckMap(kvmap, rules, msgs); m == nil {
-		t.Error("CheckMap校验失败")
-	}
-
-	kvmap = map[string]interface{}{
-		"id":   "1",
-		"name": "john",
-	}
-	rules = map[string]string{
-		"id":   "required|between:1,100",
-		"name": "required|length:4,16",
-	}
-	msgs = map[string]interface{}{
-		"id": "ID不能为空|ID范围应当为:min到:max",
-		"name": map[string]string{
-			"required": "名称不能为空",
-			"length":   "名称长度为:min到:max个字符",
-		},
-	}
-	if m := gvalid.CheckMap(kvmap, rules, msgs); m != nil {
-		t.Error(m)
-	}
-
-	kvmap = map[string]interface{}{
-		"id":   "1",
-		"name": "john",
-	}
-	rules = map[string]string{
-		"id":   "",
-		"name": "",
-	}
-	msgs = map[string]interface{}{
-		"id": "ID不能为空|ID范围应当为:min到:max",
-		"name": map[string]string{
-			"required": "名称不能为空",
-			"length":   "名称长度为:min到:max个字符",
-		},
-	}
-	if m := gvalid.CheckMap(kvmap, rules, msgs); m != nil {
-		t.Error(m)
-	}
-
-	kvmap = map[string]interface{}{
-		"id":   "1",
-		"name": "john",
-	}
-	rules2 := []string{
-		"@required|between:1,100",
-		"@required|length:4,16",
-	}
-	msgs = map[string]interface{}{
-		"id": "ID不能为空|ID范围应当为:min到:max",
-		"name": map[string]string{
-			"required": "名称不能为空",
-			"length":   "名称长度为:min到:max个字符",
-		},
-	}
-	if m := gvalid.CheckMap(kvmap, rules2, msgs); m != nil {
-		t.Error(m)
-	}
-
-	kvmap = map[string]interface{}{
-		"id":   "1",
-		"name": "john",
-	}
-	rules2 = []string{
-		"id@required|between:1,100",
-		"name@required|length:4,16#名称不能为空|",
-	}
-	msgs = map[string]interface{}{
-		"id": "ID不能为空|ID范围应当为:min到:max",
-		"name": map[string]string{
-			"required": "名称不能为空",
-			"length":   "名称长度为:min到:max个字符",
-		},
-	}
-	if m := gvalid.CheckMap(kvmap, rules2, msgs); m != nil {
-		t.Error(m)
-	}
-
-	kvmap = map[string]interface{}{
-		"id":   "1",
-		"name": "john",
-	}
-	rules2 = []string{
-		"id@required|between:1,100",
-		"name@required|length:4,16#名称不能为空",
-	}
-	msgs = map[string]interface{}{
-		"id": "ID不能为空|ID范围应当为:min到:max",
-		"name": map[string]string{
-			"required": "名称不能为空",
-			"length":   "名称长度为:min到:max个字符",
-		},
-	}
-	if m := gvalid.CheckMap(kvmap, rules2, msgs); m != nil {
-		t.Error(m)
-	}
-}
-
-// 如果值为nil，并且不需要require*验证时，其他验证失效
-func Test_CheckMapWithNilAndNotRequiredField(t *testing.T) {
-	data := map[string]interface{}{
-		"id": "1",
-	}
-	rules := map[string]string{
-		"id":   "required",
-		"name": "length:4,16",
-	}
-	if m := gvalid.CheckMap(data, rules); m != nil {
-		t.Error(m)
-	}
-}
-
-func Test_Sequence(t *testing.T) {
-	gtest.Case(t, func() {
-		params := map[string]interface{}{
-			"passport":  "",
-			"password":  "123456",
-			"password2": "1234567",
-		}
-		rules := []string{
-			"passport@required|length:6,16#账号不能为空|账号长度应当在:min到:max之间",
-			"password@required|length:6,16|same:password2#密码不能为空|密码长度应当在:min到:max之间|两次密码输入不相等",
-			"password2@required|length:6,16#",
-		}
-		err := gvalid.CheckMap(params, rules)
-		gtest.AssertNE(err, nil)
-		gtest.Assert(len(err.Map()), 2)
-		gtest.Assert(err.Map()["required"], "账号不能为空")
-		gtest.Assert(err.Map()["length"], "账号长度应当在6到16之间")
-		gtest.Assert(len(err.Maps()), 2)
-
-		gtest.Assert(err.String(), "账号不能为空; 账号长度应当在6到16之间; 两次密码输入不相等")
-		gtest.Assert(err.Strings(), []string{"账号不能为空", "账号长度应当在6到16之间", "两次密码输入不相等"})
-
-		k, m := err.FirstItem()
-		gtest.Assert(k, "passport")
-		gtest.Assert(m, err.Map())
-
-		r, s := err.FirstRule()
-		gtest.Assert(r, "required")
-		gtest.Assert(s, "账号不能为空")
-	})
-}
+// 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 gvalid_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/util/gvalid"
+)
+
+func Test_CheckMap(t *testing.T) {
+
+	var params interface{}
+	if m := gvalid.CheckMap(params, nil, nil); m == nil {
+		t.Error("CheckMap校验失败")
+	}
+
+	kvmap := map[string]interface{}{
+		"id":   "0",
+		"name": "john",
+	}
+	rules := map[string]string{
+		"id":   "required|between:1,100",
+		"name": "required|length:6,16",
+	}
+	msgs := gvalid.CustomMsg{
+		"id": "ID不能为空|ID范围应当为:min到:max",
+		"name": map[string]string{
+			"required": "名称不能为空",
+			"length":   "名称长度为:min到:max个字符",
+		},
+	}
+	if m := gvalid.CheckMap(kvmap, rules, msgs); m == nil {
+		t.Error("CheckMap校验失败")
+	}
+
+	kvmap = map[string]interface{}{
+		"id":   "1",
+		"name": "john",
+	}
+	rules = map[string]string{
+		"id":   "required|between:1,100",
+		"name": "required|length:4,16",
+	}
+	msgs = map[string]interface{}{
+		"id": "ID不能为空|ID范围应当为:min到:max",
+		"name": map[string]string{
+			"required": "名称不能为空",
+			"length":   "名称长度为:min到:max个字符",
+		},
+	}
+	if m := gvalid.CheckMap(kvmap, rules, msgs); m != nil {
+		t.Error(m)
+	}
+
+	kvmap = map[string]interface{}{
+		"id":   "1",
+		"name": "john",
+	}
+	rules = map[string]string{
+		"id":   "",
+		"name": "",
+	}
+	msgs = map[string]interface{}{
+		"id": "ID不能为空|ID范围应当为:min到:max",
+		"name": map[string]string{
+			"required": "名称不能为空",
+			"length":   "名称长度为:min到:max个字符",
+		},
+	}
+	if m := gvalid.CheckMap(kvmap, rules, msgs); m != nil {
+		t.Error(m)
+	}
+
+	kvmap = map[string]interface{}{
+		"id":   "1",
+		"name": "john",
+	}
+	rules2 := []string{
+		"@required|between:1,100",
+		"@required|length:4,16",
+	}
+	msgs = map[string]interface{}{
+		"id": "ID不能为空|ID范围应当为:min到:max",
+		"name": map[string]string{
+			"required": "名称不能为空",
+			"length":   "名称长度为:min到:max个字符",
+		},
+	}
+	if m := gvalid.CheckMap(kvmap, rules2, msgs); m != nil {
+		t.Error(m)
+	}
+
+	kvmap = map[string]interface{}{
+		"id":   "1",
+		"name": "john",
+	}
+	rules2 = []string{
+		"id@required|between:1,100",
+		"name@required|length:4,16#名称不能为空|",
+	}
+	msgs = map[string]interface{}{
+		"id": "ID不能为空|ID范围应当为:min到:max",
+		"name": map[string]string{
+			"required": "名称不能为空",
+			"length":   "名称长度为:min到:max个字符",
+		},
+	}
+	if m := gvalid.CheckMap(kvmap, rules2, msgs); m != nil {
+		t.Error(m)
+	}
+
+	kvmap = map[string]interface{}{
+		"id":   "1",
+		"name": "john",
+	}
+	rules2 = []string{
+		"id@required|between:1,100",
+		"name@required|length:4,16#名称不能为空",
+	}
+	msgs = map[string]interface{}{
+		"id": "ID不能为空|ID范围应当为:min到:max",
+		"name": map[string]string{
+			"required": "名称不能为空",
+			"length":   "名称长度为:min到:max个字符",
+		},
+	}
+	if m := gvalid.CheckMap(kvmap, rules2, msgs); m != nil {
+		t.Error(m)
+	}
+}
+
+// 如果值为nil，并且不需要require*验证时，其他验证失效
+func Test_CheckMapWithNilAndNotRequiredField(t *testing.T) {
+	data := map[string]interface{}{
+		"id": "1",
+	}
+	rules := map[string]string{
+		"id":   "required",
+		"name": "length:4,16",
+	}
+	if m := gvalid.CheckMap(data, rules); m != nil {
+		t.Error(m)
+	}
+}
+
+func Test_Sequence(t *testing.T) {
+	gtest.Case(t, func() {
+		params := map[string]interface{}{
+			"passport":  "",
+			"password":  "123456",
+			"password2": "1234567",
+		}
+		rules := []string{
+			"passport@required|length:6,16#账号不能为空|账号长度应当在:min到:max之间",
+			"password@required|length:6,16|same:password2#密码不能为空|密码长度应当在:min到:max之间|两次密码输入不相等",
+			"password2@required|length:6,16#",
+		}
+		err := gvalid.CheckMap(params, rules)
+		gtest.AssertNE(err, nil)
+		gtest.Assert(len(err.Map()), 2)
+		gtest.Assert(err.Map()["required"], "账号不能为空")
+		gtest.Assert(err.Map()["length"], "账号长度应当在6到16之间")
+		gtest.Assert(len(err.Maps()), 2)
+
+		gtest.Assert(err.String(), "账号不能为空; 账号长度应当在6到16之间; 两次密码输入不相等")
+		gtest.Assert(err.Strings(), []string{"账号不能为空", "账号长度应当在6到16之间", "两次密码输入不相等"})
+
+		k, m := err.FirstItem()
+		gtest.Assert(k, "passport")
+		gtest.Assert(m, err.Map())
+
+		r, s := err.FirstRule()
+		gtest.Assert(r, "required")
+		gtest.Assert(s, "账号不能为空")
+	})
+}
diff --git a/g/util/gvalid/gvalid_unit_checkstruct_test.go b/g/util/gvalid/gvalid_unit_checkstruct_test.go
index 01a2dc2f3..7d8bfc2e9 100755
--- a/g/util/gvalid/gvalid_unit_checkstruct_test.go
+++ b/g/util/gvalid/gvalid_unit_checkstruct_test.go
@@ -1,224 +1,224 @@
-// 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 gvalid_test
-
-import (
-	"testing"
-
-	"github.com/gogf/gf/g/test/gtest"
-	"github.com/gogf/gf/g/util/gvalid"
-)
-
-func Test_CheckStruct(t *testing.T) {
-	gtest.Case(t, func() {
-		type Object struct {
-			Name string
-			Age  int
-		}
-		rules := []string{
-			"@required|length:6,16",
-			"@between:18,30",
-		}
-		msgs := map[string]interface{}{
-			"Name": map[string]string{
-				"required": "名称不能为空",
-				"length":   "名称长度为:min到:max个字符",
-			},
-			"Age": "年龄为18到30周岁",
-		}
-		obj := &Object{"john", 16}
-		err := gvalid.CheckStruct(obj, rules, msgs)
-		gtest.Assert(err, nil)
-	})
-
-	gtest.Case(t, func() {
-		type Object struct {
-			Name string
-			Age  int
-		}
-		rules := []string{
-			"Name@required|length:6,16#名称不能为空",
-			"Age@between:18,30",
-		}
-		msgs := map[string]interface{}{
-			"Name": map[string]string{
-				"required": "名称不能为空",
-				"length":   "名称长度为:min到:max个字符",
-			},
-			"Age": "年龄为18到30周岁",
-		}
-		obj := &Object{"john", 16}
-		err := gvalid.CheckStruct(obj, rules, msgs)
-		gtest.AssertNE(err, nil)
-		gtest.Assert(len(err.Maps()), 2)
-		gtest.Assert(err.Maps()["Name"]["required"], "")
-		gtest.Assert(err.Maps()["Name"]["length"], "名称长度为6到16个字符")
-		gtest.Assert(err.Maps()["Age"]["between"], "年龄为18到30周岁")
-	})
-
-	gtest.Case(t, func() {
-		type Object struct {
-			Name string
-			Age  int
-		}
-		rules := []string{
-			"Name@required|length:6,16#名称不能为空|",
-			"Age@between:18,30",
-		}
-		msgs := map[string]interface{}{
-			"Name": map[string]string{
-				"required": "名称不能为空",
-				"length":   "名称长度为:min到:max个字符",
-			},
-			"Age": "年龄为18到30周岁",
-		}
-		obj := &Object{"john", 16}
-		err := gvalid.CheckStruct(obj, rules, msgs)
-		gtest.AssertNE(err, nil)
-		gtest.Assert(len(err.Maps()), 2)
-		gtest.Assert(err.Maps()["Name"]["required"], "")
-		gtest.Assert(err.Maps()["Name"]["length"], "名称长度为6到16个字符")
-		gtest.Assert(err.Maps()["Age"]["between"], "年龄为18到30周岁")
-	})
-
-	gtest.Case(t, func() {
-		type Object struct {
-			Name string
-			Age  int
-		}
-		rules := map[string]string{
-			"Name": "required|length:6,16",
-			"Age":  "between:18,30",
-		}
-		msgs := map[string]interface{}{
-			"Name": map[string]string{
-				"required": "名称不能为空",
-				"length":   "名称长度为:min到:max个字符",
-			},
-			"Age": "年龄为18到30周岁",
-		}
-		obj := &Object{"john", 16}
-		err := gvalid.CheckStruct(obj, rules, msgs)
-		gtest.AssertNE(err, nil)
-		gtest.Assert(len(err.Maps()), 2)
-		gtest.Assert(err.Maps()["Name"]["required"], "")
-		gtest.Assert(err.Maps()["Name"]["length"], "名称长度为6到16个字符")
-		gtest.Assert(err.Maps()["Age"]["between"], "年龄为18到30周岁")
-	})
-
-	gtest.Case(t, func() {
-		type LoginRequest struct {
-			Username string `json:"username" gvalid:"username@required#用户名不能为空"`
-			Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
-		}
-		var login LoginRequest
-		err := gvalid.CheckStruct(login, nil)
-		gtest.AssertNE(err, nil)
-		gtest.Assert(len(err.Maps()), 2)
-		gtest.Assert(err.Maps()["username"]["required"], "用户名不能为空")
-		gtest.Assert(err.Maps()["password"]["required"], "登录密码不能为空")
-	})
-
-	gtest.Case(t, func() {
-		type LoginRequest struct {
-			Username string `json:"username" gvalid:"@required#用户名不能为空"`
-			Password string `json:"password" gvalid:"@required#登录密码不能为空"`
-		}
-		var login LoginRequest
-		err := gvalid.CheckStruct(login, nil)
-		gtest.Assert(err, nil)
-	})
-
-	gtest.Case(t, func() {
-		type LoginRequest struct {
-			username string `json:"username" gvalid:"username@required#用户名不能为空"`
-			Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
-		}
-		var login LoginRequest
-		err := gvalid.CheckStruct(login, nil)
-		gtest.AssertNE(err, nil)
-		gtest.Assert(err.Maps()["password"]["required"], "登录密码不能为空")
-	})
-
-	// gvalid tag
-	gtest.Case(t, func() {
-		type User struct {
-			Id       int    `gvalid:"uid@required|min:10#|ID不能为空"`
-			Age      int    `gvalid:"age@required#年龄不能为空"`
-			Username string `json:"username" gvalid:"username@required#用户名不能为空"`
-			Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
-		}
-		user := &User{
-			Id:       1,
-			Username: "john",
-			Password: "123456",
-		}
-		err := gvalid.CheckStruct(user, nil)
-		gtest.AssertNE(err, nil)
-		gtest.Assert(len(err.Maps()), 1)
-		gtest.Assert(err.Maps()["uid"]["min"], "ID不能为空")
-	})
-
-	gtest.Case(t, func() {
-		type User struct {
-			Id       int    `gvalid:"uid@required|min:10#|ID不能为空"`
-			Age      int    `gvalid:"age@required#年龄不能为空"`
-			Username string `json:"username" gvalid:"username@required#用户名不能为空"`
-			Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
-		}
-		user := &User{
-			Id:       1,
-			Username: "john",
-			Password: "123456",
-		}
-
-		rules := []string{
-			"username@required#用户名不能为空",
-		}
-		
-		err := gvalid.CheckStruct(user, rules)
-		gtest.AssertNE(err, nil)
-		gtest.Assert(len(err.Maps()), 1)
-		gtest.Assert(err.Maps()["uid"]["min"], "ID不能为空")
-	})
-
-	gtest.Case(t, func() {
-		type User struct {
-			Id       int    `gvalid:"uid@required|min:10#ID不能为空"`
-			Age      int    `gvalid:"age@required#年龄不能为空"`
-			Username string `json:"username" gvalid:"username@required#用户名不能为空"`
-			Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
-		}
-		user := &User{
-			Id:       1,
-			Username: "john",
-			Password: "123456",
-		}
-		err := gvalid.CheckStruct(user, nil)
-		gtest.AssertNE(err, nil)
-		gtest.Assert(len(err.Maps()), 1)
-	})
-
-	// valid tag
-	gtest.Case(t, func() {
-		type User struct {
-			Id       int    `valid:"uid@required|min:10#|ID不能为空"`
-			Age      int    `valid:"age@required#年龄不能为空"`
-			Username string `json:"username" gvalid:"username@required#用户名不能为空"`
-			Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
-		}
-		user := &User{
-			Id:       1,
-			Username: "john",
-			Password: "123456",
-		}
-		err := gvalid.CheckStruct(user, nil)
-		gtest.AssertNE(err, nil)
-		gtest.Assert(len(err.Maps()), 1)
-		gtest.Assert(err.Maps()["uid"]["min"], "ID不能为空")
-	})
-}
+// 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 gvalid_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/util/gvalid"
+)
+
+func Test_CheckStruct(t *testing.T) {
+	gtest.Case(t, func() {
+		type Object struct {
+			Name string
+			Age  int
+		}
+		rules := []string{
+			"@required|length:6,16",
+			"@between:18,30",
+		}
+		msgs := map[string]interface{}{
+			"Name": map[string]string{
+				"required": "名称不能为空",
+				"length":   "名称长度为:min到:max个字符",
+			},
+			"Age": "年龄为18到30周岁",
+		}
+		obj := &Object{"john", 16}
+		err := gvalid.CheckStruct(obj, rules, msgs)
+		gtest.Assert(err, nil)
+	})
+
+	gtest.Case(t, func() {
+		type Object struct {
+			Name string
+			Age  int
+		}
+		rules := []string{
+			"Name@required|length:6,16#名称不能为空",
+			"Age@between:18,30",
+		}
+		msgs := map[string]interface{}{
+			"Name": map[string]string{
+				"required": "名称不能为空",
+				"length":   "名称长度为:min到:max个字符",
+			},
+			"Age": "年龄为18到30周岁",
+		}
+		obj := &Object{"john", 16}
+		err := gvalid.CheckStruct(obj, rules, msgs)
+		gtest.AssertNE(err, nil)
+		gtest.Assert(len(err.Maps()), 2)
+		gtest.Assert(err.Maps()["Name"]["required"], "")
+		gtest.Assert(err.Maps()["Name"]["length"], "名称长度为6到16个字符")
+		gtest.Assert(err.Maps()["Age"]["between"], "年龄为18到30周岁")
+	})
+
+	gtest.Case(t, func() {
+		type Object struct {
+			Name string
+			Age  int
+		}
+		rules := []string{
+			"Name@required|length:6,16#名称不能为空|",
+			"Age@between:18,30",
+		}
+		msgs := map[string]interface{}{
+			"Name": map[string]string{
+				"required": "名称不能为空",
+				"length":   "名称长度为:min到:max个字符",
+			},
+			"Age": "年龄为18到30周岁",
+		}
+		obj := &Object{"john", 16}
+		err := gvalid.CheckStruct(obj, rules, msgs)
+		gtest.AssertNE(err, nil)
+		gtest.Assert(len(err.Maps()), 2)
+		gtest.Assert(err.Maps()["Name"]["required"], "")
+		gtest.Assert(err.Maps()["Name"]["length"], "名称长度为6到16个字符")
+		gtest.Assert(err.Maps()["Age"]["between"], "年龄为18到30周岁")
+	})
+
+	gtest.Case(t, func() {
+		type Object struct {
+			Name string
+			Age  int
+		}
+		rules := map[string]string{
+			"Name": "required|length:6,16",
+			"Age":  "between:18,30",
+		}
+		msgs := map[string]interface{}{
+			"Name": map[string]string{
+				"required": "名称不能为空",
+				"length":   "名称长度为:min到:max个字符",
+			},
+			"Age": "年龄为18到30周岁",
+		}
+		obj := &Object{"john", 16}
+		err := gvalid.CheckStruct(obj, rules, msgs)
+		gtest.AssertNE(err, nil)
+		gtest.Assert(len(err.Maps()), 2)
+		gtest.Assert(err.Maps()["Name"]["required"], "")
+		gtest.Assert(err.Maps()["Name"]["length"], "名称长度为6到16个字符")
+		gtest.Assert(err.Maps()["Age"]["between"], "年龄为18到30周岁")
+	})
+
+	gtest.Case(t, func() {
+		type LoginRequest struct {
+			Username string `json:"username" gvalid:"username@required#用户名不能为空"`
+			Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
+		}
+		var login LoginRequest
+		err := gvalid.CheckStruct(login, nil)
+		gtest.AssertNE(err, nil)
+		gtest.Assert(len(err.Maps()), 2)
+		gtest.Assert(err.Maps()["username"]["required"], "用户名不能为空")
+		gtest.Assert(err.Maps()["password"]["required"], "登录密码不能为空")
+	})
+
+	gtest.Case(t, func() {
+		type LoginRequest struct {
+			Username string `json:"username" gvalid:"@required#用户名不能为空"`
+			Password string `json:"password" gvalid:"@required#登录密码不能为空"`
+		}
+		var login LoginRequest
+		err := gvalid.CheckStruct(login, nil)
+		gtest.Assert(err, nil)
+	})
+
+	gtest.Case(t, func() {
+		type LoginRequest struct {
+			username string `json:"username" gvalid:"username@required#用户名不能为空"`
+			Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
+		}
+		var login LoginRequest
+		err := gvalid.CheckStruct(login, nil)
+		gtest.AssertNE(err, nil)
+		gtest.Assert(err.Maps()["password"]["required"], "登录密码不能为空")
+	})
+
+	// gvalid tag
+	gtest.Case(t, func() {
+		type User struct {
+			Id       int    `gvalid:"uid@required|min:10#|ID不能为空"`
+			Age      int    `gvalid:"age@required#年龄不能为空"`
+			Username string `json:"username" gvalid:"username@required#用户名不能为空"`
+			Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
+		}
+		user := &User{
+			Id:       1,
+			Username: "john",
+			Password: "123456",
+		}
+		err := gvalid.CheckStruct(user, nil)
+		gtest.AssertNE(err, nil)
+		gtest.Assert(len(err.Maps()), 1)
+		gtest.Assert(err.Maps()["uid"]["min"], "ID不能为空")
+	})
+
+	gtest.Case(t, func() {
+		type User struct {
+			Id       int    `gvalid:"uid@required|min:10#|ID不能为空"`
+			Age      int    `gvalid:"age@required#年龄不能为空"`
+			Username string `json:"username" gvalid:"username@required#用户名不能为空"`
+			Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
+		}
+		user := &User{
+			Id:       1,
+			Username: "john",
+			Password: "123456",
+		}
+
+		rules := []string{
+			"username@required#用户名不能为空",
+		}
+
+		err := gvalid.CheckStruct(user, rules)
+		gtest.AssertNE(err, nil)
+		gtest.Assert(len(err.Maps()), 1)
+		gtest.Assert(err.Maps()["uid"]["min"], "ID不能为空")
+	})
+
+	gtest.Case(t, func() {
+		type User struct {
+			Id       int    `gvalid:"uid@required|min:10#ID不能为空"`
+			Age      int    `gvalid:"age@required#年龄不能为空"`
+			Username string `json:"username" gvalid:"username@required#用户名不能为空"`
+			Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
+		}
+		user := &User{
+			Id:       1,
+			Username: "john",
+			Password: "123456",
+		}
+		err := gvalid.CheckStruct(user, nil)
+		gtest.AssertNE(err, nil)
+		gtest.Assert(len(err.Maps()), 1)
+	})
+
+	// valid tag
+	gtest.Case(t, func() {
+		type User struct {
+			Id       int    `valid:"uid@required|min:10#|ID不能为空"`
+			Age      int    `valid:"age@required#年龄不能为空"`
+			Username string `json:"username" gvalid:"username@required#用户名不能为空"`
+			Password string `json:"password" gvalid:"password@required#登录密码不能为空"`
+		}
+		user := &User{
+			Id:       1,
+			Username: "john",
+			Password: "123456",
+		}
+		err := gvalid.CheckStruct(user, nil)
+		gtest.AssertNE(err, nil)
+		gtest.Assert(len(err.Maps()), 1)
+		gtest.Assert(err.Maps()["uid"]["min"], "ID不能为空")
+	})
+}
diff --git a/g/util/gvalid/gvalid_unit_customerror_test.go b/g/util/gvalid/gvalid_unit_customerror_test.go
index 26f512552..e3d06e8f7 100755
--- a/g/util/gvalid/gvalid_unit_customerror_test.go
+++ b/g/util/gvalid/gvalid_unit_customerror_test.go
@@ -1,94 +1,94 @@
-// 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 gvalid_test
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/gogf/gf/g/test/gtest"
-	"github.com/gogf/gf/g/util/gvalid"
-)
-
-func Test_Map(t *testing.T) {
-	err := &gvalid.Error{}
-	m := err.Map()
-	gtest.Assert(m, nil)
-}
-
-func Test_FirstString(t *testing.T) {
-	err := &gvalid.Error{}
-	n := err.FirstString()
-	gtest.Assert(n, "")
-}
-
-func Test_SetDefaultErrorMsgs(t *testing.T) {
-	rule := "integer|length:6,16"
-	msgs := map[string]string{
-		"integer": "请输入一个整数",
-		"length":  "参数长度不对啊老铁",
-	}
-	gvalid.SetDefaultErrorMsgs(msgs)
-	e := gvalid.Check("6.66", rule, nil)
-	if e == nil || len(e.Map()) != 2 {
-		t.Error("规则校验失败")
-	} else {
-		if v, ok := e.Map()["integer"]; ok {
-			if strings.Compare(v, msgs["integer"]) != 0 {
-				t.Error("错误信息不匹配")
-			}
-		}
-		if v, ok := e.Map()["length"]; ok {
-			if strings.Compare(v, msgs["length"]) != 0 {
-				t.Error("错误信息不匹配")
-			}
-		}
-	}
-}
-
-func Test_CustomError1(t *testing.T) {
-	rule := "integer|length:6,16"
-	msgs := map[string]string{
-		"integer": "请输入一个整数",
-		"length":  "参数长度不对啊老铁",
-	}
-	e := gvalid.Check("6.66", rule, msgs)
-	if e == nil || len(e.Map()) != 2 {
-		t.Error("规则校验失败")
-	} else {
-		if v, ok := e.Map()["integer"]; ok {
-			if strings.Compare(v, msgs["integer"]) != 0 {
-				t.Error("错误信息不匹配")
-			}
-		}
-		if v, ok := e.Map()["length"]; ok {
-			if strings.Compare(v, msgs["length"]) != 0 {
-				t.Error("错误信息不匹配")
-			}
-		}
-	}
-}
-
-func Test_CustomError2(t *testing.T) {
-	rule := "integer|length:6,16"
-	msgs := "请输入一个整数|参数长度不对啊老铁"
-	e := gvalid.Check("6.66", rule, msgs)
-	if e == nil || len(e.Map()) != 2 {
-		t.Error("规则校验失败")
-	} else {
-		if v, ok := e.Map()["integer"]; ok {
-			if strings.Compare(v, "请输入一个整数") != 0 {
-				t.Error("错误信息不匹配")
-			}
-		}
-		if v, ok := e.Map()["length"]; ok {
-			if strings.Compare(v, "参数长度不对啊老铁") != 0 {
-				t.Error("错误信息不匹配")
-			}
-		}
-	}
-}
+// 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 gvalid_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/util/gvalid"
+)
+
+func Test_Map(t *testing.T) {
+	err := &gvalid.Error{}
+	m := err.Map()
+	gtest.Assert(m, nil)
+}
+
+func Test_FirstString(t *testing.T) {
+	err := &gvalid.Error{}
+	n := err.FirstString()
+	gtest.Assert(n, "")
+}
+
+func Test_SetDefaultErrorMsgs(t *testing.T) {
+	rule := "integer|length:6,16"
+	msgs := map[string]string{
+		"integer": "请输入一个整数",
+		"length":  "参数长度不对啊老铁",
+	}
+	gvalid.SetDefaultErrorMsgs(msgs)
+	e := gvalid.Check("6.66", rule, nil)
+	if e == nil || len(e.Map()) != 2 {
+		t.Error("规则校验失败")
+	} else {
+		if v, ok := e.Map()["integer"]; ok {
+			if strings.Compare(v, msgs["integer"]) != 0 {
+				t.Error("错误信息不匹配")
+			}
+		}
+		if v, ok := e.Map()["length"]; ok {
+			if strings.Compare(v, msgs["length"]) != 0 {
+				t.Error("错误信息不匹配")
+			}
+		}
+	}
+}
+
+func Test_CustomError1(t *testing.T) {
+	rule := "integer|length:6,16"
+	msgs := map[string]string{
+		"integer": "请输入一个整数",
+		"length":  "参数长度不对啊老铁",
+	}
+	e := gvalid.Check("6.66", rule, msgs)
+	if e == nil || len(e.Map()) != 2 {
+		t.Error("规则校验失败")
+	} else {
+		if v, ok := e.Map()["integer"]; ok {
+			if strings.Compare(v, msgs["integer"]) != 0 {
+				t.Error("错误信息不匹配")
+			}
+		}
+		if v, ok := e.Map()["length"]; ok {
+			if strings.Compare(v, msgs["length"]) != 0 {
+				t.Error("错误信息不匹配")
+			}
+		}
+	}
+}
+
+func Test_CustomError2(t *testing.T) {
+	rule := "integer|length:6,16"
+	msgs := "请输入一个整数|参数长度不对啊老铁"
+	e := gvalid.Check("6.66", rule, msgs)
+	if e == nil || len(e.Map()) != 2 {
+		t.Error("规则校验失败")
+	} else {
+		if v, ok := e.Map()["integer"]; ok {
+			if strings.Compare(v, "请输入一个整数") != 0 {
+				t.Error("错误信息不匹配")
+			}
+		}
+		if v, ok := e.Map()["length"]; ok {
+			if strings.Compare(v, "参数长度不对啊老铁") != 0 {
+				t.Error("错误信息不匹配")
+			}
+		}
+	}
+}