diff --git a/Makefile b/Makefile
index b0d2e24a..7211144a 100644
--- a/Makefile
+++ b/Makefile
@@ -18,7 +18,10 @@ test:
 		cat tmp.out; \
 		if grep -q "^--- FAIL" tmp.out; then \
 			rm tmp.out; \
-			exit 1;\
+			exit 1; \
+		elif grep -q "build failed" tmp.out; then \
+			rm tmp.out; \
+			exit; \
 		fi; \
 		if [ -f profile.out ]; then \
 			cat profile.out | grep -v "mode:" >> coverage.out; \
diff --git a/binding/binding_test.go b/binding/binding_test.go
index c0204d7f..740749be 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -11,6 +11,7 @@ import (
 	"io/ioutil"
 	"mime/multipart"
 	"net/http"
+	"strconv"
 	"testing"
 	"time"
 
@@ -690,6 +691,28 @@ func TestUriBinding(t *testing.T) {
 	assert.Equal(t, map[string]interface{}(nil), not.Name)
 }
 
+func TestUriInnerBinding(t *testing.T) {
+	type Tag struct {
+		Name string `uri:"name"`
+		S    struct {
+			Age int `uri:"age"`
+		}
+	}
+
+	expectedName := "mike"
+	expectedAge := 25
+
+	m := map[string][]string{
+		"name": {expectedName},
+		"age":  {strconv.Itoa(expectedAge)},
+	}
+
+	var tag Tag
+	assert.NoError(t, Uri.BindUri(m, &tag))
+	assert.Equal(t, tag.Name, expectedName)
+	assert.Equal(t, tag.S.Age, expectedAge)
+}
+
 func testFormBinding(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Form
 	assert.Equal(t, "form", b.Name())
diff --git a/binding/form_mapping.go b/binding/form_mapping.go
index d893c21c..8900ab70 100644
--- a/binding/form_mapping.go
+++ b/binding/form_mapping.go
@@ -55,7 +55,7 @@ func mapFormByTag(ptr interface{}, form map[string][]string, tag string) error {
 				structFieldKind = structField.Kind()
 			}
 			if structFieldKind == reflect.Struct {
-				err := mapForm(structField.Addr().Interface(), form)
+				err := mapFormByTag(structField.Addr().Interface(), form, tag)
 				if err != nil {
 					return err
 				}
diff --git a/context_test.go b/context_test.go
index dced73fd..836b3ecb 100644
--- a/context_test.go
+++ b/context_test.go
@@ -1457,7 +1457,7 @@ func TestContextShouldBindWithXML(t *testing.T) {
 	c.Request, _ = http.NewRequest("POST", "/", bytes.NewBufferString(`<?xml version="1.0" encoding="UTF-8"?>
 		<root>
 			<foo>FOO</foo>
-		   	<bar>BAR</bar>
+			<bar>BAR</bar>
 		</root>`))
 	c.Request.Header.Add("Content-Type", MIMEXML) // set fake content-type
 
@@ -1475,15 +1475,19 @@ func TestContextShouldBindWithQuery(t *testing.T) {
 	w := httptest.NewRecorder()
 	c, _ := CreateTestContext(w)
 
-	c.Request, _ = http.NewRequest("POST", "/?foo=bar&bar=foo", bytes.NewBufferString("foo=unused"))
+	c.Request, _ = http.NewRequest("POST", "/?foo=bar&bar=foo&Foo=bar1&Bar=foo1", bytes.NewBufferString("foo=unused"))
 
 	var obj struct {
-		Foo string `form:"foo"`
-		Bar string `form:"bar"`
+		Foo  string `form:"foo"`
+		Bar  string `form:"bar"`
+		Foo1 string `form:"Foo"`
+		Bar1 string `form:"Bar"`
 	}
 	assert.NoError(t, c.ShouldBindQuery(&obj))
 	assert.Equal(t, "foo", obj.Bar)
 	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, "foo1", obj.Bar1)
+	assert.Equal(t, "bar1", obj.Foo1)
 	assert.Equal(t, 0, w.Body.Len())
 }
 
diff --git a/gin_integration_test.go b/gin_integration_test.go
index e14a688c..01d5cf5e 100644
--- a/gin_integration_test.go
+++ b/gin_integration_test.go
@@ -137,7 +137,7 @@ func TestBadUnixSocket(t *testing.T) {
 func TestFileDescriptor(t *testing.T) {
 	router := New()
 
-	addr, err := net.ResolveTCPAddr("tcp", ":8000")
+	addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
 	assert.NoError(t, err)
 	listener, err := net.ListenTCP("tcp", addr)
 	assert.NoError(t, err)
@@ -152,7 +152,7 @@ func TestFileDescriptor(t *testing.T) {
 	// otherwise the main thread will complete
 	time.Sleep(5 * time.Millisecond)
 
-	c, err := net.Dial("tcp", "localhost:8000")
+	c, err := net.Dial("tcp", listener.Addr().String())
 	assert.NoError(t, err)
 
 	fmt.Fprintf(c, "GET /example HTTP/1.0\r\n\r\n")
diff --git a/logger.go b/logger.go
index a64af697..a55d26e0 100644
--- a/logger.go
+++ b/logger.go
@@ -35,9 +35,9 @@ type LoggerConfig struct {
 	// Optional. Default value is gin.DefaultWriter.
 	Output io.Writer
 
-	// SkipPathes is a url path array which logs are not written.
+	// SkipPaths is a url path array which logs are not written.
 	// Optional.
-	SkipPathes []string
+	SkipPaths []string
 }
 
 // LogFormatter gives the signature of the formatter function passed to LoggerWithFormatter
@@ -45,15 +45,24 @@ type LogFormatter func(params LogFormatterParams) string
 
 // LogFormatterParams is the structure any formatter will be handed when time to log comes
 type LogFormatterParams struct {
-	Request      *http.Request
-	TimeStamp    time.Time
-	StatusCode   int
-	Latency      time.Duration
-	ClientIP     string
-	Method       string
-	Path         string
+	Request *http.Request
+
+	// TimeStamp shows the time after the server returns a response.
+	TimeStamp time.Time
+	// StatusCode is HTTP response code.
+	StatusCode int
+	// Latency is how much time the server cost to process a certain request.
+	Latency time.Duration
+	// ClientIP equals Context's ClientIP method.
+	ClientIP string
+	// Method is the HTTP method given to the request.
+	Method string
+	// Path is a path the client requests.
+	Path string
+	// ErrorMessage is set if error has occurred in processing the request.
 	ErrorMessage string
-	IsTerm       bool
+	// IsTerm shows whether does gin's output descriptor refers to a terminal.
+	IsTerm bool
 }
 
 // defaultLogFormatter is the default log format function Logger middleware uses.
@@ -114,8 +123,8 @@ func LoggerWithFormatter(f LogFormatter) HandlerFunc {
 // Example: os.Stdout, a file opened in write mode, a socket...
 func LoggerWithWriter(out io.Writer, notlogged ...string) HandlerFunc {
 	return LoggerWithConfig(LoggerConfig{
-		Output:     out,
-		SkipPathes: notlogged,
+		Output:    out,
+		SkipPaths: notlogged,
 	})
 }
 
@@ -131,7 +140,7 @@ func LoggerWithConfig(conf LoggerConfig) HandlerFunc {
 		out = DefaultWriter
 	}
 
-	notlogged := conf.SkipPathes
+	notlogged := conf.SkipPaths
 
 	isTerm := true
 
diff --git a/logger_test.go b/logger_test.go
index 909ddd39..350599d4 100644
--- a/logger_test.go
+++ b/logger_test.go
@@ -320,8 +320,8 @@ func TestLoggerWithConfigSkippingPaths(t *testing.T) {
 	buffer := new(bytes.Buffer)
 	router := New()
 	router.Use(LoggerWithConfig(LoggerConfig{
-		Output:     buffer,
-		SkipPathes: []string{"/skipped"},
+		Output:    buffer,
+		SkipPaths: []string{"/skipped"},
 	}))
 	router.GET("/logged", func(c *Context) {})
 	router.GET("/skipped", func(c *Context) {})
diff --git a/routergroup.go b/routergroup.go
index 2b41dfda..297d3574 100644
--- a/routergroup.go
+++ b/routergroup.go
@@ -47,7 +47,7 @@ type RouterGroup struct {
 
 var _ IRouter = &RouterGroup{}
 
-// Use adds middleware to the group, see example code in github.
+// Use adds middleware to the group, see example code in GitHub.
 func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
 	group.Handlers = append(group.Handlers, middleware...)
 	return group.returnObj()
@@ -78,7 +78,7 @@ func (group *RouterGroup) handle(httpMethod, relativePath string, handlers Handl
 
 // Handle registers a new request handle and middleware with the given path and method.
 // The last handler should be the real handler, the other ones should be middleware that can and should be shared among different routes.
-// See the example code in github.
+// See the example code in GitHub.
 //
 // For GET, POST, PUT, PATCH and DELETE requests the respective shortcut
 // functions can be used.
diff --git a/tools.go b/tools/tools.go
similarity index 88%
rename from tools.go
rename to tools/tools.go
index 9f96406a..7113e71e 100644
--- a/tools.go
+++ b/tools/tools.go
@@ -4,12 +4,12 @@
 
 // +build tools
 
-// This file exists to cause `go mod` and `go get` to believe these tools
+// This package exists to cause `go mod` and `go get` to believe these tools
 // are dependencies, even though they are not runtime dependencies of any
 // gin package. This means they will appear in `go.mod` file, but will not
 // be a part of the build.
 
-package gin
+package tools
 
 import (
 	_ "github.com/campoy/embedmd"