diff --git a/go.sum b/go.sum
index 2c33c1b..42ba14f 100644
--- a/go.sum
+++ b/go.sum
@@ -2,6 +2,7 @@ github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
diff --git a/middleware/basic_auth_test.go b/middleware/basic_auth_test.go
index 5e273b3..d408c47 100644
--- a/middleware/basic_auth_test.go
+++ b/middleware/basic_auth_test.go
@@ -38,7 +38,7 @@ func TestNoVildatePanic(t *testing.T) {
 	defer func() {
 		r := recover()
 		assert.NotNil(r)
-		assert.Equal(r.(error), ErrBasicAuthRequireValidateFunction)
+		assert.Equal(ErrBasicAuthRequireValidateFunction, r.(error))
 	}()
 
 	NewBasicAuth(BasicAuthConfig{})
@@ -89,8 +89,8 @@ func TestBasicAuth(t *testing.T) {
 		})
 		resp := httptest.NewRecorder()
 		e.ServeHTTP(resp, req)
-		assert.Equal(resp.Code, http.StatusUnauthorized)
-		assert.Equal(resp.Header().Get(elton.HeaderWWWAuthenticate), `basic realm="basic auth tips"`)
+		assert.Equal(http.StatusUnauthorized, resp.Code)
+		assert.Equal(`basic realm="basic auth tips"`, resp.Header().Get(elton.HeaderWWWAuthenticate))
 	})
 
 	t.Run("auth validate fail", func(t *testing.T) {
@@ -103,14 +103,14 @@ func TestBasicAuth(t *testing.T) {
 		req.Header.Set(elton.HeaderAuthorization, "basic YTpi")
 		resp := httptest.NewRecorder()
 		e.ServeHTTP(resp, req)
-		assert.Equal(resp.Code, http.StatusUnauthorized)
-		assert.Equal(resp.Body.String(), "category=elton-basic-auth, message=unAuthorized")
+		assert.Equal(http.StatusUnauthorized, resp.Code)
+		assert.Equal("category=elton-basic-auth, message=unAuthorized", resp.Body.String())
 
 		req.Header.Set(elton.HeaderAuthorization, "basic bjph")
 		resp = httptest.NewRecorder()
 		e.ServeHTTP(resp, req)
-		assert.Equal(resp.Code, http.StatusBadRequest)
-		assert.Equal(resp.Body.String(), "message=account is invalid")
+		assert.Equal(http.StatusBadRequest, resp.Code)
+		assert.Equal("message=account is invalid", resp.Body.String())
 	})
 
 	t.Run("validate error", func(t *testing.T) {
@@ -127,8 +127,8 @@ func TestBasicAuth(t *testing.T) {
 		})
 		resp := httptest.NewRecorder()
 		e.ServeHTTP(resp, req)
-		assert.Equal(resp.Code, http.StatusBadRequest)
-		assert.Equal(resp.Body.String(), "category=elton-basic-auth, message=abcd")
+		assert.Equal(http.StatusBadRequest, resp.Code)
+		assert.Equal("category=elton-basic-auth, message=abcd", resp.Body.String())
 	})
 
 	t.Run("auth success", func(t *testing.T) {
diff --git a/middleware/body_parser_test.go b/middleware/body_parser_test.go
index 5bdc9fd..05633c7 100644
--- a/middleware/body_parser_test.go
+++ b/middleware/body_parser_test.go
@@ -189,7 +189,7 @@ func TestBodyParser(t *testing.T) {
 
 		assert.Nil(err)
 		assert.True(done)
-		assert.Equal(c.RequestBody, []byte("a"))
+		assert.Equal([]byte("a"), c.RequestBody)
 	})
 
 	t.Run("pass method", func(t *testing.T) {
@@ -230,7 +230,7 @@ func TestBodyParser(t *testing.T) {
 		c := elton.NewContext(nil, req)
 		err := bodyParser(c)
 		assert.NotNil(err)
-		assert.Equal(err.Error(), "category=elton-body-parser, message=message=abc")
+		assert.Equal("category=elton-body-parser, message=message=abc", err.Error())
 	})
 
 	t.Run("body over limit size", func(t *testing.T) {
@@ -243,7 +243,7 @@ func TestBodyParser(t *testing.T) {
 		c := elton.NewContext(nil, req)
 		err := bodyParser(c)
 		assert.NotNil(err)
-		assert.Equal(err.Error(), "category=elton-body-parser, message=request body is too large, it should be <= 1")
+		assert.Equal("category=elton-body-parser, message=request body is too large, it should be <= 1", err.Error())
 	})
 
 	t.Run("parse json success", func(t *testing.T) {
diff --git a/middleware/compress_test.go b/middleware/compress_test.go
index 959aeb6..4fbc7ef 100644
--- a/middleware/compress_test.go
+++ b/middleware/compress_test.go
@@ -116,7 +116,7 @@ func TestCompress(t *testing.T) {
 		}
 		fn := NewDefaultCompress()
 		err := fn(c)
-		assert.Equal(err, customErr)
+		assert.Equal(customErr, err)
 	})
 
 	t.Run("normal", func(t *testing.T) {
diff --git a/middleware/concurrent_limiter_test.go b/middleware/concurrent_limiter_test.go
index 1a14aa8..0ede2fa 100644
--- a/middleware/concurrent_limiter_test.go
+++ b/middleware/concurrent_limiter_test.go
@@ -117,6 +117,6 @@ func TestConcurrentLimiter(t *testing.T) {
 		assert := assert.New(t)
 		c.Params = new(elton.RouteParams)
 		err := fn(c)
-		assert.Equal(err.Error(), "message=key is invalid")
+		assert.Equal("message=key is invalid", err.Error())
 	})
 }
diff --git a/middleware/etag_test.go b/middleware/etag_test.go
index 6535662..d12c683 100644
--- a/middleware/etag_test.go
+++ b/middleware/etag_test.go
@@ -67,7 +67,7 @@ func TestETag(t *testing.T) {
 			return customErr
 		}
 		err := fn(c)
-		assert.Equal(err, customErr)
+		assert.Equal(customErr, err)
 	})
 
 	t.Run("no body", func(t *testing.T) {
@@ -100,6 +100,7 @@ func TestETag(t *testing.T) {
 	})
 
 	t.Run("gen eTag", func(t *testing.T) {
+		assert := assert.New(t)
 		resp := httptest.NewRecorder()
 		c := elton.NewContext(resp, nil)
 		c.Next = func() error {
@@ -110,12 +111,8 @@ func TestETag(t *testing.T) {
 			return nil
 		}
 		err := fn(c)
-		if err != nil {
-			t.Fatalf("eTag middleware fail, %v", err)
-		}
-		if c.GetHeader(elton.HeaderETag) != `"13-yo9YroUOjW1obRvVoXfrCiL2JGE="` {
-			t.Fatalf("gen eTag fail")
-		}
+		assert.Nil(err)
+		assert.Equal(`"13-yo9YroUOjW1obRvVoXfrCiL2JGE="`, c.GetHeader(elton.HeaderETag))
 	})
 }
 
diff --git a/middleware/fresh_test.go b/middleware/fresh_test.go
index 7def140..291c58d 100644
--- a/middleware/fresh_test.go
+++ b/middleware/fresh_test.go
@@ -63,7 +63,7 @@ func TestFresh(t *testing.T) {
 		}
 		fn := NewFresh(FreshConfig{})
 		err := fn(c)
-		assert.Equal(err, customErr, "custom error should be return")
+		assert.Equal(customErr, err, "custom error should be return")
 	})
 
 	t.Run("not modified", func(t *testing.T) {
@@ -87,7 +87,7 @@ func TestFresh(t *testing.T) {
 		assert.Nil(err)
 		assert.True(done)
 
-		assert.Equal(c.StatusCode, 304, "status code should be 304")
+		assert.Equal(304, c.StatusCode, "status code should be 304")
 		assert.Nil(c.Body, "body should be nil")
 		assert.Nil(c.BodyBuffer, "body buffer should be nil")
 	})
@@ -105,7 +105,7 @@ func TestFresh(t *testing.T) {
 		c.NoContent()
 		err := fn(c)
 		assert.Nil(err)
-		assert.Equal(c.StatusCode, 204, "no body should be passed by fresh")
+		assert.Equal(204, c.StatusCode, "no body should be passed by fresh")
 	})
 
 	t.Run("post method", func(t *testing.T) {
@@ -130,7 +130,7 @@ func TestFresh(t *testing.T) {
 		assert.Nil(err)
 		assert.True(done)
 
-		assert.Equal(c.StatusCode, 200, "post requset should be passed by fresh")
+		assert.Equal(200, c.StatusCode, "post requset should be passed by fresh")
 		assert.NotNil(c.Body, "post requset should be passed by fresh")
 		assert.NotNil(c.BodyBuffer, "post requset should be passed by fresh")
 	})
@@ -157,7 +157,7 @@ func TestFresh(t *testing.T) {
 		assert.Nil(err)
 		assert.True(done)
 
-		assert.Equal(c.StatusCode, http.StatusBadRequest, "error response should be passed by fresh")
+		assert.Equal(http.StatusBadRequest, c.StatusCode, "error response should be passed by fresh")
 		assert.NotNil(c.Body, "error response should be passed by fresh")
 		assert.NotNil(c.BodyBuffer, "error response should be passed by fresh")
 	})
diff --git a/middleware/logger_test.go b/middleware/logger_test.go
index 479553a..45cc701 100644
--- a/middleware/logger_test.go
+++ b/middleware/logger_test.go
@@ -35,22 +35,12 @@ import (
 )
 
 func TestGetHumanReadableSize(t *testing.T) {
-	if getHumanReadableSize(1024*1024) != "1MB" {
-		t.Fatalf("1024 * 1024 should be 1MB")
-	}
-	if getHumanReadableSize(1024*1024+500*1024) != "1.49MB" {
-		t.Fatalf("1024*1024+500*1024 should be 1.49MB")
-	}
-
-	if getHumanReadableSize(1024) != "1KB" {
-		t.Fatalf("1024 should be 1KB")
-	}
-	if getHumanReadableSize(1024+500) != "1.49KB" {
-		t.Fatalf("1024+500 should be 1.49KB")
-	}
-	if getHumanReadableSize(500) != "500B" {
-		t.Fatalf("500 should be 500B")
-	}
+	assert := assert.New(t)
+	assert.Equal("1MB", getHumanReadableSize(1024*1024))
+	assert.Equal("1.49MB", getHumanReadableSize(1024*1024+500*1024))
+	assert.Equal("1KB", getHumanReadableSize(1024))
+	assert.Equal("1.49KB", getHumanReadableSize(1024+500))
+	assert.Equal("500B", getHumanReadableSize(500))
 }
 
 func TestLogger(t *testing.T) {
@@ -84,9 +74,7 @@ func TestLogger(t *testing.T) {
 		config := LoggerConfig{
 			Format: "{latency} {latency-ms}",
 			OnLog: func(log string, _ *elton.Context) {
-				if len(strings.Split(log, " ")) != 2 {
-					t.Fatalf("get latency fail")
-				}
+				assert.Equal(2, len(strings.Split(log, " ")))
 			},
 		}
 		m := NewLogger(config)
@@ -105,9 +93,7 @@ func TestLogger(t *testing.T) {
 		config := LoggerConfig{
 			Format: "{when}  {when-iso}  {when-utc-iso}  {when-unix}  {when-iso-ms}  {when-utc-iso-ms}",
 			OnLog: func(log string, _ *elton.Context) {
-				if len(strings.Split(log, "  ")) != 6 {
-					t.Fatalf("get when fail")
-				}
+				assert.Equal(6, len(strings.Split(log, "  ")))
 			},
 		}
 		m := NewLogger(config)
@@ -125,9 +111,7 @@ func TestLogger(t *testing.T) {
 		config := LoggerConfig{
 			Format: "{~jt}",
 			OnLog: func(log string, _ *elton.Context) {
-				if log != "abc" {
-					t.Fatalf("get cookie value fail")
-				}
+				assert.Equal("abc", log, "get cookie value fail")
 			},
 		}
 		m := NewLogger(config)
@@ -149,9 +133,7 @@ func TestLogger(t *testing.T) {
 		config := LoggerConfig{
 			Format: "{>X-Token} {<X-Response-Id} place-holder",
 			OnLog: func(log string, _ *elton.Context) {
-				if log != "abc def place-holder" {
-					t.Fatalf("get header value fail")
-				}
+				assert.Equal("abc def place-holder", log, "get header value fail")
 			},
 		}
 		m := NewLogger(config)
diff --git a/middleware/proxy_test.go b/middleware/proxy_test.go
index 9422053..28a9d2d 100644
--- a/middleware/proxy_test.go
+++ b/middleware/proxy_test.go
@@ -37,7 +37,7 @@ func TestNoTargetPanic(t *testing.T) {
 	assert := assert.New(t)
 	defer func() {
 		r := recover()
-		assert.Equal(r.(error), ErrProxyNoTargetFunction)
+		assert.Equal(ErrProxyNoTargetFunction, r.(error))
 	}()
 	NewProxy(ProxyConfig{})
 }
@@ -63,13 +63,13 @@ func TestGenerateRewrites(t *testing.T) {
 		"a:b:c",
 	})
 	assert.Nil(err)
-	assert.Equal(len(regs), 0, "rewrite regexp map should be 0")
+	assert.Equal(0, len(regs), "rewrite regexp map should be 0")
 
 	regs, err = generateRewrites([]string{
 		"/(d/:a",
 	})
 	assert.NotNil(err)
-	assert.Equal(len(regs), 0, "regexp map should be 0 when error occur")
+	assert.Equal(0, len(regs), "regexp map should be 0 when error occur")
 }
 
 func TestProxy(t *testing.T) {
@@ -98,11 +98,11 @@ func TestProxy(t *testing.T) {
 		}
 		err := fn(c)
 		assert.Nil(err)
-		assert.Equal(c.GetHeader("Content-Encoding"), "gzip")
-		assert.Equal(c.Request.URL.Path, originalPath)
-		assert.Equal(req.Host, originalHost)
+		assert.Equal("gzip", c.GetHeader("Content-Encoding"))
+		assert.Equal(originalPath, c.Request.URL.Path)
+		assert.Equal(originalHost, req.Host)
 		assert.True(done)
-		assert.Equal(c.StatusCode, http.StatusOK)
+		assert.Equal(http.StatusOK, c.StatusCode)
 	})
 
 	t.Run("target picker", func(t *testing.T) {
@@ -131,7 +131,7 @@ func TestProxy(t *testing.T) {
 		assert.Nil(err)
 		assert.True(done)
 		assert.True(callBackDone)
-		assert.Equal(c.StatusCode, http.StatusOK)
+		assert.Equal(http.StatusOK, c.StatusCode)
 	})
 
 	t.Run("target picker error", func(t *testing.T) {
@@ -148,7 +148,7 @@ func TestProxy(t *testing.T) {
 		resp := httptest.NewRecorder()
 		c := elton.NewContext(resp, req)
 		err := fn(c)
-		assert.Equal(err.Error(), "abcd")
+		assert.Equal("abcd", err.Error())
 	})
 
 	t.Run("no target", func(t *testing.T) {
@@ -165,7 +165,7 @@ func TestProxy(t *testing.T) {
 		resp := httptest.NewRecorder()
 		c := elton.NewContext(resp, req)
 		err := fn(c)
-		assert.Equal(err.Error(), "category=elton-proxy, message=target can not be nil")
+		assert.Equal("category=elton-proxy, message=target can not be nil", err.Error())
 	})
 
 	t.Run("proxy error", func(t *testing.T) {
diff --git a/middleware/recover_test.go b/middleware/recover_test.go
index 9c3342d..ca15883 100644
--- a/middleware/recover_test.go
+++ b/middleware/recover_test.go
@@ -59,8 +59,8 @@ func TestRecover(t *testing.T) {
 		})
 
 		e.ServeHTTP(resp, req)
-		assert.Equal(resp.Code, http.StatusInternalServerError)
-		assert.Equal(resp.Body.String(), "category=elton-recover, message=abc")
+		assert.Equal(http.StatusInternalServerError, resp.Code)
+		assert.Equal("category=elton-recover, message=abc", resp.Body.String())
 		assert.True(ctx.Committed)
 		assert.True(catchError)
 		for _, key := range keys {
diff --git a/middleware/responder_test.go b/middleware/responder_test.go
index f41c92a..b7696a6 100644
--- a/middleware/responder_test.go
+++ b/middleware/responder_test.go
@@ -35,18 +35,18 @@ import (
 
 func checkResponse(t *testing.T, resp *httptest.ResponseRecorder, code int, data string) {
 	assert := assert.New(t)
-	assert.Equal(resp.Body.String(), data)
-	assert.Equal(resp.Code, code)
+	assert.Equal(data, resp.Body.String())
+	assert.Equal(code, resp.Code)
 }
 
 func checkJSON(t *testing.T, resp *httptest.ResponseRecorder) {
 	assert := assert.New(t)
-	assert.Equal(resp.Header().Get(elton.HeaderContentType), elton.MIMEApplicationJSON)
+	assert.Equal(elton.MIMEApplicationJSON, resp.Header().Get(elton.HeaderContentType))
 }
 
 func checkContentType(t *testing.T, resp *httptest.ResponseRecorder, contentType string) {
 	assert := assert.New(t)
-	assert.Equal(resp.Header().Get(elton.HeaderContentType), contentType)
+	assert.Equal(contentType, resp.Header().Get(elton.HeaderContentType))
 }
 
 func TestResponder(t *testing.T) {
@@ -82,7 +82,7 @@ func TestResponder(t *testing.T) {
 		}
 		fn := NewDefaultResponder()
 		err := fn(c)
-		assert.Equal(err, customErr)
+		assert.Equal(customErr, err)
 		assert.True(done)
 	})
 
@@ -195,8 +195,8 @@ func TestResponder(t *testing.T) {
 		})
 		resp := httptest.NewRecorder()
 		e.ServeHTTP(resp, req)
-		assert.Equal(resp.Code, 200)
-		assert.Equal(resp.Body.String(), "abcd")
+		assert.Equal(200, resp.Code)
+		assert.Equal("abcd", resp.Body.String())
 	})
 
 	t.Run("no content", func(t *testing.T) {
@@ -209,7 +209,7 @@ func TestResponder(t *testing.T) {
 		})
 		resp := httptest.NewRecorder()
 		e.ServeHTTP(resp, req)
-		assert.Equal(resp.Code, http.StatusNoContent)
+		assert.Equal(http.StatusNoContent, resp.Code)
 	})
 
 	t.Run("accepted(202)", func(t *testing.T) {
@@ -223,6 +223,6 @@ func TestResponder(t *testing.T) {
 		resp := httptest.NewRecorder()
 		e.ServeHTTP(resp, req)
 		assert.Empty(resp.Body)
-		assert.Equal(resp.Code, http.StatusAccepted)
+		assert.Equal(http.StatusAccepted, resp.Code)
 	})
 }
diff --git a/middleware/static_serve_test.go b/middleware/static_serve_test.go
index 9dab49b..8fd6bcf 100644
--- a/middleware/static_serve_test.go
+++ b/middleware/static_serve_test.go
@@ -101,8 +101,8 @@ func (mf *MockFileStat) Sys() interface{} {
 
 func TestGenerateETag(t *testing.T) {
 	assert := assert.New(t)
-	assert.Equal(generateETag([]byte("")), `"0-2jmj7l5rSw0yVb_vlWAYkK_YBwk="`)
-	assert.Equal(generateETag([]byte("abc")), `"3-qZk-NkcGgWq6PiVxeFDCbJzQ2J0="`)
+	assert.Equal(`"0-2jmj7l5rSw0yVb_vlWAYkK_YBwk="`, generateETag([]byte("")))
+	assert.Equal(`"3-qZk-NkcGgWq6PiVxeFDCbJzQ2J0="`, generateETag([]byte("abc")))
 }
 
 func TestFS(t *testing.T) {
@@ -140,7 +140,7 @@ func TestStaticServe(t *testing.T) {
 		req := httptest.NewRequest("GET", "/index.html?a=1", nil)
 		c := elton.NewContext(nil, req)
 		err := fn(c)
-		assert.Equal(err, ErrStaticServeNotAllowQueryString, "should return not allow query string error")
+		assert.Equal(ErrStaticServeNotAllowQueryString, err, "should return not allow query string error")
 	})
 
 	t.Run("not allow dot file", func(t *testing.T) {
@@ -152,7 +152,7 @@ func TestStaticServe(t *testing.T) {
 		req := httptest.NewRequest("GET", "/.index.html", nil)
 		c := elton.NewContext(nil, req)
 		err := fn(c)
-		assert.Equal(err, ErrStaticServeNotAllowAccessDot, "should return not allow dot error")
+		assert.Equal(ErrStaticServeNotAllowAccessDot, err, "should return not allow dot error")
 	})
 
 	t.Run("not found return error", func(t *testing.T) {
@@ -166,7 +166,7 @@ func TestStaticServe(t *testing.T) {
 			return nil
 		}
 		err := fn(c)
-		assert.Equal(err, ErrStaticServeNotFound, "should return not found error")
+		assert.Equal(ErrStaticServeNotFound, err, "should return not found error")
 	})
 
 	t.Run("not found pass to next", func(t *testing.T) {
@@ -201,8 +201,8 @@ func TestStaticServe(t *testing.T) {
 		}
 		err := fn(c)
 		assert.Nil(err)
-		assert.NotEqual(c.GetHeader(elton.HeaderContentEncoding), "gzip")
-		assert.Equal(c.GetHeader(elton.HeaderETag), `"a-1oFGwuX-Q3qfLHqK_7iCcc_0YYI="`)
+		assert.NotEqual("gzip", c.GetHeader(elton.HeaderContentEncoding))
+		assert.Equal(`"a-1oFGwuX-Q3qfLHqK_7iCcc_0YYI="`, c.GetHeader(elton.HeaderETag))
 	})
 
 	t.Run("get index.html", func(t *testing.T) {
@@ -219,9 +219,9 @@ func TestStaticServe(t *testing.T) {
 		err := fn(c)
 		assert.Nil(err, "serve index.html fail")
 
-		assert.Equal(c.GetHeader(elton.HeaderETag), `W/"400-5cfb1ad2"`, "generate etag fail")
+		assert.Equal(`W/"400-5cfb1ad2"`, c.GetHeader(elton.HeaderETag), "generate etag fail")
 		assert.NotEmpty(c.GetHeader(elton.HeaderLastModified), "last modified shouldn't be empty")
-		assert.Equal(c.GetHeader("Content-Type"), "text/html; charset=utf-8")
+		assert.Equal("text/html; charset=utf-8", c.GetHeader("Content-Type"))
 		assert.True(c.IsReaderBody())
 	})
 
@@ -241,7 +241,7 @@ func TestStaticServe(t *testing.T) {
 		}
 		err := fn(c)
 		assert.Nil(err)
-		assert.Equal(c.GetHeader("X-IDC"), "GZ", "set custom header fail")
+		assert.Equal("GZ", c.GetHeader("X-IDC"), "set custom header fail")
 	})
 
 	t.Run("set (s)max-age", func(t *testing.T) {
@@ -259,7 +259,7 @@ func TestStaticServe(t *testing.T) {
 		}
 		err := fn(c)
 		assert.Nil(err)
-		assert.Equal(c.GetHeader(elton.HeaderCacheControl), "public, max-age=86400, s-maxage=300", "set max age header fail")
+		assert.Equal("public, max-age=86400, s-maxage=300", c.GetHeader(elton.HeaderCacheControl), "set max age header fail")
 	})
 
 	t.Run("out of path", func(t *testing.T) {
@@ -277,7 +277,7 @@ func TestStaticServe(t *testing.T) {
 			return nil
 		}
 		err := fn(c)
-		assert.Equal(err.Error(), "category=elton-static-serve, message=out of path", "out of path should return error")
+		assert.Equal("category=elton-static-serve, message=out of path", err.Error(), "out of path should return error")
 	})
 
 	t.Run("get file error", func(t *testing.T) {
@@ -294,6 +294,6 @@ func TestStaticServe(t *testing.T) {
 			return nil
 		}
 		err := fn(c)
-		assert.Equal(err.Error(), "category=elton-static-serve, message=abcd", "get file fail should return error")
+		assert.Equal("category=elton-static-serve, message=abcd", err.Error(), "get file fail should return error")
 	})
 }
diff --git a/middleware/stats_test.go b/middleware/stats_test.go
index 8e861ec..18fe6fc 100644
--- a/middleware/stats_test.go
+++ b/middleware/stats_test.go
@@ -75,9 +75,7 @@ func TestStats(t *testing.T) {
 		done := false
 		fn := NewStats(StatsConfig{
 			OnStats: func(info *StatsInfo, _ *elton.Context) {
-				if info.Status != http.StatusOK {
-					t.Fatalf("status code should be 200")
-				}
+				assert.Equal(http.StatusOK, info.Status, "status code should be 200")
 				done = true
 			},
 		})
@@ -97,7 +95,7 @@ func TestStats(t *testing.T) {
 		done := false
 		fn := NewStats(StatsConfig{
 			OnStats: func(info *StatsInfo, _ *elton.Context) {
-				assert.Equal(info.Status, http.StatusBadRequest)
+				assert.Equal(http.StatusBadRequest, info.Status)
 				done = true
 			},
 		})
@@ -117,7 +115,7 @@ func TestStats(t *testing.T) {
 		done := false
 		fn := NewStats(StatsConfig{
 			OnStats: func(info *StatsInfo, _ *elton.Context) {
-				assert.Equal(info.Status, http.StatusInternalServerError)
+				assert.Equal(http.StatusInternalServerError, info.Status)
 				done = true
 			},
 		})
diff --git a/middleware/tracker_test.go b/middleware/tracker_test.go
index 0b538ab..a2d824f 100644
--- a/middleware/tracker_test.go
+++ b/middleware/tracker_test.go
@@ -36,7 +36,7 @@ func TestNoTrackPanic(t *testing.T) {
 	done := false
 	defer func() {
 		r := recover()
-		assert.Equal(r.(error), ErrTrackerNoFunction)
+		assert.Equal(ErrTrackerNoFunction, r.(error))
 		done = true
 	}()
 
@@ -47,13 +47,13 @@ func TestNoTrackPanic(t *testing.T) {
 func TestConverMap(t *testing.T) {
 	assert := assert.New(t)
 	assert.Nil(convertMap(nil, nil))
-	assert.Equal(convertMap(map[string]string{
-		"password": "123",
-		"foo":      "bar",
-	}, defaultTrackerMaskFields), map[string]string{
+	assert.Equal(map[string]string{
 		"foo":      "bar",
 		"password": "***",
-	})
+	}, convertMap(map[string]string{
+		"password": "123",
+		"foo":      "bar",
+	}, defaultTrackerMaskFields))
 }
 
 func TestTracker(t *testing.T) {
@@ -62,11 +62,11 @@ func TestTracker(t *testing.T) {
 	done := false
 	fn := NewTracker(TrackerConfig{
 		OnTrack: func(info *TrackerInfo, _ *elton.Context) {
-			assert.Equal(info.Result, HandleFail)
-			assert.Equal(info.Query["type"], "1")
-			assert.Equal(info.Query["passwordType"], "***")
-			assert.Equal(info.Params["category"], "login")
-			assert.Equal(info.Form["password"], "***")
+			assert.Equal(HandleFail, info.Result)
+			assert.Equal("1", info.Query["type"])
+			assert.Equal("***", info.Query["passwordType"])
+			assert.Equal("login", info.Params["category"])
+			assert.Equal("***", info.Form["password"])
 			done = true
 		},
 	})
@@ -82,6 +82,6 @@ func TestTracker(t *testing.T) {
 		return customErr
 	}
 	err := fn(c)
-	assert.Equal(err, customErr)
+	assert.Equal(customErr, err)
 	assert.True(done, "tracker middleware fail")
 }