From 105cdf6fe65a9b1e848a79c7953a237af12b9616 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=99=88=E5=9B=BD=E6=BD=AE?= <2892931976@qq.com>
Date: Wed, 3 Jul 2019 14:28:20 +0800
Subject: [PATCH 1/5] 20190703 14:25

---
 g/util/gvalid/gvalid_unit_basic_all_test.go   | 1678 +++++++++--------
 g/util/gvalid/gvalid_unit_checkmap_test.go    |  281 ++-
 g/util/gvalid/gvalid_unit_checkstruct_test.go |  316 +++-
 g/util/gvalid/gvalid_unit_customerror_test.go |  174 +-
 4 files changed, 1367 insertions(+), 1082 deletions(-)
 mode change 100644 => 100755 g/util/gvalid/gvalid_unit_basic_all_test.go
 mode change 100644 => 100755 g/util/gvalid/gvalid_unit_checkmap_test.go
 mode change 100644 => 100755 g/util/gvalid/gvalid_unit_checkstruct_test.go
 mode change 100644 => 100755 g/util/gvalid/gvalid_unit_customerror_test.go

diff --git a/g/util/gvalid/gvalid_unit_basic_all_test.go b/g/util/gvalid/gvalid_unit_basic_all_test.go
old mode 100644
new mode 100755
index 6d9642b2e..dcd9e2c90
--- a/g/util/gvalid/gvalid_unit_basic_all_test.go
+++ b/g/util/gvalid/gvalid_unit_basic_all_test.go
@@ -1,811 +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 (
-	"github.com/gogf/gf/g"
-	"github.com/gogf/gf/g/test/gtest"
-	"github.com/gogf/gf/g/util/gvalid"
-	"testing"
-)
-
-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"
-	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_MaxLength(t *testing.T) {
-	rule := "max-length:6"
-	if m := gvalid.Check("12345", rule, nil); m != nil {
-		t.Error(m)
-	}
-	if m := gvalid.Check("1234567", rule, 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("大小范围校验失败")
-	}
-}
-
-func Test_Min(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "min:100"
-		val1 := "1"
-		val2 := "99"
-		val3 := "100"
-		val4 := "1000"
-		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_Max(t *testing.T) {
-	gtest.Case(t, func() {
-		rule := "max:100"
-		val1 := "1"
-		val2 := "99"
-		val3 := "100"
-		val4 := "1000"
-		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.Assert(err3, nil)
-		gtest.AssertNE(err4, 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
old mode 100644
new mode 100755
index 76a75dfb8..009d72bc3
--- a/g/util/gvalid/gvalid_unit_checkmap_test.go
+++ b/g/util/gvalid/gvalid_unit_checkmap_test.go
@@ -1,99 +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 (
-	"github.com/gogf/gf/g/test/gtest"
-	"github.com/gogf/gf/g/util/gvalid"
-	"testing"
-)
-
-func Test_CheckMap(t *testing.T) {
-	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)
-	}
-}
-
-// 如果值为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
old mode 100644
new mode 100755
index 40e3178f0..01a2dc2f3
--- a/g/util/gvalid/gvalid_unit_checkstruct_test.go
+++ b/g/util/gvalid/gvalid_unit_checkstruct_test.go
@@ -1,92 +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 := 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"], "登录密码不能为空")
-	})
-
-	// 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不能为空")
-	})
-
-	// 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
old mode 100644
new mode 100755
index e6c7bf3fc..26f512552
--- a/g/util/gvalid/gvalid_unit_customerror_test.go
+++ b/g/util/gvalid/gvalid_unit_customerror_test.go
@@ -1,80 +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 (
-	"github.com/gogf/gf/g/util/gvalid"
-	"strings"
-	"testing"
-)
-
-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("错误信息不匹配")
+			}
+		}
+	}
+}

From 363dede57c5d85d5c497bfaa4c4d7571706a1ebc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=99=88=E5=9B=BD=E6=BD=AE?= <2892931976@qq.com>
Date: Thu, 4 Jul 2019 11:19:59 +0800
Subject: [PATCH 2/5] gvalid test 20190704 11:16

---
 g/util/gvalid/gvalid_unit_basic_all_test.go   | 1734 ++++++++---------
 g/util/gvalid/gvalid_unit_checkmap_test.go    |  364 ++--
 g/util/gvalid/gvalid_unit_checkstruct_test.go |  448 ++---
 g/util/gvalid/gvalid_unit_customerror_test.go |  188 +-
 4 files changed, 1367 insertions(+), 1367 deletions(-)

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("错误信息不匹配")
+			}
+		}
+	}
+}

From 1c713407196b1ce868c8b03562f20bd428ff07d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=99=88=E5=9B=BD=E6=BD=AE?= <2892931976@qq.com>
Date: Thu, 4 Jul 2019 15:03:56 +0800
Subject: [PATCH 3/5] gfcache test 20190704 15:00

---
 g/os/gfcache/gfcache_z_unit_test.go | 65 +++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100755 g/os/gfcache/gfcache_z_unit_test.go

diff --git a/g/os/gfcache/gfcache_z_unit_test.go b/g/os/gfcache/gfcache_z_unit_test.go
new file mode 100755
index 000000000..77b02403a
--- /dev/null
+++ b/g/os/gfcache/gfcache_z_unit_test.go
@@ -0,0 +1,65 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+// go test *.go -bench=".*" -benchmem
+
+package gfcache_test
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/g/os/gfcache"
+	"github.com/gogf/gf/g/os/gfile"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+func TestGetContents(t *testing.T) {
+	gtest.Case(t, func() {
+
+		var f *os.File
+		var err error
+		fileName := "test.txt"
+		strTest := "123"
+
+		if !gfile.Exists(fileName) {
+			f, err = gfile.Create(fileName)
+			if err != nil {
+				t.Error("create file fail")
+			}
+		}
+
+		cache := gfcache.GetContents(fileName, 2)
+
+		if gfile.Exists(fileName) {
+			f, err = gfile.OpenFile(fileName, os.O_APPEND|os.O_WRONLY, os.ModeAppend)
+			if err != nil {
+				t.Error("file open fail", err)
+			}
+		}
+
+		defer f.Close()
+
+		_, err = f.Write([]byte(strTest))
+		if err != nil {
+			t.Error("write error", err)
+		}
+
+		cache = gfcache.GetContents(fileName)
+		gtest.Assert(cache, "")
+
+		time.Sleep(time.Duration(4) * time.Second)
+
+		if gfile.Exists(fileName) {
+			err = gfile.Remove(fileName)
+			if err != nil {
+				t.Error("file remove fail", err)
+			}
+		}
+	})
+
+}

From 125af33941e5175c50ed9bf595869430ddddcc36 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=99=88=E5=9B=BD=E6=BD=AE?= <2892931976@qq.com>
Date: Tue, 9 Jul 2019 15:10:02 +0800
Subject: [PATCH 4/5] gvalid and gfcache test 20190709 15:06

---
 g/os/gfcache/gfcache_z_unit_test.go         | 63 +++++++++++++++------
 g/util/gvalid/gvalid_unit_basic_all_test.go |  6 +-
 2 files changed, 48 insertions(+), 21 deletions(-)

diff --git a/g/os/gfcache/gfcache_z_unit_test.go b/g/os/gfcache/gfcache_z_unit_test.go
index 77b02403a..b45a1fe13 100755
--- a/g/os/gfcache/gfcache_z_unit_test.go
+++ b/g/os/gfcache/gfcache_z_unit_test.go
@@ -9,6 +9,7 @@
 package gfcache_test
 
 import (
+	"io/ioutil"
 	"os"
 	"testing"
 	"time"
@@ -23,43 +24,69 @@ func TestGetContents(t *testing.T) {
 
 		var f *os.File
 		var err error
-		fileName := "test.txt"
+		fileName := "test"
 		strTest := "123"
 
 		if !gfile.Exists(fileName) {
-			f, err = gfile.Create(fileName)
+			f, err = ioutil.TempFile("", fileName)
 			if err != nil {
 				t.Error("create file fail")
 			}
 		}
 
-		cache := gfcache.GetContents(fileName, 2)
+		defer f.Close()
+		defer os.Remove(f.Name())
 
-		if gfile.Exists(fileName) {
-			f, err = gfile.OpenFile(fileName, os.O_APPEND|os.O_WRONLY, os.ModeAppend)
+		if gfile.Exists(f.Name()) {
+
+			f, err = gfile.OpenFile(f.Name(), os.O_APPEND|os.O_WRONLY, os.ModeAppend)
 			if err != nil {
 				t.Error("file open fail", err)
 			}
+
+			err = gfile.PutContents(f.Name(), strTest)
+			if err != nil {
+				t.Error("write error", err)
+			}
+
+			cache := gfcache.GetContents(f.Name(), 1)
+			gtest.Assert(cache, strTest)
+		}
+	})
+
+	gtest.Case(t, func() {
+
+		var f *os.File
+		var err error
+		fileName := "test2"
+		strTest := "123"
+
+		if !gfile.Exists(fileName) {
+			f, err = ioutil.TempFile("", fileName)
+			if err != nil {
+				t.Error("create file fail")
+			}
 		}
 
 		defer f.Close()
+		defer os.Remove(f.Name())
 
-		_, err = f.Write([]byte(strTest))
-		if err != nil {
-			t.Error("write error", err)
-		}
+		if gfile.Exists(f.Name()) {
+			cache := gfcache.GetContents(f.Name())
 
-		cache = gfcache.GetContents(fileName)
-		gtest.Assert(cache, "")
-
-		time.Sleep(time.Duration(4) * time.Second)
-
-		if gfile.Exists(fileName) {
-			err = gfile.Remove(fileName)
+			f, err = gfile.OpenFile(f.Name(), os.O_APPEND|os.O_WRONLY, os.ModeAppend)
 			if err != nil {
-				t.Error("file remove fail", err)
+				t.Error("file open fail", err)
 			}
+
+			err = gfile.PutContents(f.Name(), strTest)
+			if err != nil {
+				t.Error("write error", err)
+			}
+
+			gtest.Assert(cache, "")
+
+			time.Sleep(100 * time.Millisecond)
 		}
 	})
-
 }
diff --git a/g/util/gvalid/gvalid_unit_basic_all_test.go b/g/util/gvalid/gvalid_unit_basic_all_test.go
index 10731887a..7345e69de 100755
--- a/g/util/gvalid/gvalid_unit_basic_all_test.go
+++ b/g/util/gvalid/gvalid_unit_basic_all_test.go
@@ -24,9 +24,9 @@ func Test_Check(t *testing.T) {
 		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)
+		gtest.Assert(err1, "invalid rules:abc:6,16")
+		gtest.Assert(err2, "invalid rules:abc:6,16")
+		gtest.Assert(err3, "invalid rules:abc:6,16")
 	})
 }
 

From 0481b4025b12ac588ab1661f4ec9866bdb4514bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=99=88=E5=9B=BD=E6=BD=AE?= <2892931976@qq.com>
Date: Fri, 12 Jul 2019 10:23:28 +0800
Subject: [PATCH 5/5] gvalid test 20190712 10:20

---
 g/util/gvalid/gvalid_unit_customerror_test.go | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/g/util/gvalid/gvalid_unit_customerror_test.go b/g/util/gvalid/gvalid_unit_customerror_test.go
index e3d06e8f7..c7cea0db8 100755
--- a/g/util/gvalid/gvalid_unit_customerror_test.go
+++ b/g/util/gvalid/gvalid_unit_customerror_test.go
@@ -15,15 +15,23 @@ import (
 )
 
 func Test_Map(t *testing.T) {
-	err := &gvalid.Error{}
-	m := err.Map()
-	gtest.Assert(m, nil)
+	rule := "ipv4"
+	val := "0.0.0"
+	msg := map[string]string{
+		"ipv4": "IPv4地址格式不正确",
+	}
+
+	err := gvalid.Check(val, rule, nil)
+	gtest.Assert(err.Map(), msg)
 }
 
 func Test_FirstString(t *testing.T) {
-	err := &gvalid.Error{}
+	rule := "ipv4"
+	val := "0.0.0"
+
+	err := gvalid.Check(val, rule, nil)
 	n := err.FirstString()
-	gtest.Assert(n, "")
+	gtest.Assert(n, "IPv4地址格式不正确")
 }
 
 func Test_SetDefaultErrorMsgs(t *testing.T) {