fix sonar Part3

2021-02-03 19:42:42 +08:00
parent 6f98a01bfd
commit 62aa0188c4
18 changed files with 513 additions and 977 deletions
--- a/adapter/session/sess_cookie_test.go
+++ b/adapter/session/sess_cookie_test.go
@@ -22,6 +22,8 @@ import (
 	"testing"
 )

+const setCookieKey = "Set-Cookie"
+
 func TestCookie(t *testing.T) {
 	config := `{"cookieName":"gosessionid","enableSetCookie":false,"gclifetime":3600,"ProviderConfig":"{\"cookieName\":\"gosessionid\",\"securityKey\":\"beegocookiehashkey\"}"}`
 	conf := new(ManagerConfig)
@@ -46,7 +48,8 @@ func TestCookie(t *testing.T) {
 		t.Fatal("get username error")
 	}
 	sess.SessionRelease(w)
-	if cookiestr := w.Header().Get("Set-Cookie"); cookiestr == "" {
+	
+	if cookiestr := w.Header().Get(setCookieKey); cookiestr == "" {
 		t.Fatal("setcookie error")
 	} else {
 		parts := strings.Split(strings.TrimSpace(cookiestr), ";")
@@ -79,7 +82,7 @@ func TestDestorySessionCookie(t *testing.T) {

 	// request again ,will get same sesssion id .
 	r1, _ := http.NewRequest("GET", "/", nil)
-	r1.Header.Set("Cookie", w.Header().Get("Set-Cookie"))
+	r1.Header.Set("Cookie", w.Header().Get(setCookieKey))
 	w = httptest.NewRecorder()
 	newSession, err := globalSessions.SessionStart(w, r1)
 	if err != nil {
@@ -92,7 +95,7 @@ func TestDestorySessionCookie(t *testing.T) {
 	// After destroy session , will get a new session id .
 	globalSessions.SessionDestroy(w, r1)
 	r2, _ := http.NewRequest("GET", "/", nil)
-	r2.Header.Set("Cookie", w.Header().Get("Set-Cookie"))
+	r2.Header.Set("Cookie", w.Header().Get(setCookieKey))

 	w = httptest.NewRecorder()
 	newSession, err = globalSessions.SessionStart(w, r2)
--- a/adapter/templatefunc_test.go
+++ b/adapter/templatefunc_test.go
@@ -19,19 +19,15 @@ import (
 	"net/url"
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/assert"
 )

 func TestSubstr(t *testing.T) {
 	s := `012345`
-	if Substr(s, 0, 2) != "01" {
-		t.Error("should be equal")
-	}
-	if Substr(s, 0, 100) != "012345" {
-		t.Error("should be equal")
-	}
-	if Substr(s, 12, 100) != "012345" {
-		t.Error("should be equal")
-	}
+	assert.Equal(t, "01", Substr(s, 0, 2))
+	assert.Equal(t, "012345", Substr(s, 0, 100))
+	assert.Equal(t, "012345", Substr(s, 12, 100))
 }

 func TestHtml2str(t *testing.T) {
@@ -39,73 +35,51 @@ func TestHtml2str(t *testing.T) {


 	\n`
-	if HTML2str(h) != "123\\n\n\\n" {
-		t.Error("should be equal")
-	}
+	assert.Equal(t, "123\\n\n\\n", HTML2str(h))
 }

 func TestDateFormat(t *testing.T) {
 	ts := "Mon, 01 Jul 2013 13:27:42 CST"
 	tt, _ := time.Parse(time.RFC1123, ts)

-	if ss := DateFormat(tt, "2006-01-02 15:04:05"); ss != "2013-07-01 13:27:42" {
-		t.Errorf("2013-07-01 13:27:42 does not equal %v", ss)
-	}
+	assert.Equal(t, "2013-07-01 13:27:42", DateFormat(tt, "2006-01-02 15:04:05"))
 }

 func TestDate(t *testing.T) {
 	ts := "Mon, 01 Jul 2013 13:27:42 CST"
 	tt, _ := time.Parse(time.RFC1123, ts)

-	if ss := Date(tt, "Y-m-d H:i:s"); ss != "2013-07-01 13:27:42" {
-		t.Errorf("2013-07-01 13:27:42 does not equal %v", ss)
-	}
-	if ss := Date(tt, "y-n-j h:i:s A"); ss != "13-7-1 01:27:42 PM" {
-		t.Errorf("13-7-1 01:27:42 PM does not equal %v", ss)
-	}
-	if ss := Date(tt, "D, d M Y g:i:s a"); ss != "Mon, 01 Jul 2013 1:27:42 pm" {
-		t.Errorf("Mon, 01 Jul 2013 1:27:42 pm does not equal %v", ss)
-	}
-	if ss := Date(tt, "l, d F Y G:i:s"); ss != "Monday, 01 July 2013 13:27:42" {
-		t.Errorf("Monday, 01 July 2013 13:27:42 does not equal %v", ss)
-	}
+	assert.Equal(t, "2013-07-01 13:27:42", Date(tt, "Y-m-d H:i:s"))
+
+	assert.Equal(t, "13-7-1 01:27:42 PM", Date(tt, "y-n-j h:i:s A"))
+	assert.Equal(t, "Mon, 01 Jul 2013 1:27:42 pm", Date(tt, "D, d M Y g:i:s a"))
+	assert.Equal(t, "Monday, 01 July 2013 13:27:42", Date(tt, "l, d F Y G:i:s"))
 }

 func TestCompareRelated(t *testing.T) {
-	if !Compare("abc", "abc") {
-		t.Error("should be equal")
-	}
-	if Compare("abc", "aBc") {
-		t.Error("should be not equal")
-	}
-	if !Compare("1", 1) {
-		t.Error("should be equal")
-	}
-	if CompareNot("abc", "abc") {
-		t.Error("should be equal")
-	}
-	if !CompareNot("abc", "aBc") {
-		t.Error("should be not equal")
-	}
-	if !NotNil("a string") {
-		t.Error("should not be nil")
-	}
+	assert.True(t, Compare("abc", "abc"))
+
+	assert.False(t, Compare("abc", "aBc"))
+
+	assert.True(t, Compare("1", 1))
+
+	assert.False(t, CompareNot("abc", "abc"))
+
+	assert.True(t, CompareNot("abc", "aBc"))
+	assert.True(t, NotNil("a string"))
 }

 func TestHtmlquote(t *testing.T) {
 	h := `&lt;&#39;&nbsp;&rdquo;&ldquo;&amp;&#34;&gt;`
 	s := `<' ”“&">`
-	if Htmlquote(s) != h {
-		t.Error("should be equal")
-	}
+	assert.Equal(t, h, Htmlquote(s))
 }

 func TestHtmlunquote(t *testing.T) {
 	h := `&lt;&#39;&nbsp;&rdquo;&ldquo;&amp;&#34;&gt;`
 	s := `<' ”“&">`
-	if Htmlunquote(h) != s {
-		t.Error("should be equal")
-	}
+	assert.Equal(t, s, Htmlunquote(h))
+
 }

 func TestParseForm(t *testing.T) {
@@ -148,55 +122,42 @@ func TestParseForm(t *testing.T) {
 		"hobby":        []string{"", "Basketball", "Football"},
 		"memo":         []string{"nothing"},
 	}
-	if err := ParseForm(form, u); err == nil {
-		t.Fatal("nothing will be changed")
-	}
-	if err := ParseForm(form, &u); err != nil {
-		t.Fatal(err)
-	}
-	if u.ID != 0 {
-		t.Errorf("ID should equal 0 but got %v", u.ID)
-	}
-	if len(u.tag) != 0 {
-		t.Errorf("tag's length should equal 0 but got %v", len(u.tag))
-	}
-	if u.Name.(string) != "test" {
-		t.Errorf("Name should equal `test` but got `%v`", u.Name.(string))
-	}
-	if u.Age != 40 {
-		t.Errorf("Age should equal 40 but got %v", u.Age)
-	}
-	if u.Email != "test@gmail.com" {
-		t.Errorf("Email should equal `test@gmail.com` but got `%v`", u.Email)
-	}
-	if u.Intro != "I am an engineer!" {
-		t.Errorf("Intro should equal `I am an engineer!` but got `%v`", u.Intro)
-	}
-	if !u.StrBool {
-		t.Errorf("strboll should equal `true`, but got `%v`", u.StrBool)
-	}
+
+	assert.NotNil(t, ParseForm(form, u))
+
+	assert.Nil(t, ParseForm(form, &u))
+
+	assert.Equal(t, 0, u.ID)
+
+	assert.Equal(t, 0, len(u.tag))
+
+	assert.Equal(t, "test", u.Name)
+
+	assert.Equal(t, 40, u.Age)
+
+	assert.Equal(t, "test@gmail.com", u.Email)
+
+	assert.Equal(t, "I am an engineer!", u.Intro)
+
+	assert.True(t, u.StrBool)
+
 	y, m, d := u.Date.Date()
-	if y != 2014 || m.String() != "November" || d != 12 {
-		t.Errorf("Date should equal `2014-11-12`, but got `%v`", u.Date.String())
-	}
-	if u.Organization != "beego" {
-		t.Errorf("Organization should equal `beego`, but got `%v`", u.Organization)
-	}
-	if u.Title != "CXO" {
-		t.Errorf("Title should equal `CXO`, but got `%v`", u.Title)
-	}
-	if u.Hobby[0] != "" {
-		t.Errorf("Hobby should equal ``, but got `%v`", u.Hobby[0])
-	}
-	if u.Hobby[1] != "Basketball" {
-		t.Errorf("Hobby should equal `Basketball`, but got `%v`", u.Hobby[1])
-	}
-	if u.Hobby[2] != "Football" {
-		t.Errorf("Hobby should equal `Football`, but got `%v`", u.Hobby[2])
-	}
-	if len(u.Memo) != 0 {
-		t.Errorf("Memo's length should equal 0 but got %v", len(u.Memo))
-	}
+
+	assert.Equal(t, 2014, y)
+	assert.Equal(t, "November", m.String())
+	assert.Equal(t, 12, d)
+
+	assert.Equal(t, "beego", u.Organization)
+
+	assert.Equal(t, "CXO", u.Title)
+
+	assert.Equal(t, "", u.Hobby[0])
+
+	assert.Equal(t, "Basketball", u.Hobby[1])
+
+	assert.Equal(t, "Football", u.Hobby[2])
+
+	assert.Equal(t, 0, len(u.Memo))
 }

 func TestRenderForm(t *testing.T) {
@@ -212,18 +173,14 @@ func TestRenderForm(t *testing.T) {

 	u := user{Name: "test", Intro: "Some Text"}
 	output := RenderForm(u)
-	if output != template.HTML("") {
-		t.Errorf("output should be empty but got %v", output)
-	}
+	assert.Equal(t, template.HTML(""), output)
 	output = RenderForm(&u)
 	result := template.HTML(
 		`Name: <input name="username" type="text" value="test"></br>` +
 			`年龄：<input name="age" type="text" value="0"></br>` +
 			`Sex: <input name="Sex" type="text" value=""></br>` +
 			`Intro: <textarea name="Intro">Some Text</textarea>`)
-	if output != result {
-		t.Errorf("output should equal `%v` but got `%v`", result, output)
-	}
+	assert.Equal(t, result, output)
 }

 func TestMapGet(t *testing.T) {
@@ -233,29 +190,18 @@ func TestMapGet(t *testing.T) {
 		"1": 2,
 	}

-	if res, err := MapGet(m1, "a"); err == nil {
-		if res.(int64) != 1 {
-			t.Errorf("Should return 1, but return %v", res)
-		}
-	} else {
-		t.Errorf("Error happens %v", err)
-	}
+	res, err := MapGet(m1, "a")
+	assert.Nil(t, err)
+	assert.Equal(t, int64(1), res)

-	if res, err := MapGet(m1, "1"); err == nil {
-		if res.(int64) != 2 {
-			t.Errorf("Should return 2, but return %v", res)
-		}
-	} else {
-		t.Errorf("Error happens %v", err)
-	}
+	res, err = MapGet(m1, "1")
+	assert.Nil(t, err)
+	assert.Equal(t, int64(2), res)

-	if res, err := MapGet(m1, 1); err == nil {
-		if res.(int64) != 2 {
-			t.Errorf("Should return 2, but return %v", res)
-		}
-	} else {
-		t.Errorf("Error happens %v", err)
-	}
+
+	res, err = MapGet(m1, 1)
+	assert.Nil(t, err)
+	assert.Equal(t, int64(2), res)

 	// test 2 level map
 	m2 := M{
@@ -264,13 +210,9 @@ func TestMapGet(t *testing.T) {
 		},
 	}

-	if res, err := MapGet(m2, 1, 2); err == nil {
-		if res.(float64) != 3.5 {
-			t.Errorf("Should return 3.5, but return %v", res)
-		}
-	} else {
-		t.Errorf("Error happens %v", err)
-	}
+	res, err = MapGet(m2, 1, 2)
+	assert.Nil(t, err)
+	assert.Equal(t, 3.5, res)

 	// test 5 level map
 	m5 := M{
@@ -285,20 +227,13 @@ func TestMapGet(t *testing.T) {
 		},
 	}

-	if res, err := MapGet(m5, 1, 2, 3, 4, 5); err == nil {
-		if res.(float64) != 1.2 {
-			t.Errorf("Should return 1.2, but return %v", res)
-		}
-	} else {
-		t.Errorf("Error happens %v", err)
-	}
+	res, err = MapGet(m5, 1, 2, 3, 4, 5)
+	assert.Nil(t, err)
+	assert.Equal(t, 1.2, res)

 	// check whether element not exists in map
-	if res, err := MapGet(m5, 5, 4, 3, 2, 1); err == nil {
-		if res != nil {
-			t.Errorf("Should return nil, but return %v", res)
-		}
-	} else {
-		t.Errorf("Error happens %v", err)
-	}
+	res, err = MapGet(m5, 5, 4, 3, 2, 1)
+	assert.Nil(t, err)
+	assert.Nil(t, res)
+
 }
--- a/adapter/toolbox/statistics_test.go
+++ b/adapter/toolbox/statistics_test.go
@@ -21,13 +21,16 @@ import (
 )

 func TestStatics(t *testing.T) {
-	StatisticsMap.AddStatistics("POST", "/api/user", "&admin.user", time.Duration(2000))
-	StatisticsMap.AddStatistics("POST", "/api/user", "&admin.user", time.Duration(120000))
-	StatisticsMap.AddStatistics("GET", "/api/user", "&admin.user", time.Duration(13000))
-	StatisticsMap.AddStatistics("POST", "/api/admin", "&admin.user", time.Duration(14000))
-	StatisticsMap.AddStatistics("POST", "/api/user/astaxie", "&admin.user", time.Duration(12000))
-	StatisticsMap.AddStatistics("POST", "/api/user/xiemengjun", "&admin.user", time.Duration(13000))
-	StatisticsMap.AddStatistics("DELETE", "/api/user", "&admin.user", time.Duration(1400))
+	userApi := "/api/user"
+	post := "POST"
+	adminUser := "&admin.user"
+	StatisticsMap.AddStatistics(post, userApi, adminUser, time.Duration(2000))
+	StatisticsMap.AddStatistics(post, userApi, adminUser, time.Duration(120000))
+	StatisticsMap.AddStatistics("GET", userApi, adminUser, time.Duration(13000))
+	StatisticsMap.AddStatistics(post, "/api/admin", adminUser, time.Duration(14000))
+	StatisticsMap.AddStatistics(post, "/api/user/astaxie", adminUser, time.Duration(12000))
+	StatisticsMap.AddStatistics(post, "/api/user/xiemengjun", adminUser, time.Duration(13000))
+	StatisticsMap.AddStatistics("DELETE", userApi, adminUser, time.Duration(1400))
 	t.Log(StatisticsMap.GetMap())

 	data := StatisticsMap.GetMapData()
--- a/adapter/utils/rand_test.go
+++ b/adapter/utils/rand_test.go
@@ -16,7 +16,7 @@ package utils

 import "testing"

-func TestRand_01(t *testing.T) {
+func TestRand01(t *testing.T) {
 	bs0 := RandomCreateBytes(16)
 	bs1 := RandomCreateBytes(16)

--- a/adapter/validation/validation_test.go
+++ b/adapter/validation/validation_test.go
@@ -18,131 +18,83 @@ import (
 	"regexp"
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/assert"
 )

 func TestRequired(t *testing.T) {
 	valid := Validation{}

-	if valid.Required(nil, "nil").Ok {
-		t.Error("nil object should be false")
-	}
-	if !valid.Required(true, "bool").Ok {
-		t.Error("Bool value should always return true")
-	}
-	if !valid.Required(false, "bool").Ok {
-		t.Error("Bool value should always return true")
-	}
-	if valid.Required("", "string").Ok {
-		t.Error("\"'\" string should be false")
-	}
-	if valid.Required(" ", "string").Ok {
-		t.Error("\" \" string should be false") // For #2361
-	}
-	if valid.Required("\n", "string").Ok {
-		t.Error("new line string should be false") // For #2361
-	}
-	if !valid.Required("astaxie", "string").Ok {
-		t.Error("string should be true")
-	}
-	if valid.Required(0, "zero").Ok {
-		t.Error("Integer should not be equal 0")
-	}
-	if !valid.Required(1, "int").Ok {
-		t.Error("Integer except 0 should be true")
-	}
-	if !valid.Required(time.Now(), "time").Ok {
-		t.Error("time should be true")
-	}
-	if valid.Required([]string{}, "emptySlice").Ok {
-		t.Error("empty slice should be false")
-	}
-	if !valid.Required([]interface{}{"ok"}, "slice").Ok {
-		t.Error("slice should be true")
-	}
+	assert.False(t, valid.Required(nil, "nil").Ok)
+	assert.True(t, valid.Required(true, "bool").Ok)
+
+	assert.True(t, valid.Required(false, "bool").Ok)
+	assert.False(t, valid.Required("", "string").Ok)
+	assert.False(t, valid.Required(" ", "string").Ok)
+	assert.False(t, valid.Required("\n", "string").Ok)
+
+	assert.True(t, valid.Required("astaxie", "string").Ok)
+	assert.False(t, valid.Required(0, "zero").Ok)
+
+	assert.True(t, valid.Required(1, "int").Ok)
+
+	assert.True(t, valid.Required(time.Now(), "time").Ok)
+
+	assert.False(t, valid.Required([]string{}, "emptySlice").Ok)
+
+	assert.True(t, valid.Required([]interface{}{"ok"}, "slice").Ok)
 }

 func TestMin(t *testing.T) {
 	valid := Validation{}

-	if valid.Min(-1, 0, "min0").Ok {
-		t.Error("-1 is less than the minimum value of 0 should be false")
-	}
-	if !valid.Min(1, 0, "min0").Ok {
-		t.Error("1 is greater or equal than the minimum value of 0 should be true")
-	}
+	assert.False(t, valid.Min(-1, 0, "min0").Ok)
+	assert.True(t, valid.Min(1, 0, "min0").Ok)
+
 }

 func TestMax(t *testing.T) {
 	valid := Validation{}

-	if valid.Max(1, 0, "max0").Ok {
-		t.Error("1 is greater than the minimum value of 0 should be false")
-	}
-	if !valid.Max(-1, 0, "max0").Ok {
-		t.Error("-1 is less or equal than the maximum value of 0 should be true")
-	}
+	assert.False(t, valid.Max(1, 0, "max0").Ok)
+	assert.True(t, valid.Max(-1, 0, "max0").Ok)
 }

 func TestRange(t *testing.T) {
 	valid := Validation{}

-	if valid.Range(-1, 0, 1, "range0_1").Ok {
-		t.Error("-1 is between 0 and 1 should be false")
-	}
-	if !valid.Range(1, 0, 1, "range0_1").Ok {
-		t.Error("1 is between 0 and 1 should be true")
-	}
+	assert.False(t, valid.Range(-1, 0, 1, "range0_1").Ok)
+
+	assert.True(t, valid.Range(1, 0, 1, "range0_1").Ok)
 }

 func TestMinSize(t *testing.T) {
 	valid := Validation{}

-	if valid.MinSize("", 1, "minSize1").Ok {
-		t.Error("the length of \"\" is less than the minimum value of 1 should be false")
-	}
-	if !valid.MinSize("ok", 1, "minSize1").Ok {
-		t.Error("the length of \"ok\" is greater or equal than the minimum value of 1 should be true")
-	}
-	if valid.MinSize([]string{}, 1, "minSize1").Ok {
-		t.Error("the length of empty slice is less than the minimum value of 1 should be false")
-	}
-	if !valid.MinSize([]interface{}{"ok"}, 1, "minSize1").Ok {
-		t.Error("the length of [\"ok\"] is greater or equal than the minimum value of 1 should be true")
-	}
+	assert.False(t, valid.MinSize("", 1, "minSize1").Ok)
+
+	assert.True(t, valid.MinSize("ok", 1, "minSize1").Ok)
+	assert.False(t, valid.MinSize([]string{}, 1, "minSize1").Ok)
+	assert.True(t, valid.MinSize([]interface{}{"ok"}, 1, "minSize1").Ok)
 }

 func TestMaxSize(t *testing.T) {
 	valid := Validation{}

-	if valid.MaxSize("ok", 1, "maxSize1").Ok {
-		t.Error("the length of \"ok\" is greater than the maximum value of 1 should be false")
-	}
-	if !valid.MaxSize("", 1, "maxSize1").Ok {
-		t.Error("the length of \"\" is less or equal than the maximum value of 1 should be true")
-	}
-	if valid.MaxSize([]interface{}{"ok", false}, 1, "maxSize1").Ok {
-		t.Error("the length of [\"ok\", false] is greater than the maximum value of 1 should be false")
-	}
-	if !valid.MaxSize([]string{}, 1, "maxSize1").Ok {
-		t.Error("the length of empty slice is less or equal than the maximum value of 1 should be true")
-	}
+	assert.False(t, valid.MaxSize("ok", 1, "maxSize1").Ok)
+	assert.True(t, valid.MaxSize("", 1, "maxSize1").Ok)
+	assert.False(t, valid.MaxSize([]interface{}{"ok", false}, 1, "maxSize1").Ok)
+	assert.True(t, valid.MaxSize([]string{}, 1, "maxSize1").Ok)
 }

 func TestLength(t *testing.T) {
 	valid := Validation{}

-	if valid.Length("", 1, "length1").Ok {
-		t.Error("the length of \"\" must equal 1 should be false")
-	}
-	if !valid.Length("1", 1, "length1").Ok {
-		t.Error("the length of \"1\" must equal 1 should be true")
-	}
-	if valid.Length([]string{}, 1, "length1").Ok {
-		t.Error("the length of empty slice must equal 1 should be false")
-	}
-	if !valid.Length([]interface{}{"ok"}, 1, "length1").Ok {
-		t.Error("the length of [\"ok\"] must equal 1 should be true")
-	}
+	assert.False(t, valid.Length("", 1, "length1").Ok)
+	assert.True(t, valid.Length("1", 1, "length1").Ok)
+
+	assert.False(t, valid.Length([]string{}, 1, "length1").Ok)
+	assert.True(t, valid.Length([]interface{}{"ok"}, 1, "length1").Ok)
 }

 func TestAlpha(t *testing.T) {
@@ -178,13 +130,16 @@ func TestAlphaNumeric(t *testing.T) {
 	}
 }

+const email = "suchuangji@gmail.com"
+
 func TestMatch(t *testing.T) {
 	valid := Validation{}

 	if valid.Match("suchuangji@gmail", regexp.MustCompile(`^\w+@\w+\.\w+$`), "match").Ok {
 		t.Error("\"suchuangji@gmail\" match \"^\\w+@\\w+\\.\\w+$\"  should be false")
 	}
-	if !valid.Match("suchuangji@gmail.com", regexp.MustCompile(`^\w+@\w+\.\w+$`), "match").Ok {
+
+	if !valid.Match(email, regexp.MustCompile(`^\w+@\w+\.\w+$`), "match").Ok {
 		t.Error("\"suchuangji@gmail\" match \"^\\w+@\\w+\\.\\w+$\"  should be true")
 	}
 }
@@ -217,7 +172,7 @@ func TestEmail(t *testing.T) {
 	if valid.Email("not@a email", "email").Ok {
 		t.Error("\"not@a email\" is a valid email address should be false")
 	}
-	if !valid.Email("suchuangji@gmail.com", "email").Ok {
+	if !valid.Email(email, "email").Ok {
 		t.Error("\"suchuangji@gmail.com\" is a valid email address should be true")
 	}
 	if valid.Email("@suchuangji@gmail.com", "email").Ok {
@@ -242,7 +197,7 @@ func TestIP(t *testing.T) {
 func TestBase64(t *testing.T) {
 	valid := Validation{}

-	if valid.Base64("suchuangji@gmail.com", "base64").Ok {
+	if valid.Base64(email, "base64").Ok {
 		t.Error("\"suchuangji@gmail.com\" are a valid base64 characters should be false")
 	}
 	if !valid.Base64("c3VjaHVhbmdqaUBnbWFpbC5jb20=", "base64").Ok {
@@ -370,44 +325,25 @@ func TestValid(t *testing.T) {

 	u := user{Name: "test@/test/;com", Age: 40}
 	b, err := valid.Valid(u)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !b {
-		t.Error("validation should be passed")
-	}
+	assert.Nil(t, err)
+	assert.True(t, b)

 	uptr := &user{Name: "test", Age: 40}
 	valid.Clear()
 	b, err = valid.Valid(uptr)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if b {
-		t.Error("validation should not be passed")
-	}
-	if len(valid.Errors) != 1 {
-		t.Fatalf("valid errors len should be 1 but got %d", len(valid.Errors))
-	}
-	if valid.Errors[0].Key != "Name.Match" {
-		t.Errorf("Message key should be `Name.Match` but got %s", valid.Errors[0].Key)
-	}
+
+	assert.Nil(t, err)
+	assert.False(t, b)
+	assert.Equal(t, 1, len(valid.Errors))
+	assert.Equal(t, "Name.Match", valid.Errors[0].Key)

 	u = user{Name: "test@/test/;com", Age: 180}
 	valid.Clear()
 	b, err = valid.Valid(u)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if b {
-		t.Error("validation should not be passed")
-	}
-	if len(valid.Errors) != 1 {
-		t.Fatalf("valid errors len should be 1 but got %d", len(valid.Errors))
-	}
-	if valid.Errors[0].Key != "Age.Range." {
-		t.Errorf("Message key should be `Age.Range` but got %s", valid.Errors[0].Key)
-	}
+	assert.Nil(t, err)
+	assert.False(t, b)
+	assert.Equal(t, 1, len(valid.Errors))
+	assert.Equal(t, "Age.Range.", valid.Errors[0].Key)
 }

 func TestRecursiveValid(t *testing.T) {
@@ -432,12 +368,8 @@ func TestRecursiveValid(t *testing.T) {

 	u := Account{Password: "abc123_", U: User{}}
 	b, err := valid.RecursiveValid(u)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if b {
-		t.Error("validation should not be passed")
-	}
+	assert.Nil(t, err)
+	assert.False(t, b)
 }

 func TestSkipValid(t *testing.T) {
@@ -474,21 +406,13 @@ func TestSkipValid(t *testing.T) {

 	valid := Validation{}
 	b, err := valid.Valid(u)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if b {
-		t.Fatal("validation should not be passed")
-	}
+	assert.Nil(t, err)
+	assert.False(t, b)

 	valid = Validation{RequiredFirst: true}
 	b, err = valid.Valid(u)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !b {
-		t.Fatal("validation should be passed")
-	}
+	assert.Nil(t, err)
+	assert.True(t, b)
 }

 func TestPointer(t *testing.T) {
@@ -506,12 +430,8 @@ func TestPointer(t *testing.T) {

 	valid := Validation{}
 	b, err := valid.Valid(u)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if b {
-		t.Fatal("validation should not be passed")
-	}
+	assert.Nil(t, err)
+	assert.False(t, b)

 	validEmail := "a@a.com"
 	u = User{
@@ -521,12 +441,8 @@ func TestPointer(t *testing.T) {

 	valid = Validation{RequiredFirst: true}
 	b, err = valid.Valid(u)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !b {
-		t.Fatal("validation should be passed")
-	}
+	assert.Nil(t, err)
+	assert.True(t, b)

 	u = User{
 		ReqEmail: &validEmail,
@@ -535,12 +451,8 @@ func TestPointer(t *testing.T) {

 	valid = Validation{}
 	b, err = valid.Valid(u)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if b {
-		t.Fatal("validation should not be passed")
-	}
+	assert.Nil(t, err)
+	assert.False(t, b)

 	invalidEmail := "a@a"
 	u = User{
@@ -550,12 +462,8 @@ func TestPointer(t *testing.T) {

 	valid = Validation{RequiredFirst: true}
 	b, err = valid.Valid(u)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if b {
-		t.Fatal("validation should not be passed")
-	}
+	assert.Nil(t, err)
+	assert.False(t, b)

 	u = User{
 		ReqEmail: &validEmail,
@@ -564,12 +472,8 @@ func TestPointer(t *testing.T) {

 	valid = Validation{}
 	b, err = valid.Valid(u)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if b {
-		t.Fatal("validation should not be passed")
-	}
+	assert.Nil(t, err)
+	assert.False(t, b)
 }

 func TestCanSkipAlso(t *testing.T) {
@@ -589,21 +493,14 @@ func TestCanSkipAlso(t *testing.T) {

 	valid := Validation{RequiredFirst: true}
 	b, err := valid.Valid(u)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if b {
-		t.Fatal("validation should not be passed")
-	}
+	assert.Nil(t, err)
+	assert.False(t, b)

 	valid = Validation{RequiredFirst: true}
 	valid.CanSkipAlso("Range")
 	b, err = valid.Valid(u)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !b {
-		t.Fatal("validation should be passed")
-	}
+
+	assert.Nil(t, err)
+	assert.True(t, b)

 }