From 1e88466d234a82ce4aeca904bce8a0b93fac3d42 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Thu, 26 Oct 2017 10:25:25 +0800
Subject: [PATCH 01/32] Update the comment of Version (#1141)

---
 gin.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gin.go b/gin.go
index 8cfb1f13..4857f3ae 100644
--- a/gin.go
+++ b/gin.go
@@ -14,8 +14,8 @@ import (
 	"github.com/gin-gonic/gin/render"
 )
 
-// Version is Framework's version.
 const (
+	// Version is Framework's version.
 	Version                = "v1.2"
 	defaultMultipartMemory = 32 << 20 // 32 MB
 )

From b7e8a6b9b062473c7f3f4f5c16d0a28b6244de48 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 29 Oct 2017 20:12:22 +0800
Subject: [PATCH 02/32] style(import): not use aliase when import package
 (#1146)

---
 binding/binding.go       | 2 +-
 binding/json.go          | 4 +---
 binding/query.go         | 4 +---
 binding/validate_test.go | 3 +--
 4 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/binding/binding.go b/binding/binding.go
index a09cc221..dc32d538 100644
--- a/binding/binding.go
+++ b/binding/binding.go
@@ -7,7 +7,7 @@ package binding
 import (
 	"net/http"
 
-	validator "gopkg.in/go-playground/validator.v8"
+	"gopkg.in/go-playground/validator.v8"
 )
 
 const (
diff --git a/binding/json.go b/binding/json.go
index f600a5f4..b7c856af 100644
--- a/binding/json.go
+++ b/binding/json.go
@@ -10,9 +10,7 @@ import (
 	"github.com/gin-gonic/gin/json"
 )
 
-var (
-	EnableDecoderUseNumber = false
-)
+var EnableDecoderUseNumber = false
 
 type jsonBinding struct{}
 
diff --git a/binding/query.go b/binding/query.go
index a789f798..219743f2 100644
--- a/binding/query.go
+++ b/binding/query.go
@@ -4,9 +4,7 @@
 
 package binding
 
-import (
-	"net/http"
-)
+import "net/http"
 
 type queryBinding struct{}
 
diff --git a/binding/validate_test.go b/binding/validate_test.go
index 523e1298..8ca79989 100644
--- a/binding/validate_test.go
+++ b/binding/validate_test.go
@@ -10,9 +10,8 @@ import (
 	"testing"
 	"time"
 
-	validator "gopkg.in/go-playground/validator.v8"
-
 	"github.com/stretchr/testify/assert"
+	"gopkg.in/go-playground/validator.v8"
 )
 
 type testInterface interface {

From 6653d5d588740eb73d2245ef04d5a407d3c3f034 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Mon, 30 Oct 2017 10:38:38 +0800
Subject: [PATCH 03/32] fix markdown render (#1149)

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 7113058d..b7181036 100644
--- a/README.md
+++ b/README.md
@@ -74,10 +74,10 @@ BenchmarkTigerTonic_GithubAll               |    1000    |  1439483    |  239104
 BenchmarkTraffic_GithubAll                  |     100    | 11383067    | 2659329    | 21848
 BenchmarkVulcan_GithubAll                   |    5000    |   394253    |   19894    |   609
 
-(1): Total Repetitions achieved in constant time, higher means more confident result
-(2): Single Repetition Duration (ns/op), lower is better
-(3): Heap Memory (B/op), lower is better
-(4): Average Allocations per Repetition (allocs/op), lower is better
+- (1): Total Repetitions achieved in constant time, higher means more confident result
+- (2): Single Repetition Duration (ns/op), lower is better
+- (3): Heap Memory (B/op), lower is better
+- (4): Average Allocations per Repetition (allocs/op), lower is better
 
 ## Gin v1. stable
 

From 76ad15ab32d000115cb7622a8317d7425dfc039c Mon Sep 17 00:00:00 2001
From: Mike Stipicevic <mst@ableton.com>
Date: Thu, 2 Nov 2017 14:48:54 +0100
Subject: [PATCH 04/32] Update comment to reflect correct constant. (#1144)

The constant is `DebugMode`, as defined in [mode.go](https://github.com/gin-gonic/gin/blob/1e88466d234a82ce4aeca904bce8a0b93fac3d42/mode.go#L16).
---
 debug.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/debug.go b/debug.go
index 449291e6..897c4943 100644
--- a/debug.go
+++ b/debug.go
@@ -15,7 +15,7 @@ func init() {
 }
 
 // IsDebugging returns true if the framework is running in debug mode.
-// Use SetMode(gin.Release) to disable debug mode.
+// Use SetMode(gin.ReleaseMode) to disable debug mode.
 func IsDebugging() bool {
 	return ginMode == debugCode
 }

From 9ae1e5db2a47219bfae9147d372bd07b21ca0e08 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 12 Nov 2017 13:11:22 +0800
Subject: [PATCH 05/32] add package for govendor (#1166)

* add package for govendor

* fix vet error.

Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com>

* add missing example.

Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com>

* update gin-gonic/autotls

Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com>
---
 README.md                                      |  4 ++--
 .../auto-tls/{example1.go => example1/main.go} |  0
 .../auto-tls/{example2.go => example2/main.go} |  0
 vendor/vendor.json                             | 18 +++++++++++++++---
 4 files changed, 17 insertions(+), 5 deletions(-)
 rename examples/auto-tls/{example1.go => example1/main.go} (100%)
 rename examples/auto-tls/{example2.go => example2/main.go} (100%)

diff --git a/README.md b/README.md
index b7181036..6b8cdd7e 100644
--- a/README.md
+++ b/README.md
@@ -1133,7 +1133,7 @@ func main() {
 
 example for 1-line LetsEncrypt HTTPS servers.
 
-[embedmd]:# (examples/auto-tls/example1.go go)
+[embedmd]:# (examples/auto-tls/example1/main.go go)
 ```go
 package main
 
@@ -1158,7 +1158,7 @@ func main() {
 
 example for custom autocert manager.
 
-[embedmd]:# (examples/auto-tls/example2.go go)
+[embedmd]:# (examples/auto-tls/example2/main.go go)
 ```go
 package main
 
diff --git a/examples/auto-tls/example1.go b/examples/auto-tls/example1/main.go
similarity index 100%
rename from examples/auto-tls/example1.go
rename to examples/auto-tls/example1/main.go
diff --git a/examples/auto-tls/example2.go b/examples/auto-tls/example2/main.go
similarity index 100%
rename from examples/auto-tls/example2.go
rename to examples/auto-tls/example2/main.go
diff --git a/vendor/vendor.json b/vendor/vendor.json
index bcefee10..573abe24 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -22,10 +22,10 @@
 			"revisionTime": "2017-01-09T09:34:21Z"
 		},
 		{
-			"checksumSHA1": "FJKrZuFmeLJp8HDeJc6UkIDBPUw=",
+			"checksumSHA1": "+vZNyF2MykVjenLg1TpjjgjthV0=",
 			"path": "github.com/gin-gonic/autotls",
-			"revision": "5b3297bdcee778ff3bbdc99ab7c41e1c2677d22d",
-			"revisionTime": "2017-04-16T09:39:34Z"
+			"revision": "8ca25fbde72bb72a00466215b94b489c71fcb815",
+			"revisionTime": "2017-09-16T16:54:15Z"
 		},
 		{
 			"checksumSHA1": "qlPUeFabwF4RKAOF1H+yBFU1Veg=",
@@ -65,6 +65,12 @@
 			"revision": "976c720a22c8eb4eb6a0b4348ad85ad12491a506",
 			"revisionTime": "2016-09-25T22:06:09Z"
 		},
+		{
+			"checksumSHA1": "IopMW+arBezL5bqOfrVU6UEfn28=",
+			"path": "github.com/thinkerou/favicon",
+			"revision": "94a442a49da6e2d44bdd5e0d2e2e185c43a19d93",
+			"revisionTime": "2017-07-10T14:05:20Z"
+		},
 		{
 			"checksumSHA1": "CoxdaTYdPZNJXr8mJfLxye428N0=",
 			"path": "github.com/ugorji/go/codec",
@@ -90,6 +96,12 @@
 			"revision": "d4c55e66d8c3a2f3382d264b08e3e3454a66355a",
 			"revisionTime": "2016-10-18T08:54:36Z"
 		},
+		{
+			"checksumSHA1": "S0DP7Pn7sZUmXc55IzZnNvERu6s=",
+			"path": "golang.org/x/sync/errgroup",
+			"revision": "8e0aa688b654ef28caa72506fa5ec8dba9fc7690",
+			"revisionTime": "2017-07-19T03:38:01Z"
+		},
 		{
 			"checksumSHA1": "TVEkpH3gq84iQ39I4R+mlDwjuVI=",
 			"path": "golang.org/x/sys/unix",

From 9a4ecc87d6f8272b8e2450f9c0ab12d3e814521f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 12 Nov 2017 13:24:51 +0800
Subject: [PATCH 06/32] format some codes style (#1165)

---
 context.go       | 13 +++++--------
 gin.go           |  4 ++--
 json/json.go     |  4 +---
 json/jsoniter.go |  4 +---
 4 files changed, 9 insertions(+), 16 deletions(-)

diff --git a/context.go b/context.go
index 5b67dcc0..1ed65fed 100644
--- a/context.go
+++ b/context.go
@@ -33,9 +33,7 @@ const (
 	MIMEMultipartPOSTForm = binding.MIMEMultipartPOSTForm
 )
 
-const (
-	abortIndex int8 = math.MaxInt8 / 2
-)
+const abortIndex int8 = math.MaxInt8 / 2
 
 // Context is the most important part of gin. It allows us to pass variables between middleware,
 // manage the flow, validate the JSON of a request and render a JSON response for example.
@@ -105,8 +103,7 @@ func (c *Context) Handler() HandlerFunc {
 // See example in GitHub.
 func (c *Context) Next() {
 	c.index++
-	s := int8(len(c.handlers))
-	for ; c.index < s; c.index++ {
+	for s := int8(len(c.handlers)); c.index < s; c.index++ {
 		c.handlers[c.index](c)
 	}
 }
@@ -521,11 +518,11 @@ func (c *Context) ClientIP() string {
 			clientIP = clientIP[0:index]
 		}
 		clientIP = strings.TrimSpace(clientIP)
-		if len(clientIP) > 0 {
+		if clientIP != "" {
 			return clientIP
 		}
 		clientIP = strings.TrimSpace(c.requestHeader("X-Real-Ip"))
-		if len(clientIP) > 0 {
+		if clientIP != "" {
 			return clientIP
 		}
 	}
@@ -588,7 +585,7 @@ func (c *Context) Status(code int) {
 // It writes a header in the response.
 // If value == "", this method removes the header `c.Writer.Header().Del(key)`
 func (c *Context) Header(key, value string) {
-	if len(value) == 0 {
+	if value == "" {
 		c.Writer.Header().Del(key)
 	} else {
 		c.Writer.Header().Set(key, value)
diff --git a/gin.go b/gin.go
index 4857f3ae..b59712bf 100644
--- a/gin.go
+++ b/gin.go
@@ -403,8 +403,8 @@ func redirectTrailingSlash(c *Context) {
 		code = 307
 	}
 
-	if len(path) > 1 && path[len(path)-1] == '/' {
-		req.URL.Path = path[:len(path)-1]
+	if length := len(path); length > 1 && path[length-1] == '/' {
+		req.URL.Path = path[:length-1]
 	} else {
 		req.URL.Path = path + "/"
 	}
diff --git a/json/json.go b/json/json.go
index d2d0f8b3..aa76aa30 100644
--- a/json/json.go
+++ b/json/json.go
@@ -6,9 +6,7 @@
 
 package json
 
-import (
-	"encoding/json"
-)
+import "encoding/json"
 
 var (
 	Marshal       = json.Marshal
diff --git a/json/jsoniter.go b/json/jsoniter.go
index 65deee59..ffe1424a 100644
--- a/json/jsoniter.go
+++ b/json/jsoniter.go
@@ -6,9 +6,7 @@
 
 package json
 
-import (
-	"github.com/json-iterator/go"
-)
+import "github.com/json-iterator/go"
 
 var (
 	json          = jsoniter.ConfigCompatibleWithStandardLibrary

From 80f691159fa5821b654b4b78cee8a5cb4316fcd7 Mon Sep 17 00:00:00 2001
From: Andrii Bubis <firstrow@gmail.com>
Date: Sun, 12 Nov 2017 07:37:32 +0200
Subject: [PATCH 07/32] Added simple testing documentation and examples (#1156)

---
 README.md                   | 46 +++++++++++++++++++++++++++++++++++++
 examples/basic/main.go      |  7 +++++-
 examples/basic/main_test.go | 20 ++++++++++++++++
 3 files changed, 72 insertions(+), 1 deletion(-)
 create mode 100644 examples/basic/main_test.go

diff --git a/README.md b/README.md
index 6b8cdd7e..bffcce37 100644
--- a/README.md
+++ b/README.md
@@ -1344,6 +1344,52 @@ func main() {
 }
 ```
 
+## Testing
+
+The `net/http/httptest` package is preferable way for HTTP testing.
+
+```go
+package main
+
+func setupRouter() *gin.Engine {
+	r := gin.Default()
+	r.GET("/ping", func(c *gin.Context) {
+		c.String(200, "pong")
+	})
+	return r
+}
+
+func main() {
+	r := setupRouter()
+	r.Run(":8080")
+}
+```
+
+Test for code example above:
+
+```go
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPingRoute(t *testing.T) {
+	router := setupRouter()
+
+	w := httptest.NewRecorder()
+	req, _ := http.NewRequest("GET", "/ping", nil)
+	router.ServeHTTP(w, req)
+
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "pong", w.Body.String())
+}
+```
+
 ## Users  [![Sourcegraph](https://sourcegraph.com/github.com/gin-gonic/gin/-/badge.svg)](https://sourcegraph.com/github.com/gin-gonic/gin?badge)
 
 Awesome project lists using [Gin](https://github.com/gin-gonic/gin) web framework.
diff --git a/examples/basic/main.go b/examples/basic/main.go
index 984c06ab..473c6a09 100644
--- a/examples/basic/main.go
+++ b/examples/basic/main.go
@@ -6,7 +6,7 @@ import (
 
 var DB = make(map[string]string)
 
-func main() {
+func setupRouter() *gin.Engine {
 	// Disable Console Color
 	// gin.DisableConsoleColor()
 	r := gin.Default()
@@ -53,6 +53,11 @@ func main() {
 		}
 	})
 
+	return r
+}
+
+func main() {
+	r := setupRouter()
 	// Listen and Server in 0.0.0.0:8080
 	r.Run(":8080")
 }
diff --git a/examples/basic/main_test.go b/examples/basic/main_test.go
new file mode 100644
index 00000000..61203d66
--- /dev/null
+++ b/examples/basic/main_test.go
@@ -0,0 +1,20 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPingRoute(t *testing.T) {
+	router := setupRouter()
+
+	w := httptest.NewRecorder()
+	req, _ := http.NewRequest("GET", "/ping", nil)
+	router.ServeHTTP(w, req)
+
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "pong", w.Body.String())
+}

From ae9f03e6e80212e45427f811683f2a512cc8f506 Mon Sep 17 00:00:00 2001
From: Richard Lee <dlackty@gmail.com>
Date: Sun, 12 Nov 2017 13:56:59 +0800
Subject: [PATCH 08/32] Fix up syntax error in README (#1155)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index bffcce37..7d3b9194 100644
--- a/README.md
+++ b/README.md
@@ -472,7 +472,7 @@ func main() {
 	// Example for binding JSON ({"user": "manu", "password": "123"})
 	router.POST("/loginJSON", func(c *gin.Context) {
 		var json Login
-		if err = c.ShouldBindJSON(&json); err == nil {
+		if err := c.ShouldBindJSON(&json); err == nil {
 			if json.User == "manu" && json.Password == "123" {
 				c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
 			} else {

From 1f377cb847977aeeed30c3e77377c8a9ff7ccff1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Tue, 21 Nov 2017 09:27:57 +0800
Subject: [PATCH 09/32] Add test cases for RunTLS and each mode (#1173)

* add RunTLS test cases and add debug/test mode cases

* add release mode cases
---
 fixtures/testdata/cert.pem |  18 ++++++
 fixtures/testdata/key.pem  |  27 ++++++++
 gin_test.go                | 128 +++++++++++++++++++++++++++++++------
 3 files changed, 155 insertions(+), 18 deletions(-)
 create mode 100644 fixtures/testdata/cert.pem
 create mode 100644 fixtures/testdata/key.pem

diff --git a/fixtures/testdata/cert.pem b/fixtures/testdata/cert.pem
new file mode 100644
index 00000000..c1d3d632
--- /dev/null
+++ b/fixtures/testdata/cert.pem
@@ -0,0 +1,18 @@
+-----BEGIN CERTIFICATE-----
+MIIC9DCCAdygAwIBAgIQUNSK+OxWHYYFxHVJV0IlpDANBgkqhkiG9w0BAQsFADAS
+MRAwDgYDVQQKEwdBY21lIENvMB4XDTE3MTExNjEyMDA0N1oXDTE4MTExNjEyMDA0
+N1owEjEQMA4GA1UEChMHQWNtZSBDbzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCC
+AQoCggEBAKmyj/YZpD59Bpy4w3qf6VzMw9uUBsWp+IP4kl7z5cmGHYUHn/YopTLH
+vR23GAB12p6Km5QWzCBuJF4j61PJXHfg3/rjShZ77JcQ3kzxuy1iKDI+DNKN7Klz
+rdjJ49QD0lczZHeBvvCL7JsJFKFjGy62rnStuW8LaIEdtjXT+GUZTxJh6G7yPYfD
+MS1IsdMQGOdbGwNa+qogMuQPh0TzHw+C73myKrjY6pREijknMC/rnIMz9dLPt6Kl
+xXy4br443dpY6dYGIhDuKhROT+vZ05HKasuuQUFhY7v/KoUpEZMB9rfUSzjQ5fak
+eDUAMniXRcd+DmwvboG2TI6ixmuPK+ECAwEAAaNGMEQwDgYDVR0PAQH/BAQDAgWg
+MBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwDwYDVR0RBAgwBocE
+fwAAATANBgkqhkiG9w0BAQsFAAOCAQEAMXOLvj7BFsxdbcfRPBd0OFrH/8lI7vPV
+LRcJ6r5iv0cnNvZXXbIOQLbg4clJAWjoE08nRm1KvNXhKdns0ELEV86YN2S6jThq
+rIGrBqKtaJLB3M9BtDSiQ6SGPLYrWvmhj3Avi8PbSGy51bpGbqopd16j6LYU7Cp2
+TefMRlOAFtHojpCVon1CMpqcNxS0WNlQ3lUBSrw3HB0o12x++roja2ibF54tSHXB
+KUuadoEzN+mMBwenEBychmAGzdiG4GQHRmhigh85+mtW6UMGiqyCZHs0EgE9FCLL
+sRrsTI/VOzLz6lluygXkOsXrP+PP0SvmE3eylWjj9e2nj/u/Cy2YKg==
+-----END CERTIFICATE-----
diff --git a/fixtures/testdata/key.pem b/fixtures/testdata/key.pem
new file mode 100644
index 00000000..c2a0181f
--- /dev/null
+++ b/fixtures/testdata/key.pem
@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEAqbKP9hmkPn0GnLjDep/pXMzD25QGxan4g/iSXvPlyYYdhQef
+9iilMse9HbcYAHXanoqblBbMIG4kXiPrU8lcd+Df+uNKFnvslxDeTPG7LWIoMj4M
+0o3sqXOt2Mnj1APSVzNkd4G+8IvsmwkUoWMbLraudK25bwtogR22NdP4ZRlPEmHo
+bvI9h8MxLUix0xAY51sbA1r6qiAy5A+HRPMfD4LvebIquNjqlESKOScwL+ucgzP1
+0s+3oqXFfLhuvjjd2ljp1gYiEO4qFE5P69nTkcpqy65BQWFju/8qhSkRkwH2t9RL
+ONDl9qR4NQAyeJdFx34ObC9ugbZMjqLGa48r4QIDAQABAoIBAD5mhd+GMEo2KU9J
+9b/Ku8I/HapJtW/L/7Fvn0tBPncrVQGM+zpGWfDhV95sbGwG6lwwNeNvuqIWPlNL
+vAY0XkdKrrIQEDdSXH50WnpKzXxzwrou7QIj5Cmvevbjzl4xBZDBOilj0XWczmV4
+IljyG5XC4UXQeAaoWEZaSZ1jk8yAt2Zq1Hgg7HqhHsK/arWXBgax+4K5nV/s9gZx
+yjKU9mXTIs7k/aNnZqwQKqcZF+l3mvbZttOaFwsP14H0I8OFWhnM9hie54Dejqxi
+f4/llNxDqUs6lqJfP3qNxtORLcFe75M+Yl8v7g2hkjtLdZBakPzSTEx3TAK/UHgi
+aM8DdxECgYEA3fmg/PI4EgUEj0C3SCmQXR/CnQLMUQgb54s0asp4akvp+M7YCcr1
+pQd3HFUpBwhBcJg5LeSe87vLupY7pHCKk56cl9WY6hse0b9sP/7DWJuGiO62m0E0
+vNjQ2jpG99oR2ROIHHeWsGCpGLmrRT/kY+vR3M+AOLZniXlOCw8k0aUCgYEAw7WL
+XFWLxgZYQYilywqrQmfv1MBfaUCvykO6oWB+f6mmnihSFjecI+nDw/b3yXVYGEgy
+0ebkuw0jP8suC8wBqX9WuXj+9nZNomJRssJyOMiEhDEqUiTztFPSp9pdruoakLTh
+Wk1p9NralOqGPUmxpXlFKVmYRTUbluikVxDypI0CgYBn6sqEQH0hann0+o4TWWn9
+PrYkPUAbm1k8771tVTZERR/W3Dbldr/DL5iCihe39BR2urziEEqdvkglJNntJMar
+TzDuIBADYQjvltb9qq4XGFBGYMLaMg+XbUVxNKEuvUdnwa4R7aZ9EfN34MwekkfA
+w5Cu9/GGG1ajVEfGA6PwBQKBgA3o71jGs8KFXOx7e90sivOTU5Z5fc6LTHNB0Rf7
+NcJ5GmCPWRY/KZfb25AoE4B8GKDRMNt+X69zxZeZJ1KrU0rqxA02rlhyHB54gnoE
+G/4xMkn6/JkOC0w70PMhMBtohC7YzFOQwQEoNPT0nkno3Pl33xSLS6lPlwBo1JVj
+nPtZAoGACXNLXYkR5vexE+w6FGl59r4RQhu1XU8Mr5DIHeB7kXPN3RKbS201M+Tb
+SB5jbu0iDV477XkzSNmhaksFf2wM9MT6CaE+8n3UU5tMa+MmBGgwYTp/i9HkqVh5
+jjpJifn1VWBINd4cpNzwCg9LXoo0tbtUPWwGzqVeyo/YE5GIHGo=
+-----END RSA PRIVATE KEY-----
diff --git a/gin_test.go b/gin_test.go
index bdf5a9a9..57985dce 100644
--- a/gin_test.go
+++ b/gin_test.go
@@ -5,6 +5,7 @@
 package gin
 
 import (
+	"crypto/tls"
 	"fmt"
 	"html/template"
 	"io/ioutil"
@@ -21,9 +22,9 @@ func formatAsDate(t time.Time) string {
 	return fmt.Sprintf("%d/%02d/%02d", year, month, day)
 }
 
-func setupHTMLFiles(t *testing.T) func() {
+func setupHTMLFiles(t *testing.T, mode string, tls bool) func() {
 	go func() {
-		SetMode(TestMode)
+		SetMode(mode)
 		router := New()
 		router.Delims("{[{", "}]}")
 		router.SetFuncMap(template.FuncMap{
@@ -38,16 +39,21 @@ func setupHTMLFiles(t *testing.T) func() {
 				"now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC),
 			})
 		})
-		router.Run(":8888")
+		if tls {
+			// these files generated by `go run $GOROOT/src/crypto/tls/generate_cert.go --host 127.0.0.1`
+			router.RunTLS(":9999", "./fixtures/testdata/cert.pem", "./fixtures/testdata/key.pem")
+		} else {
+			router.Run(":8888")
+		}
 	}()
 	t.Log("waiting 1 second for server startup")
 	time.Sleep(1 * time.Second)
 	return func() {}
 }
 
-func setupHTMLGlob(t *testing.T) func() {
+func setupHTMLGlob(t *testing.T, mode string, tls bool) func() {
 	go func() {
-		SetMode(DebugMode)
+		SetMode(mode)
 		router := New()
 		router.Delims("{[{", "}]}")
 		router.SetFuncMap(template.FuncMap{
@@ -62,16 +68,20 @@ func setupHTMLGlob(t *testing.T) func() {
 				"now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC),
 			})
 		})
-		router.Run(":8888")
+		if tls {
+			// these files generated by `go run $GOROOT/src/crypto/tls/generate_cert.go --host 127.0.0.1`
+			router.RunTLS(":9999", "./fixtures/testdata/cert.pem", "./fixtures/testdata/key.pem")
+		} else {
+			router.Run(":8888")
+		}
 	}()
 	t.Log("waiting 1 second for server startup")
 	time.Sleep(1 * time.Second)
 	return func() {}
 }
 
-//TODO
 func TestLoadHTMLGlob(t *testing.T) {
-	td := setupHTMLGlob(t)
+	td := setupHTMLGlob(t, DebugMode, false)
 	res, err := http.Get("http://127.0.0.1:8888/test")
 	if err != nil {
 		fmt.Println(err)
@@ -83,9 +93,55 @@ func TestLoadHTMLGlob(t *testing.T) {
 	td()
 }
 
+func TestLoadHTMLGlob2(t *testing.T) {
+	td := setupHTMLGlob(t, TestMode, false)
+	res, err := http.Get("http://127.0.0.1:8888/test")
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	resp, _ := ioutil.ReadAll(res.Body)
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+
+	td()
+}
+
+func TestLoadHTMLGlob3(t *testing.T) {
+	td := setupHTMLGlob(t, ReleaseMode, false)
+	res, err := http.Get("http://127.0.0.1:8888/test")
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	resp, _ := ioutil.ReadAll(res.Body)
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+
+	td()
+}
+
+func TestLoadHTMLGlobUsingTLS(t *testing.T) {
+	td := setupHTMLGlob(t, DebugMode, true)
+	// Use InsecureSkipVerify for avoiding `x509: certificate signed by unknown authority` error
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: true,
+		},
+	}
+	client := &http.Client{Transport: tr}
+	res, err := client.Get("https://127.0.0.1:9999/test")
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	resp, _ := ioutil.ReadAll(res.Body)
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+
+	td()
+}
+
 func TestLoadHTMLGlobFromFuncMap(t *testing.T) {
 	time.Now()
-	td := setupHTMLGlob(t)
+	td := setupHTMLGlob(t, DebugMode, false)
 	res, err := http.Get("http://127.0.0.1:8888/raw")
 	if err != nil {
 		fmt.Println(err)
@@ -97,9 +153,6 @@ func TestLoadHTMLGlobFromFuncMap(t *testing.T) {
 	td()
 }
 
-// func (engine *Engine) LoadHTMLFiles(files ...string) {
-// func (engine *Engine) RunTLS(addr string, cert string, key string) error {
-
 func init() {
 	SetMode(TestMode)
 }
@@ -127,7 +180,7 @@ func TestCreateEngine(t *testing.T) {
 // }
 
 func TestLoadHTMLFiles(t *testing.T) {
-	td := setupHTMLFiles(t)
+	td := setupHTMLFiles(t, TestMode, false)
 	res, err := http.Get("http://127.0.0.1:8888/test")
 	if err != nil {
 		fmt.Println(err)
@@ -138,9 +191,52 @@ func TestLoadHTMLFiles(t *testing.T) {
 	td()
 }
 
+func TestLoadHTMLFiles2(t *testing.T) {
+	td := setupHTMLFiles(t, DebugMode, false)
+	res, err := http.Get("http://127.0.0.1:8888/test")
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	resp, _ := ioutil.ReadAll(res.Body)
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+	td()
+}
+
+func TestLoadHTMLFiles3(t *testing.T) {
+	td := setupHTMLFiles(t, ReleaseMode, false)
+	res, err := http.Get("http://127.0.0.1:8888/test")
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	resp, _ := ioutil.ReadAll(res.Body)
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+	td()
+}
+
+func TestLoadHTMLFilesUsingTLS(t *testing.T) {
+	td := setupHTMLFiles(t, TestMode, true)
+	// Use InsecureSkipVerify for avoiding `x509: certificate signed by unknown authority` error
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: true,
+		},
+	}
+	client := &http.Client{Transport: tr}
+	res, err := client.Get("https://127.0.0.1:9999/test")
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	resp, _ := ioutil.ReadAll(res.Body)
+	assert.Equal(t, "<h1>Hello world</h1>", string(resp[:]))
+	td()
+}
+
 func TestLoadHTMLFilesFuncMap(t *testing.T) {
 	time.Now()
-	td := setupHTMLFiles(t)
+	td := setupHTMLFiles(t, TestMode, false)
 	res, err := http.Get("http://127.0.0.1:8888/raw")
 	if err != nil {
 		fmt.Println(err)
@@ -152,10 +248,6 @@ func TestLoadHTMLFilesFuncMap(t *testing.T) {
 	td()
 }
 
-func TestLoadHTMLReleaseMode(t *testing.T) {
-
-}
-
 func TestAddRoute(t *testing.T) {
 	router := New()
 	router.addRoute("GET", "/", HandlersChain{func(_ *Context) {}})

From 7e5aff8ea7456c90f0e362c1e23a192416cbbab7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Tue, 21 Nov 2017 10:03:57 +0800
Subject: [PATCH 10/32] simple code and increase coverage (#1174)

---
 mode.go | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/mode.go b/mode.go
index 393e13ec..394bebee 100644
--- a/mode.go
+++ b/mode.go
@@ -39,16 +39,12 @@ var modeName = DebugMode
 
 func init() {
 	mode := os.Getenv(ENV_GIN_MODE)
-	if mode == "" {
-		SetMode(DebugMode)
-	} else {
-		SetMode(mode)
-	}
+	SetMode(mode)
 }
 
 func SetMode(value string) {
 	switch value {
-	case DebugMode:
+	case DebugMode, "":
 		ginMode = debugCode
 	case ReleaseMode:
 		ginMode = releaseCode

From eeb57848cac06c360a3c262837394051018b8f66 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Tue, 21 Nov 2017 21:18:45 +0800
Subject: [PATCH 11/32] update assert param(expect, actual) position (#1177)

---
 context_test.go     | 286 ++++++++++++++++++++++----------------------
 gin_test.go         |   4 +-
 logger_test.go      |  24 ++--
 mode_test.go        |  16 +--
 path_test.go        |   4 +-
 recovery_test.go    |   4 +-
 routergroup_test.go |  20 ++--
 routes_test.go      | 124 +++++++++----------
 utils_test.go       |  60 +++++-----
 9 files changed, 271 insertions(+), 271 deletions(-)

diff --git a/context_test.go b/context_test.go
index 8cd05f6c..932d9b1d 100644
--- a/context_test.go
+++ b/context_test.go
@@ -180,14 +180,14 @@ func TestContextSetGet(t *testing.T) {
 	c.Set("foo", "bar")
 
 	value, err := c.Get("foo")
-	assert.Equal(t, value, "bar")
+	assert.Equal(t, "bar", value)
 	assert.True(t, err)
 
 	value, err = c.Get("foo2")
 	assert.Nil(t, value)
 	assert.False(t, err)
 
-	assert.Equal(t, c.MustGet("foo"), "bar")
+	assert.Equal(t, "bar", c.MustGet("foo"))
 	assert.Panics(t, func() { c.MustGet("no_exist") })
 }
 
@@ -221,7 +221,7 @@ func TestContextGetString(t *testing.T) {
 func TestContextSetGetBool(t *testing.T) {
 	c, _ := CreateTestContext(httptest.NewRecorder())
 	c.Set("bool", true)
-	assert.Equal(t, true, c.GetBool("bool"))
+	assert.True(t, c.GetBool("bool"))
 }
 
 func TestContextGetInt(t *testing.T) {
@@ -338,26 +338,26 @@ func TestContextQuery(t *testing.T) {
 
 	value, ok := c.GetQuery("foo")
 	assert.True(t, ok)
-	assert.Equal(t, value, "bar")
-	assert.Equal(t, c.DefaultQuery("foo", "none"), "bar")
-	assert.Equal(t, c.Query("foo"), "bar")
+	assert.Equal(t, "bar", value)
+	assert.Equal(t, "bar", c.DefaultQuery("foo", "none"))
+	assert.Equal(t, "bar", c.Query("foo"))
 
 	value, ok = c.GetQuery("page")
 	assert.True(t, ok)
-	assert.Equal(t, value, "10")
-	assert.Equal(t, c.DefaultQuery("page", "0"), "10")
-	assert.Equal(t, c.Query("page"), "10")
+	assert.Equal(t, "10", value)
+	assert.Equal(t, "10", c.DefaultQuery("page", "0"))
+	assert.Equal(t, "10", c.Query("page"))
 
 	value, ok = c.GetQuery("id")
 	assert.True(t, ok)
 	assert.Empty(t, value)
-	assert.Equal(t, c.DefaultQuery("id", "nada"), "")
+	assert.Empty(t, c.DefaultQuery("id", "nada"))
 	assert.Empty(t, c.Query("id"))
 
 	value, ok = c.GetQuery("NoKey")
 	assert.False(t, ok)
 	assert.Empty(t, value)
-	assert.Equal(t, c.DefaultQuery("NoKey", "nada"), "nada")
+	assert.Equal(t, "nada", c.DefaultQuery("NoKey", "nada"))
 	assert.Empty(t, c.Query("NoKey"))
 
 	// postform should not mess
@@ -373,29 +373,29 @@ func TestContextQueryAndPostForm(t *testing.T) {
 	c.Request, _ = http.NewRequest("POST", "/?both=GET&id=main&id=omit&array[]=first&array[]=second", body)
 	c.Request.Header.Add("Content-Type", MIMEPOSTForm)
 
-	assert.Equal(t, c.DefaultPostForm("foo", "none"), "bar")
-	assert.Equal(t, c.PostForm("foo"), "bar")
+	assert.Equal(t, "bar", c.DefaultPostForm("foo", "none"))
+	assert.Equal(t, "bar", c.PostForm("foo"))
 	assert.Empty(t, c.Query("foo"))
 
 	value, ok := c.GetPostForm("page")
 	assert.True(t, ok)
-	assert.Equal(t, value, "11")
-	assert.Equal(t, c.DefaultPostForm("page", "0"), "11")
-	assert.Equal(t, c.PostForm("page"), "11")
-	assert.Equal(t, c.Query("page"), "")
+	assert.Equal(t, "11", value)
+	assert.Equal(t, "11", c.DefaultPostForm("page", "0"))
+	assert.Equal(t, "11", c.PostForm("page"))
+	assert.Empty(t, c.Query("page"))
 
 	value, ok = c.GetPostForm("both")
 	assert.True(t, ok)
 	assert.Empty(t, value)
 	assert.Empty(t, c.PostForm("both"))
-	assert.Equal(t, c.DefaultPostForm("both", "nothing"), "")
-	assert.Equal(t, c.Query("both"), "GET")
+	assert.Empty(t, c.DefaultPostForm("both", "nothing"))
+	assert.Equal(t, "GET", c.Query("both"), "GET")
 
 	value, ok = c.GetQuery("id")
 	assert.True(t, ok)
-	assert.Equal(t, value, "main")
-	assert.Equal(t, c.DefaultPostForm("id", "000"), "000")
-	assert.Equal(t, c.Query("id"), "main")
+	assert.Equal(t, "main", value)
+	assert.Equal(t, "000", c.DefaultPostForm("id", "000"))
+	assert.Equal(t, "main", c.Query("id"))
 	assert.Empty(t, c.PostForm("id"))
 
 	value, ok = c.GetQuery("NoKey")
@@ -404,8 +404,8 @@ func TestContextQueryAndPostForm(t *testing.T) {
 	value, ok = c.GetPostForm("NoKey")
 	assert.False(t, ok)
 	assert.Empty(t, value)
-	assert.Equal(t, c.DefaultPostForm("NoKey", "nada"), "nada")
-	assert.Equal(t, c.DefaultQuery("NoKey", "nothing"), "nothing")
+	assert.Equal(t, "nada", c.DefaultPostForm("NoKey", "nada"))
+	assert.Equal(t, "nothing", c.DefaultQuery("NoKey", "nothing"))
 	assert.Empty(t, c.PostForm("NoKey"))
 	assert.Empty(t, c.Query("NoKey"))
 
@@ -417,11 +417,11 @@ func TestContextQueryAndPostForm(t *testing.T) {
 		Array []string `form:"array[]"`
 	}
 	assert.NoError(t, c.Bind(&obj))
-	assert.Equal(t, obj.Foo, "bar")
-	assert.Equal(t, obj.ID, "main")
-	assert.Equal(t, obj.Page, 11)
-	assert.Equal(t, obj.Both, "")
-	assert.Equal(t, obj.Array, []string{"first", "second"})
+	assert.Equal(t, "bar", obj.Foo, "bar")
+	assert.Equal(t, "main", obj.ID, "main")
+	assert.Equal(t, 11, obj.Page, 11)
+	assert.Empty(t, obj.Both)
+	assert.Equal(t, []string{"first", "second"}, obj.Array)
 
 	values, ok := c.GetQueryArray("array[]")
 	assert.True(t, ok)
@@ -456,37 +456,37 @@ func TestContextPostFormMultipart(t *testing.T) {
 		BlankTime    time.Time `form:"blank_time" time_format:"02/01/2006 15:04"`
 	}
 	assert.NoError(t, c.Bind(&obj))
-	assert.Equal(t, obj.Foo, "bar")
-	assert.Equal(t, obj.Bar, "10")
-	assert.Equal(t, obj.BarAsInt, 10)
-	assert.Equal(t, obj.Array, []string{"first", "second"})
-	assert.Equal(t, obj.ID, "")
-	assert.Equal(t, obj.TimeLocal.Format("02/01/2006 15:04"), "31/12/2016 14:55")
-	assert.Equal(t, obj.TimeLocal.Location(), time.Local)
-	assert.Equal(t, obj.TimeUTC.Format("02/01/2006 15:04"), "31/12/2016 14:55")
-	assert.Equal(t, obj.TimeUTC.Location(), time.UTC)
+	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, "10", obj.Bar)
+	assert.Equal(t, 10, obj.BarAsInt)
+	assert.Equal(t, []string{"first", "second"}, obj.Array)
+	assert.Empty(t, obj.ID)
+	assert.Equal(t, "31/12/2016 14:55", obj.TimeLocal.Format("02/01/2006 15:04"))
+	assert.Equal(t, time.Local, obj.TimeLocal.Location())
+	assert.Equal(t, "31/12/2016 14:55", obj.TimeUTC.Format("02/01/2006 15:04"))
+	assert.Equal(t, time.UTC, obj.TimeUTC.Location())
 	loc, _ := time.LoadLocation("Asia/Tokyo")
-	assert.Equal(t, obj.TimeLocation.Format("02/01/2006 15:04"), "31/12/2016 14:55")
-	assert.Equal(t, obj.TimeLocation.Location(), loc)
+	assert.Equal(t, "31/12/2016 14:55", obj.TimeLocation.Format("02/01/2006 15:04"))
+	assert.Equal(t, loc, obj.TimeLocation.Location())
 	assert.True(t, obj.BlankTime.IsZero())
 
 	value, ok := c.GetQuery("foo")
 	assert.False(t, ok)
 	assert.Empty(t, value)
 	assert.Empty(t, c.Query("bar"))
-	assert.Equal(t, c.DefaultQuery("id", "nothing"), "nothing")
+	assert.Equal(t, "nothing", c.DefaultQuery("id", "nothing"))
 
 	value, ok = c.GetPostForm("foo")
 	assert.True(t, ok)
-	assert.Equal(t, value, "bar")
-	assert.Equal(t, c.PostForm("foo"), "bar")
+	assert.Equal(t, "bar", value)
+	assert.Equal(t, "bar", c.PostForm("foo"))
 
 	value, ok = c.GetPostForm("array")
 	assert.True(t, ok)
-	assert.Equal(t, value, "first")
-	assert.Equal(t, c.PostForm("array"), "first")
+	assert.Equal(t, "first", value)
+	assert.Equal(t, "first", c.PostForm("array"))
 
-	assert.Equal(t, c.DefaultPostForm("bar", "nothing"), "10")
+	assert.Equal(t, "10", c.DefaultPostForm("bar", "nothing"))
 
 	value, ok = c.GetPostForm("id")
 	assert.True(t, ok)
@@ -497,7 +497,7 @@ func TestContextPostFormMultipart(t *testing.T) {
 	value, ok = c.GetPostForm("nokey")
 	assert.False(t, ok)
 	assert.Empty(t, value)
-	assert.Equal(t, c.DefaultPostForm("nokey", "nothing"), "nothing")
+	assert.Equal(t, "nothing", c.DefaultPostForm("nokey", "nothing"))
 
 	values, ok := c.GetPostFormArray("array")
 	assert.True(t, ok)
@@ -519,13 +519,13 @@ func TestContextPostFormMultipart(t *testing.T) {
 func TestContextSetCookie(t *testing.T) {
 	c, _ := CreateTestContext(httptest.NewRecorder())
 	c.SetCookie("user", "gin", 1, "/", "localhost", true, true)
-	assert.Equal(t, c.Writer.Header().Get("Set-Cookie"), "user=gin; Path=/; Domain=localhost; Max-Age=1; HttpOnly; Secure")
+	assert.Equal(t, "user=gin; Path=/; Domain=localhost; Max-Age=1; HttpOnly; Secure", c.Writer.Header().Get("Set-Cookie"))
 }
 
 func TestContextSetCookiePathEmpty(t *testing.T) {
 	c, _ := CreateTestContext(httptest.NewRecorder())
 	c.SetCookie("user", "gin", 1, "", "localhost", true, true)
-	assert.Equal(t, c.Writer.Header().Get("Set-Cookie"), "user=gin; Path=/; Domain=localhost; Max-Age=1; HttpOnly; Secure")
+	assert.Equal(t, "user=gin; Path=/; Domain=localhost; Max-Age=1; HttpOnly; Secure", c.Writer.Header().Get("Set-Cookie"))
 }
 
 func TestContextGetCookie(t *testing.T) {
@@ -533,17 +533,17 @@ func TestContextGetCookie(t *testing.T) {
 	c.Request, _ = http.NewRequest("GET", "/get", nil)
 	c.Request.Header.Set("Cookie", "user=gin")
 	cookie, _ := c.Cookie("user")
-	assert.Equal(t, cookie, "gin")
+	assert.Equal(t, "gin", cookie)
 
 	_, err := c.Cookie("nokey")
 	assert.Error(t, err)
 }
 
 func TestContextBodyAllowedForStatus(t *testing.T) {
-	assert.Equal(t, false, bodyAllowedForStatus(102))
-	assert.Equal(t, false, bodyAllowedForStatus(204))
-	assert.Equal(t, false, bodyAllowedForStatus(304))
-	assert.Equal(t, true, bodyAllowedForStatus(500))
+	assert.False(t, false, bodyAllowedForStatus(102))
+	assert.False(t, false, bodyAllowedForStatus(204))
+	assert.False(t, false, bodyAllowedForStatus(304))
+	assert.True(t, true, bodyAllowedForStatus(500))
 }
 
 type TestPanicRender struct {
@@ -589,7 +589,7 @@ func TestContextRenderNoContentJSON(t *testing.T) {
 	c.JSON(204, H{"foo": "bar"})
 
 	assert.Equal(t, 204, w.Code)
-	assert.Equal(t, "", w.Body.String())
+	assert.Empty(t, w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
@@ -616,7 +616,7 @@ func TestContextRenderNoContentAPIJSON(t *testing.T) {
 	c.JSON(204, H{"foo": "bar"})
 
 	assert.Equal(t, 204, w.Code)
-	assert.Equal(t, "", w.Body.String())
+	assert.Empty(t, w.Body.String())
 	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/vnd.api+json")
 }
 
@@ -628,7 +628,7 @@ func TestContextRenderIndentedJSON(t *testing.T) {
 
 	c.IndentedJSON(201, H{"foo": "bar", "bar": "foo", "nested": H{"foo": "bar"}})
 
-	assert.Equal(t, w.Code, 201)
+	assert.Equal(t, 201, w.Code)
 	assert.Equal(t, "{\n    \"bar\": \"foo\",\n    \"foo\": \"bar\",\n    \"nested\": {\n        \"foo\": \"bar\"\n    }\n}", w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
@@ -641,7 +641,7 @@ func TestContextRenderNoContentIndentedJSON(t *testing.T) {
 	c.IndentedJSON(204, H{"foo": "bar", "bar": "foo", "nested": H{"foo": "bar"}})
 
 	assert.Equal(t, 204, w.Code)
-	assert.Equal(t, "", w.Body.String())
+	assert.Empty(t, w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
@@ -654,9 +654,9 @@ func TestContextRenderSecureJSON(t *testing.T) {
 	router.SecureJsonPrefix("&&&START&&&")
 	c.SecureJSON(201, []string{"foo", "bar"})
 
-	assert.Equal(t, w.Code, 201)
-	assert.Equal(t, w.Body.String(), "&&&START&&&[\"foo\",\"bar\"]")
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/json; charset=utf-8")
+	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, "&&&START&&&[\"foo\",\"bar\"]", w.Body.String())
+	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 // Tests that no Custom JSON is rendered if code is 204
@@ -667,8 +667,8 @@ func TestContextRenderNoContentSecureJSON(t *testing.T) {
 	c.SecureJSON(204, []string{"foo", "bar"})
 
 	assert.Equal(t, 204, w.Code)
-	assert.Equal(t, "", w.Body.String())
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/json; charset=utf-8")
+	assert.Empty(t, w.Body.String())
+	assert.Equal(t, "application/json; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 // Tests that the response executes the templates
@@ -681,9 +681,9 @@ func TestContextRenderHTML(t *testing.T) {
 
 	c.HTML(201, "t", H{"name": "alexandernyquist"})
 
-	assert.Equal(t, w.Code, 201)
-	assert.Equal(t, w.Body.String(), "Hello alexandernyquist")
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/html; charset=utf-8")
+	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, "Hello alexandernyquist", w.Body.String())
+	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 // Tests that no HTML is rendered if code is 204
@@ -696,8 +696,8 @@ func TestContextRenderNoContentHTML(t *testing.T) {
 	c.HTML(204, "t", H{"name": "alexandernyquist"})
 
 	assert.Equal(t, 204, w.Code)
-	assert.Equal(t, "", w.Body.String())
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/html; charset=utf-8")
+	assert.Empty(t, w.Body.String())
+	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 // TestContextXML tests that the response is serialized as XML
@@ -708,9 +708,9 @@ func TestContextRenderXML(t *testing.T) {
 
 	c.XML(201, H{"foo": "bar"})
 
-	assert.Equal(t, w.Code, 201)
-	assert.Equal(t, w.Body.String(), "<map><foo>bar</foo></map>")
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/xml; charset=utf-8")
+	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, "<map><foo>bar</foo></map>", w.Body.String())
+	assert.Equal(t, "application/xml; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 // Tests that no XML is rendered if code is 204
@@ -721,8 +721,8 @@ func TestContextRenderNoContentXML(t *testing.T) {
 	c.XML(204, H{"foo": "bar"})
 
 	assert.Equal(t, 204, w.Code)
-	assert.Equal(t, "", w.Body.String())
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/xml; charset=utf-8")
+	assert.Empty(t, w.Body.String())
+	assert.Equal(t, "application/xml; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 // TestContextString tests that the response is returned
@@ -733,9 +733,9 @@ func TestContextRenderString(t *testing.T) {
 
 	c.String(201, "test %s %d", "string", 2)
 
-	assert.Equal(t, w.Code, 201)
-	assert.Equal(t, w.Body.String(), "test string 2")
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8")
+	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, "test string 2", w.Body.String())
+	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 // Tests that no String is rendered if code is 204
@@ -746,8 +746,8 @@ func TestContextRenderNoContentString(t *testing.T) {
 	c.String(204, "test %s %d", "string", 2)
 
 	assert.Equal(t, 204, w.Code)
-	assert.Equal(t, "", w.Body.String())
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8")
+	assert.Empty(t, w.Body.String())
+	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 // TestContextString tests that the response is returned
@@ -759,9 +759,9 @@ func TestContextRenderHTMLString(t *testing.T) {
 	c.Header("Content-Type", "text/html; charset=utf-8")
 	c.String(201, "<html>%s %d</html>", "string", 3)
 
-	assert.Equal(t, w.Code, 201)
-	assert.Equal(t, w.Body.String(), "<html>string 3</html>")
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/html; charset=utf-8")
+	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, "<html>string 3</html>", w.Body.String())
+	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 // Tests that no HTML String is rendered if code is 204
@@ -773,8 +773,8 @@ func TestContextRenderNoContentHTMLString(t *testing.T) {
 	c.String(204, "<html>%s %d</html>", "string", 3)
 
 	assert.Equal(t, 204, w.Code)
-	assert.Equal(t, "", w.Body.String())
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/html; charset=utf-8")
+	assert.Empty(t, w.Body.String())
+	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 // TestContextData tests that the response can be written from `bytesting`
@@ -785,9 +785,9 @@ func TestContextRenderData(t *testing.T) {
 
 	c.Data(201, "text/csv", []byte(`foo,bar`))
 
-	assert.Equal(t, w.Code, 201)
-	assert.Equal(t, w.Body.String(), "foo,bar")
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/csv")
+	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, "foo,bar", w.Body.String())
+	assert.Equal(t, "text/csv", w.HeaderMap.Get("Content-Type"))
 }
 
 // Tests that no Custom Data is rendered if code is 204
@@ -798,8 +798,8 @@ func TestContextRenderNoContentData(t *testing.T) {
 	c.Data(204, "text/csv", []byte(`foo,bar`))
 
 	assert.Equal(t, 204, w.Code)
-	assert.Equal(t, "", w.Body.String())
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/csv")
+	assert.Empty(t, w.Body.String())
+	assert.Equal(t, "text/csv", w.HeaderMap.Get("Content-Type"))
 }
 
 func TestContextRenderSSE(t *testing.T) {
@@ -826,9 +826,9 @@ func TestContextRenderFile(t *testing.T) {
 	c.Request, _ = http.NewRequest("GET", "/", nil)
 	c.File("./gin.go")
 
-	assert.Equal(t, w.Code, 200)
+	assert.Equal(t, 200, w.Code)
 	assert.Contains(t, w.Body.String(), "func New() *Engine {")
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8")
+	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 // TestContextRenderYAML tests that the response is serialized as YAML
@@ -839,9 +839,9 @@ func TestContextRenderYAML(t *testing.T) {
 
 	c.YAML(201, H{"foo": "bar"})
 
-	assert.Equal(t, w.Code, 201)
-	assert.Equal(t, w.Body.String(), "foo: bar\n")
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "application/x-yaml; charset=utf-8")
+	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, "foo: bar\n", w.Body.String())
+	assert.Equal(t, "application/x-yaml; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 func TestContextHeaders(t *testing.T) {
@@ -849,13 +849,13 @@ func TestContextHeaders(t *testing.T) {
 	c.Header("Content-Type", "text/plain")
 	c.Header("X-Custom", "value")
 
-	assert.Equal(t, c.Writer.Header().Get("Content-Type"), "text/plain")
-	assert.Equal(t, c.Writer.Header().Get("X-Custom"), "value")
+	assert.Equal(t, "text/plain", c.Writer.Header().Get("Content-Type"))
+	assert.Equal(t, "value", c.Writer.Header().Get("X-Custom"))
 
 	c.Header("Content-Type", "text/html")
 	c.Header("X-Custom", "")
 
-	assert.Equal(t, c.Writer.Header().Get("Content-Type"), "text/html")
+	assert.Equal(t, "text/html", c.Writer.Header().Get("Content-Type"))
 	_, exist := c.Writer.Header()["X-Custom"]
 	assert.False(t, exist)
 }
@@ -871,8 +871,8 @@ func TestContextRenderRedirectWithRelativePath(t *testing.T) {
 
 	c.Redirect(301, "/path")
 	c.Writer.WriteHeaderNow()
-	assert.Equal(t, w.Code, 301)
-	assert.Equal(t, w.Header().Get("Location"), "/path")
+	assert.Equal(t, 301, w.Code)
+	assert.Equal(t, "/path", w.Header().Get("Location"))
 }
 
 func TestContextRenderRedirectWithAbsolutePath(t *testing.T) {
@@ -883,8 +883,8 @@ func TestContextRenderRedirectWithAbsolutePath(t *testing.T) {
 	c.Redirect(302, "http://google.com")
 	c.Writer.WriteHeaderNow()
 
-	assert.Equal(t, w.Code, 302)
-	assert.Equal(t, w.Header().Get("Location"), "http://google.com")
+	assert.Equal(t, 302, w.Code)
+	assert.Equal(t, "http://google.com", w.Header().Get("Location"))
 }
 
 func TestContextRenderRedirectWith201(t *testing.T) {
@@ -895,8 +895,8 @@ func TestContextRenderRedirectWith201(t *testing.T) {
 	c.Redirect(201, "/resource")
 	c.Writer.WriteHeaderNow()
 
-	assert.Equal(t, w.Code, 201)
-	assert.Equal(t, w.Header().Get("Location"), "/resource")
+	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, "/resource", w.Header().Get("Location"))
 }
 
 func TestContextRenderRedirectAll(t *testing.T) {
@@ -977,8 +977,8 @@ func TestContextNegotiationFormat(t *testing.T) {
 	c.Request, _ = http.NewRequest("POST", "", nil)
 
 	assert.Panics(t, func() { c.NegotiateFormat() })
-	assert.Equal(t, c.NegotiateFormat(MIMEJSON, MIMEXML), MIMEJSON)
-	assert.Equal(t, c.NegotiateFormat(MIMEHTML, MIMEJSON), MIMEHTML)
+	assert.Equal(t, MIMEJSON, c.NegotiateFormat(MIMEJSON, MIMEXML))
+	assert.Equal(t, MIMEHTML, c.NegotiateFormat(MIMEHTML, MIMEJSON))
 }
 
 func TestContextNegotiationFormatWithAccept(t *testing.T) {
@@ -986,9 +986,9 @@ func TestContextNegotiationFormatWithAccept(t *testing.T) {
 	c.Request, _ = http.NewRequest("POST", "/", nil)
 	c.Request.Header.Add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
 
-	assert.Equal(t, c.NegotiateFormat(MIMEJSON, MIMEXML), MIMEXML)
-	assert.Equal(t, c.NegotiateFormat(MIMEXML, MIMEHTML), MIMEHTML)
-	assert.Equal(t, c.NegotiateFormat(MIMEJSON), "")
+	assert.Equal(t, MIMEXML, c.NegotiateFormat(MIMEJSON, MIMEXML))
+	assert.Equal(t, MIMEHTML, c.NegotiateFormat(MIMEXML, MIMEHTML))
+	assert.Empty(t, c.NegotiateFormat(MIMEJSON))
 }
 
 func TestContextNegotiationFormatCustum(t *testing.T) {
@@ -999,9 +999,9 @@ func TestContextNegotiationFormatCustum(t *testing.T) {
 	c.Accepted = nil
 	c.SetAccepted(MIMEJSON, MIMEXML)
 
-	assert.Equal(t, c.NegotiateFormat(MIMEJSON, MIMEXML), MIMEJSON)
-	assert.Equal(t, c.NegotiateFormat(MIMEXML, MIMEHTML), MIMEXML)
-	assert.Equal(t, c.NegotiateFormat(MIMEJSON), MIMEJSON)
+	assert.Equal(t, MIMEJSON, c.NegotiateFormat(MIMEJSON, MIMEXML))
+	assert.Equal(t, MIMEXML, c.NegotiateFormat(MIMEXML, MIMEHTML))
+	assert.Equal(t, MIMEJSON, c.NegotiateFormat(MIMEJSON))
 }
 
 func TestContextIsAborted(t *testing.T) {
@@ -1027,9 +1027,9 @@ func TestContextAbortWithStatus(t *testing.T) {
 	c.index = 4
 	c.AbortWithStatus(401)
 
-	assert.Equal(t, c.index, abortIndex)
-	assert.Equal(t, c.Writer.Status(), 401)
-	assert.Equal(t, w.Code, 401)
+	assert.Equal(t, abortIndex, c.index)
+	assert.Equal(t, 401, c.Writer.Status())
+	assert.Equal(t, 401, w.Code)
 	assert.True(t, c.IsAborted())
 }
 
@@ -1049,13 +1049,13 @@ func TestContextAbortWithStatusJSON(t *testing.T) {
 
 	c.AbortWithStatusJSON(415, in)
 
-	assert.Equal(t, c.index, abortIndex)
-	assert.Equal(t, c.Writer.Status(), 415)
-	assert.Equal(t, w.Code, 415)
+	assert.Equal(t, abortIndex, c.index)
+	assert.Equal(t, 415, c.Writer.Status())
+	assert.Equal(t, 415, w.Code)
 	assert.True(t, c.IsAborted())
 
 	contentType := w.Header().Get("Content-Type")
-	assert.Equal(t, contentType, "application/json; charset=utf-8")
+	assert.Equal(t, "application/json; charset=utf-8", contentType)
 
 	buf := new(bytes.Buffer)
 	buf.ReadFrom(w.Body)
@@ -1069,7 +1069,7 @@ func TestContextError(t *testing.T) {
 
 	c.Error(errors.New("first error"))
 	assert.Len(t, c.Errors, 1)
-	assert.Equal(t, c.Errors.String(), "Error #01: first error\n")
+	assert.Equal(t, "Error #01: first error\n", c.Errors.String())
 
 	c.Error(&Error{
 		Err:  errors.New("second error"),
@@ -1078,13 +1078,13 @@ func TestContextError(t *testing.T) {
 	})
 	assert.Len(t, c.Errors, 2)
 
-	assert.Equal(t, c.Errors[0].Err, errors.New("first error"))
+	assert.Equal(t, errors.New("first error"), c.Errors[0].Err)
 	assert.Nil(t, c.Errors[0].Meta)
-	assert.Equal(t, c.Errors[0].Type, ErrorTypePrivate)
+	assert.Equal(t, ErrorTypePrivate, c.Errors[0].Type)
 
-	assert.Equal(t, c.Errors[1].Err, errors.New("second error"))
-	assert.Equal(t, c.Errors[1].Meta, "some data 2")
-	assert.Equal(t, c.Errors[1].Type, ErrorTypePublic)
+	assert.Equal(t, errors.New("second error"), c.Errors[1].Err)
+	assert.Equal(t, "some data 2", c.Errors[1].Meta)
+	assert.Equal(t, ErrorTypePublic, c.Errors[1].Type)
 
 	assert.Equal(t, c.Errors.Last(), c.Errors[1])
 
@@ -1102,12 +1102,12 @@ func TestContextTypedError(t *testing.T) {
 	c.Error(errors.New("interno 0")).SetType(ErrorTypePrivate)
 
 	for _, err := range c.Errors.ByType(ErrorTypePublic) {
-		assert.Equal(t, err.Type, ErrorTypePublic)
+		assert.Equal(t, ErrorTypePublic, err.Type)
 	}
 	for _, err := range c.Errors.ByType(ErrorTypePrivate) {
-		assert.Equal(t, err.Type, ErrorTypePrivate)
+		assert.Equal(t, ErrorTypePrivate, err.Type)
 	}
-	assert.Equal(t, c.Errors.Errors(), []string{"externo 0", "interno 0"})
+	assert.Equal(t, []string{"externo 0", "interno 0"}, c.Errors.Errors())
 }
 
 func TestContextAbortWithError(t *testing.T) {
@@ -1116,8 +1116,8 @@ func TestContextAbortWithError(t *testing.T) {
 
 	c.AbortWithError(401, errors.New("bad input")).SetMeta("some input")
 
-	assert.Equal(t, w.Code, 401)
-	assert.Equal(t, c.index, abortIndex)
+	assert.Equal(t, 401, w.Code)
+	assert.Equal(t, abortIndex, c.index)
 	assert.True(t, c.IsAborted())
 }
 
@@ -1148,7 +1148,7 @@ func TestContextClientIP(t *testing.T) {
 
 	// no port
 	c.Request.RemoteAddr = "50.50.50.50"
-	assert.Equal(t, "", c.ClientIP())
+	assert.Empty(t, c.ClientIP())
 }
 
 func TestContextContentType(t *testing.T) {
@@ -1156,7 +1156,7 @@ func TestContextContentType(t *testing.T) {
 	c.Request, _ = http.NewRequest("POST", "/", nil)
 	c.Request.Header.Set("Content-Type", "application/json; charset=utf-8")
 
-	assert.Equal(t, c.ContentType(), "application/json")
+	assert.Equal(t, "application/json", c.ContentType())
 }
 
 func TestContextAutoBindJSON(t *testing.T) {
@@ -1169,8 +1169,8 @@ func TestContextAutoBindJSON(t *testing.T) {
 		Bar string `json:"bar"`
 	}
 	assert.NoError(t, c.Bind(&obj))
-	assert.Equal(t, obj.Bar, "foo")
-	assert.Equal(t, obj.Foo, "bar")
+	assert.Equal(t, "foo", obj.Bar)
+	assert.Equal(t, "bar", obj.Foo)
 	assert.Empty(t, c.Errors)
 }
 
@@ -1186,9 +1186,9 @@ func TestContextBindWithJSON(t *testing.T) {
 		Bar string `json:"bar"`
 	}
 	assert.NoError(t, c.BindJSON(&obj))
-	assert.Equal(t, obj.Bar, "foo")
-	assert.Equal(t, obj.Foo, "bar")
-	assert.Equal(t, w.Body.Len(), 0)
+	assert.Equal(t, "foo", obj.Bar)
+	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, 0, w.Body.Len())
 }
 
 func TestContextBindWithQuery(t *testing.T) {
@@ -1224,7 +1224,7 @@ func TestContextBadAutoBind(t *testing.T) {
 
 	assert.Empty(t, obj.Bar)
 	assert.Empty(t, obj.Foo)
-	assert.Equal(t, w.Code, 400)
+	assert.Equal(t, 400, w.Code)
 	assert.True(t, c.IsAborted())
 }
 
@@ -1238,8 +1238,8 @@ func TestContextAutoShouldBindJSON(t *testing.T) {
 		Bar string `json:"bar"`
 	}
 	assert.NoError(t, c.ShouldBind(&obj))
-	assert.Equal(t, obj.Bar, "foo")
-	assert.Equal(t, obj.Foo, "bar")
+	assert.Equal(t, "foo", obj.Bar)
+	assert.Equal(t, "bar", obj.Foo)
 	assert.Empty(t, c.Errors)
 }
 
@@ -1255,9 +1255,9 @@ func TestContextShouldBindWithJSON(t *testing.T) {
 		Bar string `json:"bar"`
 	}
 	assert.NoError(t, c.ShouldBindJSON(&obj))
-	assert.Equal(t, obj.Bar, "foo")
-	assert.Equal(t, obj.Foo, "bar")
-	assert.Equal(t, w.Body.Len(), 0)
+	assert.Equal(t, "foo", obj.Bar)
+	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, 0, w.Body.Len())
 }
 
 func TestContextShouldBindWithQuery(t *testing.T) {
@@ -1307,7 +1307,7 @@ func TestContextGolangContext(t *testing.T) {
 	assert.Nil(t, c.Value("foo"))
 
 	c.Set("foo", "bar")
-	assert.Equal(t, c.Value("foo"), "bar")
+	assert.Equal(t, "bar", c.Value("foo"))
 	assert.Nil(t, c.Value(1))
 }
 
@@ -1339,7 +1339,7 @@ func TestGetRequestHeaderValue(t *testing.T) {
 	c.Request.Header.Set("Gin-Version", "1.0.0")
 
 	assert.Equal(t, "1.0.0", c.GetHeader("Gin-Version"))
-	assert.Equal(t, "", c.GetHeader("Connection"))
+	assert.Empty(t, c.GetHeader("Connection"))
 }
 
 func TestContextGetRawData(t *testing.T) {
diff --git a/gin_test.go b/gin_test.go
index 57985dce..3ac60577 100644
--- a/gin_test.go
+++ b/gin_test.go
@@ -170,12 +170,12 @@ func TestCreateEngine(t *testing.T) {
 // 	router.LoadHTMLGlob("*.testtmpl")
 // 	r := router.HTMLRender.(render.HTMLDebug)
 // 	assert.Empty(t, r.Files)
-// 	assert.Equal(t, r.Glob, "*.testtmpl")
+// 	assert.Equal(t, "*.testtmpl", r.Glob)
 //
 // 	router.LoadHTMLFiles("index.html.testtmpl", "login.html.testtmpl")
 // 	r = router.HTMLRender.(render.HTMLDebug)
 // 	assert.Empty(t, r.Glob)
-// 	assert.Equal(t, r.Files, []string{"index.html", "login.html"})
+// 	assert.Equal(t, []string{"index.html", "login.html"}, r.Files)
 // 	SetMode(TestMode)
 // }
 
diff --git a/logger_test.go b/logger_test.go
index 62c1366f..74a9659c 100644
--- a/logger_test.go
+++ b/logger_test.go
@@ -82,21 +82,21 @@ func TestLogger(t *testing.T) {
 }
 
 func TestColorForMethod(t *testing.T) {
-	assert.Equal(t, colorForMethod("GET"), string([]byte{27, 91, 57, 55, 59, 52, 52, 109}), "get should be blue")
-	assert.Equal(t, colorForMethod("POST"), string([]byte{27, 91, 57, 55, 59, 52, 54, 109}), "post should be cyan")
-	assert.Equal(t, colorForMethod("PUT"), string([]byte{27, 91, 57, 55, 59, 52, 51, 109}), "put should be yellow")
-	assert.Equal(t, colorForMethod("DELETE"), string([]byte{27, 91, 57, 55, 59, 52, 49, 109}), "delete should be red")
-	assert.Equal(t, colorForMethod("PATCH"), string([]byte{27, 91, 57, 55, 59, 52, 50, 109}), "patch should be green")
-	assert.Equal(t, colorForMethod("HEAD"), string([]byte{27, 91, 57, 55, 59, 52, 53, 109}), "head should be magenta")
-	assert.Equal(t, colorForMethod("OPTIONS"), string([]byte{27, 91, 57, 48, 59, 52, 55, 109}), "options should be white")
-	assert.Equal(t, colorForMethod("TRACE"), string([]byte{27, 91, 48, 109}), "trace is not defined and should be the reset color")
+	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 52, 109}), colorForMethod("GET"), "get should be blue")
+	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 54, 109}), colorForMethod("POST"), "post should be cyan")
+	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 51, 109}), colorForMethod("PUT"), "put should be yellow")
+	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 49, 109}), colorForMethod("DELETE"), "delete should be red")
+	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 50, 109}), colorForMethod("PATCH"), "patch should be green")
+	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 53, 109}), colorForMethod("HEAD"), "head should be magenta")
+	assert.Equal(t, string([]byte{27, 91, 57, 48, 59, 52, 55, 109}), colorForMethod("OPTIONS"), "options should be white")
+	assert.Equal(t, string([]byte{27, 91, 48, 109}), colorForMethod("TRACE"), "trace is not defined and should be the reset color")
 }
 
 func TestColorForStatus(t *testing.T) {
-	assert.Equal(t, colorForStatus(200), string([]byte{27, 91, 57, 55, 59, 52, 50, 109}), "2xx should be green")
-	assert.Equal(t, colorForStatus(301), string([]byte{27, 91, 57, 48, 59, 52, 55, 109}), "3xx should be white")
-	assert.Equal(t, colorForStatus(404), string([]byte{27, 91, 57, 55, 59, 52, 51, 109}), "4xx should be yellow")
-	assert.Equal(t, colorForStatus(2), string([]byte{27, 91, 57, 55, 59, 52, 49, 109}), "other things should be red")
+	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 50, 109}), colorForStatus(200), "2xx should be green")
+	assert.Equal(t, string([]byte{27, 91, 57, 48, 59, 52, 55, 109}), colorForStatus(301), "3xx should be white")
+	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 51, 109}), colorForStatus(404), "4xx should be yellow")
+	assert.Equal(t, string([]byte{27, 91, 57, 55, 59, 52, 49, 109}), colorForStatus(2), "other things should be red")
 }
 
 func TestErrorLogger(t *testing.T) {
diff --git a/mode_test.go b/mode_test.go
index f3b88a12..7eaca823 100644
--- a/mode_test.go
+++ b/mode_test.go
@@ -17,21 +17,21 @@ func init() {
 }
 
 func TestSetMode(t *testing.T) {
-	assert.Equal(t, ginMode, testCode)
-	assert.Equal(t, Mode(), TestMode)
+	assert.Equal(t, testCode, ginMode)
+	assert.Equal(t, TestMode, Mode())
 	os.Unsetenv(ENV_GIN_MODE)
 
 	SetMode(DebugMode)
-	assert.Equal(t, ginMode, debugCode)
-	assert.Equal(t, Mode(), DebugMode)
+	assert.Equal(t, debugCode, ginMode)
+	assert.Equal(t, DebugMode, Mode())
 
 	SetMode(ReleaseMode)
-	assert.Equal(t, ginMode, releaseCode)
-	assert.Equal(t, Mode(), ReleaseMode)
+	assert.Equal(t, releaseCode, ginMode)
+	assert.Equal(t, ReleaseMode, Mode())
 
 	SetMode(TestMode)
-	assert.Equal(t, ginMode, testCode)
-	assert.Equal(t, Mode(), TestMode)
+	assert.Equal(t, testCode, ginMode)
+	assert.Equal(t, TestMode, Mode())
 
 	assert.Panics(t, func() { SetMode("unknown") })
 }
diff --git a/path_test.go b/path_test.go
index bf2e5f62..4a6d945b 100644
--- a/path_test.go
+++ b/path_test.go
@@ -67,8 +67,8 @@ var cleanTests = []struct {
 
 func TestPathClean(t *testing.T) {
 	for _, test := range cleanTests {
-		assert.Equal(t, cleanPath(test.path), test.result)
-		assert.Equal(t, cleanPath(test.result), test.result)
+		assert.Equal(t, test.result, cleanPath(test.path))
+		assert.Equal(t, test.result, cleanPath(test.result))
 	}
 }
 
diff --git a/recovery_test.go b/recovery_test.go
index 4545ba3c..de3b62a5 100644
--- a/recovery_test.go
+++ b/recovery_test.go
@@ -22,7 +22,7 @@ func TestPanicInHandler(t *testing.T) {
 	// RUN
 	w := performRequest(router, "GET", "/recovery")
 	// TEST
-	assert.Equal(t, w.Code, 500)
+	assert.Equal(t, 500, w.Code)
 	assert.Contains(t, buffer.String(), "GET /recovery")
 	assert.Contains(t, buffer.String(), "Oupps, Houston, we have a problem")
 	assert.Contains(t, buffer.String(), "TestPanicInHandler")
@@ -39,5 +39,5 @@ func TestPanicWithAbort(t *testing.T) {
 	// RUN
 	w := performRequest(router, "GET", "/recovery")
 	// TEST
-	assert.Equal(t, w.Code, 400)
+	assert.Equal(t, 400, w.Code)
 }
diff --git a/routergroup_test.go b/routergroup_test.go
index b0589b52..a362e23d 100644
--- a/routergroup_test.go
+++ b/routergroup_test.go
@@ -20,15 +20,15 @@ func TestRouterGroupBasic(t *testing.T) {
 	group.Use(func(c *Context) {})
 
 	assert.Len(t, group.Handlers, 2)
-	assert.Equal(t, group.BasePath(), "/hola")
-	assert.Equal(t, group.engine, router)
+	assert.Equal(t, "/hola", group.BasePath())
+	assert.Equal(t, router, group.engine)
 
 	group2 := group.Group("manu")
 	group2.Use(func(c *Context) {}, func(c *Context) {})
 
 	assert.Len(t, group2.Handlers, 4)
-	assert.Equal(t, group2.BasePath(), "/hola/manu")
-	assert.Equal(t, group2.engine, router)
+	assert.Equal(t, "/hola/manu", group2.BasePath())
+	assert.Equal(t, router, group2.engine)
 }
 
 func TestRouterGroupBasicHandle(t *testing.T) {
@@ -44,10 +44,10 @@ func TestRouterGroupBasicHandle(t *testing.T) {
 func performRequestInGroup(t *testing.T, method string) {
 	router := New()
 	v1 := router.Group("v1", func(c *Context) {})
-	assert.Equal(t, v1.BasePath(), "/v1")
+	assert.Equal(t, "/v1", v1.BasePath())
 
 	login := v1.Group("/login/", func(c *Context) {}, func(c *Context) {})
-	assert.Equal(t, login.BasePath(), "/v1/login/")
+	assert.Equal(t, "/v1/login/", login.BasePath())
 
 	handler := func(c *Context) {
 		c.String(400, "the method was %s and index %d", c.Request.Method, c.index)
@@ -80,12 +80,12 @@ func performRequestInGroup(t *testing.T, method string) {
 	}
 
 	w := performRequest(router, method, "/v1/login/test")
-	assert.Equal(t, w.Code, 400)
-	assert.Equal(t, w.Body.String(), "the method was "+method+" and index 3")
+	assert.Equal(t, 400, w.Code)
+	assert.Equal(t, "the method was "+method+" and index 3", w.Body.String())
 
 	w = performRequest(router, method, "/v1/test")
-	assert.Equal(t, w.Code, 400)
-	assert.Equal(t, w.Body.String(), "the method was "+method+" and index 1")
+	assert.Equal(t, 400, w.Code)
+	assert.Equal(t, "the method was "+method+" and index 1", w.Body.String())
 }
 
 func TestRouterGroupInvalidStatic(t *testing.T) {
diff --git a/routes_test.go b/routes_test.go
index b44b6431..81293907 100644
--- a/routes_test.go
+++ b/routes_test.go
@@ -36,7 +36,7 @@ func testRouteOK(method string, t *testing.T) {
 
 	w := performRequest(r, method, "/test")
 	assert.True(t, passed)
-	assert.Equal(t, w.Code, http.StatusOK)
+	assert.Equal(t, http.StatusOK, w.Code)
 
 	performRequest(r, method, "/test2")
 	assert.True(t, passedAny)
@@ -53,7 +53,7 @@ func testRouteNotOK(method string, t *testing.T) {
 	w := performRequest(router, method, "/test")
 
 	assert.False(t, passed)
-	assert.Equal(t, w.Code, http.StatusNotFound)
+	assert.Equal(t, http.StatusNotFound, w.Code)
 }
 
 // TestSingleRouteOK tests that POST route is correctly invoked.
@@ -74,7 +74,7 @@ func testRouteNotOK2(method string, t *testing.T) {
 	w := performRequest(router, method, "/test")
 
 	assert.False(t, passed)
-	assert.Equal(t, w.Code, http.StatusMethodNotAllowed)
+	assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
 }
 
 func TestRouterMethod(t *testing.T) {
@@ -93,8 +93,8 @@ func TestRouterMethod(t *testing.T) {
 
 	w := performRequest(router, "PUT", "/hey")
 
-	assert.Equal(t, w.Code, 200)
-	assert.Equal(t, w.Body.String(), "called")
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "called", w.Body.String())
 }
 
 func TestRouterGroupRouteOK(t *testing.T) {
@@ -143,43 +143,43 @@ func TestRouteRedirectTrailingSlash(t *testing.T) {
 	router.PUT("/path4/", func(c *Context) {})
 
 	w := performRequest(router, "GET", "/path/")
-	assert.Equal(t, w.Header().Get("Location"), "/path")
-	assert.Equal(t, w.Code, 301)
+	assert.Equal(t, "/path", w.Header().Get("Location"))
+	assert.Equal(t, 301, w.Code)
 
 	w = performRequest(router, "GET", "/path2")
-	assert.Equal(t, w.Header().Get("Location"), "/path2/")
-	assert.Equal(t, w.Code, 301)
+	assert.Equal(t, "/path2/", w.Header().Get("Location"))
+	assert.Equal(t, 301, w.Code)
 
 	w = performRequest(router, "POST", "/path3/")
-	assert.Equal(t, w.Header().Get("Location"), "/path3")
-	assert.Equal(t, w.Code, 307)
+	assert.Equal(t, "/path3", w.Header().Get("Location"))
+	assert.Equal(t, 307, w.Code)
 
 	w = performRequest(router, "PUT", "/path4")
-	assert.Equal(t, w.Header().Get("Location"), "/path4/")
-	assert.Equal(t, w.Code, 307)
+	assert.Equal(t, "/path4/", w.Header().Get("Location"))
+	assert.Equal(t, 307, w.Code)
 
 	w = performRequest(router, "GET", "/path")
-	assert.Equal(t, w.Code, 200)
+	assert.Equal(t, 200, w.Code)
 
 	w = performRequest(router, "GET", "/path2/")
-	assert.Equal(t, w.Code, 200)
+	assert.Equal(t, 200, w.Code)
 
 	w = performRequest(router, "POST", "/path3")
-	assert.Equal(t, w.Code, 200)
+	assert.Equal(t, 200, w.Code)
 
 	w = performRequest(router, "PUT", "/path4/")
-	assert.Equal(t, w.Code, 200)
+	assert.Equal(t, 200, w.Code)
 
 	router.RedirectTrailingSlash = false
 
 	w = performRequest(router, "GET", "/path/")
-	assert.Equal(t, w.Code, 404)
+	assert.Equal(t, 404, w.Code)
 	w = performRequest(router, "GET", "/path2")
-	assert.Equal(t, w.Code, 404)
+	assert.Equal(t, 404, w.Code)
 	w = performRequest(router, "POST", "/path3/")
-	assert.Equal(t, w.Code, 404)
+	assert.Equal(t, 404, w.Code)
 	w = performRequest(router, "PUT", "/path4")
-	assert.Equal(t, w.Code, 404)
+	assert.Equal(t, 404, w.Code)
 }
 
 func TestRouteRedirectFixedPath(t *testing.T) {
@@ -193,20 +193,20 @@ func TestRouteRedirectFixedPath(t *testing.T) {
 	router.POST("/Path4/", func(c *Context) {})
 
 	w := performRequest(router, "GET", "/PATH")
-	assert.Equal(t, w.Header().Get("Location"), "/path")
-	assert.Equal(t, w.Code, 301)
+	assert.Equal(t, "/path", w.Header().Get("Location"))
+	assert.Equal(t, 301, w.Code)
 
 	w = performRequest(router, "GET", "/path2")
-	assert.Equal(t, w.Header().Get("Location"), "/Path2")
-	assert.Equal(t, w.Code, 301)
+	assert.Equal(t, "/Path2", w.Header().Get("Location"))
+	assert.Equal(t, 301, w.Code)
 
 	w = performRequest(router, "POST", "/path3")
-	assert.Equal(t, w.Header().Get("Location"), "/PATH3")
-	assert.Equal(t, w.Code, 307)
+	assert.Equal(t, "/PATH3", w.Header().Get("Location"))
+	assert.Equal(t, 307, w.Code)
 
 	w = performRequest(router, "POST", "/path4")
-	assert.Equal(t, w.Header().Get("Location"), "/Path4/")
-	assert.Equal(t, w.Code, 307)
+	assert.Equal(t, "/Path4/", w.Header().Get("Location"))
+	assert.Equal(t, 307, w.Code)
 }
 
 // TestContextParamsGet tests that a parameter can be parsed from the URL.
@@ -236,10 +236,10 @@ func TestRouteParamsByName(t *testing.T) {
 
 	w := performRequest(router, "GET", "/test/john/smith/is/super/great")
 
-	assert.Equal(t, w.Code, 200)
-	assert.Equal(t, name, "john")
-	assert.Equal(t, lastName, "smith")
-	assert.Equal(t, wild, "/is/super/great")
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "john", name)
+	assert.Equal(t, "smith", lastName)
+	assert.Equal(t, "/is/super/great", wild)
 }
 
 // TestHandleStaticFile - ensure the static file handles properly
@@ -265,15 +265,15 @@ func TestRouteStaticFile(t *testing.T) {
 	w2 := performRequest(router, "GET", "/result")
 
 	assert.Equal(t, w, w2)
-	assert.Equal(t, w.Code, 200)
-	assert.Equal(t, w.Body.String(), "Gin Web Framework")
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8")
+	assert.Equal(t, 200, w.Code)
+	assert.Equal(t, "Gin Web Framework", w.Body.String())
+	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 
 	w3 := performRequest(router, "HEAD", "/using_static/"+filename)
 	w4 := performRequest(router, "HEAD", "/result")
 
 	assert.Equal(t, w3, w4)
-	assert.Equal(t, w3.Code, 200)
+	assert.Equal(t, 200, w3.Code)
 }
 
 // TestHandleStaticDir - ensure the root/sub dir handles properly
@@ -283,9 +283,9 @@ func TestRouteStaticListingDir(t *testing.T) {
 
 	w := performRequest(router, "GET", "/")
 
-	assert.Equal(t, w.Code, 200)
+	assert.Equal(t, 200, w.Code)
 	assert.Contains(t, w.Body.String(), "gin.go")
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/html; charset=utf-8")
+	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
 // TestHandleHeadToDir - ensure the root/sub dir handles properly
@@ -295,7 +295,7 @@ func TestRouteStaticNoListing(t *testing.T) {
 
 	w := performRequest(router, "GET", "/")
 
-	assert.Equal(t, w.Code, 404)
+	assert.Equal(t, 404, w.Code)
 	assert.NotContains(t, w.Body.String(), "gin.go")
 }
 
@@ -310,12 +310,12 @@ func TestRouterMiddlewareAndStatic(t *testing.T) {
 
 	w := performRequest(router, "GET", "/gin.go")
 
-	assert.Equal(t, w.Code, 200)
+	assert.Equal(t, 200, w.Code)
 	assert.Contains(t, w.Body.String(), "package gin")
-	assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8")
+	assert.Equal(t, "text/plain; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 	assert.NotEqual(t, w.HeaderMap.Get("Last-Modified"), "Mon, 02 Jan 2006 15:04:05 MST")
-	assert.Equal(t, w.HeaderMap.Get("Expires"), "Mon, 02 Jan 2006 15:04:05 MST")
-	assert.Equal(t, w.HeaderMap.Get("x-GIN"), "Gin Framework")
+	assert.Equal(t, "Mon, 02 Jan 2006 15:04:05 MST", w.HeaderMap.Get("Expires"))
+	assert.Equal(t, "Gin Framework", w.HeaderMap.Get("x-GIN"))
 }
 
 func TestRouteNotAllowedEnabled(t *testing.T) {
@@ -323,14 +323,14 @@ func TestRouteNotAllowedEnabled(t *testing.T) {
 	router.HandleMethodNotAllowed = true
 	router.POST("/path", func(c *Context) {})
 	w := performRequest(router, "GET", "/path")
-	assert.Equal(t, w.Code, http.StatusMethodNotAllowed)
+	assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
 
 	router.NoMethod(func(c *Context) {
 		c.String(http.StatusTeapot, "responseText")
 	})
 	w = performRequest(router, "GET", "/path")
-	assert.Equal(t, w.Body.String(), "responseText")
-	assert.Equal(t, w.Code, http.StatusTeapot)
+	assert.Equal(t, "responseText", w.Body.String())
+	assert.Equal(t, http.StatusTeapot, w.Code)
 }
 
 func TestRouteNotAllowedDisabled(t *testing.T) {
@@ -338,14 +338,14 @@ func TestRouteNotAllowedDisabled(t *testing.T) {
 	router.HandleMethodNotAllowed = false
 	router.POST("/path", func(c *Context) {})
 	w := performRequest(router, "GET", "/path")
-	assert.Equal(t, w.Code, 404)
+	assert.Equal(t, 404, w.Code)
 
 	router.NoMethod(func(c *Context) {
 		c.String(http.StatusTeapot, "responseText")
 	})
 	w = performRequest(router, "GET", "/path")
-	assert.Equal(t, w.Body.String(), "404 page not found")
-	assert.Equal(t, w.Code, 404)
+	assert.Equal(t, "404 page not found", w.Body.String())
+	assert.Equal(t, 404, w.Code)
 }
 
 func TestRouterNotFound(t *testing.T) {
@@ -372,9 +372,9 @@ func TestRouterNotFound(t *testing.T) {
 	}
 	for _, tr := range testRoutes {
 		w := performRequest(router, "GET", tr.route)
-		assert.Equal(t, w.Code, tr.code)
+		assert.Equal(t, tr.code, w.Code)
 		if w.Code != 404 {
-			assert.Equal(t, fmt.Sprint(w.Header().Get("Location")), tr.location)
+			assert.Equal(t, tr.location, fmt.Sprint(w.Header().Get("Location")))
 		}
 	}
 
@@ -385,20 +385,20 @@ func TestRouterNotFound(t *testing.T) {
 		notFound = true
 	})
 	w := performRequest(router, "GET", "/nope")
-	assert.Equal(t, w.Code, 404)
+	assert.Equal(t, 404, w.Code)
 	assert.True(t, notFound)
 
 	// Test other method than GET (want 307 instead of 301)
 	router.PATCH("/path", func(c *Context) {})
 	w = performRequest(router, "PATCH", "/path/")
-	assert.Equal(t, w.Code, 307)
-	assert.Equal(t, fmt.Sprint(w.Header()), "map[Location:[/path]]")
+	assert.Equal(t, 307, w.Code)
+	assert.Equal(t, "map[Location:[/path]]", fmt.Sprint(w.Header()))
 
 	// Test special case where no node for the prefix "/" exists
 	router = New()
 	router.GET("/a", func(c *Context) {})
 	w = performRequest(router, "GET", "/")
-	assert.Equal(t, w.Code, 404)
+	assert.Equal(t, 404, w.Code)
 }
 
 func TestRouteRawPath(t *testing.T) {
@@ -409,15 +409,15 @@ func TestRouteRawPath(t *testing.T) {
 		name := c.Params.ByName("name")
 		num := c.Params.ByName("num")
 
-		assert.Equal(t, c.Param("name"), name)
-		assert.Equal(t, c.Param("num"), num)
+		assert.Equal(t, name, c.Param("name"))
+		assert.Equal(t, num, c.Param("num"))
 
 		assert.Equal(t, "Some/Other/Project", name)
 		assert.Equal(t, "222", num)
 	})
 
 	w := performRequest(route, "POST", "/project/Some%2FOther%2FProject/build/222")
-	assert.Equal(t, w.Code, 200)
+	assert.Equal(t, 200, w.Code)
 }
 
 func TestRouteRawPathNoUnescape(t *testing.T) {
@@ -429,15 +429,15 @@ func TestRouteRawPathNoUnescape(t *testing.T) {
 		name := c.Params.ByName("name")
 		num := c.Params.ByName("num")
 
-		assert.Equal(t, c.Param("name"), name)
-		assert.Equal(t, c.Param("num"), num)
+		assert.Equal(t, name, c.Param("name"))
+		assert.Equal(t, num, c.Param("num"))
 
 		assert.Equal(t, "Some%2FOther%2FProject", name)
 		assert.Equal(t, "333", num)
 	})
 
 	w := performRequest(route, "POST", "/project/Some%2FOther%2FProject/build/333")
-	assert.Equal(t, w.Code, 200)
+	assert.Equal(t, 200, w.Code)
 }
 
 func TestRouteServeErrorWithWriteHeader(t *testing.T) {
diff --git a/utils_test.go b/utils_test.go
index 599172fe..3d019e7e 100644
--- a/utils_test.go
+++ b/utils_test.go
@@ -21,8 +21,8 @@ type testStruct struct {
 }
 
 func (t *testStruct) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	assert.Equal(t.T, req.Method, "POST")
-	assert.Equal(t.T, req.URL.Path, "/path")
+	assert.Equal(t.T, "POST", req.Method)
+	assert.Equal(t.T, "/path", req.URL.Path)
 	w.WriteHeader(500)
 	fmt.Fprint(w, "hello")
 }
@@ -31,50 +31,50 @@ func TestWrap(t *testing.T) {
 	router := New()
 	router.POST("/path", WrapH(&testStruct{t}))
 	router.GET("/path2", WrapF(func(w http.ResponseWriter, req *http.Request) {
-		assert.Equal(t, req.Method, "GET")
-		assert.Equal(t, req.URL.Path, "/path2")
+		assert.Equal(t, "GET", req.Method)
+		assert.Equal(t, "/path2", req.URL.Path)
 		w.WriteHeader(400)
 		fmt.Fprint(w, "hola!")
 	}))
 
 	w := performRequest(router, "POST", "/path")
-	assert.Equal(t, w.Code, 500)
-	assert.Equal(t, w.Body.String(), "hello")
+	assert.Equal(t, 500, w.Code)
+	assert.Equal(t, "hello", w.Body.String())
 
 	w = performRequest(router, "GET", "/path2")
-	assert.Equal(t, w.Code, 400)
-	assert.Equal(t, w.Body.String(), "hola!")
+	assert.Equal(t, 400, w.Code)
+	assert.Equal(t, "hola!", w.Body.String())
 }
 
 func TestLastChar(t *testing.T) {
-	assert.Equal(t, lastChar("hola"), uint8('a'))
-	assert.Equal(t, lastChar("adios"), uint8('s'))
+	assert.Equal(t, uint8('a'), lastChar("hola"))
+	assert.Equal(t, uint8('s'), lastChar("adios"))
 	assert.Panics(t, func() { lastChar("") })
 }
 
 func TestParseAccept(t *testing.T) {
 	parts := parseAccept("text/html , application/xhtml+xml,application/xml;q=0.9,  */* ;q=0.8")
 	assert.Len(t, parts, 4)
-	assert.Equal(t, parts[0], "text/html")
-	assert.Equal(t, parts[1], "application/xhtml+xml")
-	assert.Equal(t, parts[2], "application/xml")
-	assert.Equal(t, parts[3], "*/*")
+	assert.Equal(t, "text/html", parts[0])
+	assert.Equal(t, "application/xhtml+xml", parts[1])
+	assert.Equal(t, "application/xml", parts[2])
+	assert.Equal(t, "*/*", parts[3])
 }
 
 func TestChooseData(t *testing.T) {
 	A := "a"
 	B := "b"
-	assert.Equal(t, chooseData(A, B), A)
-	assert.Equal(t, chooseData(nil, B), B)
+	assert.Equal(t, A, chooseData(A, B))
+	assert.Equal(t, B, chooseData(nil, B))
 	assert.Panics(t, func() { chooseData(nil, nil) })
 }
 
 func TestFilterFlags(t *testing.T) {
 	result := filterFlags("text/html ")
-	assert.Equal(t, result, "text/html")
+	assert.Equal(t, "text/html", result)
 
 	result = filterFlags("text/html;")
-	assert.Equal(t, result, "text/html")
+	assert.Equal(t, "text/html", result)
 }
 
 func TestFunctionName(t *testing.T) {
@@ -86,16 +86,16 @@ func somefunction() {
 }
 
 func TestJoinPaths(t *testing.T) {
-	assert.Equal(t, joinPaths("", ""), "")
-	assert.Equal(t, joinPaths("", "/"), "/")
-	assert.Equal(t, joinPaths("/a", ""), "/a")
-	assert.Equal(t, joinPaths("/a/", ""), "/a/")
-	assert.Equal(t, joinPaths("/a/", "/"), "/a/")
-	assert.Equal(t, joinPaths("/a", "/"), "/a/")
-	assert.Equal(t, joinPaths("/a", "/hola"), "/a/hola")
-	assert.Equal(t, joinPaths("/a/", "/hola"), "/a/hola")
-	assert.Equal(t, joinPaths("/a/", "/hola/"), "/a/hola/")
-	assert.Equal(t, joinPaths("/a/", "/hola//"), "/a/hola/")
+	assert.Equal(t, "", joinPaths("", ""))
+	assert.Equal(t, "/", joinPaths("", "/"))
+	assert.Equal(t, "/a", joinPaths("/a", ""))
+	assert.Equal(t, "/a/", joinPaths("/a/", ""))
+	assert.Equal(t, "/a/", joinPaths("/a/", "/"))
+	assert.Equal(t, "/a/", joinPaths("/a", "/"))
+	assert.Equal(t, "/a/hola", joinPaths("/a", "/hola"))
+	assert.Equal(t, "/a/hola", joinPaths("/a/", "/hola"))
+	assert.Equal(t, "/a/hola/", joinPaths("/a/", "/hola/"))
+	assert.Equal(t, "/a/hola/", joinPaths("/a/", "/hola//"))
 }
 
 type bindTestStruct struct {
@@ -113,8 +113,8 @@ func TestBindMiddleware(t *testing.T) {
 	})
 	performRequest(router, "GET", "/?foo=hola&bar=10")
 	assert.True(t, called)
-	assert.Equal(t, value.Foo, "hola")
-	assert.Equal(t, value.Bar, 10)
+	assert.Equal(t, "hola", value.Foo)
+	assert.Equal(t, 10, value.Bar)
 
 	called = false
 	performRequest(router, "GET", "/?foo=hola&bar=1")

From 6f94fd05c98d1043e329398f6f742dc680be9b29 Mon Sep 17 00:00:00 2001
From: Boris Borshevsky <BorisBorshevsky@gmail.com>
Date: Wed, 29 Nov 2017 04:50:14 +0200
Subject: [PATCH 12/32] Linting and optimizing struct memory signature. (#1184)

* fix cleanPath spell (#969)

* linter and optimize structs
---
 README.md                            |  2 +-
 benchmarks_test.go                   |  2 --
 binding/form_mapping.go              |  9 ---------
 errors.go                            |  2 +-
 examples/custom-validation/server.go |  2 +-
 examples/realtime-advanced/stats.go  |  4 ++--
 gin.go                               | 21 +++++++++++----------
 gin_integration_test.go              |  2 +-
 mode.go                              |  6 +++---
 tree.go                              | 14 +++++++-------
 tree_test.go                         | 11 -----------
 11 files changed, 27 insertions(+), 48 deletions(-)

diff --git a/README.md b/README.md
index 7d3b9194..3ac051a4 100644
--- a/README.md
+++ b/README.md
@@ -540,7 +540,7 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
-	validator "gopkg.in/go-playground/validator.v8"
+	"gopkg.in/go-playground/validator.v8"
 )
 
 type Booking struct {
diff --git a/benchmarks_test.go b/benchmarks_test.go
index a2c62ba3..e7970034 100644
--- a/benchmarks_test.go
+++ b/benchmarks_test.go
@@ -59,8 +59,6 @@ func BenchmarkOneRouteJSON(B *testing.B) {
 	runRequest(B, router, "GET", "/json")
 }
 
-var htmlContentType = []string{"text/html; charset=utf-8"}
-
 func BenchmarkOneRouteHTML(B *testing.B) {
 	router := New()
 	t := template.Must(template.New("index").Parse(`
diff --git a/binding/form_mapping.go b/binding/form_mapping.go
index c968dc08..dd8c6246 100644
--- a/binding/form_mapping.go
+++ b/binding/form_mapping.go
@@ -179,12 +179,3 @@ func setTimeField(val string, structField reflect.StructField, value reflect.Val
 	value.Set(reflect.ValueOf(t))
 	return nil
 }
-
-// Don't pass in pointers to bind to. Can lead to bugs. See:
-// https://github.com/codegangsta/martini-contrib/issues/40
-// https://github.com/codegangsta/martini-contrib/pull/34#issuecomment-29683659
-func ensureNotPointer(obj interface{}) {
-	if reflect.TypeOf(obj).Kind() == reflect.Ptr {
-		panic("Pointers are not accepted as binding models")
-	}
-}
diff --git a/errors.go b/errors.go
index 6f3c9868..dbfccd85 100644
--- a/errors.go
+++ b/errors.go
@@ -148,7 +148,7 @@ func (a errorMsgs) String() string {
 	}
 	var buffer bytes.Buffer
 	for i, msg := range a {
-		fmt.Fprintf(&buffer, "Error #%02d: %s\n", (i + 1), msg.Err)
+		fmt.Fprintf(&buffer, "Error #%02d: %s\n", i+1, msg.Err)
 		if msg.Meta != nil {
 			fmt.Fprintf(&buffer, "     Meta: %v\n", msg.Meta)
 		}
diff --git a/examples/custom-validation/server.go b/examples/custom-validation/server.go
index 0b67ce10..31d449f0 100644
--- a/examples/custom-validation/server.go
+++ b/examples/custom-validation/server.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
-	validator "gopkg.in/go-playground/validator.v8"
+	"gopkg.in/go-playground/validator.v8"
 )
 
 type Booking struct {
diff --git a/examples/realtime-advanced/stats.go b/examples/realtime-advanced/stats.go
index 4bca3ae4..4afedcb5 100644
--- a/examples/realtime-advanced/stats.go
+++ b/examples/realtime-advanced/stats.go
@@ -29,8 +29,8 @@ func statsWorker() {
 			"timestamp":  uint64(time.Now().Unix()),
 			"HeapInuse":  stats.HeapInuse,
 			"StackInuse": stats.StackInuse,
-			"Mallocs":    (stats.Mallocs - lastMallocs),
-			"Frees":      (stats.Frees - lastFrees),
+			"Mallocs":    stats.Mallocs - lastMallocs,
+			"Frees":      stats.Frees - lastFrees,
 			"Inbound":    uint64(messages.Get("inbound")),
 			"Outbound":   uint64(messages.Get("outbound")),
 			"Connected":  connectedUsers(),
diff --git a/gin.go b/gin.go
index b59712bf..edcb9193 100644
--- a/gin.go
+++ b/gin.go
@@ -49,16 +49,6 @@ type RoutesInfo []RouteInfo
 // Create an instance of Engine, by using New() or Default()
 type Engine struct {
 	RouterGroup
-	delims           render.Delims
-	secureJsonPrefix string
-	HTMLRender       render.HTMLRender
-	FuncMap          template.FuncMap
-	allNoRoute       HandlersChain
-	allNoMethod      HandlersChain
-	noRoute          HandlersChain
-	noMethod         HandlersChain
-	pool             sync.Pool
-	trees            methodTrees
 
 	// Enables automatic redirection if the current route can't be matched but a
 	// handler for the path with (without) the trailing slash exists.
@@ -102,6 +92,17 @@ type Engine struct {
 	// Value of 'maxMemory' param that is given to http.Request's ParseMultipartForm
 	// method call.
 	MaxMultipartMemory int64
+
+	delims           render.Delims
+	secureJsonPrefix string
+	HTMLRender       render.HTMLRender
+	FuncMap          template.FuncMap
+	allNoRoute       HandlersChain
+	allNoMethod      HandlersChain
+	noRoute          HandlersChain
+	noMethod         HandlersChain
+	pool             sync.Pool
+	trees            methodTrees
 }
 
 var _ IRouter = &Engine{}
diff --git a/gin_integration_test.go b/gin_integration_test.go
index f45dd6c1..52f78842 100644
--- a/gin_integration_test.go
+++ b/gin_integration_test.go
@@ -94,7 +94,7 @@ func TestUnixSocket(t *testing.T) {
 	c, err := net.Dial("unix", "/tmp/unix_unit_test")
 	assert.NoError(t, err)
 
-	fmt.Fprintf(c, "GET /example HTTP/1.0\r\n\r\n")
+	fmt.Fprint(c, "GET /example HTTP/1.0\r\n\r\n")
 	scanner := bufio.NewScanner(c)
 	var response string
 	for scanner.Scan() {
diff --git a/mode.go b/mode.go
index 394bebee..9c4f0246 100644
--- a/mode.go
+++ b/mode.go
@@ -14,9 +14,9 @@ import (
 const ENV_GIN_MODE = "GIN_MODE"
 
 const (
-	DebugMode   string = "debug"
-	ReleaseMode string = "release"
-	TestMode    string = "test"
+	DebugMode   = "debug"
+	ReleaseMode = "release"
+	TestMode    = "test"
 )
 const (
 	debugCode = iota
diff --git a/tree.go b/tree.go
index f67edd5d..20e3704b 100644
--- a/tree.go
+++ b/tree.go
@@ -87,13 +87,13 @@ const (
 
 type node struct {
 	path      string
-	wildChild bool
-	nType     nodeType
-	maxParams uint8
 	indices   string
 	children  []*node
 	handlers  HandlersChain
 	priority  uint32
+	nType     nodeType
+	maxParams uint8
+	wildChild bool
 }
 
 // increments priority of the given child and reorders if necessary.
@@ -384,7 +384,7 @@ walk: // Outer loop for walking the tree
 					// Nothing found.
 					// We can recommend to redirect to the same URL without a
 					// trailing slash if a leaf exists for that path.
-					tsr = (path == "/" && n.handlers != nil)
+					tsr = path == "/" && n.handlers != nil
 					return
 				}
 
@@ -424,7 +424,7 @@ walk: // Outer loop for walking the tree
 						}
 
 						// ... but we can't
-						tsr = (len(path) == end+1)
+						tsr = len(path) == end+1
 						return
 					}
 
@@ -435,7 +435,7 @@ walk: // Outer loop for walking the tree
 						// No handle found. Check if a handle for this path + a
 						// trailing slash exists for TSR recommendation
 						n = n.children[0]
-						tsr = (n.path == "/" && n.handlers != nil)
+						tsr = n.path == "/" && n.handlers != nil
 					}
 
 					return
@@ -530,7 +530,7 @@ func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPa
 
 				// Nothing found. We can recommend to redirect to the same URL
 				// without a trailing slash if a leaf exists for that path
-				found = (fixTrailingSlash && path == "/" && n.handlers != nil)
+				found = fixTrailingSlash && path == "/" && n.handlers != nil
 				return
 			}
 
diff --git a/tree_test.go b/tree_test.go
index c0edd42b..5bc27171 100644
--- a/tree_test.go
+++ b/tree_test.go
@@ -5,22 +5,11 @@
 package gin
 
 import (
-	"fmt"
 	"reflect"
 	"strings"
 	"testing"
 )
 
-func printChildren(n *node, prefix string) {
-	fmt.Printf(" %02d:%02d %s%s[%d] %v %t %d \r\n", n.priority, n.maxParams, prefix, n.path, len(n.children), n.handlers, n.wildChild, n.nType)
-	for l := len(n.path); l > 0; l-- {
-		prefix += " "
-	}
-	for _, child := range n.children {
-		printChildren(child, prefix)
-	}
-}
-
 // Used as a workaround since we can't compare functions or their addressses
 var fakeHandlerValue string
 

From 9e895470ddd40a45f28dbe4e96bfb5e893d54f9e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Wed, 29 Nov 2017 16:42:51 +0800
Subject: [PATCH 13/32] add deprecated test case (#1176)

* add deprecated test case

* swap assert param

* remove
---
 context_test.go    | 25 +++++++++++++++++++++++++
 deprecated_test.go | 31 +++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+)
 create mode 100644 deprecated_test.go

diff --git a/context_test.go b/context_test.go
index 932d9b1d..9024cfc1 100644
--- a/context_test.go
+++ b/context_test.go
@@ -676,6 +676,7 @@ func TestContextRenderNoContentSecureJSON(t *testing.T) {
 func TestContextRenderHTML(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, router := CreateTestContext(w)
+
 	templ := template.Must(template.New("t").Parse(`Hello {{.name}}`))
 	router.SetHTMLTemplate(templ)
 
@@ -686,6 +687,30 @@ func TestContextRenderHTML(t *testing.T) {
 	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
 }
 
+func TestContextRenderHTML2(t *testing.T) {
+	w := httptest.NewRecorder()
+	c, router := CreateTestContext(w)
+
+	// print debug warning log when Engine.trees > 0
+	router.addRoute("GET", "/", HandlersChain{func(_ *Context) {}})
+	assert.Len(t, router.trees, 1)
+
+	var b bytes.Buffer
+	setup(&b)
+	defer teardown()
+
+	templ := template.Must(template.New("t").Parse(`Hello {{.name}}`))
+	router.SetHTMLTemplate(templ)
+
+	assert.Equal(t, "[GIN-debug] [WARNING] Since SetHTMLTemplate() is NOT thread-safe. It should only be called\nat initialization. ie. before any route is registered or the router is listening in a socket:\n\n\trouter := gin.Default()\n\trouter.SetHTMLTemplate(template) // << good place\n\n", b.String())
+
+	c.HTML(201, "t", H{"name": "alexandernyquist"})
+
+	assert.Equal(t, 201, w.Code)
+	assert.Equal(t, "Hello alexandernyquist", w.Body.String())
+	assert.Equal(t, "text/html; charset=utf-8", w.HeaderMap.Get("Content-Type"))
+}
+
 // Tests that no HTML is rendered if code is 204
 func TestContextRenderNoContentHTML(t *testing.T) {
 	w := httptest.NewRecorder()
diff --git a/deprecated_test.go b/deprecated_test.go
new file mode 100644
index 00000000..7a875fe4
--- /dev/null
+++ b/deprecated_test.go
@@ -0,0 +1,31 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"bytes"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin/binding"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBindWith(t *testing.T) {
+	w := httptest.NewRecorder()
+	c, _ := CreateTestContext(w)
+
+	c.Request, _ = http.NewRequest("POST", "/?foo=bar&bar=foo", bytes.NewBufferString("foo=unused"))
+
+	var obj struct {
+		Foo string `form:"foo"`
+		Bar string `form:"bar"`
+	}
+	assert.NoError(t, c.BindWith(&obj, binding.Form))
+	assert.Equal(t, "foo", obj.Bar)
+	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, 0, w.Body.Len())
+}

From 13a40fcd2c2807e872768b725d1abe32ecd4712f Mon Sep 17 00:00:00 2001
From: Max Hilbrunner <mhilbrunner@users.noreply.github.com>
Date: Sat, 16 Dec 2017 17:52:07 +0100
Subject: [PATCH 14/32] README: Small update to clarify on Goroutines (#1199)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 3ac051a4..046752f4 100644
--- a/README.md
+++ b/README.md
@@ -1071,7 +1071,7 @@ func main() {
 
 ### Goroutines inside a middleware
 
-When starting inside a middleware or handler, you **SHOULD NOT** use the original context inside it, you have to use a read-only copy.
+When starting new Goroutines inside a middleware or handler, you **SHOULD NOT** use the original context inside it, you have to use a read-only copy.
 
 ```go
 func main() {

From 25e7cd75ed51f2e3ef2315e836fe8100608a3c47 Mon Sep 17 00:00:00 2001
From: TaeJun Park <miking38@gmail.com>
Date: Sun, 17 Dec 2017 09:05:30 +0900
Subject: [PATCH 15/32] Update README.md (#1188)

change path from '~/go/...' to '$GOPATH/...'
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 046752f4..3e1af556 100644
--- a/README.md
+++ b/README.md
@@ -117,7 +117,7 @@ $ go get github.com/kardianos/govendor
 2. Create your project folder and `cd` inside
 
 ```sh
-$ mkdir -p ~/go/src/github.com/myusername/project && cd "$_"
+$ mkdir -p $GOPATH/src/github.com/myusername/project && cd "$_"
 ```
 
 3. Vendor init your project and add gin

From b70b8ab20c6f15732226fbd536e28f138629a046 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Sun, 17 Dec 2017 13:02:33 +0800
Subject: [PATCH 16/32] use lower if the struct is private (#1185)

---
 auth.go      | 12 ++++++------
 auth_test.go | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/auth.go b/auth.go
index 302a4fad..c2143091 100644
--- a/auth.go
+++ b/auth.go
@@ -17,8 +17,8 @@ const AuthUserKey = "user"
 type Accounts map[string]string
 
 type authPair struct {
-	Value string
-	User  string
+	value string
+	user  string
 }
 
 type authPairs []authPair
@@ -28,8 +28,8 @@ func (a authPairs) searchCredential(authValue string) (string, bool) {
 		return "", false
 	}
 	for _, pair := range a {
-		if pair.Value == authValue {
-			return pair.User, true
+		if pair.value == authValue {
+			return pair.user, true
 		}
 	}
 	return "", false
@@ -74,8 +74,8 @@ func processAccounts(accounts Accounts) authPairs {
 		assert1(user != "", "User can not be empty")
 		value := authorizationHeader(user, password)
 		pairs = append(pairs, authPair{
-			Value: value,
-			User:  user,
+			value: value,
+			user:  user,
 		})
 	}
 	return pairs
diff --git a/auth_test.go b/auth_test.go
index 2f1ae70e..dc8523b0 100644
--- a/auth_test.go
+++ b/auth_test.go
@@ -22,16 +22,16 @@ func TestBasicAuth(t *testing.T) {
 
 	assert.Len(t, pairs, 3)
 	assert.Contains(t, pairs, authPair{
-		User:  "bar",
-		Value: "Basic YmFyOmZvbw==",
+		user:  "bar",
+		value: "Basic YmFyOmZvbw==",
 	})
 	assert.Contains(t, pairs, authPair{
-		User:  "foo",
-		Value: "Basic Zm9vOmJhcg==",
+		user:  "foo",
+		value: "Basic Zm9vOmJhcg==",
 	})
 	assert.Contains(t, pairs, authPair{
-		User:  "admin",
-		Value: "Basic YWRtaW46cGFzc3dvcmQ=",
+		user:  "admin",
+		value: "Basic YWRtaW46cGFzc3dvcmQ=",
 	})
 }
 

From 46662e700bd20289503475770dbf0384e43398eb Mon Sep 17 00:00:00 2001
From: Himanshu Mishra <OrkoHunter@users.noreply.github.com>
Date: Wed, 20 Dec 2017 07:02:39 +0530
Subject: [PATCH 17/32] Doc: Fix typo in documentation of Bind (#1204)

---
 context.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/context.go b/context.go
index 1ed65fed..90d4c6e5 100644
--- a/context.go
+++ b/context.go
@@ -449,10 +449,10 @@ func (c *Context) SaveUploadedFile(file *multipart.FileHeader, dst string) error
 // Depending the "Content-Type" header different bindings are used:
 //     "application/json" --> JSON binding
 //     "application/xml"  --> XML binding
-// otherwise --> returns an error
+// otherwise --> returns an error.
 // It parses the request's body as JSON if Content-Type == "application/json" using JSON or XML as a JSON input.
 // It decodes the json payload into the struct specified as a pointer.
-// It will writes a 400 error and sets Content-Type header "text/plain" in the response if input is not valid.
+// It writes a 400 error and sets Content-Type header "text/plain" in the response if input is not valid.
 func (c *Context) Bind(obj interface{}) error {
 	b := binding.Default(c.Request.Method, c.ContentType())
 	return c.MustBindWith(obj, b)

From 05547037e47317954d30d9858ef2015607483739 Mon Sep 17 00:00:00 2001
From: Levi Olson <olson.levi@gmail.com>
Date: Wed, 20 Dec 2017 20:48:11 -0600
Subject: [PATCH 18/32] Minor grammatical correction in README (#1206)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 3e1af556..63137883 100644
--- a/README.md
+++ b/README.md
@@ -385,7 +385,7 @@ func main() {
 	r := gin.New()
 
 	// Global middleware
-	// Logger middleware will write the logs to gin.DefaultWriter even you set with GIN_MODE=release.
+	// Logger middleware will write the logs to gin.DefaultWriter even if you set with GIN_MODE=release.
 	// By default gin.DefaultWriter = os.Stdout
 	r.Use(gin.Logger())
 

From a816f9e9dbf820d7d01e8d363539da976fb8aa40 Mon Sep 17 00:00:00 2001
From: Weilin Shi <934587911@qq.com>
Date: Thu, 21 Dec 2017 11:00:17 +0800
Subject: [PATCH 19/32] Remove redundant if err != nil check (#1202)

* Remove redundant if err != nil check

* Return e.EncodeToken instead of create a new variable
---
 render/render_test.go | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/render/render_test.go b/render/render_test.go
index e4df5b6d..35662cf3 100644
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -111,10 +111,8 @@ func (h xmlmap) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
 			return err
 		}
 	}
-	if err := e.EncodeToken(xml.EndElement{Name: start.Name}); err != nil {
-		return err
-	}
-	return nil
+
+	return e.EncodeToken(xml.EndElement{Name: start.Name})
 }
 
 func TestRenderXML(t *testing.T) {

From 6626358d4fefa40ec37ca4b502c6c7d0cdea6d18 Mon Sep 17 00:00:00 2001
From: Weilin Shi <934587911@qq.com>
Date: Mon, 25 Dec 2017 13:58:02 +0800
Subject: [PATCH 20/32] Fix golint warnings in utils.go (#1209)

---
 utils.go | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/utils.go b/utils.go
index e909bb70..99d19af4 100644
--- a/utils.go
+++ b/utils.go
@@ -33,18 +33,23 @@ func Bind(val interface{}) HandlerFunc {
 	}
 }
 
+// WrapF is a helper function for wrapping http.HandlerFunc
+// Returns a Gin middleware
 func WrapF(f http.HandlerFunc) HandlerFunc {
 	return func(c *Context) {
 		f(c.Writer, c.Request)
 	}
 }
 
+// WrapH is a helper function for wrapping http.Handler
+// Returns a Gin middleware
 func WrapH(h http.Handler) HandlerFunc {
 	return func(c *Context) {
 		h.ServeHTTP(c.Writer, c.Request)
 	}
 }
 
+// H is a shortcup for map[string]interface{}
 type H map[string]interface{}
 
 // MarshalXML allows type H to be used with xml.Marshal.
@@ -65,10 +70,8 @@ func (h H) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
 			return err
 		}
 	}
-	if err := e.EncodeToken(xml.EndElement{Name: start.Name}); err != nil {
-		return err
-	}
-	return nil
+
+	return e.EncodeToken(xml.EndElement{Name: start.Name})
 }
 
 func assert1(guard bool, text string) {

From a712f77d7aaec7eb4766a663924aaa4e54d3fe70 Mon Sep 17 00:00:00 2001
From: Weilin Shi <934587911@qq.com>
Date: Fri, 29 Dec 2017 17:10:28 +0800
Subject: [PATCH 21/32] Fix some golint warnings in gin.go (#1215)

---
 gin.go | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/gin.go b/gin.go
index edcb9193..4205eff0 100644
--- a/gin.go
+++ b/gin.go
@@ -160,11 +160,14 @@ func (engine *Engine) Delims(left, right string) *Engine {
 	return engine
 }
 
+// SecureJsonPrefix sets the secureJsonPrefix used in Context.SecureJSON.
 func (engine *Engine) SecureJsonPrefix(prefix string) *Engine {
 	engine.secureJsonPrefix = prefix
 	return engine
 }
 
+// LoadHTMLGlob loads HTML files identified by glob pattern
+// and associates the result with HTML renderer.
 func (engine *Engine) LoadHTMLGlob(pattern string) {
 	left := engine.delims.Left
 	right := engine.delims.Right
@@ -179,6 +182,8 @@ func (engine *Engine) LoadHTMLGlob(pattern string) {
 	engine.SetHTMLTemplate(templ)
 }
 
+// LoadHTMLFiles loads a slice of HTML files
+// and associates the result with HTML renderer.
 func (engine *Engine) LoadHTMLFiles(files ...string) {
 	if IsDebugging() {
 		engine.HTMLRender = render.HTMLDebug{Files: files, FuncMap: engine.FuncMap, Delims: engine.delims}
@@ -189,6 +194,7 @@ func (engine *Engine) LoadHTMLFiles(files ...string) {
 	engine.SetHTMLTemplate(templ)
 }
 
+// SetHTMLTemplate associate a template with HTML renderer.
 func (engine *Engine) SetHTMLTemplate(templ *template.Template) {
 	if len(engine.trees) > 0 {
 		debugPrintWARNINGSetHTMLTemplate()
@@ -197,6 +203,7 @@ func (engine *Engine) SetHTMLTemplate(templ *template.Template) {
 	engine.HTMLRender = render.HTMLProduction{Template: templ.Funcs(engine.FuncMap)}
 }
 
+// SetFuncMap sets the FuncMap used for template.FuncMap.
 func (engine *Engine) SetFuncMap(funcMap template.FuncMap) {
 	engine.FuncMap = funcMap
 }

From 8a6792d5162d449eb79743e372d5b651cc385561 Mon Sep 17 00:00:00 2001
From: Kevin Zhu <ipandtcp@gmail.com>
Date: Tue, 23 Jan 2018 10:07:33 +0800
Subject: [PATCH 22/32] Fix README.md example code (#1231)

r -> router
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 63137883..2ad2fc11 100644
--- a/README.md
+++ b/README.md
@@ -435,7 +435,7 @@ func main() {
         c.String(200, "pong")
     })
 
-    r.Run(":8080")
+    router.Run(":8080")
 }
 ```
 

From 7a9a290b36bb803a18874aa5c5b108be2d7eb34d Mon Sep 17 00:00:00 2001
From: MW Lim <williamchange@gmail.com>
Date: Tue, 23 Jan 2018 10:36:36 +0800
Subject: [PATCH 23/32] minor typo in README.md (#1219)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 2ad2fc11..6e421f02 100644
--- a/README.md
+++ b/README.md
@@ -1190,7 +1190,7 @@ func main() {
 
 ### Run multiple service using Gin
 
-See the [question](https://github.com/gin-gonic/gin/issues/346) and try the folling example:
+See the [question](https://github.com/gin-gonic/gin/issues/346) and try the following example:
 
 [embedmd]:# (examples/multiple-service/main.go go)
 ```go

From 2fbb97117cda046278ad34bd7bac35cbc38c68d5 Mon Sep 17 00:00:00 2001
From: Bo-Yi Wu <appleboy.tw@gmail.com>
Date: Wed, 24 Jan 2018 11:06:42 +0800
Subject: [PATCH 24/32] fix(build): remove unused target. (#1183)

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 9ba475a4..51a2d191 100644
--- a/Makefile
+++ b/Makefile
@@ -2,7 +2,7 @@ GOFMT ?= gofmt "-s"
 PACKAGES ?= $(shell go list ./... | grep -v /vendor/)
 GOFILES := $(shell find . -name "*.go" -type f -not -path "./vendor/*")
 
-all: build
+all: install
 
 install: deps
 	govendor sync

From 783c7ee9c14eac0e65b501664b4f553291556b43 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=94=B0=E6=AC=A7?= <thinkerou@gmail.com>
Date: Fri, 26 Jan 2018 11:46:11 +0800
Subject: [PATCH 25/32] Add some test cases and run test cases on
 binding/render dir (#1168)

* Travis run test cases on binding and render dir and add some test cases for binding and render
---
 .gitignore              |   1 +
 Makefile                |   2 +-
 binding/binding_test.go | 768 ++++++++++++++++++++++++++++++++++++++++
 coverage.sh             |  13 +
 render/render_test.go   | 175 ++++++++-
 5 files changed, 957 insertions(+), 2 deletions(-)
 create mode 100644 coverage.sh

diff --git a/.gitignore b/.gitignore
index f3b636df..14dc8f20 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,4 @@ vendor/*
 !vendor/vendor.json
 coverage.out
 count.out
+test
diff --git a/Makefile b/Makefile
index 51a2d191..5468563a 100644
--- a/Makefile
+++ b/Makefile
@@ -9,7 +9,7 @@ install: deps
 
 .PHONY: test
 test:
-	go test -v -covermode=count -coverprofile=coverage.out
+	sh coverage.sh
 
 .PHONY: fmt
 fmt:
diff --git a/binding/binding_test.go b/binding/binding_test.go
index 5575e166..0c0f9f81 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -6,9 +6,13 @@ package binding
 
 import (
 	"bytes"
+	"encoding/json"
+	"errors"
+	"io/ioutil"
 	"mime/multipart"
 	"net/http"
 	"testing"
+	"time"
 
 	"github.com/gin-gonic/gin/binding/example"
 	"github.com/golang/protobuf/proto"
@@ -25,6 +29,116 @@ type FooBarStruct struct {
 	Bar string `msgpack:"bar" json:"bar" form:"bar" xml:"bar" binding:"required"`
 }
 
+type FooStructUseNumber struct {
+	Foo interface{} `json:"foo" binding:"required"`
+}
+
+type FooBarStructForTimeType struct {
+	TimeFoo time.Time `form:"time_foo" time_format:"2006-01-02" time_utc:"1" time_location:"Asia/Chongqing"`
+	TimeBar time.Time `form:"time_bar" time_format:"2006-01-02" time_utc:"1"`
+}
+
+type FooStructForTimeTypeNotFormat struct {
+	TimeFoo time.Time `form:"time_foo"`
+}
+
+type FooStructForTimeTypeFailFormat struct {
+	TimeFoo time.Time `form:"time_foo" time_format:"2017-11-15"`
+}
+
+type FooStructForTimeTypeFailLocation struct {
+	TimeFoo time.Time `form:"time_foo" time_format:"2006-01-02" time_location:"/asia/chongqing"`
+}
+
+type FooStructForMapType struct {
+	// Unknown type: not support map
+	MapFoo map[string]interface{} `form:"map_foo"`
+}
+
+type InvalidNameType struct {
+	TestName string `invalid_name:"test_name"`
+}
+
+type InvalidNameMapType struct {
+	TestName struct {
+		MapFoo map[string]interface{} `form:"map_foo"`
+	}
+}
+
+type FooStructForSliceType struct {
+	SliceFoo []int `form:"slice_foo"`
+}
+
+type FooStructForSliceMapType struct {
+	// Unknown type: not support map
+	SliceMapFoo []map[string]interface{} `form:"slice_map_foo"`
+}
+
+type FooBarStructForIntType struct {
+	IntFoo int `form:"int_foo"`
+	IntBar int `form:"int_bar" binding:"required"`
+}
+
+type FooBarStructForInt8Type struct {
+	Int8Foo int8 `form:"int8_foo"`
+	Int8Bar int8 `form:"int8_bar" binding:"required"`
+}
+
+type FooBarStructForInt16Type struct {
+	Int16Foo int16 `form:"int16_foo"`
+	Int16Bar int16 `form:"int16_bar" binding:"required"`
+}
+
+type FooBarStructForInt32Type struct {
+	Int32Foo int32 `form:"int32_foo"`
+	Int32Bar int32 `form:"int32_bar" binding:"required"`
+}
+
+type FooBarStructForInt64Type struct {
+	Int64Foo int64 `form:"int64_foo"`
+	Int64Bar int64 `form:"int64_bar" binding:"required"`
+}
+
+type FooBarStructForUintType struct {
+	UintFoo uint `form:"uint_foo"`
+	UintBar uint `form:"uint_bar" binding:"required"`
+}
+
+type FooBarStructForUint8Type struct {
+	Uint8Foo uint8 `form:"uint8_foo"`
+	Uint8Bar uint8 `form:"uint8_bar" binding:"required"`
+}
+
+type FooBarStructForUint16Type struct {
+	Uint16Foo uint16 `form:"uint16_foo"`
+	Uint16Bar uint16 `form:"uint16_bar" binding:"required"`
+}
+
+type FooBarStructForUint32Type struct {
+	Uint32Foo uint32 `form:"uint32_foo"`
+	Uint32Bar uint32 `form:"uint32_bar" binding:"required"`
+}
+
+type FooBarStructForUint64Type struct {
+	Uint64Foo uint64 `form:"uint64_foo"`
+	Uint64Bar uint64 `form:"uint64_bar" binding:"required"`
+}
+
+type FooBarStructForBoolType struct {
+	BoolFoo bool `form:"bool_foo"`
+	BoolBar bool `form:"bool_bar" binding:"required"`
+}
+
+type FooBarStructForFloat32Type struct {
+	Float32Foo float32 `form:"float32_foo"`
+	Float32Bar float32 `form:"float32_bar" binding:"required"`
+}
+
+type FooBarStructForFloat64Type struct {
+	Float64Foo float64 `form:"float64_foo"`
+	Float64Bar float64 `form:"float64_bar" binding:"required"`
+}
+
 func TestBindingDefault(t *testing.T) {
 	assert.Equal(t, Default("GET", ""), Form)
 	assert.Equal(t, Default("GET", MIMEJSON), Form)
@@ -55,6 +169,20 @@ func TestBindingJSON(t *testing.T) {
 		`{"foo": "bar"}`, `{"bar": "foo"}`)
 }
 
+func TestBindingJSONUseNumber(t *testing.T) {
+	testBodyBindingUseNumber(t,
+		JSON, "json",
+		"/", "/",
+		`{"foo": 123}`, `{"bar": "foo"}`)
+}
+
+func TestBindingJSONUseNumber2(t *testing.T) {
+	testBodyBindingUseNumber2(t,
+		JSON, "json",
+		"/", "/",
+		`{"foo": 123}`, `{"bar": "foo"}`)
+}
+
 func TestBindingForm(t *testing.T) {
 	testFormBinding(t, "POST",
 		"/", "/",
@@ -67,6 +195,174 @@ func TestBindingForm2(t *testing.T) {
 		"", "")
 }
 
+func TestBindingFormForTime(t *testing.T) {
+	testFormBindingForTime(t, "POST",
+		"/", "/",
+		"time_foo=2017-11-15&time_bar=", "bar2=foo")
+	testFormBindingForTimeNotFormat(t, "POST",
+		"/", "/",
+		"time_foo=2017-11-15", "bar2=foo")
+	testFormBindingForTimeFailFormat(t, "POST",
+		"/", "/",
+		"time_foo=2017-11-15", "bar2=foo")
+	testFormBindingForTimeFailLocation(t, "POST",
+		"/", "/",
+		"time_foo=2017-11-15", "bar2=foo")
+}
+
+func TestBindingFormForTime2(t *testing.T) {
+	testFormBindingForTime(t, "GET",
+		"/?time_foo=2017-11-15&time_bar=", "/?bar2=foo",
+		"", "")
+	testFormBindingForTimeNotFormat(t, "GET",
+		"/?time_foo=2017-11-15", "/?bar2=foo",
+		"", "")
+	testFormBindingForTimeFailFormat(t, "GET",
+		"/?time_foo=2017-11-15", "/?bar2=foo",
+		"", "")
+	testFormBindingForTimeFailLocation(t, "GET",
+		"/?time_foo=2017-11-15", "/?bar2=foo",
+		"", "")
+}
+
+func TestBindingFormInvalidName(t *testing.T) {
+	testFormBindingInvalidName(t, "POST",
+		"/", "/",
+		"test_name=bar", "bar2=foo")
+}
+
+func TestBindingFormInvalidName2(t *testing.T) {
+	testFormBindingInvalidName2(t, "POST",
+		"/", "/",
+		"map_foo=bar", "bar2=foo")
+}
+
+func TestBindingFormForType(t *testing.T) {
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"map_foo=", "bar2=1", "Map")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"slice_foo=1&slice_foo=2", "bar2=1&bar2=2", "Slice")
+
+	testFormBindingForType(t, "GET",
+		"/?slice_foo=1&slice_foo=2", "/?bar2=1&bar2=2",
+		"", "", "Slice")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"slice_map_foo=1&slice_map_foo=2", "bar2=1&bar2=2", "SliceMap")
+
+	testFormBindingForType(t, "GET",
+		"/?slice_map_foo=1&slice_map_foo=2", "/?bar2=1&bar2=2",
+		"", "", "SliceMap")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"int_foo=&int_bar=-12", "bar2=-123", "Int")
+
+	testFormBindingForType(t, "GET",
+		"/?int_foo=&int_bar=-12", "/?bar2=-123",
+		"", "", "Int")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"int8_foo=&int8_bar=-12", "bar2=-123", "Int8")
+
+	testFormBindingForType(t, "GET",
+		"/?int8_foo=&int8_bar=-12", "/?bar2=-123",
+		"", "", "Int8")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"int16_foo=&int16_bar=-12", "bar2=-123", "Int16")
+
+	testFormBindingForType(t, "GET",
+		"/?int16_foo=&int16_bar=-12", "/?bar2=-123",
+		"", "", "Int16")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"int32_foo=&int32_bar=-12", "bar2=-123", "Int32")
+
+	testFormBindingForType(t, "GET",
+		"/?int32_foo=&int32_bar=-12", "/?bar2=-123",
+		"", "", "Int32")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"int64_foo=&int64_bar=-12", "bar2=-123", "Int64")
+
+	testFormBindingForType(t, "GET",
+		"/?int64_foo=&int64_bar=-12", "/?bar2=-123",
+		"", "", "Int64")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"uint_foo=&uint_bar=12", "bar2=123", "Uint")
+
+	testFormBindingForType(t, "GET",
+		"/?uint_foo=&uint_bar=12", "/?bar2=123",
+		"", "", "Uint")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"uint8_foo=&uint8_bar=12", "bar2=123", "Uint8")
+
+	testFormBindingForType(t, "GET",
+		"/?uint8_foo=&uint8_bar=12", "/?bar2=123",
+		"", "", "Uint8")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"uint16_foo=&uint16_bar=12", "bar2=123", "Uint16")
+
+	testFormBindingForType(t, "GET",
+		"/?uint16_foo=&uint16_bar=12", "/?bar2=123",
+		"", "", "Uint16")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"uint32_foo=&uint32_bar=12", "bar2=123", "Uint32")
+
+	testFormBindingForType(t, "GET",
+		"/?uint32_foo=&uint32_bar=12", "/?bar2=123",
+		"", "", "Uint32")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"uint64_foo=&uint64_bar=12", "bar2=123", "Uint64")
+
+	testFormBindingForType(t, "GET",
+		"/?uint64_foo=&uint64_bar=12", "/?bar2=123",
+		"", "", "Uint64")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"bool_foo=&bool_bar=true", "bar2=true", "Bool")
+
+	testFormBindingForType(t, "GET",
+		"/?bool_foo=&bool_bar=true", "/?bar2=true",
+		"", "", "Bool")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"float32_foo=&float32_bar=-12.34", "bar2=12.3", "Float32")
+
+	testFormBindingForType(t, "GET",
+		"/?float32_foo=&float32_bar=-12.34", "/?bar2=12.3",
+		"", "", "Float32")
+
+	testFormBindingForType(t, "POST",
+		"/", "/",
+		"float64_foo=&float64_bar=-12.34", "bar2=12.3", "Float64")
+
+	testFormBindingForType(t, "GET",
+		"/?float64_foo=&float64_bar=-12.34", "/?bar2=12.3",
+		"", "", "Float64")
+}
+
 func TestBindingQuery(t *testing.T) {
 	testQueryBinding(t, "POST",
 		"/?foo=bar&bar=foo", "/",
@@ -79,6 +375,18 @@ func TestBindingQuery2(t *testing.T) {
 		"foo=unused", "")
 }
 
+func TestBindingQueryFail(t *testing.T) {
+	testQueryBindingFail(t, "POST",
+		"/?map_foo=", "/",
+		"map_foo=unused", "bar2=foo")
+}
+
+func TestBindingQueryFail2(t *testing.T) {
+	testQueryBindingFail(t, "GET",
+		"/?map_foo=", "/?bar2=foo",
+		"map_foo=unused", "")
+}
+
 func TestBindingXML(t *testing.T) {
 	testBodyBinding(t,
 		XML, "xml",
@@ -86,12 +394,25 @@ func TestBindingXML(t *testing.T) {
 		"<map><foo>bar</foo></map>", "<map><bar>foo</bar></map>")
 }
 
+func TestBindingXMLFail(t *testing.T) {
+	testBodyBindingFail(t,
+		XML, "xml",
+		"/", "/",
+		"<map><foo>bar<foo></map>", "<map><bar>foo</bar></map>")
+}
+
 func createFormPostRequest() *http.Request {
 	req, _ := http.NewRequest("POST", "/?foo=getfoo&bar=getbar", bytes.NewBufferString("foo=bar&bar=foo"))
 	req.Header.Set("Content-Type", MIMEPOSTForm)
 	return req
 }
 
+func createFormPostRequestFail() *http.Request {
+	req, _ := http.NewRequest("POST", "/?map_foo=getfoo", bytes.NewBufferString("map_foo=bar"))
+	req.Header.Set("Content-Type", MIMEPOSTForm)
+	return req
+}
+
 func createFormMultipartRequest() *http.Request {
 	boundary := "--testboundary"
 	body := new(bytes.Buffer)
@@ -106,24 +427,53 @@ func createFormMultipartRequest() *http.Request {
 	return req
 }
 
+func createFormMultipartRequestFail() *http.Request {
+	boundary := "--testboundary"
+	body := new(bytes.Buffer)
+	mw := multipart.NewWriter(body)
+	defer mw.Close()
+
+	mw.SetBoundary(boundary)
+	mw.WriteField("map_foo", "bar")
+	req, _ := http.NewRequest("POST", "/?map_foo=getfoo", body)
+	req.Header.Set("Content-Type", MIMEMultipartPOSTForm+"; boundary="+boundary)
+	return req
+}
+
 func TestBindingFormPost(t *testing.T) {
 	req := createFormPostRequest()
 	var obj FooBarStruct
 	FormPost.Bind(req, &obj)
 
+	assert.Equal(t, FormPost.Name(), "form-urlencoded")
 	assert.Equal(t, obj.Foo, "bar")
 	assert.Equal(t, obj.Bar, "foo")
 }
 
+func TestBindingFormPostFail(t *testing.T) {
+	req := createFormPostRequestFail()
+	var obj FooStructForMapType
+	err := FormPost.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
 func TestBindingFormMultipart(t *testing.T) {
 	req := createFormMultipartRequest()
 	var obj FooBarStruct
 	FormMultipart.Bind(req, &obj)
 
+	assert.Equal(t, FormMultipart.Name(), "multipart/form-data")
 	assert.Equal(t, obj.Foo, "bar")
 	assert.Equal(t, obj.Bar, "foo")
 }
 
+func TestBindingFormMultipartFail(t *testing.T) {
+	req := createFormMultipartRequestFail()
+	var obj FooStructForMapType
+	err := FormMultipart.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
 func TestBindingProtoBuf(t *testing.T) {
 	test := &example.Test{
 		Label: proto.String("yes"),
@@ -136,6 +486,18 @@ func TestBindingProtoBuf(t *testing.T) {
 		string(data), string(data[1:]))
 }
 
+func TestBindingProtoBufFail(t *testing.T) {
+	test := &example.Test{
+		Label: proto.String("yes"),
+	}
+	data, _ := proto.Marshal(test)
+
+	testProtoBodyBindingFail(t,
+		ProtoBuf, "protobuf",
+		"/", "/",
+		string(data), string(data[1:]))
+}
+
 func TestBindingMsgPack(t *testing.T) {
 	test := FooStruct{
 		Foo: "bar",
@@ -216,6 +578,323 @@ func testFormBinding(t *testing.T, method, path, badPath, body, badBody string)
 	assert.Error(t, err)
 }
 
+func TestFormBindingFail(t *testing.T) {
+	b := Form
+	assert.Equal(t, b.Name(), "form")
+
+	obj := FooBarStruct{}
+	req, _ := http.NewRequest("POST", "/", nil)
+	err := b.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
+func TestFormPostBindingFail(t *testing.T) {
+	b := FormPost
+	assert.Equal(t, b.Name(), "form-urlencoded")
+
+	obj := FooBarStruct{}
+	req, _ := http.NewRequest("POST", "/", nil)
+	err := b.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
+func TestFormMultipartBindingFail(t *testing.T) {
+	b := FormMultipart
+	assert.Equal(t, b.Name(), "multipart/form-data")
+
+	obj := FooBarStruct{}
+	req, _ := http.NewRequest("POST", "/", nil)
+	err := b.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
+func testFormBindingForTime(t *testing.T, method, path, badPath, body, badBody string) {
+	b := Form
+	assert.Equal(t, b.Name(), "form")
+
+	obj := FooBarStructForTimeType{}
+	req := requestWithBody(method, path, body)
+	if method == "POST" {
+		req.Header.Add("Content-Type", MIMEPOSTForm)
+	}
+	err := b.Bind(req, &obj)
+
+	assert.NoError(t, err)
+	assert.Equal(t, obj.TimeFoo.Unix(), int64(1510675200))
+	assert.Equal(t, obj.TimeFoo.Location().String(), "Asia/Chongqing")
+	assert.Equal(t, obj.TimeBar.Unix(), int64(-62135596800))
+	assert.Equal(t, obj.TimeBar.Location().String(), "UTC")
+
+	obj = FooBarStructForTimeType{}
+	req = requestWithBody(method, badPath, badBody)
+	err = JSON.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
+func testFormBindingForTimeNotFormat(t *testing.T, method, path, badPath, body, badBody string) {
+	b := Form
+	assert.Equal(t, b.Name(), "form")
+
+	obj := FooStructForTimeTypeNotFormat{}
+	req := requestWithBody(method, path, body)
+	if method == "POST" {
+		req.Header.Add("Content-Type", MIMEPOSTForm)
+	}
+	err := b.Bind(req, &obj)
+	assert.Error(t, err)
+
+	obj = FooStructForTimeTypeNotFormat{}
+	req = requestWithBody(method, badPath, badBody)
+	err = JSON.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
+func testFormBindingForTimeFailFormat(t *testing.T, method, path, badPath, body, badBody string) {
+	b := Form
+	assert.Equal(t, b.Name(), "form")
+
+	obj := FooStructForTimeTypeFailFormat{}
+	req := requestWithBody(method, path, body)
+	if method == "POST" {
+		req.Header.Add("Content-Type", MIMEPOSTForm)
+	}
+	err := b.Bind(req, &obj)
+	assert.Error(t, err)
+
+	obj = FooStructForTimeTypeFailFormat{}
+	req = requestWithBody(method, badPath, badBody)
+	err = JSON.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
+func testFormBindingForTimeFailLocation(t *testing.T, method, path, badPath, body, badBody string) {
+	b := Form
+	assert.Equal(t, b.Name(), "form")
+
+	obj := FooStructForTimeTypeFailLocation{}
+	req := requestWithBody(method, path, body)
+	if method == "POST" {
+		req.Header.Add("Content-Type", MIMEPOSTForm)
+	}
+	err := b.Bind(req, &obj)
+	assert.Error(t, err)
+
+	obj = FooStructForTimeTypeFailLocation{}
+	req = requestWithBody(method, badPath, badBody)
+	err = JSON.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
+func testFormBindingInvalidName(t *testing.T, method, path, badPath, body, badBody string) {
+	b := Form
+	assert.Equal(t, b.Name(), "form")
+
+	obj := InvalidNameType{}
+	req := requestWithBody(method, path, body)
+	if method == "POST" {
+		req.Header.Add("Content-Type", MIMEPOSTForm)
+	}
+	err := b.Bind(req, &obj)
+	assert.NoError(t, err)
+	assert.Equal(t, obj.TestName, "")
+
+	obj = InvalidNameType{}
+	req = requestWithBody(method, badPath, badBody)
+	err = JSON.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
+func testFormBindingInvalidName2(t *testing.T, method, path, badPath, body, badBody string) {
+	b := Form
+	assert.Equal(t, b.Name(), "form")
+
+	obj := InvalidNameMapType{}
+	req := requestWithBody(method, path, body)
+	if method == "POST" {
+		req.Header.Add("Content-Type", MIMEPOSTForm)
+	}
+	err := b.Bind(req, &obj)
+	assert.Error(t, err)
+
+	obj = InvalidNameMapType{}
+	req = requestWithBody(method, badPath, badBody)
+	err = JSON.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
+func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody string, typ string) {
+	b := Form
+	assert.Equal(t, b.Name(), "form")
+
+	req := requestWithBody(method, path, body)
+	if method == "POST" {
+		req.Header.Add("Content-Type", MIMEPOSTForm)
+	}
+	switch typ {
+	case "Int":
+		obj := FooBarStructForIntType{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.IntFoo, int(0))
+		assert.Equal(t, obj.IntBar, int(-12))
+
+		obj = FooBarStructForIntType{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Int8":
+		obj := FooBarStructForInt8Type{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.Int8Foo, int8(0))
+		assert.Equal(t, obj.Int8Bar, int8(-12))
+
+		obj = FooBarStructForInt8Type{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Int16":
+		obj := FooBarStructForInt16Type{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.Int16Foo, int16(0))
+		assert.Equal(t, obj.Int16Bar, int16(-12))
+
+		obj = FooBarStructForInt16Type{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Int32":
+		obj := FooBarStructForInt32Type{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.Int32Foo, int32(0))
+		assert.Equal(t, obj.Int32Bar, int32(-12))
+
+		obj = FooBarStructForInt32Type{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Int64":
+		obj := FooBarStructForInt64Type{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.Int64Foo, int64(0))
+		assert.Equal(t, obj.Int64Bar, int64(-12))
+
+		obj = FooBarStructForInt64Type{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Uint":
+		obj := FooBarStructForUintType{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.UintFoo, uint(0x0))
+		assert.Equal(t, obj.UintBar, uint(0xc))
+
+		obj = FooBarStructForUintType{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Uint8":
+		obj := FooBarStructForUint8Type{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.Uint8Foo, uint8(0x0))
+		assert.Equal(t, obj.Uint8Bar, uint8(0xc))
+
+		obj = FooBarStructForUint8Type{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Uint16":
+		obj := FooBarStructForUint16Type{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.Uint16Foo, uint16(0x0))
+		assert.Equal(t, obj.Uint16Bar, uint16(0xc))
+
+		obj = FooBarStructForUint16Type{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Uint32":
+		obj := FooBarStructForUint32Type{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.Uint32Foo, uint32(0x0))
+		assert.Equal(t, obj.Uint32Bar, uint32(0xc))
+
+		obj = FooBarStructForUint32Type{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Uint64":
+		obj := FooBarStructForUint64Type{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.Uint64Foo, uint64(0x0))
+		assert.Equal(t, obj.Uint64Bar, uint64(0xc))
+
+		obj = FooBarStructForUint64Type{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Float32":
+		obj := FooBarStructForFloat32Type{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.Float32Foo, float32(0.0))
+		assert.Equal(t, obj.Float32Bar, float32(-12.34))
+
+		obj = FooBarStructForFloat32Type{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Float64":
+		obj := FooBarStructForFloat64Type{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.Float64Foo, float64(0.0))
+		assert.Equal(t, obj.Float64Bar, float64(-12.34))
+
+		obj = FooBarStructForFloat64Type{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Bool":
+		obj := FooBarStructForBoolType{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.BoolFoo, false)
+		assert.Equal(t, obj.BoolBar, true)
+
+		obj = FooBarStructForBoolType{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Slice":
+		obj := FooStructForSliceType{}
+		err := b.Bind(req, &obj)
+		assert.NoError(t, err)
+		assert.Equal(t, obj.SliceFoo, []int{1, 2})
+
+		obj = FooStructForSliceType{}
+		req = requestWithBody(method, badPath, badBody)
+		err = JSON.Bind(req, &obj)
+		assert.Error(t, err)
+	case "Map":
+		obj := FooStructForMapType{}
+		err := b.Bind(req, &obj)
+		assert.Error(t, err)
+	case "SliceMap":
+		obj := FooStructForSliceMapType{}
+		err := b.Bind(req, &obj)
+		assert.Error(t, err)
+	}
+}
+
 func testQueryBinding(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Query
 	assert.Equal(t, b.Name(), "query")
@@ -231,6 +910,19 @@ func testQueryBinding(t *testing.T, method, path, badPath, body, badBody string)
 	assert.Equal(t, obj.Bar, "foo")
 }
 
+func testQueryBindingFail(t *testing.T, method, path, badPath, body, badBody string) {
+	b := Query
+	assert.Equal(t, b.Name(), "query")
+
+	obj := FooStructForMapType{}
+	req := requestWithBody(method, path, body)
+	if method == "POST" {
+		req.Header.Add("Content-Type", MIMEPOSTForm)
+	}
+	err := b.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
 func testBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
 	assert.Equal(t, b.Name(), name)
 
@@ -246,6 +938,58 @@ func testBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody
 	assert.Error(t, err)
 }
 
+func testBodyBindingUseNumber(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
+	assert.Equal(t, b.Name(), name)
+
+	obj := FooStructUseNumber{}
+	req := requestWithBody("POST", path, body)
+	EnableDecoderUseNumber = true
+	err := b.Bind(req, &obj)
+	assert.NoError(t, err)
+	// we hope it is int64(123)
+	v, e := obj.Foo.(json.Number).Int64()
+	assert.NoError(t, e)
+	assert.Equal(t, v, int64(123))
+
+	obj = FooStructUseNumber{}
+	req = requestWithBody("POST", badPath, badBody)
+	err = JSON.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
+func testBodyBindingUseNumber2(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
+	assert.Equal(t, b.Name(), name)
+
+	obj := FooStructUseNumber{}
+	req := requestWithBody("POST", path, body)
+	EnableDecoderUseNumber = false
+	err := b.Bind(req, &obj)
+	assert.NoError(t, err)
+	// it will return float64(123) if not use EnableDecoderUseNumber
+	// maybe it is not hoped
+	assert.Equal(t, obj.Foo, float64(123))
+
+	obj = FooStructUseNumber{}
+	req = requestWithBody("POST", badPath, badBody)
+	err = JSON.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
+func testBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
+	assert.Equal(t, b.Name(), name)
+
+	obj := FooStruct{}
+	req := requestWithBody("POST", path, body)
+	err := b.Bind(req, &obj)
+	assert.Error(t, err)
+	assert.Equal(t, obj.Foo, "")
+
+	obj = FooStruct{}
+	req = requestWithBody("POST", badPath, badBody)
+	err = JSON.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
 func testProtoBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
 	assert.Equal(t, b.Name(), name)
 
@@ -263,6 +1007,30 @@ func testProtoBodyBinding(t *testing.T, b Binding, name, path, badPath, body, ba
 	assert.Error(t, err)
 }
 
+type hook struct{}
+
+func (h hook) Read([]byte) (int, error) {
+	return 0, errors.New("error")
+}
+
+func testProtoBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
+	assert.Equal(t, b.Name(), name)
+
+	obj := example.Test{}
+	req := requestWithBody("POST", path, body)
+
+	req.Body = ioutil.NopCloser(&hook{})
+	req.Header.Add("Content-Type", MIMEPROTOBUF)
+	err := b.Bind(req, &obj)
+	assert.Error(t, err)
+
+	obj = example.Test{}
+	req = requestWithBody("POST", badPath, badBody)
+	req.Header.Add("Content-Type", MIMEPROTOBUF)
+	err = ProtoBuf.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
 func testMsgPackBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
 	assert.Equal(t, b.Name(), name)
 
diff --git a/coverage.sh b/coverage.sh
new file mode 100644
index 00000000..81437f91
--- /dev/null
+++ b/coverage.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+set -e
+
+echo "mode: count" > coverage.out
+
+for d in $(go list ./... | grep -E 'gin$|binding$|render$'); do
+    go test -v -covermode=count -coverprofile=profile.out $d
+    if [ -f profile.out ]; then
+        cat profile.out | grep -v "mode:" >> coverage.out
+        rm profile.out
+    fi
+done
diff --git a/render/render_test.go b/render/render_test.go
index 35662cf3..530e222a 100644
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -7,7 +7,9 @@ package render
 import (
 	"bytes"
 	"encoding/xml"
+	"errors"
 	"html/template"
+	"net/http"
 	"net/http/httptest"
 	"testing"
 
@@ -24,6 +26,9 @@ func TestRenderMsgPack(t *testing.T) {
 		"foo": "bar",
 	}
 
+	(MsgPack{data}).WriteContentType(w)
+	assert.Equal(t, w.Header().Get("Content-Type"), "application/msgpack; charset=utf-8")
+
 	err := (MsgPack{data}).Render(w)
 
 	assert.NoError(t, err)
@@ -45,6 +50,9 @@ func TestRenderJSON(t *testing.T) {
 		"foo": "bar",
 	}
 
+	(JSON{data}).WriteContentType(w)
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
+
 	err := (JSON{data}).Render(w)
 
 	assert.NoError(t, err)
@@ -52,6 +60,14 @@ func TestRenderJSON(t *testing.T) {
 	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
+func TestRenderJSONPanics(t *testing.T) {
+	w := httptest.NewRecorder()
+	data := make(chan int)
+
+	// json: unsupported type: chan int
+	assert.Panics(t, func() { (JSON{data}).Render(w) })
+}
+
 func TestRenderIndentedJSON(t *testing.T) {
 	w := httptest.NewRecorder()
 	data := map[string]interface{}{
@@ -66,12 +82,24 @@ func TestRenderIndentedJSON(t *testing.T) {
 	assert.Equal(t, w.Header().Get("Content-Type"), "application/json; charset=utf-8")
 }
 
+func TestRenderIndentedJSONPanics(t *testing.T) {
+	w := httptest.NewRecorder()
+	data := make(chan int)
+
+	// json: unsupported type: chan int
+	err := (IndentedJSON{data}).Render(w)
+	assert.Error(t, err)
+}
+
 func TestRenderSecureJSON(t *testing.T) {
 	w1 := httptest.NewRecorder()
 	data := map[string]interface{}{
 		"foo": "bar",
 	}
 
+	(SecureJSON{"while(1);", data}).WriteContentType(w1)
+	assert.Equal(t, "application/json; charset=utf-8", w1.Header().Get("Content-Type"))
+
 	err1 := (SecureJSON{"while(1);", data}).Render(w1)
 
 	assert.NoError(t, err1)
@@ -91,6 +119,15 @@ func TestRenderSecureJSON(t *testing.T) {
 	assert.Equal(t, "application/json; charset=utf-8", w2.Header().Get("Content-Type"))
 }
 
+func TestRenderSecureJSONFail(t *testing.T) {
+	w := httptest.NewRecorder()
+	data := make(chan int)
+
+	// json: unsupported type: chan int
+	err := (SecureJSON{"while(1);", data}).Render(w)
+	assert.Error(t, err)
+}
+
 type xmlmap map[string]interface{}
 
 // Allows type H to be used with xml.Marshal
@@ -115,12 +152,45 @@ func (h xmlmap) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
 	return e.EncodeToken(xml.EndElement{Name: start.Name})
 }
 
+func TestRenderYAML(t *testing.T) {
+	w := httptest.NewRecorder()
+	data := `
+a : Easy!
+b:
+	c: 2
+	d: [3, 4]
+	`
+	(YAML{data}).WriteContentType(w)
+	assert.Equal(t, w.Header().Get("Content-Type"), "application/x-yaml; charset=utf-8")
+
+	err := (YAML{data}).Render(w)
+	assert.NoError(t, err)
+	assert.Equal(t, w.Body.String(), "\"\\na : Easy!\\nb:\\n\\tc: 2\\n\\td: [3, 4]\\n\\t\"\n")
+	assert.Equal(t, w.Header().Get("Content-Type"), "application/x-yaml; charset=utf-8")
+}
+
+type fail struct{}
+
+// Hook MarshalYAML
+func (ft *fail) MarshalYAML() (interface{}, error) {
+	return nil, errors.New("fail")
+}
+
+func TestRenderYAMLFail(t *testing.T) {
+	w := httptest.NewRecorder()
+	err := (YAML{&fail{}}).Render(w)
+	assert.Error(t, err)
+}
+
 func TestRenderXML(t *testing.T) {
 	w := httptest.NewRecorder()
 	data := xmlmap{
 		"foo": "bar",
 	}
 
+	(XML{data}).WriteContentType(w)
+	assert.Equal(t, w.Header().Get("Content-Type"), "application/xml; charset=utf-8")
+
 	err := (XML{data}).Render(w)
 
 	assert.NoError(t, err)
@@ -129,7 +199,30 @@ func TestRenderXML(t *testing.T) {
 }
 
 func TestRenderRedirect(t *testing.T) {
-	// TODO
+	req, err := http.NewRequest("GET", "/test-redirect", nil)
+	assert.NoError(t, err)
+
+	data1 := Redirect{
+		Code:     301,
+		Request:  req,
+		Location: "/new/location",
+	}
+
+	w := httptest.NewRecorder()
+	err = data1.Render(w)
+	assert.NoError(t, err)
+
+	data2 := Redirect{
+		Code:     200,
+		Request:  req,
+		Location: "/new/location",
+	}
+
+	w = httptest.NewRecorder()
+	assert.Panics(t, func() { data2.Render(w) })
+
+	// only improve coverage
+	data2.WriteContentType(w)
 }
 
 func TestRenderData(t *testing.T) {
@@ -149,6 +242,12 @@ func TestRenderData(t *testing.T) {
 func TestRenderString(t *testing.T) {
 	w := httptest.NewRecorder()
 
+	(String{
+		Format: "hello %s %d",
+		Data:   []interface{}{},
+	}).WriteContentType(w)
+	assert.Equal(t, w.Header().Get("Content-Type"), "text/plain; charset=utf-8")
+
 	err := (String{
 		Format: "hola %s %d",
 		Data:   []interface{}{"manu", 2},
@@ -159,6 +258,19 @@ func TestRenderString(t *testing.T) {
 	assert.Equal(t, w.Header().Get("Content-Type"), "text/plain; charset=utf-8")
 }
 
+func TestRenderStringLenZero(t *testing.T) {
+	w := httptest.NewRecorder()
+
+	err := (String{
+		Format: "hola %s %d",
+		Data:   []interface{}{},
+	}).Render(w)
+
+	assert.NoError(t, err)
+	assert.Equal(t, w.Body.String(), "hola %s %d")
+	assert.Equal(t, w.Header().Get("Content-Type"), "text/plain; charset=utf-8")
+}
+
 func TestRenderHTMLTemplate(t *testing.T) {
 	w := httptest.NewRecorder()
 	templ := template.Must(template.New("t").Parse(`Hello {{.name}}`))
@@ -174,3 +286,64 @@ func TestRenderHTMLTemplate(t *testing.T) {
 	assert.Equal(t, w.Body.String(), "Hello alexandernyquist")
 	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
 }
+
+func TestRenderHTMLTemplateEmptyName(t *testing.T) {
+	w := httptest.NewRecorder()
+	templ := template.Must(template.New("").Parse(`Hello {{.name}}`))
+
+	htmlRender := HTMLProduction{Template: templ}
+	instance := htmlRender.Instance("", map[string]interface{}{
+		"name": "alexandernyquist",
+	})
+
+	err := instance.Render(w)
+
+	assert.NoError(t, err)
+	assert.Equal(t, w.Body.String(), "Hello alexandernyquist")
+	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+}
+
+func TestRenderHTMLDebugFiles(t *testing.T) {
+	w := httptest.NewRecorder()
+	htmlRender := HTMLDebug{Files: []string{"../fixtures/basic/hello.tmpl"},
+		Glob:    "",
+		Delims:  Delims{Left: "{[{", Right: "}]}"},
+		FuncMap: nil,
+	}
+	instance := htmlRender.Instance("hello.tmpl", map[string]interface{}{
+		"name": "thinkerou",
+	})
+
+	err := instance.Render(w)
+
+	assert.NoError(t, err)
+	assert.Equal(t, w.Body.String(), "<h1>Hello thinkerou</h1>")
+	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+}
+
+func TestRenderHTMLDebugGlob(t *testing.T) {
+	w := httptest.NewRecorder()
+	htmlRender := HTMLDebug{Files: nil,
+		Glob:    "../fixtures/basic/hello*",
+		Delims:  Delims{Left: "{[{", Right: "}]}"},
+		FuncMap: nil,
+	}
+	instance := htmlRender.Instance("hello.tmpl", map[string]interface{}{
+		"name": "thinkerou",
+	})
+
+	err := instance.Render(w)
+
+	assert.NoError(t, err)
+	assert.Equal(t, w.Body.String(), "<h1>Hello thinkerou</h1>")
+	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+}
+
+func TestRenderHTMLDebugPanics(t *testing.T) {
+	htmlRender := HTMLDebug{Files: nil,
+		Glob:    "",
+		Delims:  Delims{"{{", "}}"},
+		FuncMap: nil,
+	}
+	assert.Panics(t, func() { htmlRender.Instance("", nil) })
+}

From ae22f0c87091eb75e08429082935ec48035320ac Mon Sep 17 00:00:00 2001
From: Eason Lin <easonlin404@gmail.com>
Date: Thu, 22 Feb 2018 21:00:20 +0800
Subject: [PATCH 26/32] chore(travis): add 1.10 version (#1256)

---
 .travis.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.travis.yml b/.travis.yml
index ec12cad6..63b5d113 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,6 +5,7 @@ go:
   - 1.7.x
   - 1.8.x
   - 1.9.x
+  - 1.10.x
   - master
 
 git:

From cbb1ee80b1c2a53c46872e43ed15c664917eb905 Mon Sep 17 00:00:00 2001
From: README Bot <35302948+codetriage-readme-bot@users.noreply.github.com>
Date: Thu, 22 Feb 2018 07:28:50 -0600
Subject: [PATCH 27/32] Add CodeTriage badge to gin-gonic/gin (#1249)

Adds a badge showing the number of people helping this repo on CodeTriage.

[![Open Source Helpers](https://www.codetriage.com/gin-gonic/gin/badges/users.svg)](https://www.codetriage.com/gin-gonic/gin)

## What is CodeTriage?

CodeTriage is an Open Source app that is designed to make contributing to Open Source projects easier. It works by sending subscribers a few open issues in their inbox. If subscribers get busy, there is an algorithm that backs off issue load so they do not get overwhelmed

[Read more about the CodeTriage project](https://www.codetriage.com/what).

## Why am I getting this PR?

Your project was picked by the human, @schneems. They selected it from the projects submitted to https://www.codetriage.com and hand edited the PR. How did your project get added to [CodeTriage](https://www.codetriage.com/what)? Roughly 6 months ago, [dinsaw](https://github.com/dinsaw) added this project to CodeTriage in order to start contributing. Since then, 5 people have subscribed to help this repo.

## What does adding a badge accomplish?

Adding a badge invites people to help contribute to your project. It also lets developers know that others are invested in the longterm success and maintainability of the project.

You can see an example of a CodeTriage badge on these popular OSS READMEs:

- [![](https://www.codetriage.com/rails/rails/badges/users.svg)](https://www.codetriage.com/rails/rails) https://github.com/rails/rails
- [![](https://www.codetriage.com/crystal-lang/crystal/badges/users.svg)](https://www.codetriage.com/crystal-lang/crystal) https://github.com/crystal-lang/crystal

## Have a question or comment?

While I am a bot, this PR was manually reviewed and monitored by a human - @schneems. My job is writing commit messages and handling PR logistics.

If you have any questions, you can reply back to this PR and they will be answered by @schneems. If you do not want a badge right now, no worries, close the PR, you will not hear from me again.

Thanks for making your project Open Source! Any feedback is greatly appreciated.
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 6e421f02..b51aa10c 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,7 @@
  [![Go Report Card](https://goreportcard.com/badge/github.com/gin-gonic/gin)](https://goreportcard.com/report/github.com/gin-gonic/gin)
  [![GoDoc](https://godoc.org/github.com/gin-gonic/gin?status.svg)](https://godoc.org/github.com/gin-gonic/gin)
  [![Join the chat at https://gitter.im/gin-gonic/gin](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/gin-gonic/gin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Open Source Helpers](https://www.codetriage.com/gin-gonic/gin/badges/users.svg)](https://www.codetriage.com/gin-gonic/gin)
 
 Gin is a web framework written in Go (Golang). It features a martini-like API with much better performance, up to 40 times faster thanks to [httprouter](https://github.com/julienschmidt/httprouter). If you need performance and good productivity, you will love Gin.
 

From 5d3f30cfc81f9109850fa9043a19783cbbde68a5 Mon Sep 17 00:00:00 2001
From: Mario Kostelac <mario@intercom.io>
Date: Fri, 23 Feb 2018 01:09:33 +0000
Subject: [PATCH 28/32] Make "" mode being the same as debug mode (#1250)

Not setting mode explicitly sets gin into debug mode, but it does not
make it possible to retrieve gin mode as Debug since it's set to "".
---
 mode.go      | 3 +++
 mode_test.go | 4 ++++
 2 files changed, 7 insertions(+)

diff --git a/mode.go b/mode.go
index 9c4f0246..9df4e45f 100644
--- a/mode.go
+++ b/mode.go
@@ -53,6 +53,9 @@ func SetMode(value string) {
 	default:
 		panic("gin mode unknown: " + value)
 	}
+	if value == "" {
+		value = DebugMode
+	}
 	modeName = value
 }
 
diff --git a/mode_test.go b/mode_test.go
index 7eaca823..cf27acd8 100644
--- a/mode_test.go
+++ b/mode_test.go
@@ -21,6 +21,10 @@ func TestSetMode(t *testing.T) {
 	assert.Equal(t, TestMode, Mode())
 	os.Unsetenv(ENV_GIN_MODE)
 
+	SetMode("")
+	assert.Equal(t, debugCode, ginMode)
+	assert.Equal(t, DebugMode, Mode())
+
 	SetMode(DebugMode)
 	assert.Equal(t, debugCode, ginMode)
 	assert.Equal(t, DebugMode, Mode())

From 3e3f9bca81da5a4d2664d075012ae5aca9e70b9e Mon Sep 17 00:00:00 2001
From: Romain Beuque <rbeuque74@gmail.com>
Date: Tue, 20 Mar 2018 07:05:24 +0100
Subject: [PATCH 29/32] doc(graceful-shutdown): failure to ListenAndServe
 should be a reason to exit (#1287)

Signed-off-by: Romain Beuque <romain.beuque@gmail.com>
---
 README.md                                              | 4 ++--
 examples/graceful-shutdown/graceful-shutdown/server.go | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index b51aa10c..72ac99bd 100644
--- a/README.md
+++ b/README.md
@@ -1324,8 +1324,8 @@ func main() {
 
 	go func() {
 		// service connections
-		if err := srv.ListenAndServe(); err != nil {
-			log.Printf("listen: %s\n", err)
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("listen: %s\n", err)
 		}
 	}()
 
diff --git a/examples/graceful-shutdown/graceful-shutdown/server.go b/examples/graceful-shutdown/graceful-shutdown/server.go
index 6debe7f5..af4f2146 100644
--- a/examples/graceful-shutdown/graceful-shutdown/server.go
+++ b/examples/graceful-shutdown/graceful-shutdown/server.go
@@ -27,8 +27,8 @@ func main() {
 
 	go func() {
 		// service connections
-		if err := srv.ListenAndServe(); err != nil {
-			log.Printf("listen: %s\n", err)
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("listen: %s\n", err)
 		}
 	}()
 

From 65a65c2edd4e86f96634a553f07a25c38f2b1c75 Mon Sep 17 00:00:00 2001
From: hellojukay <hellojukay@163.com>
Date: Tue, 20 Mar 2018 14:42:51 +0800
Subject: [PATCH 30/32] add gin panic time log (#1270)

* add gin pinic time log

* Update recovery.go
---
 recovery.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/recovery.go b/recovery.go
index 89b39fec..dcbeba74 100644
--- a/recovery.go
+++ b/recovery.go
@@ -12,6 +12,7 @@ import (
 	"log"
 	"net/http/httputil"
 	"runtime"
+	"time"
 )
 
 var (
@@ -38,7 +39,7 @@ func RecoveryWithWriter(out io.Writer) HandlerFunc {
 				if logger != nil {
 					stack := stack(3)
 					httprequest, _ := httputil.DumpRequest(c.Request, false)
-					logger.Printf("[Recovery] panic recovered:\n%s\n%s\n%s%s", string(httprequest), err, stack, reset)
+					logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s", timeFormat(time.Now()), string(httprequest), err, stack, reset)
 				}
 				c.AbortWithStatus(500)
 			}
@@ -107,3 +108,8 @@ func function(pc uintptr) []byte {
 	name = bytes.Replace(name, centerDot, dot, -1)
 	return name
 }
+
+func timeFormat(t time.Time) string {
+	var timeString = t.Format("2006/01/02 - 15:04:05")
+	return timeString
+}

From 6d913fc343cfac80d656db5be67a0ffb1323ba0d Mon Sep 17 00:00:00 2001
From: Suhas Karanth <sudo-suhas@users.noreply.github.com>
Date: Thu, 29 Mar 2018 12:03:07 +0530
Subject: [PATCH 31/32] fix(binding): Expose validator engine used by the
 default Validator (#1277)

* fix(binding): Expose validator engine used by the default Validator

- Add func ValidatorEngine for returning the underlying validator engine used
  in the default StructValidator implementation.
- Remove the function RegisterValidation from the StructValidator interface
  which made it immpossible to use a StructValidator implementation without the
  validator.v8 library.
- Update and rename test for registering validation
  Test{RegisterValidation => ValidatorEngine}.
- Update readme and example for registering custom validation.
- Add example for registering struct level validation.
- Add documentation for the following binding funcs/types:
  - Binding interface
  - StructValidator interface
  - Validator instance
  - Binding implementations
  - Default func

* fix(binding): Move validator engine getter inside interface

* docs: rm date cmd from custom validation demo
---
 README.md                                 | 13 +++--
 binding/binding.go                        | 23 +++++---
 binding/default_validator.go              |  8 ++-
 binding/json.go                           |  3 ++
 binding/validate_test.go                  |  9 ++--
 examples/custom-validation/server.go      |  6 ++-
 examples/struct-lvl-validations/README.md | 50 ++++++++++++++++++
 examples/struct-lvl-validations/server.go | 64 +++++++++++++++++++++++
 8 files changed, 161 insertions(+), 15 deletions(-)
 create mode 100644 examples/struct-lvl-validations/README.md
 create mode 100644 examples/struct-lvl-validations/server.go

diff --git a/README.md b/README.md
index 72ac99bd..7dd7f734 100644
--- a/README.md
+++ b/README.md
@@ -564,7 +564,11 @@ func bookableDate(
 
 func main() {
 	route := gin.Default()
-	binding.Validator.RegisterValidation("bookabledate", bookableDate)
+
+	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
+		v.RegisterValidation("bookabledate", bookableDate)
+	}
+
 	route.GET("/bookable", getBookable)
 	route.Run(":8085")
 }
@@ -580,13 +584,16 @@ func getBookable(c *gin.Context) {
 ```
 
 ```console
-$ curl "localhost:8085/bookable?check_in=2017-08-16&check_out=2017-08-17"
+$ curl "localhost:8085/bookable?check_in=2018-04-16&check_out=2018-04-17"
 {"message":"Booking dates are valid!"}
 
-$ curl "localhost:8085/bookable?check_in=2017-08-15&check_out=2017-08-16"
+$ curl "localhost:8085/bookable?check_in=2018-03-08&check_out=2018-03-09"
 {"error":"Key: 'Booking.CheckIn' Error:Field validation for 'CheckIn' failed on the 'bookabledate' tag"}
 ```
 
+[Struct level validations](https://github.com/go-playground/validator/releases/tag/v8.7) can also be registed this way.
+See the [struct-lvl-validation example](examples/struct-lvl-validations) to learn more.
+
 ### Only Bind Query String
 
 `ShouldBindQuery` function only binds the query params and not the post data. See the [detail information](https://github.com/gin-gonic/gin/issues/742#issuecomment-315953017).
diff --git a/binding/binding.go b/binding/binding.go
index dc32d538..646eb80a 100644
--- a/binding/binding.go
+++ b/binding/binding.go
@@ -6,8 +6,6 @@ package binding
 
 import (
 	"net/http"
-
-	"gopkg.in/go-playground/validator.v8"
 )
 
 const (
@@ -23,11 +21,18 @@ const (
 	MIMEMSGPACK2          = "application/msgpack"
 )
 
+// Binding describes the interface which needs to be implemented for binding the
+// data present in the request such as JSON request body, query parameters or
+// the form POST.
 type Binding interface {
 	Name() string
 	Bind(*http.Request, interface{}) error
 }
 
+// StructValidator is the minimal interface which needs to be implemented in
+// order for it to be used as the validator engine for ensuring the correctness
+// of the reqest. Gin provides a default implementation for this using
+// https://github.com/go-playground/validator/tree/v8.18.2.
 type StructValidator interface {
 	// ValidateStruct can receive any kind of type and it should never panic, even if the configuration is not right.
 	// If the received type is not a struct, any validation should be skipped and nil must be returned.
@@ -36,14 +41,18 @@ type StructValidator interface {
 	// Otherwise nil must be returned.
 	ValidateStruct(interface{}) error
 
-	// RegisterValidation adds a validation Func to a Validate's map of validators denoted by the key
-	// NOTE: if the key already exists, the previous validation function will be replaced.
-	// NOTE: this method is not thread-safe it is intended that these all be registered prior to any validation
-	RegisterValidation(string, validator.Func) error
+	// Engine returns the underlying validator engine which powers the
+	// StructValidator implementation.
+	Engine() interface{}
 }
 
+// Validator is the default validator which implements the StructValidator
+// interface. It uses https://github.com/go-playground/validator/tree/v8.18.2
+// under the hood.
 var Validator StructValidator = &defaultValidator{}
 
+// These implement the Binding interface and can be used to bind the data
+// present in the request to struct instances.
 var (
 	JSON          = jsonBinding{}
 	XML           = xmlBinding{}
@@ -55,6 +64,8 @@ var (
 	MsgPack       = msgpackBinding{}
 )
 
+// Default returns the appropriate Binding instance based on the HTTP method
+// and the content type.
 func Default(method, contentType string) Binding {
 	if method == "GET" {
 		return Form
diff --git a/binding/default_validator.go b/binding/default_validator.go
index 6336bb6e..c67aa8a3 100644
--- a/binding/default_validator.go
+++ b/binding/default_validator.go
@@ -28,9 +28,13 @@ func (v *defaultValidator) ValidateStruct(obj interface{}) error {
 	return nil
 }
 
-func (v *defaultValidator) RegisterValidation(key string, fn validator.Func) error {
+// Engine returns the underlying validator engine which powers the default
+// Validator instance. This is useful if you want to register custom validations
+// or struct level validations. See validator GoDoc for more info -
+// https://godoc.org/gopkg.in/go-playground/validator.v8
+func (v *defaultValidator) Engine() interface{} {
 	v.lazyinit()
-	return v.validate.RegisterValidation(key, fn)
+	return v.validate
 }
 
 func (v *defaultValidator) lazyinit() {
diff --git a/binding/json.go b/binding/json.go
index b7c856af..e928a8c1 100644
--- a/binding/json.go
+++ b/binding/json.go
@@ -10,6 +10,9 @@ import (
 	"github.com/gin-gonic/gin/json"
 )
 
+// EnableDecoderUseNumber is used to call the UseNumber method on the JSON
+// Decoder instance. UseNumber causes the Decoder to unmarshal a number into an
+// interface{} as a Number instead of as a float64.
 var EnableDecoderUseNumber = false
 
 type jsonBinding struct{}
diff --git a/binding/validate_test.go b/binding/validate_test.go
index 8ca79989..cb76063c 100644
--- a/binding/validate_test.go
+++ b/binding/validate_test.go
@@ -214,11 +214,14 @@ func notOne(
 	return false
 }
 
-func TestRegisterValidation(t *testing.T) {
+func TestValidatorEngine(t *testing.T) {
 	// This validates that the function `notOne` matches
 	// the expected function signature by `defaultValidator`
 	// and by extension the validator library.
-	err := Validator.RegisterValidation("notone", notOne)
+	engine, ok := Validator.Engine().(*validator.Validate)
+	assert.True(t, ok)
+
+	err := engine.RegisterValidation("notone", notOne)
 	// Check that we can register custom validation without error
 	assert.Nil(t, err)
 
@@ -228,6 +231,6 @@ func TestRegisterValidation(t *testing.T) {
 
 	// Check that we got back non-nil errs
 	assert.NotNil(t, errs)
-	// Check that the error matches expactation
+	// Check that the error matches expectation
 	assert.Error(t, errs, "", "", "notone")
 }
diff --git a/examples/custom-validation/server.go b/examples/custom-validation/server.go
index 31d449f0..dea0c302 100644
--- a/examples/custom-validation/server.go
+++ b/examples/custom-validation/server.go
@@ -30,7 +30,11 @@ func bookableDate(
 
 func main() {
 	route := gin.Default()
-	binding.Validator.RegisterValidation("bookabledate", bookableDate)
+
+	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
+		v.RegisterValidation("bookabledate", bookableDate)
+	}
+
 	route.GET("/bookable", getBookable)
 	route.Run(":8085")
 }
diff --git a/examples/struct-lvl-validations/README.md b/examples/struct-lvl-validations/README.md
new file mode 100644
index 00000000..1bd57f03
--- /dev/null
+++ b/examples/struct-lvl-validations/README.md
@@ -0,0 +1,50 @@
+## Struct level validations
+
+Validations can also be registered at the `struct` level when field level validations
+don't make much sense. This can also be used to solve cross-field validation elegantly.
+Additionally, it can be combined with tag validations. Struct Level validations run after
+the structs tag validations.
+
+### Example requests
+
+```shell
+# Validation errors are generated for struct tags as well as at the struct level
+$ curl -s -X POST http://localhost:8085/user \
+	-H 'content-type: application/json' \
+	-d '{}' | jq
+{
+  "error": "Key: 'User.Email' Error:Field validation for 'Email' failed on the 'required' tag\nKey: 'User.FirstName' Error:Field validation for 'FirstName' failed on the 'fnameorlname' tag\nKey: 'User.LastName' Error:Field validation for 'LastName' failed on the 'fnameorlname' tag",
+  "message": "User validation failed!"
+}
+
+# Validation fails at the struct level because neither first name nor last name are present
+$ curl -s -X POST http://localhost:8085/user \
+    -H 'content-type: application/json' \
+	-d '{"email": "george@vandaley.com"}' | jq
+{
+  "error": "Key: 'User.FirstName' Error:Field validation for 'FirstName' failed on the 'fnameorlname' tag\nKey: 'User.LastName' Error:Field validation for 'LastName' failed on the 'fnameorlname' tag",
+  "message": "User validation failed!"
+}
+
+# No validation errors when either first name or last name is present
+$ curl -X POST http://localhost:8085/user \
+    -H 'content-type: application/json' \
+	-d '{"fname": "George", "email": "george@vandaley.com"}'
+{"message":"User validation successful."}
+
+$ curl -X POST http://localhost:8085/user \
+    -H 'content-type: application/json' \
+	-d '{"lname": "Contanza", "email": "george@vandaley.com"}'
+{"message":"User validation successful."}
+
+$ curl -X POST http://localhost:8085/user \
+    -H 'content-type: application/json' \
+	-d '{"fname": "George", "lname": "Costanza", "email": "george@vandaley.com"}'
+{"message":"User validation successful."}
+```
+
+### Useful links
+
+- Validator docs - https://godoc.org/gopkg.in/go-playground/validator.v8#Validate.RegisterStructValidation
+- Struct level example - https://github.com/go-playground/validator/blob/v8.18.2/examples/struct-level/struct_level.go
+- Validator release notes - https://github.com/go-playground/validator/releases/tag/v8.7
diff --git a/examples/struct-lvl-validations/server.go b/examples/struct-lvl-validations/server.go
new file mode 100644
index 00000000..be807b78
--- /dev/null
+++ b/examples/struct-lvl-validations/server.go
@@ -0,0 +1,64 @@
+package main
+
+import (
+	"net/http"
+	"reflect"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/binding"
+	validator "gopkg.in/go-playground/validator.v8"
+)
+
+// User contains user information.
+type User struct {
+	FirstName string `json:"fname"`
+	LastName  string `json:"lname"`
+	Email     string `binding:"required,email"`
+}
+
+// UserStructLevelValidation contains custom struct level validations that don't always
+// make sense at the field validation level. For example, this function validates that either
+// FirstName or LastName exist; could have done that with a custom field validation but then
+// would have had to add it to both fields duplicating the logic + overhead, this way it's
+// only validated once.
+//
+// NOTE: you may ask why wouldn't not just do this outside of validator. Doing this way
+// hooks right into validator and you can combine with validation tags and still have a
+// common error output format.
+func UserStructLevelValidation(v *validator.Validate, structLevel *validator.StructLevel) {
+	user := structLevel.CurrentStruct.Interface().(User)
+
+	if len(user.FirstName) == 0 && len(user.LastName) == 0 {
+		structLevel.ReportError(
+			reflect.ValueOf(user.FirstName), "FirstName", "fname", "fnameorlname",
+		)
+		structLevel.ReportError(
+			reflect.ValueOf(user.LastName), "LastName", "lname", "fnameorlname",
+		)
+	}
+
+	// plus can to more, even with different tag than "fnameorlname"
+}
+
+func main() {
+	route := gin.Default()
+
+	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
+		v.RegisterStructValidation(UserStructLevelValidation, User{})
+	}
+
+	route.POST("/user", validateUser)
+	route.Run(":8085")
+}
+
+func validateUser(c *gin.Context) {
+	var u User
+	if err := c.ShouldBindJSON(&u); err == nil {
+		c.JSON(http.StatusOK, gin.H{"message": "User validation successful."})
+	} else {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"message": "User validation failed!",
+			"error":   err.Error(),
+		})
+	}
+}

From 6ad7b9c9d382844036334ad061b832e56269e14f Mon Sep 17 00:00:00 2001
From: Yoshiyuki Kinjo <yskkin+github@gmail.com>
Date: Tue, 17 Apr 2018 11:54:40 +0900
Subject: [PATCH 32/32] Fix documentation typo (#1321)

---
 utils.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils.go b/utils.go
index 99d19af4..278029d7 100644
--- a/utils.go
+++ b/utils.go
@@ -49,7 +49,7 @@ func WrapH(h http.Handler) HandlerFunc {
 	}
 }
 
-// H is a shortcup for map[string]interface{}
+// H is a shortcut for map[string]interface{}
 type H map[string]interface{}
 
 // MarshalXML allows type H to be used with xml.Marshal.