Merge branch 'master' into master

2025-10-16 21:32:11 +08:00 · 2020-06-17 11:16:24 +03:00 · 2020-06-17 11:16:24 +03:00 · 90ac8b4ed5
commit 90ac8b4ed5
parent 7c501d507b 5e40c1d49c
36 changed files with 1590 additions and 1154 deletions
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,7 +1,7 @@
 - With pull requests:
  - Open your pull request against `master`
  - Your pull request should have no more than two commits, if not you should squash them.
-  - It should pass all tests in the available continuous integrations systems such as TravisCI.
+  - It should pass all tests in the available continuous integration systems such as TravisCI.
  - You should add/modify tests to cover your proposed code changes.
  - If your pull request contains a new feature, please document it on the README.

--- a/.travis.yml
+++ b/.travis.yml
@ -11,6 +11,10 @@ matrix:
  - go: 1.13.x
    env: 
      - TESTTAGS=nomsgpack
+  - go: 1.14.x
+  - go: 1.14.x
+    env:
+      - TESTTAGS=nomsgpack
  - go: master

 git:
--- a/BENCHMARKS.md
+++ b/BENCHMARKS.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,4 +1,74 @@
-### Gin v1.5.0
+# Gin ChangeLog
+
+## Gin v1.6.3
+
+### ENHANCEMENTS
+
+  * Improve performance: Change `*sync.RWMutex` to `sync.RWMutex` in context. [#2351](https://github.com/gin-gonic/gin/pull/2351)
+
+## Gin v1.6.2
+
+### BUFIXES
+  * fix missing initial sync.RWMutex [#2305](https://github.com/gin-gonic/gin/pull/2305)
+### ENHANCEMENTS
+  * Add set samesite in cookie. [#2306](https://github.com/gin-gonic/gin/pull/2306)
+
+## Gin v1.6.1
+
+### BUFIXES
+  * Revert "fix accept incoming network connections" [#2294](https://github.com/gin-gonic/gin/pull/2294)
+
+## Gin v1.6.0
+
+### BREAKING
+  * chore(performance): Improve performance for adding RemoveExtraSlash flag [#2159](https://github.com/gin-gonic/gin/pull/2159)
+  * drop support govendor [#2148](https://github.com/gin-gonic/gin/pull/2148)
+  * Added support for SameSite cookie flag [#1615](https://github.com/gin-gonic/gin/pull/1615)
+### FEATURES
+  * add yaml negotitation [#2220](https://github.com/gin-gonic/gin/pull/2220)
+  * FileFromFS [#2112](https://github.com/gin-gonic/gin/pull/2112)
+### BUGFIXES
+  * Unix Socket Handling [#2280](https://github.com/gin-gonic/gin/pull/2280)
+  * Use json marshall in context json to fix breaking new line issue. Fixes #2209 [#2228](https://github.com/gin-gonic/gin/pull/2228)
+  * fix accept incoming network connections [#2216](https://github.com/gin-gonic/gin/pull/2216)
+  * Fixed a bug in the calculation of the maximum number of parameters [#2166](https://github.com/gin-gonic/gin/pull/2166)
+  * [FIX] allow empty headers on DataFromReader [#2121](https://github.com/gin-gonic/gin/pull/2121)
+  * Add mutex for protect Context.Keys map [#1391](https://github.com/gin-gonic/gin/pull/1391)
+### ENHANCEMENTS
+  * Add mitigation for log injection [#2277](https://github.com/gin-gonic/gin/pull/2277)
+  * tree: range over nodes values [#2229](https://github.com/gin-gonic/gin/pull/2229)
+  * tree: remove duplicate assignment [#2222](https://github.com/gin-gonic/gin/pull/2222)
+  * chore: upgrade go-isatty and json-iterator/go [#2215](https://github.com/gin-gonic/gin/pull/2215)
+  * path: sync code with httprouter [#2212](https://github.com/gin-gonic/gin/pull/2212)
+  * Use zero-copy approach to convert types between string and byte slice [#2206](https://github.com/gin-gonic/gin/pull/2206)
+  * Reuse bytes when cleaning the URL paths [#2179](https://github.com/gin-gonic/gin/pull/2179)
+  * tree: remove one else statement [#2177](https://github.com/gin-gonic/gin/pull/2177)
+  * tree: sync httprouter update (#2173) (#2172) [#2171](https://github.com/gin-gonic/gin/pull/2171)
+  * tree: sync part httprouter codes and reduce if/else [#2163](https://github.com/gin-gonic/gin/pull/2163)
+  * use http method constant [#2155](https://github.com/gin-gonic/gin/pull/2155)
+  * upgrade go-validator to v10 [#2149](https://github.com/gin-gonic/gin/pull/2149)
+  * Refactor redirect request in gin.go [#1970](https://github.com/gin-gonic/gin/pull/1970)
+  * Add build tag nomsgpack [#1852](https://github.com/gin-gonic/gin/pull/1852)
+### DOCS
+  * docs(path): improve comments [#2223](https://github.com/gin-gonic/gin/pull/2223)
+  * Renew README to fit the modification of SetCookie method [#2217](https://github.com/gin-gonic/gin/pull/2217)
+  * Fix spelling [#2202](https://github.com/gin-gonic/gin/pull/2202)
+  * Remove broken link from README. [#2198](https://github.com/gin-gonic/gin/pull/2198)
+  * Update docs on Context.Done(), Context.Deadline() and Context.Err() [#2196](https://github.com/gin-gonic/gin/pull/2196)
+  * Update validator to v10 [#2190](https://github.com/gin-gonic/gin/pull/2190)
+  * upgrade go-validator to v10 for README [#2189](https://github.com/gin-gonic/gin/pull/2189)
+  * Update to currently output [#2188](https://github.com/gin-gonic/gin/pull/2188)
+  * Fix "Custom Validators" example [#2186](https://github.com/gin-gonic/gin/pull/2186)
+  * Add project to README [#2165](https://github.com/gin-gonic/gin/pull/2165)
+  * docs(benchmarks): for gin v1.5 [#2153](https://github.com/gin-gonic/gin/pull/2153)
+  * Changed wording for clarity in README.md [#2122](https://github.com/gin-gonic/gin/pull/2122)
+### MISC
+  * ci support go1.14 [#2262](https://github.com/gin-gonic/gin/pull/2262)
+  * chore: upgrade depend version [#2231](https://github.com/gin-gonic/gin/pull/2231)
+  * Drop support go1.10 [#2147](https://github.com/gin-gonic/gin/pull/2147)
+  * fix comment in `mode.go` [#2129](https://github.com/gin-gonic/gin/pull/2129)
+
+## Gin v1.5.0

 - [FIX] Use DefaultWriter and DefaultErrorWriter for debug messages [#1891](https://github.com/gin-gonic/gin/pull/1891)
 - [NEW] Now you can parse the inline lowercase start structure [#1893](https://github.com/gin-gonic/gin/pull/1893)
@ -90,7 +160,7 @@
 - [NEW] Upgrade dependency libraries [#1491](https://github.com/gin-gonic/gin/pull/1491)


-### Gin v1.3.0
+## Gin v1.3.0

 - [NEW] Add [`func (*Context) QueryMap`](https://godoc.org/github.com/gin-gonic/gin#Context.QueryMap), [`func (*Context) GetQueryMap`](https://godoc.org/github.com/gin-gonic/gin#Context.GetQueryMap), [`func (*Context) PostFormMap`](https://godoc.org/github.com/gin-gonic/gin#Context.PostFormMap) and [`func (*Context) GetPostFormMap`](https://godoc.org/github.com/gin-gonic/gin#Context.GetPostFormMap) to support `type map[string]string` as query string or form parameters, see [#1383](https://github.com/gin-gonic/gin/pull/1383)
 - [NEW] Add [`func (*Context) AsciiJSON`](https://godoc.org/github.com/gin-gonic/gin#Context.AsciiJSON), see [#1358](https://github.com/gin-gonic/gin/pull/1358)
@ -112,7 +182,7 @@
 - [FIX] Gin Mode `""` when calling [`func Mode`](https://godoc.org/github.com/gin-gonic/gin#Mode) now returns `const DebugMode`, see [#1250](https://github.com/gin-gonic/gin/pull/1250)
 - [FIX] `Flush()` now doesn't overwrite `responseWriter` status code, see [#1460](https://github.com/gin-gonic/gin/pull/1460)

-### Gin 1.2.0
+## Gin 1.2.0

 - [NEW] Switch from godeps to govendor
 - [NEW] Add support for Let's Encrypt via gin-gonic/autotls
@ -135,15 +205,15 @@
 - [FIX] Use X-Forwarded-For before X-Real-Ip
 - [FIX] time.Time binding (#904)

-### Gin 1.1.4
+## Gin 1.1.4

 - [NEW] Support google appengine for IsTerminal func

-### Gin 1.1.3
+## Gin 1.1.3

 - [FIX] Reverted Logger: skip ANSI color commands

-### Gin 1.1
+## Gin 1.1

 - [NEW] Implement QueryArray and PostArray methods 
 - [NEW] Refactor GetQuery and GetPostForm 
@ -153,7 +223,7 @@
 - [FIX] Changed imports to gopkg instead of github in README (#733) 
 - [FIX] Logger: skip ANSI color commands if output is not a tty

-### Gin 1.0rc2 (...)
+## Gin 1.0rc2 (...)

 - [PERFORMANCE] Fast path for writing Content-Type.
 - [PERFORMANCE] Much faster 404 routing
@ -188,7 +258,7 @@
 - [FIX] MIT license in every file


-### Gin 1.0rc1 (May 22, 2015)
+## Gin 1.0rc1 (May 22, 2015)

 - [PERFORMANCE] Zero allocation router
 - [PERFORMANCE] Faster JSON, XML and text rendering
@ -232,7 +302,7 @@
 - [FIX] Better support for Google App Engine (using log instead of fmt)


-### Gin 0.6 (Mar 9, 2015)
+## Gin 0.6 (Mar 9, 2015)

 - [NEW] Support multipart/form-data
 - [NEW] NoMethod handler
@ -242,14 +312,14 @@
 - [FIX] Improve color logger


-### Gin 0.5 (Feb 7, 2015)
+## Gin 0.5 (Feb 7, 2015)

 - [NEW] Content Negotiation
 - [FIX] Solved security bug that allow a client to spoof ip
 - [FIX] Fix unexported/ignored fields in binding


-### Gin 0.4 (Aug 21, 2014)
+## Gin 0.4 (Aug 21, 2014)

 - [NEW] Development mode
 - [NEW] Unit tests
@ -258,7 +328,7 @@
 - [FIX] Improved documentation for model binding


-### Gin 0.3 (Jul 18, 2014)
+## Gin 0.3 (Jul 18, 2014)

 - [PERFORMANCE] Normal log and error log are printed in the same call.
 - [PERFORMANCE] Improve performance of NoRouter()
@ -276,7 +346,7 @@
 - [FIX] Check application/x-www-form-urlencoded when parsing form


-### Gin 0.2b (Jul 08, 2014)
+## Gin 0.2b (Jul 08, 2014)
 - [PERFORMANCE] Using sync.Pool to allocatio/gc overhead
 - [NEW] Travis CI integration
 - [NEW] Completely new logger
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -8,6 +8,6 @@
 - With pull requests:
  - Open your pull request against `master`
  - Your pull request should have no more than two commits, if not you should squash them.
-  - It should pass all tests in the available continuous integrations systems such as TravisCI.
+  - It should pass all tests in the available continuous integration systems such as TravisCI.
  - You should add/modify tests to cover your proposed code changes.
  - If your pull request contains a new feature, please document it on the README.
--- a/README.md
+++ b/README.md
@ -5,35 +5,41 @@
 [![Build Status](https://travis-ci.org/gin-gonic/gin.svg)](https://travis-ci.org/gin-gonic/gin)
 [![codecov](https://codecov.io/gh/gin-gonic/gin/branch/master/graph/badge.svg)](https://codecov.io/gh/gin-gonic/gin)
 [![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)
+[![GoDoc](https://godoc.org/github.com/gin-gonic/gin?status.svg)](https://pkg.go.dev/github.com/gin-gonic/gin?tab=doc)
 [![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)
 [![Sourcegraph](https://sourcegraph.com/github.com/gin-gonic/gin/-/badge.svg)](https://sourcegraph.com/github.com/gin-gonic/gin?badge)
 [![Open Source Helpers](https://www.codetriage.com/gin-gonic/gin/badges/users.svg)](https://www.codetriage.com/gin-gonic/gin)
 [![Release](https://img.shields.io/github/release/gin-gonic/gin.svg?style=flat-square)](https://github.com/gin-gonic/gin/releases)
+[![TODOs](https://badgen.net/https/api.tickgit.com/badgen/github.com/gin-gonic/gin)](https://www.tickgit.com/browse?repo=github.com/gin-gonic/gin)

 Gin is a web framework written in Go (Golang). It features a martini-like API with performance that is up to 40 times faster thanks to [httprouter](https://github.com/julienschmidt/httprouter). If you need performance and good productivity, you will love Gin.


 ## Contents

- [Installation](#installation)
- [Quick start](#quick-start)
- [Benchmarks](#benchmarks)
- [Gin v1.stable](#gin-v1-stable)
- [Build with jsoniter](#build-with-jsoniter)
- [API Examples](#api-examples)
-    - [Using GET,POST,PUT,PATCH,DELETE and OPTIONS](#using-get-post-put-patch-delete-and-options)
+- [Gin Web Framework](#gin-web-framework)
+  - [Contents](#contents)
+  - [Installation](#installation)
+  - [Quick start](#quick-start)
+  - [Benchmarks](#benchmarks)
+  - [Gin v1. stable](#gin-v1-stable)
+  - [Build with jsoniter](#build-with-jsoniter)
+  - [API Examples](#api-examples)
+    - [Using GET, POST, PUT, PATCH, DELETE and OPTIONS](#using-get-post-put-patch-delete-and-options)
    - [Parameters in path](#parameters-in-path)
    - [Querystring parameters](#querystring-parameters)
    - [Multipart/Urlencoded Form](#multiparturlencoded-form)
    - [Another example: query + post form](#another-example-query--post-form)
    - [Map as querystring or postform parameters](#map-as-querystring-or-postform-parameters)
    - [Upload files](#upload-files)
+      - [Single file](#single-file)
+      - [Multiple files](#multiple-files)
    - [Grouping routes](#grouping-routes)
    - [Blank Gin without middleware by default](#blank-gin-without-middleware-by-default)
    - [Using middleware](#using-middleware)
    - [How to write log file](#how-to-write-log-file)
    - [Custom Log Format](#custom-log-format)
+    - [Controlling Log output coloring](#controlling-log-output-coloring)
    - [Model binding and validation](#model-binding-and-validation)
    - [Custom Validators](#custom-validators)
    - [Only Bind Query String](#only-bind-query-string)
@ -43,10 +49,17 @@ Gin is a web framework written in Go (Golang). It features a martini-like API wi
    - [Bind HTML checkboxes](#bind-html-checkboxes)
    - [Multipart/Urlencoded binding](#multiparturlencoded-binding)
    - [XML, JSON, YAML and ProtoBuf rendering](#xml-json-yaml-and-protobuf-rendering)
-    - [JSONP rendering](#jsonp)
+      - [SecureJSON](#securejson)
+      - [JSONP](#jsonp)
+      - [AsciiJSON](#asciijson)
+      - [PureJSON](#purejson)
    - [Serving static files](#serving-static-files)
+    - [Serving data from file](#serving-data-from-file)
    - [Serving data from reader](#serving-data-from-reader)
    - [HTML rendering](#html-rendering)
+      - [Custom Template renderer](#custom-template-renderer)
+      - [Custom Delimiters](#custom-delimiters)
+      - [Custom Template Funcs](#custom-template-funcs)
    - [Multitemplate](#multitemplate)
    - [Redirects](#redirects)
    - [Custom Middleware](#custom-middleware)
@ -55,15 +68,17 @@ Gin is a web framework written in Go (Golang). It features a martini-like API wi
    - [Custom HTTP configuration](#custom-http-configuration)
    - [Support Let's Encrypt](#support-lets-encrypt)
    - [Run multiple service using Gin](#run-multiple-service-using-gin)
-    - [Graceful restart or stop](#graceful-restart-or-stop)
+    - [Graceful shutdown or restart](#graceful-shutdown-or-restart)
+      - [Third-party packages](#third-party-packages)
+      - [Manually](#manually)
    - [Build a single binary with templates](#build-a-single-binary-with-templates)
    - [Bind form-data request with custom struct](#bind-form-data-request-with-custom-struct)
    - [Try to bind body into different structs](#try-to-bind-body-into-different-structs)
    - [http2 server push](#http2-server-push)
    - [Define format for the log of routes](#define-format-for-the-log-of-routes)
    - [Set and get a cookie](#set-and-get-a-cookie)
- [Testing](#testing)
- [Users](#users)
+  - [Testing](#testing)
+  - [Users](#users)

 ## Installation

@ -121,35 +136,38 @@ Gin uses a custom version of [HttpRouter](https://github.com/julienschmidt/httpr

 [See all benchmarks](/BENCHMARKS.md)

-Benchmark name                              | (1)        | (2)         | (3) 		    | (4)
--------------------------------------------|-----------:|------------:|-----------:|---------:
-**BenchmarkGin_GithubAll**                  | **30000**  |  **48375**  |     **0**  |   **0**
-BenchmarkAce_GithubAll                      |   10000    |   134059    |   13792    |   167
-BenchmarkBear_GithubAll                     |    5000    |   534445    |   86448    |   943
-BenchmarkBeego_GithubAll                    |    3000    |   592444    |   74705    |   812
-BenchmarkBone_GithubAll                     |     200    |  6957308    |  698784    |  8453
-BenchmarkDenco_GithubAll                    |   10000    |   158819    |   20224    |   167
-BenchmarkEcho_GithubAll                     |   10000    |   154700    |    6496    |   203
-BenchmarkGocraftWeb_GithubAll               |    3000    |   570806    |  131656    |  1686
-BenchmarkGoji_GithubAll                     |    2000    |   818034    |   56112    |   334
-BenchmarkGojiv2_GithubAll                   |    2000    |  1213973    |  274768    |  3712
-BenchmarkGoJsonRest_GithubAll               |    2000    |   785796    |  134371    |  2737
-BenchmarkGoRestful_GithubAll                |     300    |  5238188    |  689672    |  4519
-BenchmarkGorillaMux_GithubAll               |     100    | 10257726    |  211840    |  2272
-BenchmarkHttpRouter_GithubAll               |   20000    |   105414    |   13792    |   167
-BenchmarkHttpTreeMux_GithubAll              |   10000    |   319934    |   65856    |   671
-BenchmarkKocha_GithubAll                    |   10000    |   209442    |   23304    |   843
-BenchmarkLARS_GithubAll                     |   20000    |    62565    |       0    |     0
-BenchmarkMacaron_GithubAll                  |    2000    |  1161270    |  204194    |  2000
-BenchmarkMartini_GithubAll                  |     200    |  9991713    |  226549    |  2325
-BenchmarkPat_GithubAll                      |     200    |  5590793    | 1499568    | 27435
-BenchmarkPossum_GithubAll                   |   10000    |   319768    |   84448    |   609
-BenchmarkR2router_GithubAll                 |   10000    |   305134    |   77328    |   979
-BenchmarkRivet_GithubAll                    |   10000    |   132134    |   16272    |   167
-BenchmarkTango_GithubAll                    |    3000    |   552754    |   63826    |  1618
-BenchmarkTigerTonic_GithubAll               |    1000    |  1439483    |  239104    |  5374
-BenchmarkTraffic_GithubAll                  |     100    | 11383067    | 2659329    | 21848
-BenchmarkVulcan_GithubAll                   |    5000    |   394253    |   19894    |   609
+| Benchmark name                 |       (1) |             (2) |          (3) |             (4) |
+| ------------------------------ | ---------:| ---------------:| ------------:| ---------------:|
+| BenchmarkGin_GithubAll         | **43550** | **27364 ns/op** |   **0 B/op** | **0 allocs/op** |
+| BenchmarkAce_GithubAll         |     40543 |     29670 ns/op |       0 B/op |     0 allocs/op |
+| BenchmarkAero_GithubAll        |     57632 |     20648 ns/op |       0 B/op |     0 allocs/op |
+| BenchmarkBear_GithubAll        |      9234 |    216179 ns/op |   86448 B/op |   943 allocs/op |
+| BenchmarkBeego_GithubAll       |      7407 |    243496 ns/op |   71456 B/op |   609 allocs/op |
+| BenchmarkBone_GithubAll        |       420 |   2922835 ns/op |  720160 B/op |  8620 allocs/op |
+| BenchmarkChi_GithubAll         |      7620 |    238331 ns/op |   87696 B/op |   609 allocs/op |
+| BenchmarkDenco_GithubAll       |     18355 |     64494 ns/op |   20224 B/op |   167 allocs/op |
+| BenchmarkEcho_GithubAll        |     31251 |     38479 ns/op |       0 B/op |     0 allocs/op |
+| BenchmarkGocraftWeb_GithubAll  |      4117 |    300062 ns/op |  131656 B/op |  1686 allocs/op |
+| BenchmarkGoji_GithubAll        |      3274 |    416158 ns/op |   56112 B/op |   334 allocs/op |
+| BenchmarkGojiv2_GithubAll      |      1402 |    870518 ns/op |  352720 B/op |  4321 allocs/op |
+| BenchmarkGoJsonRest_GithubAll  |      2976 |    401507 ns/op |  134371 B/op |  2737 allocs/op |
+| BenchmarkGoRestful_GithubAll   |       410 |   2913158 ns/op |  910144 B/op |  2938 allocs/op |
+| BenchmarkGorillaMux_GithubAll  |       346 |   3384987 ns/op |  251650 B/op |  1994 allocs/op |
+| BenchmarkGowwwRouter_GithubAll |     10000 |    143025 ns/op |   72144 B/op |   501 allocs/op |
+| BenchmarkHttpRouter_GithubAll  |     55938 |     21360 ns/op |       0 B/op |     0 allocs/op |
+| BenchmarkHttpTreeMux_GithubAll |     10000 |    153944 ns/op |   65856 B/op |   671 allocs/op |
+| BenchmarkKocha_GithubAll       |     10000 |    106315 ns/op |   23304 B/op |   843 allocs/op |
+| BenchmarkLARS_GithubAll        |     47779 |     25084 ns/op |       0 B/op |     0 allocs/op |
+| BenchmarkMacaron_GithubAll     |      3266 |    371907 ns/op |  149409 B/op |  1624 allocs/op |
+| BenchmarkMartini_GithubAll     |       331 |   3444706 ns/op |  226551 B/op |  2325 allocs/op |
+| BenchmarkPat_GithubAll         |       273 |   4381818 ns/op | 1483152 B/op | 26963 allocs/op |
+| BenchmarkPossum_GithubAll      |     10000 |    164367 ns/op |   84448 B/op |   609 allocs/op |
+| BenchmarkR2router_GithubAll    |     10000 |    160220 ns/op |   77328 B/op |   979 allocs/op |
+| BenchmarkRivet_GithubAll       |     14625 |     82453 ns/op |   16272 B/op |   167 allocs/op |
+| BenchmarkTango_GithubAll       |      6255 |    279611 ns/op |   63826 B/op |  1618 allocs/op |
+| BenchmarkTigerTonic_GithubAll  |      2008 |    687874 ns/op |  193856 B/op |  4474 allocs/op |
+| BenchmarkTraffic_GithubAll     |       355 |   3478508 ns/op |  820744 B/op | 14114 allocs/op |
+| BenchmarkVulcan_GithubAll      |      6885 |    193333 ns/op |   19894 B/op |   609 allocs/op |

 - (1): Total Repetitions achieved in constant time, higher means more confident result
 - (2): Single Repetition Duration (ns/op), lower is better
@ -339,14 +357,14 @@ References issue [#774](https://github.com/gin-gonic/gin/issues/774) and detail
 func main() {
 	router := gin.Default()
 	// Set a lower memory limit for multipart forms (default is 32 MiB)
-	// router.MaxMultipartMemory = 8 << 20  // 8 MiB
+	router.MaxMultipartMemory = 8 << 20  // 8 MiB
 	router.POST("/upload", func(c *gin.Context) {
 		// single file
 		file, _ := c.FormFile("file")
 		log.Println(file.Filename)

 		// Upload the file to specific dst.
-		// c.SaveUploadedFile(file, dst)
+		c.SaveUploadedFile(file, dst)

 		c.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))
 	})
@ -370,7 +388,7 @@ See the detail [example code](https://github.com/gin-gonic/examples/tree/master/
 func main() {
 	router := gin.Default()
 	// Set a lower memory limit for multipart forms (default is 32 MiB)
-	// router.MaxMultipartMemory = 8 << 20  // 8 MiB
+	router.MaxMultipartMemory = 8 << 20  // 8 MiB
 	router.POST("/upload", func(c *gin.Context) {
 		// Multipart form
 		form, _ := c.MultipartForm()
@ -380,7 +398,7 @@ func main() {
 			log.Println(file.Filename)

 			// Upload the file to specific dst.
-			// c.SaveUploadedFile(file, dst)
+			c.SaveUploadedFile(file, dst)
 		}
 		c.String(http.StatusOK, fmt.Sprintf("%d files uploaded!", len(files)))
 	})
@ -1170,6 +1188,24 @@ func main() {
 }
 ```

+### Serving data from file
+
+```go
+func main() {
+	router := gin.Default()
+
+	router.GET("/local/file", func(c *gin.Context) {
+		c.File("local/file.go")
+	})
+
+	var fs http.FileSystem = // ...
+	router.GET("/fs/file", func(c *gin.Context) {
+		c.FileFromFS("fs/file.go", fs)
+	})
+}
+
+```
+
 ### Serving data from reader

 ```go
@ -1358,6 +1394,12 @@ r.GET("/test", func(c *gin.Context) {
 })
 ```

+Issuing a HTTP redirect from POST. Refer to issue: [#444](https://github.com/gin-gonic/gin/issues/444)
+```go
+r.POST("/test", func(c *gin.Context) {
+	c.Redirect(http.StatusFound, "/foo")
+})
+```

 Issuing a Router redirect, use `HandleContext` like below.

@ -1657,12 +1699,13 @@ func main() {
 }
 ```

-### Graceful restart or stop
+### Graceful shutdown or restart

-Do you want to graceful restart or stop your web server?
-There are some ways this can be done.
+There are a few approaches you can use to perform a graceful shutdown or restart. You can make use of third-party packages specifically built for that, or you can manually do the same with the functions and methods from the built-in packages.

-We can use [fvbock/endless](https://github.com/fvbock/endless) to replace the default `ListenAndServe`. Refer issue [#296](https://github.com/gin-gonic/gin/issues/296) for more details.
+#### Third-party packages
+
+We can use [fvbock/endless](https://github.com/fvbock/endless) to replace the default `ListenAndServe`. Refer to issue [#296](https://github.com/gin-gonic/gin/issues/296) for more details.

 ```go
 router := gin.Default()
@ -1671,13 +1714,15 @@ router.GET("/", handler)
 endless.ListenAndServe(":4242", router)
 ```

-An alternative to endless:
+Alternatives:

 * [manners](https://github.com/braintree/manners): A polite Go HTTP server that shuts down gracefully.
 * [graceful](https://github.com/tylerb/graceful): Graceful is a Go package enabling graceful shutdown of an http.Handler server.
 * [grace](https://github.com/facebookgo/grace): Graceful restart & zero downtime deploy for Go servers.

-If you are using Go 1.8, you may not need to use this library! Consider using http.Server's built-in [Shutdown()](https://golang.org/pkg/net/http/#Server.Shutdown) method for graceful shutdowns. See the full [graceful-shutdown](https://github.com/gin-gonic/examples/tree/master/graceful-shutdown) example with gin.
+#### Manually
+
+In case you are using Go 1.8 or a later version, you may not need to use those libraries. Consider using `http.Server`'s built-in [Shutdown()](https://golang.org/pkg/net/http/#Server.Shutdown) method for graceful shutdowns. The example below describes its usage, and we've got more examples using gin [here](https://github.com/gin-gonic/examples/tree/master/graceful-shutdown).

 ```go
 // +build go1.8
@ -1708,8 +1753,9 @@ func main() {
 		Handler: router,
 	}

+	// Initializing the server in a goroutine so that
+	// it won't block the graceful shutdown handling below
 	go func() {
-		// service connections
 		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 			log.Fatalf("listen: %s\n", err)
 		}
@ -1723,18 +1769,16 @@ func main() {
 	// kill -9 is syscall.SIGKILL but can't be catch, so don't need add it
 	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 	<-quit
-	log.Println("Shutdown Server ...")
+	log.Println("Shutting down server...")

+	// The context is used to inform the server it has 5 seconds to finish
+	// the request it is currently handling
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 	if err := srv.Shutdown(ctx); err != nil {
-		log.Fatal("Server Shutdown:", err)
-	}
-	// catching ctx.Done(). timeout of 5 seconds.
-	select {
-	case <-ctx.Done():
-		log.Println("timeout of 5 seconds.")
+		log.Fatal("Server forced to shutdown:", err)
 	}
+	
 	log.Println("Server exiting")
 }
 ```
--- a/auth.go
+++ b/auth.go
@ -8,6 +8,8 @@ import (
 	"encoding/base64"
 	"net/http"
 	"strconv"
+
+	"github.com/gin-gonic/gin/internal/bytesconv"
 )

 // AuthUserKey is the cookie name for user credential in basic auth.
@ -68,8 +70,9 @@ func BasicAuth(accounts Accounts) HandlerFunc {
 }

 func processAccounts(accounts Accounts) authPairs {
-	assert1(len(accounts) > 0, "Empty list of authorized credentials")
-	pairs := make(authPairs, 0, len(accounts))
+	length := len(accounts)
+	assert1(length > 0, "Empty list of authorized credentials")
+	pairs := make(authPairs, 0, length)
 	for user, password := range accounts {
 		assert1(user != "", "User can not be empty")
 		value := authorizationHeader(user, password)
@ -83,5 +86,5 @@ func processAccounts(accounts Accounts) authPairs {

 func authorizationHeader(user, password string) string {
 	base := user + ":" + password
-	return "Basic " + base64.StdEncoding.EncodeToString([]byte(base))
+	return "Basic " + base64.StdEncoding.EncodeToString(bytesconv.StringToBytes(base))
 }
--- a/binding/form_mapping.go
+++ b/binding/form_mapping.go
@ -12,6 +12,7 @@ import (
 	"strings"
 	"time"

+	"github.com/gin-gonic/gin/internal/bytesconv"
 	"github.com/gin-gonic/gin/internal/json"
 )

@ -208,9 +209,9 @@ func setWithProperType(val string, value reflect.Value, field reflect.StructFiel
 		case time.Time:
 			return setTimeField(val, field, value)
 		}
-		return json.Unmarshal([]byte(val), value.Addr().Interface())
+		return json.Unmarshal(bytesconv.StringToBytes(val), value.Addr().Interface())
 	case reflect.Map:
-		return json.Unmarshal([]byte(val), value.Addr().Interface())
+		return json.Unmarshal(bytesconv.StringToBytes(val), value.Addr().Interface())
 	default:
 		return errUnknownType
 	}
--- a/context.go
+++ b/context.go
@ -16,6 +16,7 @@ import (
 	"net/url"
 	"os"
 	"strings"
+	"sync"
 	"time"

 	"github.com/gin-contrib/sse"
@ -33,9 +34,11 @@ const (
 	MIMEPOSTForm          = binding.MIMEPOSTForm
 	MIMEMultipartPOSTForm = binding.MIMEMultipartPOSTForm
 	MIMEYAML              = binding.MIMEYAML
-	BodyBytesKey          = "_gin-gonic/gin/bodybyteskey"
 )

+// BodyBytesKey indicates a default body bytes key.
+const BodyBytesKey = "_gin-gonic/gin/bodybyteskey"
+
 const abortIndex int8 = math.MaxInt8 / 2

 // Context is the most important part of gin. It allows us to pass variables between middleware,
@ -51,6 +54,10 @@ type Context struct {
 	fullPath string

 	engine *Engine
+	params *Params
+
+	// This mutex protect Keys map
+	mu sync.RWMutex

 	// Keys is a key/value pair exclusively for the context of each request.
 	Keys map[string]interface{}
@ -67,6 +74,10 @@ type Context struct {
 	// formCache use url.ParseQuery cached PostForm contains the parsed form data from POST, PATCH,
 	// or PUT body parameters.
 	formCache url.Values
+
+	// SameSite allows a server to define a cookie attribute making it impossible for
+	// the browser to send this cookie along with cross-site requests.
+	sameSite http.SameSite
 }

 /************************************/
@ -78,18 +89,25 @@ func (c *Context) reset() {
 	c.Params = c.Params[0:0]
 	c.handlers = nil
 	c.index = -1
+
 	c.fullPath = ""
 	c.Keys = nil
 	c.Errors = c.Errors[0:0]
 	c.Accepted = nil
 	c.queryCache = nil
 	c.formCache = nil
+	*c.params = (*c.params)[0:0]
 }

 // Copy returns a copy of the current context that can be safely used outside the request's scope.
 // This has to be used when the context has to be passed to a goroutine.
 func (c *Context) Copy() *Context {
-	var cp = *c
+	cp := Context{
+		writermem: c.writermem,
+		Request:   c.Request,
+		Params:    c.Params,
+		engine:    c.engine,
+	}
 	cp.writermem.ResponseWriter = nil
 	cp.Writer = &cp.writermem
 	cp.index = abortIndex
@ -219,16 +237,21 @@ func (c *Context) Error(err error) *Error {
 // Set is used to store a new key/value pair exclusively for this context.
 // It also lazy initializes  c.Keys if it was not used previously.
 func (c *Context) Set(key string, value interface{}) {
+	c.mu.Lock()
 	if c.Keys == nil {
 		c.Keys = make(map[string]interface{})
 	}
+
 	c.Keys[key] = value
+	c.mu.Unlock()
 }

 // Get returns the value for the given key, ie: (value, true).
 // If the value does not exists it returns (nil, false)
 func (c *Context) Get(key string) (value interface{}, exists bool) {
+	c.mu.RLock()
 	value, exists = c.Keys[key]
+	c.mu.RUnlock()
 	return
 }

@ -391,7 +414,7 @@ func (c *Context) QueryArray(key string) []string {
 	return values
 }

-func (c *Context) getQueryCache() {
+func (c *Context) initQueryCache() {
 	if c.queryCache == nil {
 		c.queryCache = c.Request.URL.Query()
 	}
@ -400,7 +423,7 @@ func (c *Context) getQueryCache() {
 // GetQueryArray returns a slice of strings for a given query key, plus
 // a boolean value whether at least one value exists for the given key.
 func (c *Context) GetQueryArray(key string) ([]string, bool) {
-	c.getQueryCache()
+	c.initQueryCache()
 	if values, ok := c.queryCache[key]; ok && len(values) > 0 {
 		return values, true
 	}
@ -416,7 +439,7 @@ func (c *Context) QueryMap(key string) map[string]string {
 // GetQueryMap returns a map for a given query key, plus a boolean value
 // whether at least one value exists for the given key.
 func (c *Context) GetQueryMap(key string) (map[string]string, bool) {
-	c.getQueryCache()
+	c.initQueryCache()
 	return c.get(c.queryCache, key)
 }

@ -458,7 +481,7 @@ func (c *Context) PostFormArray(key string) []string {
 	return values
 }

-func (c *Context) getFormCache() {
+func (c *Context) initFormCache() {
 	if c.formCache == nil {
 		c.formCache = make(url.Values)
 		req := c.Request
@ -474,7 +497,7 @@ func (c *Context) getFormCache() {
 // GetPostFormArray returns a slice of strings for a given form key, plus
 // a boolean value whether at least one value exists for the given key.
 func (c *Context) GetPostFormArray(key string) ([]string, bool) {
-	c.getFormCache()
+	c.initFormCache()
 	if values := c.formCache[key]; len(values) > 0 {
 		return values, true
 	}
@ -490,7 +513,7 @@ func (c *Context) PostFormMap(key string) map[string]string {
 // GetPostFormMap returns a map for a given form key, plus a boolean value
 // whether at least one value exists for the given key.
 func (c *Context) GetPostFormMap(key string) (map[string]string, bool) {
-	c.getFormCache()
+	c.initFormCache()
 	return c.get(c.formCache, key)
 }

@ -772,6 +795,11 @@ func (c *Context) GetRawData() ([]byte, error) {
 	return ioutil.ReadAll(c.Request.Body)
 }

+// SetSameSite with cookie
+func (c *Context) SetSameSite(samesite http.SameSite) {
+	c.sameSite = samesite
+}
+
 // SetCookie adds a Set-Cookie header to the ResponseWriter's headers.
 // The provided cookie must have a valid Name. Invalid cookies may be
 // silently dropped.
@ -785,6 +813,7 @@ func (c *Context) SetCookie(name, value string, maxAge int, path, domain string,
 		MaxAge:   maxAge,
 		Path:     path,
 		Domain:   domain,
+		SameSite: c.sameSite,
 		Secure:   secure,
 		HttpOnly: httpOnly,
 	})
@ -839,7 +868,7 @@ func (c *Context) IndentedJSON(code int, obj interface{}) {
 // Default prepends "while(1)," to response body if the given struct is array values.
 // It also sets the Content-Type as "application/json".
 func (c *Context) SecureJSON(code int, obj interface{}) {
-	c.Render(code, render.SecureJSON{Prefix: c.engine.secureJsonPrefix, Data: obj})
+	c.Render(code, render.SecureJSON{Prefix: c.engine.secureJSONPrefix, Data: obj})
 }

 // JSONP serializes the given struct as JSON into the response body.
@ -925,6 +954,17 @@ func (c *Context) File(filepath string) {
 	http.ServeFile(c.Writer, c.Request, filepath)
 }

+// FileFromFS writes the specified file from http.FileSytem into the body stream in an efficient way.
+func (c *Context) FileFromFS(filepath string, fs http.FileSystem) {
+	defer func(old string) {
+		c.Request.URL.Path = old
+	}(c.Request.URL.Path)
+
+	c.Request.URL.Path = filepath
+
+	http.FileServer(fs).ServeHTTP(c.Writer, c.Request)
+}
+
 // FileAttachment writes the specified file into the body stream in an efficient way
 // On the client side, the file will typically be downloaded with the given filename
 func (c *Context) FileAttachment(filepath, filename string) {
@ -970,6 +1010,7 @@ type Negotiate struct {
 	HTMLData interface{}
 	JSONData interface{}
 	XMLData  interface{}
+	YAMLData interface{}
 	Data     interface{}
 }

@ -988,6 +1029,10 @@ func (c *Context) Negotiate(code int, config Negotiate) {
 		data := chooseData(config.XMLData, config.Data)
 		c.XML(code, data)

+	case binding.MIMEYAML:
+		data := chooseData(config.YAMLData, config.Data)
+		c.YAML(code, data)
+
 	default:
 		c.AbortWithError(http.StatusNotAcceptable, errors.New("the accepted formats are not offered by the server")) // nolint: errcheck
 	}
--- a/context_test.go
+++ b/context_test.go
@ -604,14 +604,16 @@ func TestContextPostFormMultipart(t *testing.T) {

 func TestContextSetCookie(t *testing.T) {
 	c, _ := CreateTestContext(httptest.NewRecorder())
+	c.SetSameSite(http.SameSiteLaxMode)
 	c.SetCookie("user", "gin", 1, "/", "localhost", true, true)
-	assert.Equal(t, "user=gin; Path=/; Domain=localhost; Max-Age=1; HttpOnly; Secure", c.Writer.Header().Get("Set-Cookie"))
+	assert.Equal(t, "user=gin; Path=/; Domain=localhost; Max-Age=1; HttpOnly; Secure; SameSite=Lax", c.Writer.Header().Get("Set-Cookie"))
 }

 func TestContextSetCookiePathEmpty(t *testing.T) {
 	c, _ := CreateTestContext(httptest.NewRecorder())
+	c.SetSameSite(http.SameSiteLaxMode)
 	c.SetCookie("user", "gin", 1, "", "localhost", true, true)
-	assert.Equal(t, "user=gin; Path=/; Domain=localhost; Max-Age=1; HttpOnly; Secure", c.Writer.Header().Get("Set-Cookie"))
+	assert.Equal(t, "user=gin; Path=/; Domain=localhost; Max-Age=1; HttpOnly; Secure; SameSite=Lax", c.Writer.Header().Get("Set-Cookie"))
 }

 func TestContextGetCookie(t *testing.T) {
@ -660,7 +662,7 @@ func TestContextRenderJSON(t *testing.T) {
 	c.JSON(http.StatusCreated, H{"foo": "bar", "html": "<b>"})

 	assert.Equal(t, http.StatusCreated, w.Code)
-	assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"\\u003cb\\u003e\"}\n", w.Body.String())
+	assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"\\u003cb\\u003e\"}", w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }

@ -688,7 +690,7 @@ func TestContextRenderJSONPWithoutCallback(t *testing.T) {
 	c.JSONP(http.StatusCreated, H{"foo": "bar"})

 	assert.Equal(t, http.StatusCreated, w.Code)
-	assert.Equal(t, "{\"foo\":\"bar\"}\n", w.Body.String())
+	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }

@ -714,7 +716,7 @@ func TestContextRenderAPIJSON(t *testing.T) {
 	c.JSON(http.StatusCreated, H{"foo": "bar"})

 	assert.Equal(t, http.StatusCreated, w.Code)
-	assert.Equal(t, "{\"foo\":\"bar\"}\n", w.Body.String())
+	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
 	assert.Equal(t, "application/vnd.api+json", w.Header().Get("Content-Type"))
 }

@ -990,6 +992,19 @@ func TestContextRenderFile(t *testing.T) {
 	assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
 }

+func TestContextRenderFileFromFS(t *testing.T) {
+	w := httptest.NewRecorder()
+	c, _ := CreateTestContext(w)
+
+	c.Request, _ = http.NewRequest("GET", "/some/path", nil)
+	c.FileFromFS("./gin.go", Dir(".", false))
+
+	assert.Equal(t, http.StatusOK, w.Code)
+	assert.Contains(t, w.Body.String(), "func New() *Engine {")
+	assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
+	assert.Equal(t, "/some/path", c.Request.URL.Path)
+}
+
 func TestContextRenderAttachment(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
@ -1112,12 +1127,12 @@ func TestContextNegotiationWithJSON(t *testing.T) {
 	c.Request, _ = http.NewRequest("POST", "", nil)

 	c.Negotiate(http.StatusOK, Negotiate{
-		Offered: []string{MIMEJSON, MIMEXML},
+		Offered: []string{MIMEJSON, MIMEXML, MIMEYAML},
 		Data:    H{"foo": "bar"},
 	})

 	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Equal(t, "{\"foo\":\"bar\"}\n", w.Body.String())
+	assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }

@ -1127,7 +1142,7 @@ func TestContextNegotiationWithXML(t *testing.T) {
 	c.Request, _ = http.NewRequest("POST", "", nil)

 	c.Negotiate(http.StatusOK, Negotiate{
-		Offered: []string{MIMEXML, MIMEJSON},
+		Offered: []string{MIMEXML, MIMEJSON, MIMEYAML},
 		Data:    H{"foo": "bar"},
 	})

@ -1281,7 +1296,7 @@ func TestContextAbortWithStatusJSON(t *testing.T) {
 	_, err := buf.ReadFrom(w.Body)
 	assert.NoError(t, err)
 	jsonStringBody := buf.String()
-	assert.Equal(t, fmt.Sprint("{\"foo\":\"fooValue\",\"bar\":\"barValue\"}\n"), jsonStringBody)
+	assert.Equal(t, fmt.Sprint("{\"foo\":\"fooValue\",\"bar\":\"barValue\"}"), jsonStringBody)
 }

 func TestContextError(t *testing.T) {
@ -1903,3 +1918,16 @@ func TestRaceParamsContextCopy(t *testing.T) {
 	performRequest(router, "GET", "/name2/api")
 	wg.Wait()
 }
+
+func TestContextWithKeysMutex(t *testing.T) {
+	c := &Context{}
+	c.Set("foo", "bar")
+
+	value, err := c.Get("foo")
+	assert.Equal(t, "bar", value)
+	assert.True(t, err)
+
+	value, err = c.Get("foo2")
+	assert.Nil(t, value)
+	assert.False(t, err)
+}
--- a/debug_test.go
+++ b/debug_test.go
@ -7,6 +7,7 @@ package gin
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"html/template"
 	"io"
 	"log"
@ -64,6 +65,18 @@ func TestDebugPrintRoutes(t *testing.T) {
 	assert.Regexp(t, `^\[GIN-debug\] GET    /path/to/route/:param     --> (.*/vendor/)?github.com/gin-gonic/gin.handlerNameTest \(2 handlers\)\n$`, re)
 }

+func TestDebugPrintRouteFunc(t *testing.T) {
+	DebugPrintRouteFunc = func(httpMethod, absolutePath, handlerName string, nuHandlers int) {
+		fmt.Fprintf(DefaultWriter, "[GIN-debug] %-6s %-40s --> %s (%d handlers)\n", httpMethod, absolutePath, handlerName, nuHandlers)
+	}
+	re := captureOutput(t, func() {
+		SetMode(DebugMode)
+		debugPrintRoute("GET", "/path/to/route/:param1/:param2", HandlersChain{func(c *Context) {}, handlerNameTest})
+		SetMode(TestMode)
+	})
+	assert.Regexp(t, `^\[GIN-debug\] GET    /path/to/route/:param1/:param2           --> (.*/vendor/)?github.com/gin-gonic/gin.handlerNameTest \(2 handlers\)\n$`, re)
+}
+
 func TestDebugPrintLoadTemplate(t *testing.T) {
 	re := captureOutput(t, func() {
 		SetMode(DebugMode)
--- a/errors.go
+++ b/errors.go
@ -55,7 +55,7 @@ func (msg *Error) SetMeta(data interface{}) *Error {

 // JSON creates a properly formatted JSON
 func (msg *Error) JSON() interface{} {
-	json := H{}
+	jsonData := H{}
 	if msg.Meta != nil {
 		value := reflect.ValueOf(msg.Meta)
 		switch value.Kind() {
@ -63,16 +63,16 @@ func (msg *Error) JSON() interface{} {
 			return msg.Meta
 		case reflect.Map:
 			for _, key := range value.MapKeys() {
-				json[key.String()] = value.MapIndex(key).Interface()
+				jsonData[key.String()] = value.MapIndex(key).Interface()
 			}
 		default:
-			json["meta"] = msg.Meta
+			jsonData["meta"] = msg.Meta
 		}
 	}
-	if _, ok := json["error"]; !ok {
-		json["error"] = msg.Error()
+	if _, ok := jsonData["error"]; !ok {
+		jsonData["error"] = msg.Error()
 	}
-	return json
+	return jsonData
 }

 // MarshalJSON implements the json.Marshaller interface.
@ -135,17 +135,17 @@ func (a errorMsgs) Errors() []string {
 }

 func (a errorMsgs) JSON() interface{} {
-	switch len(a) {
+	switch length := len(a); length {
 	case 0:
 		return nil
 	case 1:
 		return a.Last().JSON()
 	default:
-		json := make([]interface{}, len(a))
+		jsonData := make([]interface{}, length)
 		for i, err := range a {
-			json[i] = err.JSON()
+			jsonData[i] = err.JSON()
 		}
-		return json
+		return jsonData
 	}
 }

--- a/fs.go
+++ b/fs.go
@ -9,7 +9,7 @@ import (
 	"os"
 )

-type onlyfilesFS struct {
+type onlyFilesFS struct {
 	fs http.FileSystem
 }

@ -26,11 +26,11 @@ func Dir(root string, listDirectory bool) http.FileSystem {
 	if listDirectory {
 		return fs
 	}
-	return &onlyfilesFS{fs}
+	return &onlyFilesFS{fs}
 }

 // Open conforms to http.Filesystem.
-func (fs onlyfilesFS) Open(name string) (http.File, error) {
+func (fs onlyFilesFS) Open(name string) (http.File, error) {
 	f, err := fs.fs.Open(name)
 	if err != nil {
 		return nil, err
--- a/gin.go
+++ b/gin.go
@ -13,17 +13,19 @@ import (
 	"path"
 	"sync"

+	"github.com/gin-gonic/gin/internal/bytesconv"
 	"github.com/gin-gonic/gin/render"
 )

 const defaultMultipartMemory = 32 << 20 // 32 MB

 var (
-	default404Body   = []byte("404 page not found")
-	default405Body   = []byte("405 method not allowed")
-	defaultAppEngine bool
+	default404Body = []byte("404 page not found")
+	default405Body = []byte("405 method not allowed")
 )

+var defaultAppEngine bool
+
 // HandlerFunc defines the handler used by gin middleware as return value.
 type HandlerFunc func(*Context)

@ -102,7 +104,7 @@ type Engine struct {
 	RemoveExtraSlash bool

 	delims           render.Delims
-	secureJsonPrefix string
+	secureJSONPrefix string
 	HTMLRender       render.HTMLRender
 	FuncMap          template.FuncMap
 	allNoRoute       HandlersChain
@ -111,6 +113,7 @@ type Engine struct {
 	noMethod         HandlersChain
 	pool             sync.Pool
 	trees            methodTrees
+	maxParams        uint16
 }

 var _ IRouter = &Engine{}
@ -143,7 +146,7 @@ func New() *Engine {
 		MaxMultipartMemory:     defaultMultipartMemory,
 		trees:                  make(methodTrees, 0, 9),
 		delims:                 render.Delims{Left: "{{", Right: "}}"},
-		secureJsonPrefix:       "while(1);",
+		secureJSONPrefix:       "while(1);",
 	}
 	engine.RouterGroup.engine = engine
 	engine.pool.New = func() interface{} {
@ -161,7 +164,8 @@ func Default() *Engine {
 }

 func (engine *Engine) allocateContext() *Context {
-	return &Context{engine: engine}
+	v := make(Params, 0, engine.maxParams)
+	return &Context{engine: engine, params: &v}
 }

 // Delims sets template left and right delims and returns a Engine instance.
@ -170,9 +174,9 @@ func (engine *Engine) Delims(left, right string) *Engine {
 	return engine
 }

-// SecureJsonPrefix sets the secureJsonPrefix used in Context.SecureJSON.
+// SecureJsonPrefix sets the secureJSONPrefix used in Context.SecureJSON.
 func (engine *Engine) SecureJsonPrefix(prefix string) *Engine {
-	engine.secureJsonPrefix = prefix
+	engine.secureJSONPrefix = prefix
 	return engine
 }

@ -254,6 +258,7 @@ func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {
 	assert1(len(handlers) > 0, "there must be at least one handler")

 	debugPrintRoute(method, path, handlers)
+
 	root := engine.trees.get(method)
 	if root == nil {
 		root = new(node)
@ -261,6 +266,11 @@ func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {
 		engine.trees = append(engine.trees, methodTree{method: method, root: root})
 	}
 	root.addRoute(path, handlers)
+
+	// Update maxParams
+	if paramsCount := countParams(path); paramsCount > engine.maxParams {
+		engine.maxParams = paramsCount
+	}
 }

 // Routes returns a slice of registered routes, including some useful information, such as:
@ -319,16 +329,13 @@ func (engine *Engine) RunUnix(file string) (err error) {
 	debugPrint("Listening and serving HTTP on unix:/%s", file)
 	defer func() { debugPrintError(err) }()

-	os.Remove(file)
 	listener, err := net.Listen("unix", file)
 	if err != nil {
 		return
 	}
 	defer listener.Close()
-	err = os.Chmod(file, 0777)
-	if err != nil {
-		return
-	}
+	defer os.Remove(file)
+
 	err = http.Serve(listener, engine)
 	return
 }
@ -403,10 +410,12 @@ func (engine *Engine) handleHTTPRequest(c *Context) {
 		}
 		root := t[i].root
 		// Find route in tree
-		value := root.getValue(rPath, c.Params, unescape)
+		value := root.getValue(rPath, c.params, unescape)
+		if value.params != nil {
+			c.Params = *value.params
+		}
 		if value.handlers != nil {
 			c.handlers = value.handlers
-			c.Params = value.params
 			c.fullPath = value.fullPath
 			c.Next()
 			c.writermem.WriteHeaderNow()
@ -477,7 +486,7 @@ func redirectFixedPath(c *Context, root *node, trailingSlash bool) bool {
 	rPath := req.URL.Path

 	if fixedPath, ok := root.findCaseInsensitivePath(cleanPath(rPath), trailingSlash); ok {
-		req.URL.Path = string(fixedPath)
+		req.URL.Path = bytesconv.BytesToString(fixedPath)
 		redirectRequest(c)
 		return true
 	}
--- a/gin_integration_test.go
+++ b/gin_integration_test.go
@ -146,15 +146,19 @@ func TestRunWithPort(t *testing.T) {
 func TestUnixSocket(t *testing.T) {
 	router := New()

+	unixTestSocket := "/tmp/unix_unit_test"
+
+	defer os.Remove(unixTestSocket)
+
 	go func() {
 		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })
-		assert.NoError(t, router.RunUnix("/tmp/unix_unit_test"))
+		assert.NoError(t, router.RunUnix(unixTestSocket))
 	}()
 	// have to wait for the goroutine to start and run the server
 	// otherwise the main thread will complete
 	time.Sleep(5 * time.Millisecond)

-	c, err := net.Dial("unix", "/tmp/unix_unit_test")
+	c, err := net.Dial("unix", unixTestSocket)
 	assert.NoError(t, err)

 	fmt.Fprint(c, "GET /example HTTP/1.0\r\n\r\n")
--- a/githubapi_test.go
+++ b/githubapi_test.go
@ -291,13 +291,13 @@ func TestShouldBindUri(t *testing.T) {

 	type Person struct {
 		Name string `uri:"name" binding:"required"`
-		Id   string `uri:"id" binding:"required"`
+		ID   string `uri:"id" binding:"required"`
 	}
 	router.Handle(http.MethodGet, "/rest/:name/:id", func(c *Context) {
 		var person Person
 		assert.NoError(t, c.ShouldBindUri(&person))
 		assert.True(t, "" != person.Name)
-		assert.True(t, "" != person.Id)
+		assert.True(t, "" != person.ID)
 		c.String(http.StatusOK, "ShouldBindUri test OK")
 	})

@ -313,13 +313,13 @@ func TestBindUri(t *testing.T) {

 	type Person struct {
 		Name string `uri:"name" binding:"required"`
-		Id   string `uri:"id" binding:"required"`
+		ID   string `uri:"id" binding:"required"`
 	}
 	router.Handle(http.MethodGet, "/rest/:name/:id", func(c *Context) {
 		var person Person
 		assert.NoError(t, c.BindUri(&person))
 		assert.True(t, "" != person.Name)
-		assert.True(t, "" != person.Id)
+		assert.True(t, "" != person.ID)
 		c.String(http.StatusOK, "BindUri test OK")
 	})

--- a/go.mod
+++ b/go.mod
@ -1,14 +1,14 @@
 module github.com/gin-gonic/gin

-go 1.12
+go 1.13

 require (
 	github.com/gin-contrib/sse v0.1.0
-	github.com/go-playground/validator/v10 v10.0.1
-	github.com/golang/protobuf v1.3.2
-	github.com/json-iterator/go v1.1.7
-	github.com/mattn/go-isatty v0.0.9
+	github.com/go-playground/validator/v10 v10.2.0
+	github.com/golang/protobuf v1.3.3
+	github.com/json-iterator/go v1.1.9
+	github.com/mattn/go-isatty v0.0.12
 	github.com/stretchr/testify v1.4.0
 	github.com/ugorji/go/codec v1.1.7
-	gopkg.in/yaml.v2 v2.2.2
+	gopkg.in/yaml.v2 v2.2.8
 )
--- a/go.sum
+++ b/go.sum
@ -9,17 +9,17 @@ github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8c
 github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
 github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
 github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
-github.com/go-playground/validator/v10 v10.0.1 h1:QgDDZpXlR/L3atIL2PbFt0TpazbtN7N6PxTGcgcyEUg=
-github.com/go-playground/validator/v10 v10.0.1/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
-github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1Vv0sFl1UcHBOY=
+github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
+github.com/golang/protobuf v1.3.3 h1:gyjaxf+svBWX08ZjK86iN9geUJF0H6gp2IRKX6Nf6/I=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/json-iterator/go v1.1.7 h1:KfgG9LzI+pYjr4xvmz/5H4FXjokeP+rlHLhv3iH62Fo=
-github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGns=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
 github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
-github.com/mattn/go-isatty v0.0.9 h1:d5US/mDsogSGW37IV293h//ZFaeajb69h+EHFsv2xGg=
-github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg=
@ -34,11 +34,12 @@ github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
 github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
 github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
 github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a h1:aYOabOQFp6Vj6W1F80affTUvO9UxmJRx8K0gsfABByQ=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42 h1:vEOn+mP2zCOVzKckCZy6YsCtDblrpj/w7B9nxGNELpg=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
--- a/internal/bytesconv/bytesconv.go
+++ b/internal/bytesconv/bytesconv.go
@ -0,0 +1,23 @@
+// Copyright 2020 Gin Core Team. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package bytesconv
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// StringToBytes converts string to byte slice without a memory allocation.
+func StringToBytes(s string) (b []byte) {
+	sh := *(*reflect.StringHeader)(unsafe.Pointer(&s))
+	bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	bh.Data, bh.Len, bh.Cap = sh.Data, sh.Len, sh.Len
+	return b
+}
+
+// BytesToString converts byte slice to string without a memory allocation.
+func BytesToString(b []byte) string {
+	return *(*string)(unsafe.Pointer(&b))
+}
--- a/internal/bytesconv/bytesconv_test.go
+++ b/internal/bytesconv/bytesconv_test.go
@ -0,0 +1,99 @@
+// Copyright 2020 Gin Core Team. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package bytesconv
+
+import (
+	"bytes"
+	"math/rand"
+	"strings"
+	"testing"
+	"time"
+)
+
+var testString = "Albert Einstein: Logic will get you from A to B. Imagination will take you everywhere."
+var testBytes = []byte(testString)
+
+func rawBytesToStr(b []byte) string {
+	return string(b)
+}
+
+func rawStrToBytes(s string) []byte {
+	return []byte(s)
+}
+
+// go test -v
+
+func TestBytesToString(t *testing.T) {
+	data := make([]byte, 1024)
+	for i := 0; i < 100; i++ {
+		rand.Read(data)
+		if rawBytesToStr(data) != BytesToString(data) {
+			t.Fatal("don't match")
+		}
+	}
+}
+
+const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+const (
+	letterIdxBits = 6                    // 6 bits to represent a letter index
+	letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
+	letterIdxMax  = 63 / letterIdxBits   // # of letter indices fitting in 63 bits
+)
+
+var src = rand.NewSource(time.Now().UnixNano())
+
+func RandStringBytesMaskImprSrcSB(n int) string {
+	sb := strings.Builder{}
+	sb.Grow(n)
+	// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
+	for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
+		if remain == 0 {
+			cache, remain = src.Int63(), letterIdxMax
+		}
+		if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
+			sb.WriteByte(letterBytes[idx])
+			i--
+		}
+		cache >>= letterIdxBits
+		remain--
+	}
+
+	return sb.String()
+}
+
+func TestStringToBytes(t *testing.T) {
+	for i := 0; i < 100; i++ {
+		s := RandStringBytesMaskImprSrcSB(64)
+		if !bytes.Equal(rawStrToBytes(s), StringToBytes(s)) {
+			t.Fatal("don't match")
+		}
+	}
+}
+
+// go test -v -run=none -bench=^BenchmarkBytesConv -benchmem=true
+
+func BenchmarkBytesConvBytesToStrRaw(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		rawBytesToStr(testBytes)
+	}
+}
+
+func BenchmarkBytesConvBytesToStr(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		BytesToString(testBytes)
+	}
+}
+
+func BenchmarkBytesConvStrToBytesRaw(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		rawStrToBytes(testString)
+	}
+}
+
+func BenchmarkBytesConvStrToBytes(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		StringToBytes(testString)
+	}
+}
--- a/internal/json/jsoniter.go
+++ b/internal/json/jsoniter.go
@ -6,7 +6,7 @@

 package json

-import "github.com/json-iterator/go"
+import jsoniter "github.com/json-iterator/go"

 var (
 	json = jsoniter.ConfigCompatibleWithStandardLibrary
--- a/logger.go
+++ b/logger.go
@ -141,7 +141,7 @@ var defaultLogFormatter = func(param LogFormatterParams) string {
 		// Truncate in a golang < 1.8 safe way
 		param.Latency = param.Latency - param.Latency%time.Second
 	}
-	return fmt.Sprintf("[GIN] %v |%s %3d %s| %13v | %15s |%s %-7s %s %s\n%s",
+	return fmt.Sprintf("[GIN] %v |%s %3d %s| %13v | %15s |%s %-7s %s %#v\n%s",
 		param.TimeStamp.Format("2006/01/02 - 15:04:05"),
 		statusColor, param.StatusCode, resetColor,
 		param.Latency,
--- a/logger_test.go
+++ b/logger_test.go
@ -158,7 +158,7 @@ func TestLoggerWithFormatter(t *testing.T) {

 	router := New()
 	router.Use(LoggerWithFormatter(func(param LogFormatterParams) string {
-		return fmt.Sprintf("[FORMATTER TEST] %v | %3d | %13v | %15s | %-7s %s\n%s",
+		return fmt.Sprintf("[FORMATTER TEST] %v | %3d | %13v | %15s | %-7s %#v\n%s",
 			param.TimeStamp.Format("2006/01/02 - 15:04:05"),
 			param.StatusCode,
 			param.Latency,
@ -275,11 +275,11 @@ func TestDefaultLogFormatter(t *testing.T) {
 		isTerm:       false,
 	}

-	assert.Equal(t, "[GIN] 2018/12/07 - 09:11:42 | 200 |            5s |     20.20.20.20 | GET      /\n", defaultLogFormatter(termFalseParam))
-	assert.Equal(t, "[GIN] 2018/12/07 - 09:11:42 | 200 |    2743h29m3s |     20.20.20.20 | GET      /\n", defaultLogFormatter(termFalseLongDurationParam))
+	assert.Equal(t, "[GIN] 2018/12/07 - 09:11:42 | 200 |            5s |     20.20.20.20 | GET      \"/\"\n", defaultLogFormatter(termFalseParam))
+	assert.Equal(t, "[GIN] 2018/12/07 - 09:11:42 | 200 |    2743h29m3s |     20.20.20.20 | GET      \"/\"\n", defaultLogFormatter(termFalseLongDurationParam))

-	assert.Equal(t, "[GIN] 2018/12/07 - 09:11:42 |\x1b[97;42m 200 \x1b[0m|            5s |     20.20.20.20 |\x1b[97;44m GET     \x1b[0m /\n", defaultLogFormatter(termTrueParam))
-	assert.Equal(t, "[GIN] 2018/12/07 - 09:11:42 |\x1b[97;42m 200 \x1b[0m|    2743h29m3s |     20.20.20.20 |\x1b[97;44m GET     \x1b[0m /\n", defaultLogFormatter(termTrueLongDurationParam))
+	assert.Equal(t, "[GIN] 2018/12/07 - 09:11:42 |\x1b[97;42m 200 \x1b[0m|            5s |     20.20.20.20 |\x1b[97;44m GET     \x1b[0m \"/\"\n", defaultLogFormatter(termTrueParam))
+	assert.Equal(t, "[GIN] 2018/12/07 - 09:11:42 |\x1b[97;42m 200 \x1b[0m|    2743h29m3s |     20.20.20.20 |\x1b[97;44m GET     \x1b[0m \"/\"\n", defaultLogFormatter(termTrueLongDurationParam))

 }

@ -369,15 +369,15 @@ func TestErrorLogger(t *testing.T) {

 	w := performRequest(router, "GET", "/error")
 	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Equal(t, "{\"error\":\"this is an error\"}\n", w.Body.String())
+	assert.Equal(t, "{\"error\":\"this is an error\"}", w.Body.String())

 	w = performRequest(router, "GET", "/abort")
 	assert.Equal(t, http.StatusUnauthorized, w.Code)
-	assert.Equal(t, "{\"error\":\"no authorized\"}\n", w.Body.String())
+	assert.Equal(t, "{\"error\":\"no authorized\"}", w.Body.String())

 	w = performRequest(router, "GET", "/print")
 	assert.Equal(t, http.StatusInternalServerError, w.Code)
-	assert.Equal(t, "hola!{\"error\":\"this is an error\"}\n", w.Body.String())
+	assert.Equal(t, "hola!{\"error\":\"this is an error\"}", w.Body.String())
 }

 func TestLoggerWithWriterSkippingPaths(t *testing.T) {
--- a/middleware_test.go
+++ b/middleware_test.go
@ -246,5 +246,5 @@ func TestMiddlewareWrite(t *testing.T) {
 	w := performRequest(router, "GET", "/")

 	assert.Equal(t, http.StatusBadRequest, w.Code)
-	assert.Equal(t, strings.Replace("hola\n<map><foo>bar</foo></map>{\"foo\":\"bar\"}\n{\"foo\":\"bar\"}\nevent:test\ndata:message\n\n", " ", "", -1), strings.Replace(w.Body.String(), " ", "", -1))
+	assert.Equal(t, strings.Replace("hola\n<map><foo>bar</foo></map>{\"foo\":\"bar\"}{\"foo\":\"bar\"}event:test\ndata:message\n\n", " ", "", -1), strings.Replace(w.Body.String(), " ", "", -1))
 }
--- a/mode.go
+++ b/mode.go
@ -22,6 +22,7 @@ const (
 	// TestMode indicates gin mode is test.
 	TestMode = "test"
 )
+
 const (
 	debugCode = iota
 	releaseCode
@ -50,8 +51,12 @@ func init() {

 // SetMode sets gin mode according to input string.
 func SetMode(value string) {
+	if value == "" {
+		value = DebugMode
+	}
+
 	switch value {
-	case DebugMode, "":
+	case DebugMode:
 		ginMode = debugCode
 	case ReleaseMode:
 		ginMode = releaseCode
@ -60,9 +65,7 @@ func SetMode(value string) {
 	default:
 		panic("gin mode unknown: " + value)
 	}
-	if value == "" {
-		value = DebugMode
-	}
+
 	modeName = value
 }

--- a/path.go
+++ b/path.go
@ -5,8 +5,6 @@

 package gin

-const stackBufSize = 128
-
 // cleanPath is the URL version of path.Clean, it returns a canonical URL path
 // for p, eliminating . and .. elements.
 //
@ -21,6 +19,7 @@ const stackBufSize = 128
 //
 // If the result of this process is an empty string, "/" is returned.
 func cleanPath(p string) string {
+	const stackBufSize = 128
 	// Turn empty string into "/"
 	if p == "" {
 		return "/"
@ -54,8 +53,9 @@ func cleanPath(p string) string {
 	trailing := n > 1 && p[n-1] == '/'

 	// A bit more clunky without a 'lazybuf' like the path package, but the loop
-	// gets completely inlined (bufApp). So in contrast to the path package this
-	// loop has no expensive function calls (except 1x make)
+	// gets completely inlined (bufApp calls).
+	// loop has no expensive function calls (except 1x make)		// So in contrast to the path package this loop has no expensive function
+	// calls (except make, if needed).

 	for r < n {
 		switch {
@ -91,14 +91,14 @@ func cleanPath(p string) string {
 			}

 		default:
-			// real path element.
-			// add slash if needed
+			// Real path element.
+			// Add slash if needed
 			if w > 1 {
 				bufApp(&buf, p, w, '/')
 				w++
 			}

-			// copy element
+			// Copy element
 			for r < n && p[r] != '/' {
 				bufApp(&buf, p, w, p[r])
 				w++
@ -107,30 +107,40 @@ func cleanPath(p string) string {
 		}
 	}

-	// re-append trailing slash
+	// Re-append trailing slash
 	if trailing && w > 1 {
 		bufApp(&buf, p, w, '/')
 		w++
 	}

+	// If the original string was not modified (or only shortened at the end),
+	// return the respective substring of the original string.
+	// Otherwise return a new string from the buffer.
 	if len(buf) == 0 {
 		return p[:w]
 	}
 	return string(buf[:w])
 }

-// internal helper to lazily create a buffer if necessary.
+// Internal helper to lazily create a buffer if necessary.
+// Calls to this function get inlined.
 func bufApp(buf *[]byte, s string, w int, c byte) {
 	b := *buf
 	if len(b) == 0 {
+		// No modification of the original string so far.
+		// If the next character is the same as in the original string, we do
+		// not yet have to allocate a buffer.
 		if s[w] == c {
 			return
 		}

-		if l := len(s); l > cap(b) {
-			*buf = make([]byte, len(s))
+		// Otherwise use either the stack buffer, if it is large enough, or
+		// allocate a new buffer on the heap, and copy all previous characters.
+		length := len(s)
+		if length > cap(b) {
+			*buf = make([]byte, length)
 		} else {
-			*buf = (*buf)[:l]
+			*buf = (*buf)[:length]
 		}
 		b = *buf

--- a/recovery.go
+++ b/recovery.go
@ -146,6 +146,6 @@ func function(pc uintptr) []byte {
 }

 func timeFormat(t time.Time) string {
-	var timeString = t.Format("2006/01/02 - 15:04:05")
+	timeString := t.Format("2006/01/02 - 15:04:05")
 	return timeString
 }
--- a/render/json.go
+++ b/render/json.go
@ -10,6 +10,7 @@ import (
 	"html/template"
 	"net/http"

+	"github.com/gin-gonic/gin/internal/bytesconv"
 	"github.com/gin-gonic/gin/internal/json"
 )

@ -40,9 +41,6 @@ type AsciiJSON struct {
 	Data interface{}
 }

-// SecureJSONPrefix is a string which represents SecureJSON prefix.
-type SecureJSONPrefix string
-
 // PureJSON contains the given interface object.
 type PureJSON struct {
 	Data interface{}
@ -66,8 +64,11 @@ func (r JSON) WriteContentType(w http.ResponseWriter) {
 // WriteJSON marshals the given interface object and writes it with custom ContentType.
 func WriteJSON(w http.ResponseWriter, obj interface{}) error {
 	writeContentType(w, jsonContentType)
-	encoder := json.NewEncoder(w)
-	err := encoder.Encode(&obj)
+	jsonBytes, err := json.Marshal(obj)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(jsonBytes)
 	return err
 }

@ -95,8 +96,9 @@ func (r SecureJSON) Render(w http.ResponseWriter) error {
 		return err
 	}
 	// if the jsonBytes is array values
-	if bytes.HasPrefix(jsonBytes, []byte("[")) && bytes.HasSuffix(jsonBytes, []byte("]")) {
-		_, err = w.Write([]byte(r.Prefix))
+	if bytes.HasPrefix(jsonBytes, bytesconv.StringToBytes("[")) && bytes.HasSuffix(jsonBytes,
+		bytesconv.StringToBytes("]")) {
+		_, err = w.Write(bytesconv.StringToBytes(r.Prefix))
 		if err != nil {
 			return err
 		}
@ -124,11 +126,11 @@ func (r JsonpJSON) Render(w http.ResponseWriter) (err error) {
 	}

 	callback := template.JSEscapeString(r.Callback)
-	_, err = w.Write([]byte(callback))
+	_, err = w.Write(bytesconv.StringToBytes(callback))
 	if err != nil {
 		return err
 	}
-	_, err = w.Write([]byte("("))
+	_, err = w.Write(bytesconv.StringToBytes("("))
 	if err != nil {
 		return err
 	}
@ -136,7 +138,7 @@ func (r JsonpJSON) Render(w http.ResponseWriter) (err error) {
 	if err != nil {
 		return err
 	}
-	_, err = w.Write([]byte(");"))
+	_, err = w.Write(bytesconv.StringToBytes(");"))
 	if err != nil {
 		return err
 	}
@ -158,7 +160,7 @@ func (r AsciiJSON) Render(w http.ResponseWriter) (err error) {
 	}

 	var buffer bytes.Buffer
-	for _, r := range string(ret) {
+	for _, r := range bytesconv.BytesToString(ret) {
 		cvt := string(r)
 		if r >= 128 {
 			cvt = fmt.Sprintf("\\u%04x", int64(r))
--- a/render/render_test.go
+++ b/render/render_test.go
@ -36,7 +36,7 @@ func TestRenderJSON(t *testing.T) {
 	err := (JSON{data}).Render(w)

 	assert.NoError(t, err)
-	assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"\\u003cb\\u003e\"}\n", w.Body.String())
+	assert.Equal(t, "{\"foo\":\"bar\",\"html\":\"\\u003cb\\u003e\"}", w.Body.String())
 	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }

--- a/render/text.go
+++ b/render/text.go
@ -6,7 +6,6 @@ package render

 import (
 	"fmt"
-	"io"
 	"net/http"
 )

@ -35,6 +34,6 @@ func WriteString(w http.ResponseWriter, format string, data []interface{}) (err
 		_, err = fmt.Fprintf(w, format, data...)
 		return
 	}
-	_, err = io.WriteString(w, format)
+	_, err = w.Write([]byte(format))
 	return
 }
--- a/routergroup.go
+++ b/routergroup.go
@ -187,7 +187,7 @@ func (group *RouterGroup) createStaticHandler(relativePath string, fs http.FileS
 	fileServer := http.StripPrefix(absolutePath, http.FileServer(fs))

 	return func(c *Context) {
-		if _, nolisting := fs.(*onlyfilesFS); nolisting {
+		if _, noListing := fs.(*onlyFilesFS); noListing {
 			c.Writer.WriteHeader(http.StatusNotFound)
 		}

--- a/routes_test.go
+++ b/routes_test.go
@ -514,7 +514,7 @@ func TestMiddlewareCalledOnceByRouterStaticFSNotFound(t *testing.T) {
 	// Middleware must be called just only once by per request.
 	middlewareCalledNum := 0
 	router.Use(func(c *Context) {
-		middlewareCalledNum += 1
+		middlewareCalledNum++
 	})

 	router.StaticFS("/", http.FileSystem(http.Dir("/thisreallydoesntexist/")))
@ -593,6 +593,9 @@ func TestRouteContextHoldsFullPath(t *testing.T) {
 		"/simple-two/one-two",
 		"/project/:name/build/*params",
 		"/project/:name/bui",
+		"/user/:id/status",
+		"/user/:id",
+		"/user/:id/profile",
 	}

 	for _, route := range routes {
--- a/tree.go
+++ b/tree.go
@ -5,9 +5,18 @@
 package gin

 import (
+	"bytes"
 	"net/url"
 	"strings"
 	"unicode"
+	"unicode/utf8"
+
+	"github.com/gin-gonic/gin/internal/bytesconv"
+)
+
+var (
+	strColon = []byte(":")
+	strStar  = []byte("*")
 )

 // Param is a single URL parameter, consisting of a key and a value.
@ -71,17 +80,12 @@ func longestCommonPrefix(a, b string) int {
 	return i
 }

-func countParams(path string) uint8 {
-	var n uint
-	for i := 0; i < len(path); i++ {
-		if path[i] == ':' || path[i] == '*' {
-			n++
-		}
-	}
-	if n >= 255 {
-		return 255
-	}
-	return uint8(n)
+func countParams(path string) uint16 {
+	var n uint16
+	s := bytesconv.StringToBytes(path)
+	n += uint16(bytes.Count(s, strColon))
+	n += uint16(bytes.Count(s, strStar))
+	return n
 }

 type nodeType uint8
@ -96,16 +100,15 @@ const (
 type node struct {
 	path      string
 	indices   string
+	wildChild bool
+	nType     nodeType
+	priority  uint32
 	children  []*node
 	handlers  HandlersChain
-	priority  uint32
-	nType     nodeType
-	maxParams uint8
-	wildChild bool
 	fullPath  string
 }

-// increments priority of the given child and reorders if necessary.
+// Increments priority of the given child and reorders if necessary
 func (n *node) incrementChildPrio(pos int) int {
 	cs := n.children
 	cs[pos].priority++
@ -116,13 +119,14 @@ func (n *node) incrementChildPrio(pos int) int {
 	for ; newPos > 0 && cs[newPos-1].priority < prio; newPos-- {
 		// Swap node positions
 		cs[newPos-1], cs[newPos] = cs[newPos], cs[newPos-1]
+
 	}

-	// build new index char string
+	// Build new index char string
 	if newPos != pos {
-		n.indices = n.indices[:newPos] + // unchanged prefix, might be empty
-			n.indices[pos:pos+1] + // the index char we move
-			n.indices[newPos:pos] + n.indices[pos+1:] // rest without char at 'pos'
+		n.indices = n.indices[:newPos] + // Unchanged prefix, might be empty
+			n.indices[pos:pos+1] + // The index char we move
+			n.indices[newPos:pos] + n.indices[pos+1:] // Rest without char at 'pos'
 	}

 	return newPos
@ -133,11 +137,10 @@ func (n *node) incrementChildPrio(pos int) int {
 func (n *node) addRoute(path string, handlers HandlersChain) {
 	fullPath := path
 	n.priority++
-	numParams := countParams(path)

 	// Empty tree
 	if len(n.path) == 0 && len(n.children) == 0 {
-		n.insertChild(numParams, path, fullPath, handlers)
+		n.insertChild(path, fullPath, handlers)
 		n.nType = root
 		return
 	}
@ -146,11 +149,6 @@ func (n *node) addRoute(path string, handlers HandlersChain) {

 walk:
 	for {
-		// Update maxParams of the current node
-		if numParams > n.maxParams {
-			n.maxParams = numParams
-		}
-
 		// Find the longest common prefix.
 		// This also implies that the common prefix contains no ':' or '*'
 		// since the existing key can't contain those chars.
@ -168,16 +166,9 @@ walk:
 				fullPath:  n.fullPath,
 			}

-			// Update maxParams (max of all children)
-			for i := range child.children {
-				if child.children[i].maxParams > child.maxParams {
-					child.maxParams = child.children[i].maxParams
-				}
-			}
-
 			n.children = []*node{&child}
 			// []byte for proper unicode char conversion, see #65
-			n.indices = string([]byte{n.path[i]})
+			n.indices = bytesconv.BytesToString([]byte{n.path[i]})
 			n.path = path[:i]
 			n.handlers = nil
 			n.wildChild = false
@ -193,18 +184,13 @@ walk:
 				n = n.children[0]
 				n.priority++

-				// Update maxParams of the child node
-				if numParams > n.maxParams {
-					n.maxParams = numParams
-				}
-				numParams--
-
 				// Check if the wildcard matches
-				if len(path) >= len(n.path) && n.path == path[:len(n.path)] {
-					// check for longer wildcard, e.g. :name and :names
-					if len(n.path) >= len(path) || path[len(n.path)] == '/' {
-						continue walk
-					}
+				if len(path) >= len(n.path) && n.path == path[:len(n.path)] &&
+					// Adding a child to a catchAll is not possible
+					n.nType != catchAll &&
+					// Check for longer wildcard, e.g. :name and :names
+					(len(n.path) >= len(path) || path[len(n.path)] == '/') {
+					continue walk
 				}

 				pathSeg := path
@ -242,16 +228,15 @@ walk:
 			// Otherwise insert it
 			if c != ':' && c != '*' {
 				// []byte for proper unicode char conversion, see #65
-				n.indices += string([]byte{c})
+				n.indices += bytesconv.BytesToString([]byte{c})
 				child := &node{
-					maxParams: numParams,
-					fullPath:  fullPath,
+					fullPath: fullPath,
 				}
 				n.children = append(n.children, child)
 				n.incrementChildPrio(len(n.indices) - 1)
 				n = child
 			}
-			n.insertChild(numParams, path, fullPath, handlers)
+			n.insertChild(path, fullPath, handlers)
 			return
 		}

@ -260,12 +245,13 @@ walk:
 			panic("handlers are already registered for path '" + fullPath + "'")
 		}
 		n.handlers = handlers
+		n.fullPath = fullPath
 		return
 	}
 }

 // Search for a wildcard segment and check the name for invalid characters.
-// Returns -1 as index, if no wildcard war found.
+// Returns -1 as index, if no wildcard was found.
 func findWildcard(path string) (wildcard string, i int, valid bool) {
 	// Find start
 	for start, c := range []byte(path) {
@ -289,8 +275,8 @@ func findWildcard(path string) (wildcard string, i int, valid bool) {
 	return "", -1, false
 }

-func (n *node) insertChild(numParams uint8, path string, fullPath string, handlers HandlersChain) {
-	for numParams > 0 {
+func (n *node) insertChild(path string, fullPath string, handlers HandlersChain) {
+	for {
 		// Find prefix until first wildcard
 		wildcard, i, valid := findWildcard(path)
 		if i < 0 { // No wildcard found
@ -324,15 +310,13 @@ func (n *node) insertChild(numParams uint8, path string, fullPath string, handle

 			n.wildChild = true
 			child := &node{
-				nType:     param,
-				path:      wildcard,
-				maxParams: numParams,
-				fullPath:  fullPath,
+				nType:    param,
+				path:     wildcard,
+				fullPath: fullPath,
 			}
 			n.children = []*node{child}
 			n = child
 			n.priority++
-			numParams--

 			// if the path doesn't end with the wildcard, then there
 			// will be another non-wildcard subpath starting with '/'
@ -340,9 +324,8 @@ func (n *node) insertChild(numParams uint8, path string, fullPath string, handle
 				path = path[len(wildcard):]

 				child := &node{
-					maxParams: numParams,
-					priority:  1,
-					fullPath:  fullPath,
+					priority: 1,
+					fullPath: fullPath,
 				}
 				n.children = []*node{child}
 				n = child
@ -355,7 +338,7 @@ func (n *node) insertChild(numParams uint8, path string, fullPath string, handle
 		}

 		// catchAll
-		if i+len(wildcard) != len(path) || numParams > 1 {
+		if i+len(wildcard) != len(path) {
 			panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
 		}

@ -375,13 +358,9 @@ func (n *node) insertChild(numParams uint8, path string, fullPath string, handle
 		child := &node{
 			wildChild: true,
 			nType:     catchAll,
-			maxParams: 1,
 			fullPath:  fullPath,
 		}
-		// update maxParams of the parent node
-		if n.maxParams < 1 {
-			n.maxParams = 1
-		}
+
 		n.children = []*node{child}
 		n.indices = string('/')
 		n = child
@ -389,19 +368,18 @@ func (n *node) insertChild(numParams uint8, path string, fullPath string, handle

 		// second node: node holding the variable
 		child = &node{
-			path:      path[i:],
-			nType:     catchAll,
-			maxParams: 1,
-			handlers:  handlers,
-			priority:  1,
-			fullPath:  fullPath,
+			path:     path[i:],
+			nType:    catchAll,
+			handlers: handlers,
+			priority: 1,
+			fullPath: fullPath,
 		}
 		n.children = []*node{child}

 		return
 	}

-	// If no wildcard was found, simple insert the path and handle
+	// If no wildcard was found, simply insert the path and handle
 	n.path = path
 	n.handlers = handlers
 	n.fullPath = fullPath
@ -410,21 +388,128 @@ func (n *node) insertChild(numParams uint8, path string, fullPath string, handle
 // nodeValue holds return values of (*Node).getValue method
 type nodeValue struct {
 	handlers HandlersChain
-	params   Params
+	params   *Params
 	tsr      bool
 	fullPath string
 }

-// getValue returns the handle registered with the given path (key). The values of
+// Returns the handle registered with the given path (key). The values of
 // wildcards are saved to a map.
 // If no handle can be found, a TSR (trailing slash redirect) recommendation is
 // made if a handle exists with an extra (without the) trailing slash for the
 // given path.
-func (n *node) getValue(path string, po Params, unescape bool) (value nodeValue) {
-	value.params = po
+func (n *node) getValue(path string, params *Params, unescape bool) (value nodeValue) {
 walk: // Outer loop for walking the tree
 	for {
 		prefix := n.path
+		if len(path) > len(prefix) {
+			if path[:len(prefix)] == prefix {
+				path = path[len(prefix):]
+				// If this node does not have a wildcard (param or catchAll)
+				// child, we can just look up the next child node and continue
+				// to walk down the tree
+				if !n.wildChild {
+					idxc := path[0]
+					for i, c := range []byte(n.indices) {
+						if c == idxc {
+							n = n.children[i]
+							continue walk
+						}
+					}
+
+					// Nothing found.
+					// We can recommend to redirect to the same URL without a
+					// trailing slash if a leaf exists for that path.
+					value.tsr = (path == "/" && n.handlers != nil)
+					return
+				}
+
+				// Handle wildcard child
+				n = n.children[0]
+				switch n.nType {
+				case param:
+					// Find param end (either '/' or path end)
+					end := 0
+					for end < len(path) && path[end] != '/' {
+						end++
+					}
+
+					// Save param value
+					if params != nil {
+						if value.params == nil {
+							value.params = params
+						}
+						// Expand slice within preallocated capacity
+						i := len(*value.params)
+						*value.params = (*value.params)[:i+1]
+						val := path[:end]
+						if unescape {
+							if v, err := url.QueryUnescape(val); err == nil {
+								val = v
+							}
+						}
+						(*value.params)[i] = Param{
+							Key:   n.path[1:],
+							Value: val,
+						}
+					}
+
+					// we need to go deeper!
+					if end < len(path) {
+						if len(n.children) > 0 {
+							path = path[end:]
+							n = n.children[0]
+							continue walk
+						}
+
+						// ... but we can't
+						value.tsr = (len(path) == end+1)
+						return
+					}
+
+					if value.handlers = n.handlers; value.handlers != nil {
+						value.fullPath = n.fullPath
+						return
+					}
+					if len(n.children) == 1 {
+						// No handle found. Check if a handle for this path + a
+						// trailing slash exists for TSR recommendation
+						n = n.children[0]
+						value.tsr = (n.path == "/" && n.handlers != nil)
+					}
+					return
+
+				case catchAll:
+					// Save param value
+					if params != nil {
+						if value.params == nil {
+							value.params = params
+						}
+						// Expand slice within preallocated capacity
+						i := len(*value.params)
+						*value.params = (*value.params)[:i+1]
+						val := path
+						if unescape {
+							if v, err := url.QueryUnescape(path); err == nil {
+								val = v
+							}
+						}
+						(*value.params)[i] = Param{
+							Key:   n.path[2:],
+							Value: val,
+						}
+					}
+
+					value.handlers = n.handlers
+					value.fullPath = n.fullPath
+					return
+
+				default:
+					panic("invalid node type")
+				}
+			}
+		}
+
 		if path == prefix {
 			// We should have reached the node containing the handle.
 			// Check if this node has a handle registered.
@ -433,6 +518,9 @@ walk: // Outer loop for walking the tree
 				return
 			}

+			// If there is no handle for this route, but this route has a
+			// wildcard child, there must be a handle for this path with an
+			// additional trailing slash
 			if path == "/" && n.wildChild && n.nType != root {
 				value.tsr = true
 				return
@ -440,9 +528,8 @@ walk: // Outer loop for walking the tree

 			// No handle found. Check if a handle for this path + a
 			// trailing slash exists for trailing slash recommendation
-			indices := n.indices
-			for i, max := 0, len(indices); i < max; i++ {
-				if indices[i] == '/' {
+			for i, c := range []byte(n.indices) {
+				if c == '/' {
 					n = n.children[i]
 					value.tsr = (len(n.path) == 1 && n.handlers != nil) ||
 						(n.nType == catchAll && n.children[0].handlers != nil)
@ -453,108 +540,6 @@ walk: // Outer loop for walking the tree
 			return
 		}

-		if len(path) > len(prefix) && path[:len(prefix)] == prefix {
-			path = path[len(prefix):]
-			// If this node does not have a wildcard (param or catchAll)
-			// child,  we can just look up the next child node and continue
-			// to walk down the tree
-			if !n.wildChild {
-				c := path[0]
-				indices := n.indices
-				for i, max := 0, len(indices); i < max; i++ {
-					if c == indices[i] {
-						n = n.children[i]
-						prefix = n.path
-						continue walk
-					}
-				}
-
-				// Nothing found.
-				// We can recommend to redirect to the same URL without a
-				// trailing slash if a leaf exists for that path.
-				value.tsr = path == "/" && n.handlers != nil
-				return
-			}
-
-			// handle wildcard child
-			n = n.children[0]
-			switch n.nType {
-			case param:
-				// find param end (either '/' or path end)
-				end := 0
-				for end < len(path) && path[end] != '/' {
-					end++
-				}
-
-				// save param value
-				if cap(value.params) < int(n.maxParams) {
-					value.params = make(Params, 0, n.maxParams)
-				}
-				i := len(value.params)
-				value.params = value.params[:i+1] // expand slice within preallocated capacity
-				value.params[i].Key = n.path[1:]
-				val := path[:end]
-				if unescape {
-					var err error
-					if value.params[i].Value, err = url.QueryUnescape(val); err != nil {
-						value.params[i].Value = val // fallback, in case of error
-					}
-				} else {
-					value.params[i].Value = val
-				}
-
-				// we need to go deeper!
-				if end < len(path) {
-					if len(n.children) > 0 {
-						path = path[end:]
-						n = n.children[0]
-						prefix = n.path
-						continue walk
-					}
-
-					// ... but we can't
-					value.tsr = len(path) == end+1
-					return
-				}
-
-				if value.handlers = n.handlers; value.handlers != nil {
-					value.fullPath = n.fullPath
-					return
-				}
-				if len(n.children) == 1 {
-					// No handle found. Check if a handle for this path + a
-					// trailing slash exists for TSR recommendation
-					n = n.children[0]
-					value.tsr = n.path == "/" && n.handlers != nil
-				}
-				return
-
-			case catchAll:
-				// save param value
-				if cap(value.params) < int(n.maxParams) {
-					value.params = make(Params, 0, n.maxParams)
-				}
-				i := len(value.params)
-				value.params = value.params[:i+1] // expand slice within preallocated capacity
-				value.params[i].Key = n.path[2:]
-				if unescape {
-					var err error
-					if value.params[i].Value, err = url.QueryUnescape(path); err != nil {
-						value.params[i].Value = path // fallback, in case of error
-					}
-				} else {
-					value.params[i].Value = path
-				}
-
-				value.handlers = n.handlers
-				value.fullPath = n.fullPath
-				return
-
-			default:
-				panic("invalid node type")
-			}
-		}
-
 		// Nothing found. We can recommend to redirect to the same URL with an
 		// extra trailing slash if a leaf exists for that path
 		value.tsr = (path == "/") ||
@ -564,109 +549,214 @@ walk: // Outer loop for walking the tree
 	}
 }

-// findCaseInsensitivePath makes a case-insensitive lookup of the given path and tries to find a handler.
+// Makes a case-insensitive lookup of the given path and tries to find a handler.
 // It can optionally also fix trailing slashes.
 // It returns the case-corrected path and a bool indicating whether the lookup
 // was successful.
-func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPath []byte, found bool) {
-	ciPath = make([]byte, 0, len(path)+1) // preallocate enough memory
+func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) ([]byte, bool) {
+	const stackBufSize = 128

-	// Outer loop for walking the tree
-	for len(path) >= len(n.path) && strings.EqualFold(path[:len(n.path)], n.path) {
-		path = path[len(n.path):]
+	// Use a static sized buffer on the stack in the common case.
+	// If the path is too long, allocate a buffer on the heap instead.
+	buf := make([]byte, 0, stackBufSize)
+	if l := len(path) + 1; l > stackBufSize {
+		buf = make([]byte, 0, l)
+	}
+
+	ciPath := n.findCaseInsensitivePathRec(
+		path,
+		buf,       // Preallocate enough memory for new path
+		[4]byte{}, // Empty rune buffer
+		fixTrailingSlash,
+	)
+
+	return ciPath, ciPath != nil
+}
+
+// Shift bytes in array by n bytes left
+func shiftNRuneBytes(rb [4]byte, n int) [4]byte {
+	switch n {
+	case 0:
+		return rb
+	case 1:
+		return [4]byte{rb[1], rb[2], rb[3], 0}
+	case 2:
+		return [4]byte{rb[2], rb[3]}
+	case 3:
+		return [4]byte{rb[3]}
+	default:
+		return [4]byte{}
+	}
+}
+
+// Recursive case-insensitive lookup function used by n.findCaseInsensitivePath
+func (n *node) findCaseInsensitivePathRec(path string, ciPath []byte, rb [4]byte, fixTrailingSlash bool) []byte {
+	npLen := len(n.path)
+
+walk: // Outer loop for walking the tree
+	for len(path) >= npLen && (npLen == 0 || strings.EqualFold(path[1:npLen], n.path[1:])) {
+		// Add common prefix to result
+		oldPath := path
+		path = path[npLen:]
 		ciPath = append(ciPath, n.path...)

-		if len(path) == 0 {
+		if len(path) > 0 {
+			// If this node does not have a wildcard (param or catchAll) child,
+			// we can just look up the next child node and continue to walk down
+			// the tree
+			if !n.wildChild {
+				// Skip rune bytes already processed
+				rb = shiftNRuneBytes(rb, npLen)
+
+				if rb[0] != 0 {
+					// Old rune not finished
+					idxc := rb[0]
+					for i, c := range []byte(n.indices) {
+						if c == idxc {
+							// continue with child node
+							n = n.children[i]
+							npLen = len(n.path)
+							continue walk
+						}
+					}
+				} else {
+					// Process a new rune
+					var rv rune
+
+					// Find rune start.
+					// Runes are up to 4 byte long,
+					// -4 would definitely be another rune.
+					var off int
+					for max := min(npLen, 3); off < max; off++ {
+						if i := npLen - off; utf8.RuneStart(oldPath[i]) {
+							// read rune from cached path
+							rv, _ = utf8.DecodeRuneInString(oldPath[i:])
+							break
+						}
+					}
+
+					// Calculate lowercase bytes of current rune
+					lo := unicode.ToLower(rv)
+					utf8.EncodeRune(rb[:], lo)
+
+					// Skip already processed bytes
+					rb = shiftNRuneBytes(rb, off)
+
+					idxc := rb[0]
+					for i, c := range []byte(n.indices) {
+						// Lowercase matches
+						if c == idxc {
+							// must use a recursive approach since both the
+							// uppercase byte and the lowercase byte might exist
+							// as an index
+							if out := n.children[i].findCaseInsensitivePathRec(
+								path, ciPath, rb, fixTrailingSlash,
+							); out != nil {
+								return out
+							}
+							break
+						}
+					}
+
+					// If we found no match, the same for the uppercase rune,
+					// if it differs
+					if up := unicode.ToUpper(rv); up != lo {
+						utf8.EncodeRune(rb[:], up)
+						rb = shiftNRuneBytes(rb, off)
+
+						idxc := rb[0]
+						for i, c := range []byte(n.indices) {
+							// Uppercase matches
+							if c == idxc {
+								// Continue with child node
+								n = n.children[i]
+								npLen = len(n.path)
+								continue walk
+							}
+						}
+					}
+				}
+
+				// Nothing found. We can recommend to redirect to the same URL
+				// without a trailing slash if a leaf exists for that path
+				if fixTrailingSlash && path == "/" && n.handlers != nil {
+					return ciPath
+				}
+				return nil
+			}
+
+			n = n.children[0]
+			switch n.nType {
+			case param:
+				// Find param end (either '/' or path end)
+				end := 0
+				for end < len(path) && path[end] != '/' {
+					end++
+				}
+
+				// Add param value to case insensitive path
+				ciPath = append(ciPath, path[:end]...)
+
+				// We need to go deeper!
+				if end < len(path) {
+					if len(n.children) > 0 {
+						// Continue with child node
+						n = n.children[0]
+						npLen = len(n.path)
+						path = path[end:]
+						continue
+					}
+
+					// ... but we can't
+					if fixTrailingSlash && len(path) == end+1 {
+						return ciPath
+					}
+					return nil
+				}
+
+				if n.handlers != nil {
+					return ciPath
+				}
+
+				if fixTrailingSlash && len(n.children) == 1 {
+					// No handle found. Check if a handle for this path + a
+					// trailing slash exists
+					n = n.children[0]
+					if n.path == "/" && n.handlers != nil {
+						return append(ciPath, '/')
+					}
+				}
+
+				return nil
+
+			case catchAll:
+				return append(ciPath, path...)
+
+			default:
+				panic("invalid node type")
+			}
+		} else {
 			// We should have reached the node containing the handle.
 			// Check if this node has a handle registered.
 			if n.handlers != nil {
-				return ciPath, true
+				return ciPath
 			}

 			// No handle found.
 			// Try to fix the path by adding a trailing slash
 			if fixTrailingSlash {
-				for i := 0; i < len(n.indices); i++ {
-					if n.indices[i] == '/' {
+				for i, c := range []byte(n.indices) {
+					if c == '/' {
 						n = n.children[i]
 						if (len(n.path) == 1 && n.handlers != nil) ||
 							(n.nType == catchAll && n.children[0].handlers != nil) {
-							return append(ciPath, '/'), true
+							return append(ciPath, '/')
 						}
-						return
+						return nil
 					}
 				}
 			}
-			return
-		}
-
-		// If this node does not have a wildcard (param or catchAll) child,
-		// we can just look up the next child node and continue to walk down
-		// the tree
-		if !n.wildChild {
-			r := unicode.ToLower(rune(path[0]))
-			for i, index := range n.indices {
-				// must use recursive approach since both index and
-				// ToLower(index) could exist. We must check both.
-				if r == unicode.ToLower(index) {
-					out, found := n.children[i].findCaseInsensitivePath(path, fixTrailingSlash)
-					if found {
-						return append(ciPath, out...), true
-					}
-				}
-			}
-
-			// 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
-			return
-		}
-
-		n = n.children[0]
-		switch n.nType {
-		case param:
-			// Find param end (either '/' or path end)
-			end := 0
-			for end < len(path) && path[end] != '/' {
-				end++
-			}
-
-			// add param value to case insensitive path
-			ciPath = append(ciPath, path[:end]...)
-
-			// we need to go deeper!
-			if end < len(path) {
-				if len(n.children) > 0 {
-					path = path[end:]
-					n = n.children[0]
-					continue
-				}
-
-				// ... but we can't
-				if fixTrailingSlash && len(path) == end+1 {
-					return ciPath, true
-				}
-				return
-			}
-
-			if n.handlers != nil {
-				return ciPath, true
-			}
-			if fixTrailingSlash && len(n.children) == 1 {
-				// No handle found. Check if a handle for this path + a
-				// trailing slash exists
-				n = n.children[0]
-				if n.path == "/" && n.handlers != nil {
-					return append(ciPath, '/'), true
-				}
-			}
-			return
-
-		case catchAll:
-			return append(ciPath, path...), true
-
-		default:
-			panic("invalid node type")
+			return nil
 		}
 	}

@ -674,13 +764,12 @@ func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPa
 	// Try to fix the path by adding / removing a trailing slash
 	if fixTrailingSlash {
 		if path == "/" {
-			return ciPath, true
+			return ciPath
 		}
-		if len(path)+1 == len(n.path) && n.path[len(path)] == '/' &&
-			strings.EqualFold(path, n.path[:len(path)]) &&
-			n.handlers != nil {
-			return append(ciPath, n.path...), true
+		if len(path)+1 == npLen && n.path[len(path)] == '/' &&
+			strings.EqualFold(path[1:], n.path[1:len(path)]) && n.handlers != nil {
+			return append(ciPath, n.path...)
 		}
 	}
-	return
+	return nil
 }
--- a/tree_test.go
+++ b/tree_test.go
@ -28,6 +28,11 @@ type testRequests []struct {
 	ps         Params
 }

+func getParams() *Params {
+	ps := make(Params, 0, 20)
+	return &ps
+}
+
 func checkRequests(t *testing.T, tree *node, requests testRequests, unescapes ...bool) {
 	unescape := false
 	if len(unescapes) >= 1 {
@ -35,7 +40,7 @@ func checkRequests(t *testing.T, tree *node, requests testRequests, unescapes ..
 	}

 	for _, request := range requests {
-		value := tree.getValue(request.path, nil, unescape)
+		value := tree.getValue(request.path, getParams(), unescape)

 		if value.handlers == nil {
 			if !request.nilHandler {
@ -50,9 +55,12 @@ func checkRequests(t *testing.T, tree *node, requests testRequests, unescapes ..
 			}
 		}

-		if !reflect.DeepEqual(value.params, request.ps) {
-			t.Errorf("Params mismatch for route '%s'", request.path)
+		if value.params != nil {
+			if !reflect.DeepEqual(*value.params, request.ps) {
+				t.Errorf("Params mismatch for route '%s'", request.path)
+			}
 		}
+
 	}
 }

@ -76,33 +84,11 @@ func checkPriorities(t *testing.T, n *node) uint32 {
 	return prio
 }

-func checkMaxParams(t *testing.T, n *node) uint8 {
-	var maxParams uint8
-	for i := range n.children {
-		params := checkMaxParams(t, n.children[i])
-		if params > maxParams {
-			maxParams = params
-		}
-	}
-	if n.nType > root && !n.wildChild {
-		maxParams++
-	}
-
-	if n.maxParams != maxParams {
-		t.Errorf(
-			"maxParams mismatch for node '%s': is %d, should be %d",
-			n.path, n.maxParams, maxParams,
-		)
-	}
-
-	return maxParams
-}
-
 func TestCountParams(t *testing.T) {
 	if countParams("/path/:param1/static/*catch-all") != 2 {
 		t.Fail()
 	}
-	if countParams(strings.Repeat("/:param", 256)) != 255 {
+	if countParams(strings.Repeat("/:param", 256)) != 256 {
 		t.Fail()
 	}
 }
@ -142,7 +128,6 @@ func TestTreeAddAndGet(t *testing.T) {
 	})

 	checkPriorities(t, tree)
-	checkMaxParams(t, tree)
 }

 func TestTreeWildcard(t *testing.T) {
@ -186,7 +171,6 @@ func TestTreeWildcard(t *testing.T) {
 	})

 	checkPriorities(t, tree)
-	checkMaxParams(t, tree)
 }

 func TestUnescapeParameters(t *testing.T) {
@ -224,7 +208,6 @@ func TestUnescapeParameters(t *testing.T) {
 	}, unescape)

 	checkPriorities(t, tree)
-	checkMaxParams(t, tree)
 }

 func catchPanic(testFunc func()) (recv interface{}) {
@ -323,12 +306,14 @@ func TestTreeDupliatePath(t *testing.T) {
 		}
 	}

+	//printChildren(tree, "")
+
 	checkRequests(t, tree, testRequests{
 		{"/", false, "/", nil},
 		{"/doc/", false, "/doc/", nil},
-		{"/src/some/file.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file.png"}}},
-		{"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{Key: "query", Value: "someth!ng+in+ünìcodé"}}},
-		{"/user_gopher", false, "/user_:name", Params{Param{Key: "name", Value: "gopher"}}},
+		{"/src/some/file.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file.png"}}},
+		{"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{"query", "someth!ng+in+ünìcodé"}}},
+		{"/user_gopher", false, "/user_:name", Params{Param{"name", "gopher"}}},
 	})
 }

@ -356,6 +341,8 @@ func TestTreeCatchAllConflict(t *testing.T) {
 		{"/src/*filepath/x", true},
 		{"/src2/", false},
 		{"/src2/*filepath/x", true},
+		{"/src3/*filepath", false},
+		{"/src3/*filepath/x", true},
 	}
 	testRoutes(t, routes)
 }
@ -372,7 +359,6 @@ func TestTreeCatchMaxParams(t *testing.T) {
 	tree := &node{}
 	var route = "/cmd/*filepath"
 	tree.addRoute(route, fakeHandler(route))
-	checkMaxParams(t, tree)
 }

 func TestTreeDoubleWildcard(t *testing.T) {
@ -508,6 +494,9 @@ func TestTreeRootTrailingSlashRedirect(t *testing.T) {
 func TestTreeFindCaseInsensitivePath(t *testing.T) {
 	tree := &node{}

+	longPath := "/l" + strings.Repeat("o", 128) + "ng"
+	lOngPath := "/l" + strings.Repeat("O", 128) + "ng/"
+
 	routes := [...]string{
 		"/hi",
 		"/b/",
@ -531,6 +520,17 @@ func TestTreeFindCaseInsensitivePath(t *testing.T) {
 		"/doc/go/away",
 		"/no/a",
 		"/no/b",
+		"/Π",
+		"/u/apfêl/",
+		"/u/äpfêl/",
+		"/u/öpfêl",
+		"/v/Äpfêl/",
+		"/v/Öpfêl",
+		"/w/♬",  // 3 byte
+		"/w/♭/", // 3 byte, last byte differs
+		"/w/𠜎",  // 4 byte
+		"/w/𠜏/", // 4 byte
+		longPath,
 	}

 	for _, route := range routes {
@ -609,6 +609,21 @@ func TestTreeFindCaseInsensitivePath(t *testing.T) {
 		{"/DOC/", "/doc", true, true},
 		{"/NO", "", false, true},
 		{"/DOC/GO", "", false, true},
+		{"/π", "/Π", true, false},
+		{"/π/", "/Π", true, true},
+		{"/u/ÄPFÊL/", "/u/äpfêl/", true, false},
+		{"/u/ÄPFÊL", "/u/äpfêl/", true, true},
+		{"/u/ÖPFÊL/", "/u/öpfêl", true, true},
+		{"/u/ÖPFÊL", "/u/öpfêl", true, false},
+		{"/v/äpfêL/", "/v/Äpfêl/", true, false},
+		{"/v/äpfêL", "/v/Äpfêl/", true, true},
+		{"/v/öpfêL/", "/v/Öpfêl", true, true},
+		{"/v/öpfêL", "/v/Öpfêl", true, false},
+		{"/w/♬/", "/w/♬", true, true},
+		{"/w/♭", "/w/♭/", true, true},
+		{"/w/𠜎/", "/w/𠜎", true, true},
+		{"/w/𠜏", "/w/𠜏/", true, true},
+		{lOngPath, longPath, true, true},
 	}
 	// With fixTrailingSlash = true
 	for _, test := range tests {
@ -696,8 +711,7 @@ func TestTreeWildcardConflictEx(t *testing.T) {
 			tree.addRoute(conflict.route, fakeHandler(conflict.route))
 		})

-		if !regexp.MustCompile(fmt.Sprintf("'%s' in new path .* conflicts with existing wildcard '%s' in existing prefix '%s'",
-			conflict.segPath, conflict.existSegPath, conflict.existPath)).MatchString(fmt.Sprint(recv)) {
+		if !regexp.MustCompile(fmt.Sprintf("'%s' in new path .* conflicts with existing wildcard '%s' in existing prefix '%s'", conflict.segPath, conflict.existSegPath, conflict.existPath)).MatchString(fmt.Sprint(recv)) {
 			t.Fatalf("invalid wildcard conflict error (%v)", recv)
 		}
 	}
--- a/utils.go
+++ b/utils.go
@ -90,13 +90,13 @@ func filterFlags(content string) string {
 }

 func chooseData(custom, wildcard interface{}) interface{} {
-	if custom == nil {
-		if wildcard == nil {
-			panic("negotiation config is invalid")
-		}
+	if custom != nil {
+		return custom
+	}
+	if wildcard != nil {
 		return wildcard
 	}
-	return custom
+	panic("negotiation config is invalid")
 }

 func parseAccept(acceptHeader string) []string {
@ -127,8 +127,7 @@ func joinPaths(absolutePath, relativePath string) string {
 	}

 	finalPath := path.Join(absolutePath, relativePath)
-	appendSlash := lastChar(relativePath) == '/' && lastChar(finalPath) != '/'
-	if appendSlash {
+	if lastChar(relativePath) == '/' && lastChar(finalPath) != '/' {
 		return finalPath + "/"
 	}
 	return finalPath
--- a/version.go
+++ b/version.go
@ -5,4 +5,4 @@
 package gin

 // Version is the current gin framework's version.
-const Version = "v1.5.0"
+const Version = "v1.6.3"