From 13042dfd4e3dfd6679c2996d796bd96890fda0d7 Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Tue, 24 Oct 2017 17:44:09 +0800
Subject: [PATCH 01/12] support default value for form

---
 binding/form_mapping.go | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/binding/form_mapping.go b/binding/form_mapping.go
index c968dc08..e824d39c 100644
--- a/binding/form_mapping.go
+++ b/binding/form_mapping.go
@@ -8,6 +8,7 @@ import (
 	"errors"
 	"reflect"
 	"strconv"
+	"strings"
 	"time"
 )
 
@@ -23,6 +24,15 @@ func mapForm(ptr interface{}, form map[string][]string) error {
 
 		structFieldKind := structField.Kind()
 		inputFieldName := typeField.Tag.Get("form")
+		inputFieldNameList := strings.Split(inputFieldName, ",")
+		inputFieldName = inputFieldNameList[0]
+		var defaultValue interface{}
+		if len(inputFieldNameList) > 1 {
+			defaultList := strings.Split(inputFieldNameList[1], "=")
+			if len(defaultList) == 2 && defaultList[0] == "default" {
+				defaultValue = defaultList[1]
+			}
+		}
 		if inputFieldName == "" {
 			inputFieldName = typeField.Name
 
@@ -38,8 +48,13 @@ func mapForm(ptr interface{}, form map[string][]string) error {
 			}
 		}
 		inputValue, exists := form[inputFieldName]
+
 		if !exists {
-			continue
+			if defaultValue.(string) == "" {
+				continue
+			}
+			inputValue = make([]string, 1)
+			inputValue[0] = defaultValue.(string)
 		}
 
 		numElems := len(inputValue)

From b4d1b55cc2efceeb8c68857735395119ac7a4dd2 Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Tue, 24 Oct 2017 21:38:42 +0800
Subject: [PATCH 02/12] fix bug for nil interface

---
 binding/form_mapping.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/binding/form_mapping.go b/binding/form_mapping.go
index e824d39c..3ced55be 100644
--- a/binding/form_mapping.go
+++ b/binding/form_mapping.go
@@ -50,7 +50,7 @@ func mapForm(ptr interface{}, form map[string][]string) error {
 		inputValue, exists := form[inputFieldName]
 
 		if !exists {
-			if defaultValue.(string) == "" {
+			if defaultValue == nil {
 				continue
 			}
 			inputValue = make([]string, 1)

From 4654192b83702ab375234caac222107da0a35c02 Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Tue, 24 Oct 2017 23:07:03 +0800
Subject: [PATCH 03/12] use SplitN and optimization code

---
 binding/form_mapping.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/binding/form_mapping.go b/binding/form_mapping.go
index 3ced55be..a042ceef 100644
--- a/binding/form_mapping.go
+++ b/binding/form_mapping.go
@@ -26,10 +26,10 @@ func mapForm(ptr interface{}, form map[string][]string) error {
 		inputFieldName := typeField.Tag.Get("form")
 		inputFieldNameList := strings.Split(inputFieldName, ",")
 		inputFieldName = inputFieldNameList[0]
-		var defaultValue interface{}
+		var defaultValue string
 		if len(inputFieldNameList) > 1 {
-			defaultList := strings.Split(inputFieldNameList[1], "=")
-			if len(defaultList) == 2 && defaultList[0] == "default" {
+			defaultList := strings.SplitN(inputFieldNameList[1], "=", 2)
+			if defaultList[0] == "default" {
 				defaultValue = defaultList[1]
 			}
 		}
@@ -50,11 +50,11 @@ func mapForm(ptr interface{}, form map[string][]string) error {
 		inputValue, exists := form[inputFieldName]
 
 		if !exists {
-			if defaultValue == nil {
+			if defaultValue == "" {
 				continue
 			}
 			inputValue = make([]string, 1)
-			inputValue[0] = defaultValue.(string)
+			inputValue[0] = defaultValue
 		}
 
 		numElems := len(inputValue)

From e9773bfdd0e02fcd1f2aa42e98b8bf62a2dd4730 Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Sun, 12 Nov 2017 17:19:31 +0800
Subject: [PATCH 04/12] add test case

---
 binding/binding_test.go | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/binding/binding_test.go b/binding/binding_test.go
index 5575e166..a88d7146 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -25,6 +25,11 @@ type FooBarStruct struct {
 	Bar string `msgpack:"bar" json:"bar" form:"bar" xml:"bar" binding:"required"`
 }
 
+type FooDefaultBarStruct struct {
+	FooStruct
+	Bar string `msgpack:"bar" json:"bar,default=hello" form:"bar" xml:"bar" binding:"required"`
+}
+
 func TestBindingDefault(t *testing.T) {
 	assert.Equal(t, Default("GET", ""), Form)
 	assert.Equal(t, Default("GET", MIMEJSON), Form)
@@ -92,6 +97,12 @@ func createFormPostRequest() *http.Request {
 	return req
 }
 
+func createDefaultFormPostRequest() *http.Request {
+	req, _ := http.NewRequest("POST", "/?foo=getfoo&bar=getbar", bytes.NewBufferString("foo=bar"))
+	req.Header.Set("Content-Type", MIMEPOSTForm)
+	return req
+}
+
 func createFormMultipartRequest() *http.Request {
 	boundary := "--testboundary"
 	body := new(bytes.Buffer)
@@ -115,6 +126,15 @@ func TestBindingFormPost(t *testing.T) {
 	assert.Equal(t, obj.Bar, "foo")
 }
 
+func TestBindingDefaultValueFormPost(t *testing.T) {
+	req := createDefaultFormPostRequest()
+	var obj FooDefaultBarStruct
+	FormPost.Bind(req, &obj)
+
+	assert.Equal(t, obj.Foo, "bar")
+	assert.Equal(t, obj.Bar, "hello")
+}
+
 func TestBindingFormMultipart(t *testing.T) {
 	req := createFormMultipartRequest()
 	var obj FooBarStruct

From 8027a23db9bf191406f9e4ab03c0369cbd6b83d2 Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Sun, 12 Nov 2017 21:30:55 +0800
Subject: [PATCH 05/12] add test cases for form(own default value)

---
 binding/binding_test.go | 34 +++++++++++++++++++++++++++++++++-
 1 file changed, 33 insertions(+), 1 deletion(-)

diff --git a/binding/binding_test.go b/binding/binding_test.go
index a88d7146..5e0cee5e 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -27,7 +27,7 @@ type FooBarStruct struct {
 
 type FooDefaultBarStruct struct {
 	FooStruct
-	Bar string `msgpack:"bar" json:"bar,default=hello" form:"bar" xml:"bar" binding:"required"`
+	Bar string `msgpack:"bar" json:"bar" form:"bar,default=hello" xml:"bar" binding:"required"`
 }
 
 func TestBindingDefault(t *testing.T) {
@@ -72,6 +72,18 @@ func TestBindingForm2(t *testing.T) {
 		"", "")
 }
 
+func TestBindingFormDefaultValue(t *testing.T) {
+	testFormBindingDefaultValue(t, "POST",
+		"/", "/",
+		"foo=bar", "bar2=foo")
+}
+
+func TestBindingFormDefaultValue2(t *testing.T) {
+	testFormBindingDefaultValue(t, "GET",
+		"/?foo=bar", "/?bar2=foo",
+		"", "")
+}
+
 func TestBindingQuery(t *testing.T) {
 	testQueryBinding(t, "POST",
 		"/?foo=bar&bar=foo", "/",
@@ -236,6 +248,26 @@ func testFormBinding(t *testing.T, method, path, badPath, body, badBody string)
 	assert.Error(t, err)
 }
 
+func testFormBindingDefaultValue(t *testing.T, method, path, badPath, body, badBody string) {
+	b := Form
+	assert.Equal(t, b.Name(), "form")
+
+	obj := FooDefaultBarStruct{}
+	req := requestWithBody(method, path, body)
+	if method == "POST" {
+		req.Header.Add("Content-Type", MIMEPOSTForm)
+	}
+	err := b.Bind(req, &obj)
+	assert.NoError(t, err)
+	assert.Equal(t, obj.Foo, "bar")
+	assert.Equal(t, obj.Bar, "hello")
+
+	obj = FooDefaultBarStruct{}
+	req = requestWithBody(method, badPath, badBody)
+	err = JSON.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
 func testQueryBinding(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Query
 	assert.Equal(t, b.Name(), "query")

From bcd046b40fc53cbb74ff122aa447ae26bd596adf Mon Sep 17 00:00:00 2001
From: tianou <tianou@kuaishou.com>
Date: Tue, 17 Apr 2018 13:05:43 +0800
Subject: [PATCH 06/12] fix invalid code

---
 binding/binding_test.go | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/binding/binding_test.go b/binding/binding_test.go
index 956e3698..ba64c26c 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -615,12 +615,12 @@ func testFormBindingDefaultValue(t *testing.T, method, path, badPath, body, badB
 	assert.Equal(t, b.Name(), "form")
 
 	obj := FooDefaultBarStruct{}
-    req := requestWithBody(method, path, body)
+	req := requestWithBody(method, path, body)
 	if method == "POST" {
 		req.Header.Add("Content-Type", MIMEPOSTForm)
 	}
 	err := b.Bind(req, &obj)
-    assert.NoError(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, obj.Foo, "bar")
 	assert.Equal(t, obj.Bar, "hello")
 
@@ -670,11 +670,6 @@ func testFormBindingForTime(t *testing.T, method, path, badPath, body, badBody s
 		req.Header.Add("Content-Type", MIMEPOSTForm)
 	}
 	err := b.Bind(req, &obj)
-	assert.NoError(t, err)
-	assert.Equal(t, obj.Foo, "bar")
-	assert.Equal(t, obj.Bar, "hello")
-
-	obj = FooDefaultBarStruct{}
 
 	assert.NoError(t, err)
 	assert.Equal(t, obj.TimeFoo.Unix(), int64(1510675200))

From 5a1c743045f4f01e2e4dd650ec628e21d075f9b3 Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Tue, 17 Apr 2018 13:15:38 +0800
Subject: [PATCH 07/12] fix code indent

---
 binding/binding_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/binding/binding_test.go b/binding/binding_test.go
index ba64c26c..7dc57ed0 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -426,8 +426,8 @@ func createFormPostRequest() *http.Request {
 
 func createDefaultFormPostRequest() *http.Request {
 	req, _ := http.NewRequest("POST", "/?foo=getfoo&bar=getbar", bytes.NewBufferString("foo=bar"))
-    req.Header.Set("Content-Type", MIMEPOSTForm)
-    return req
+	req.Header.Set("Content-Type", MIMEPOSTForm)
+	return req
 }
 
 func createFormPostRequestFail() *http.Request {

From 1486c12e21cbe27295ad4f2d93271c72897cc9f4 Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Fri, 20 Apr 2018 07:27:38 +0800
Subject: [PATCH 08/12] unify assert.Equal usage

---
 binding/binding_test.go  | 174 +++++++++++++++++++--------------------
 binding/validate_test.go |   6 +-
 render/render_test.go    |  50 +++++------
 3 files changed, 115 insertions(+), 115 deletions(-)

diff --git a/binding/binding_test.go b/binding/binding_test.go
index 7dc57ed0..3c1d0d12 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -145,26 +145,26 @@ type FooBarStructForFloat64Type struct {
 }
 
 func TestBindingDefault(t *testing.T) {
-	assert.Equal(t, Default("GET", ""), Form)
-	assert.Equal(t, Default("GET", MIMEJSON), Form)
+	assert.Equal(t, Form, Default("GET", ""))
+	assert.Equal(t, Form, Default("GET", MIMEJSON))
 
-	assert.Equal(t, Default("POST", MIMEJSON), JSON)
-	assert.Equal(t, Default("PUT", MIMEJSON), JSON)
+	assert.Equal(t, JSON, Default("POST", MIMEJSON))
+	assert.Equal(t, JSON, Default("PUT", MIMEJSON))
 
-	assert.Equal(t, Default("POST", MIMEXML), XML)
-	assert.Equal(t, Default("PUT", MIMEXML2), XML)
+	assert.Equal(t, XML, Default("POST", MIMEXML))
+	assert.Equal(t, XML, Default("PUT", MIMEXML2))
 
-	assert.Equal(t, Default("POST", MIMEPOSTForm), Form)
-	assert.Equal(t, Default("PUT", MIMEPOSTForm), Form)
+	assert.Equal(t, Form, Default("POST", MIMEPOSTForm))
+	assert.Equal(t, Form, Default("PUT", MIMEPOSTForm))
 
-	assert.Equal(t, Default("POST", MIMEMultipartPOSTForm), Form)
-	assert.Equal(t, Default("PUT", MIMEMultipartPOSTForm), Form)
+	assert.Equal(t, Form, Default("POST", MIMEMultipartPOSTForm))
+	assert.Equal(t, Form, Default("PUT", MIMEMultipartPOSTForm))
 
-	assert.Equal(t, Default("POST", MIMEPROTOBUF), ProtoBuf)
-	assert.Equal(t, Default("PUT", MIMEPROTOBUF), ProtoBuf)
+	assert.Equal(t, ProtoBuf, Default("POST", MIMEPROTOBUF))
+	assert.Equal(t, ProtoBuf, Default("PUT", MIMEPROTOBUF))
 
-	assert.Equal(t, Default("POST", MIMEMSGPACK), MsgPack)
-	assert.Equal(t, Default("PUT", MIMEMSGPACK2), MsgPack)
+	assert.Equal(t, MsgPack, Default("POST", MIMEMSGPACK))
+	assert.Equal(t, MsgPack, Default("PUT", MIMEMSGPACK2))
 }
 
 func TestBindingJSON(t *testing.T) {
@@ -468,9 +468,9 @@ func TestBindingFormPost(t *testing.T) {
 	var obj FooBarStruct
 	FormPost.Bind(req, &obj)
 
-	assert.Equal(t, FormPost.Name(), "form-urlencoded")
-	assert.Equal(t, obj.Foo, "bar")
-	assert.Equal(t, obj.Bar, "foo")
+	assert.Equal(t, "form-urlencoded", FormPost.Name())
+	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, "foor", obj.Bar)
 }
 
 func TestBindingDefaultValueFormPost(t *testing.T) {
@@ -478,8 +478,8 @@ func TestBindingDefaultValueFormPost(t *testing.T) {
 	var obj FooDefaultBarStruct
 	FormPost.Bind(req, &obj)
 
-	assert.Equal(t, obj.Foo, "bar")
-	assert.Equal(t, obj.Bar, "hello")
+	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, "hello", obj.Bar)
 }
 
 func TestBindingFormPostFail(t *testing.T) {
@@ -494,9 +494,9 @@ func TestBindingFormMultipart(t *testing.T) {
 	var obj FooBarStruct
 	FormMultipart.Bind(req, &obj)
 
-	assert.Equal(t, FormMultipart.Name(), "multipart/form-data")
-	assert.Equal(t, obj.Foo, "bar")
-	assert.Equal(t, obj.Bar, "foo")
+	assert.Equal(t, "multipart/form-data", FormMultpart.Name())
+	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, "foo", obj.Bar)
 }
 
 func TestBindingFormMultipartFail(t *testing.T) {
@@ -592,7 +592,7 @@ func TestExistsFails(t *testing.T) {
 
 func testFormBinding(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Form
-	assert.Equal(t, b.Name(), "form")
+	assert.Equal(t, "form", b.Name())
 
 	obj := FooBarStruct{}
 	req := requestWithBody(method, path, body)
@@ -601,8 +601,8 @@ func testFormBinding(t *testing.T, method, path, badPath, body, badBody string)
 	}
 	err := b.Bind(req, &obj)
 	assert.NoError(t, err)
-	assert.Equal(t, obj.Foo, "bar")
-	assert.Equal(t, obj.Bar, "foo")
+	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, "foo", obj.Bar)
 
 	obj = FooBarStruct{}
 	req = requestWithBody(method, badPath, badBody)
@@ -612,7 +612,7 @@ func testFormBinding(t *testing.T, method, path, badPath, body, badBody string)
 
 func testFormBindingDefaultValue(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Form
-	assert.Equal(t, b.Name(), "form")
+	assert.Equal(t, "form", b.Name())
 
 	obj := FooDefaultBarStruct{}
 	req := requestWithBody(method, path, body)
@@ -621,8 +621,8 @@ func testFormBindingDefaultValue(t *testing.T, method, path, badPath, body, badB
 	}
 	err := b.Bind(req, &obj)
 	assert.NoError(t, err)
-	assert.Equal(t, obj.Foo, "bar")
-	assert.Equal(t, obj.Bar, "hello")
+	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, "hello", obj.Bar)
 
 	obj = FooDefaultBarStruct{}
 	req = requestWithBody(method, badPath, badBody)
@@ -632,7 +632,7 @@ func testFormBindingDefaultValue(t *testing.T, method, path, badPath, body, badB
 
 func TestFormBindingFail(t *testing.T) {
 	b := Form
-	assert.Equal(t, b.Name(), "form")
+	assert.Equal(t, "form", b.Name())
 
 	obj := FooBarStruct{}
 	req, _ := http.NewRequest("POST", "/", nil)
@@ -642,7 +642,7 @@ func TestFormBindingFail(t *testing.T) {
 
 func TestFormPostBindingFail(t *testing.T) {
 	b := FormPost
-	assert.Equal(t, b.Name(), "form-urlencoded")
+	assert.Equal(t, "form-urlencoded", b.Name())
 
 	obj := FooBarStruct{}
 	req, _ := http.NewRequest("POST", "/", nil)
@@ -652,7 +652,7 @@ func TestFormPostBindingFail(t *testing.T) {
 
 func TestFormMultipartBindingFail(t *testing.T) {
 	b := FormMultipart
-	assert.Equal(t, b.Name(), "multipart/form-data")
+	assert.Equal(t, "multipart/form-data", b.Name())
 
 	obj := FooBarStruct{}
 	req, _ := http.NewRequest("POST", "/", nil)
@@ -662,7 +662,7 @@ func TestFormMultipartBindingFail(t *testing.T) {
 
 func testFormBindingForTime(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Form
-	assert.Equal(t, b.Name(), "form")
+	assert.Equal(t, "form", b.Name())
 
 	obj := FooBarStructForTimeType{}
 	req := requestWithBody(method, path, body)
@@ -672,10 +672,10 @@ func testFormBindingForTime(t *testing.T, method, path, badPath, body, badBody s
 	err := b.Bind(req, &obj)
 
 	assert.NoError(t, err)
-	assert.Equal(t, obj.TimeFoo.Unix(), int64(1510675200))
-	assert.Equal(t, obj.TimeFoo.Location().String(), "Asia/Chongqing")
-	assert.Equal(t, obj.TimeBar.Unix(), int64(-62135596800))
-	assert.Equal(t, obj.TimeBar.Location().String(), "UTC")
+	assert.Equal(t, int64(1510675200), obj.TimeFoo.Unix())
+	assert.Equal(t, "Asia/Chongqing", obj.TimeFoo.Location().String())
+	assert.Equal(t, int64(-62135596800), obj.TimeBar.Unix())
+	assert.Equal(t, "UTC", obj.TimeBar.Location().String())
 
 	obj = FooBarStructForTimeType{}
 	req = requestWithBody(method, badPath, badBody)
@@ -685,7 +685,7 @@ func testFormBindingForTime(t *testing.T, method, path, badPath, body, badBody s
 
 func testFormBindingForTimeNotFormat(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Form
-	assert.Equal(t, b.Name(), "form")
+	assert.Equal(t, "form", b.Name())
 
 	obj := FooStructForTimeTypeNotFormat{}
 	req := requestWithBody(method, path, body)
@@ -703,7 +703,7 @@ func testFormBindingForTimeNotFormat(t *testing.T, method, path, badPath, body,
 
 func testFormBindingForTimeFailFormat(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Form
-	assert.Equal(t, b.Name(), "form")
+	assert.Equal(t, "form", b.Name())
 
 	obj := FooStructForTimeTypeFailFormat{}
 	req := requestWithBody(method, path, body)
@@ -721,7 +721,7 @@ func testFormBindingForTimeFailFormat(t *testing.T, method, path, badPath, body,
 
 func testFormBindingForTimeFailLocation(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Form
-	assert.Equal(t, b.Name(), "form")
+	assert.Equal(t, "form", b.Name())
 
 	obj := FooStructForTimeTypeFailLocation{}
 	req := requestWithBody(method, path, body)
@@ -739,7 +739,7 @@ func testFormBindingForTimeFailLocation(t *testing.T, method, path, badPath, bod
 
 func testFormBindingInvalidName(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Form
-	assert.Equal(t, b.Name(), "form")
+	assert.Equal(t, "form", b.Name())
 
 	obj := InvalidNameType{}
 	req := requestWithBody(method, path, body)
@@ -748,7 +748,7 @@ func testFormBindingInvalidName(t *testing.T, method, path, badPath, body, badBo
 	}
 	err := b.Bind(req, &obj)
 	assert.NoError(t, err)
-	assert.Equal(t, obj.TestName, "")
+	assert.Equal(t, "", obj.TestName)
 
 	obj = InvalidNameType{}
 	req = requestWithBody(method, badPath, badBody)
@@ -758,7 +758,7 @@ func testFormBindingInvalidName(t *testing.T, method, path, badPath, body, badBo
 
 func testFormBindingInvalidName2(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Form
-	assert.Equal(t, b.Name(), "form")
+	assert.Equal(t, "form", b.Name())
 
 	obj := InvalidNameMapType{}
 	req := requestWithBody(method, path, body)
@@ -776,7 +776,7 @@ func testFormBindingInvalidName2(t *testing.T, method, path, badPath, body, badB
 
 func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody string, typ string) {
 	b := Form
-	assert.Equal(t, b.Name(), "form")
+	assert.Equal(t, "form", b.Name())
 
 	req := requestWithBody(method, path, body)
 	if method == "POST" {
@@ -787,8 +787,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForIntType{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.IntFoo, int(0))
-		assert.Equal(t, obj.IntBar, int(-12))
+		assert.Equal(t, int(0), obj.IntFoo)
+		assert.Equal(t, int(-12), obj.IntBar)
 
 		obj = FooBarStructForIntType{}
 		req = requestWithBody(method, badPath, badBody)
@@ -798,8 +798,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForInt8Type{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.Int8Foo, int8(0))
-		assert.Equal(t, obj.Int8Bar, int8(-12))
+		assert.Equal(t, int8(0), obj.Int8Foo)
+		assert.Equal(t, int8(-12), obj.Int8Bar)
 
 		obj = FooBarStructForInt8Type{}
 		req = requestWithBody(method, badPath, badBody)
@@ -809,8 +809,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForInt16Type{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.Int16Foo, int16(0))
-		assert.Equal(t, obj.Int16Bar, int16(-12))
+		assert.Equal(t, int16(0), obj.Int16Foo)
+		assert.Equal(t, int16(-12), obj.Int16Bar)
 
 		obj = FooBarStructForInt16Type{}
 		req = requestWithBody(method, badPath, badBody)
@@ -820,8 +820,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForInt32Type{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.Int32Foo, int32(0))
-		assert.Equal(t, obj.Int32Bar, int32(-12))
+		assert.Equal(t, int32(0), obj.Int32Foo)
+		assert.Equal(t, int32(-12), obj.Int32Bar)
 
 		obj = FooBarStructForInt32Type{}
 		req = requestWithBody(method, badPath, badBody)
@@ -831,8 +831,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForInt64Type{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.Int64Foo, int64(0))
-		assert.Equal(t, obj.Int64Bar, int64(-12))
+		assert.Equal(t, int64(0), obj.Int64Foo)
+		assert.Equal(t, int64(-12), obj.Int64Bar)
 
 		obj = FooBarStructForInt64Type{}
 		req = requestWithBody(method, badPath, badBody)
@@ -842,8 +842,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForUintType{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.UintFoo, uint(0x0))
-		assert.Equal(t, obj.UintBar, uint(0xc))
+		assert.Equal(t, uint(0x0), obj.UintFoo)
+		assert.Equal(t, uint(0xc), obj.UintBar)
 
 		obj = FooBarStructForUintType{}
 		req = requestWithBody(method, badPath, badBody)
@@ -853,8 +853,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForUint8Type{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.Uint8Foo, uint8(0x0))
-		assert.Equal(t, obj.Uint8Bar, uint8(0xc))
+		assert.Equal(t, uint8(0x0), obj.Uint8Foo)
+		assert.Equal(t, uint8(0xc), obj.Uint8Bar)
 
 		obj = FooBarStructForUint8Type{}
 		req = requestWithBody(method, badPath, badBody)
@@ -864,8 +864,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForUint16Type{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.Uint16Foo, uint16(0x0))
-		assert.Equal(t, obj.Uint16Bar, uint16(0xc))
+		assert.Equal(t, uint16(0x0), obj.Uint16Foo)
+		assert.Equal(t, uint16(0xc), obj.Uint16Bar)
 
 		obj = FooBarStructForUint16Type{}
 		req = requestWithBody(method, badPath, badBody)
@@ -875,8 +875,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForUint32Type{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.Uint32Foo, uint32(0x0))
-		assert.Equal(t, obj.Uint32Bar, uint32(0xc))
+		assert.Equal(t, uint32(0x0), obj.Uint32Foo)
+		assert.Equal(t, uint32(0xc), obj.Uint32Bar)
 
 		obj = FooBarStructForUint32Type{}
 		req = requestWithBody(method, badPath, badBody)
@@ -886,8 +886,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForUint64Type{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.Uint64Foo, uint64(0x0))
-		assert.Equal(t, obj.Uint64Bar, uint64(0xc))
+		assert.Equal(t, uint64(0x0), obj.Uint64Foo)
+		assert.Equal(t, uint64(0xc), obj.Uint64Bar)
 
 		obj = FooBarStructForUint64Type{}
 		req = requestWithBody(method, badPath, badBody)
@@ -897,8 +897,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForFloat32Type{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.Float32Foo, float32(0.0))
-		assert.Equal(t, obj.Float32Bar, float32(-12.34))
+		assert.Equal(t, float32(0.0), obj.Float32Foo)
+		assert.Equal(t, float32(-12.34), obj.Float32Bar)
 
 		obj = FooBarStructForFloat32Type{}
 		req = requestWithBody(method, badPath, badBody)
@@ -908,8 +908,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForFloat64Type{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.Float64Foo, float64(0.0))
-		assert.Equal(t, obj.Float64Bar, float64(-12.34))
+		assert.Equal(t, float64(0.0), obj.Float64Foo)
+		assert.Equal(t, float64(-12.34), obj.Float64Bar)
 
 		obj = FooBarStructForFloat64Type{}
 		req = requestWithBody(method, badPath, badBody)
@@ -919,8 +919,8 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooBarStructForBoolType{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.BoolFoo, false)
-		assert.Equal(t, obj.BoolBar, true)
+		assert.False(t, obj.BoolFoo)
+		assert.True(t, obj.BoolBar)
 
 		obj = FooBarStructForBoolType{}
 		req = requestWithBody(method, badPath, badBody)
@@ -930,7 +930,7 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 		obj := FooStructForSliceType{}
 		err := b.Bind(req, &obj)
 		assert.NoError(t, err)
-		assert.Equal(t, obj.SliceFoo, []int{1, 2})
+		assert.Equal(t, []int{1, 2}, obj.SliceFoo)
 
 		obj = FooStructForSliceType{}
 		req = requestWithBody(method, badPath, badBody)
@@ -949,7 +949,7 @@ func testFormBindingForType(t *testing.T, method, path, badPath, body, badBody s
 
 func testQueryBinding(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Query
-	assert.Equal(t, b.Name(), "query")
+	assert.Equal(t, "query", b.Name())
 
 	obj := FooBarStruct{}
 	req := requestWithBody(method, path, body)
@@ -958,13 +958,13 @@ func testQueryBinding(t *testing.T, method, path, badPath, body, badBody string)
 	}
 	err := b.Bind(req, &obj)
 	assert.NoError(t, err)
-	assert.Equal(t, obj.Foo, "bar")
-	assert.Equal(t, obj.Bar, "foo")
+	assert.Equal(t, "bar", obj.Foo)
+	assert.Equal(t, "foo", obj.Bar)
 }
 
 func testQueryBindingFail(t *testing.T, method, path, badPath, body, badBody string) {
 	b := Query
-	assert.Equal(t, b.Name(), "query")
+	assert.Equal(t, "query", b.Name())
 
 	obj := FooStructForMapType{}
 	req := requestWithBody(method, path, body)
@@ -976,13 +976,13 @@ func testQueryBindingFail(t *testing.T, method, path, badPath, body, badBody str
 }
 
 func testBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
-	assert.Equal(t, b.Name(), name)
+	assert.Equal(t, name, b.Name())
 
 	obj := FooStruct{}
 	req := requestWithBody("POST", path, body)
 	err := b.Bind(req, &obj)
 	assert.NoError(t, err)
-	assert.Equal(t, obj.Foo, "bar")
+	assert.Equal(t, "bar", obj.Foo)
 
 	obj = FooStruct{}
 	req = requestWithBody("POST", badPath, badBody)
@@ -991,7 +991,7 @@ func testBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody
 }
 
 func testBodyBindingUseNumber(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
-	assert.Equal(t, b.Name(), name)
+	assert.Equal(t, name, b.Name())
 
 	obj := FooStructUseNumber{}
 	req := requestWithBody("POST", path, body)
@@ -1001,7 +1001,7 @@ func testBodyBindingUseNumber(t *testing.T, b Binding, name, path, badPath, body
 	// we hope it is int64(123)
 	v, e := obj.Foo.(json.Number).Int64()
 	assert.NoError(t, e)
-	assert.Equal(t, v, int64(123))
+	assert.Equal(t, int64(123), v)
 
 	obj = FooStructUseNumber{}
 	req = requestWithBody("POST", badPath, badBody)
@@ -1010,7 +1010,7 @@ func testBodyBindingUseNumber(t *testing.T, b Binding, name, path, badPath, body
 }
 
 func testBodyBindingUseNumber2(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
-	assert.Equal(t, b.Name(), name)
+	assert.Equal(t, name, b.Name())
 
 	obj := FooStructUseNumber{}
 	req := requestWithBody("POST", path, body)
@@ -1019,7 +1019,7 @@ func testBodyBindingUseNumber2(t *testing.T, b Binding, name, path, badPath, bod
 	assert.NoError(t, err)
 	// it will return float64(123) if not use EnableDecoderUseNumber
 	// maybe it is not hoped
-	assert.Equal(t, obj.Foo, float64(123))
+	assert.Equal(t, float64(123), obj.Foo)
 
 	obj = FooStructUseNumber{}
 	req = requestWithBody("POST", badPath, badBody)
@@ -1028,13 +1028,13 @@ func testBodyBindingUseNumber2(t *testing.T, b Binding, name, path, badPath, bod
 }
 
 func testBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
-	assert.Equal(t, b.Name(), name)
+	assert.Equal(t, name, b.Name())
 
 	obj := FooStruct{}
 	req := requestWithBody("POST", path, body)
 	err := b.Bind(req, &obj)
 	assert.Error(t, err)
-	assert.Equal(t, obj.Foo, "")
+	assert.Equal(t, "", obj.Foo)
 
 	obj = FooStruct{}
 	req = requestWithBody("POST", badPath, badBody)
@@ -1043,14 +1043,14 @@ func testBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, bad
 }
 
 func testProtoBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
-	assert.Equal(t, b.Name(), name)
+	assert.Equal(t, name, b.Name())
 
 	obj := example.Test{}
 	req := requestWithBody("POST", path, body)
 	req.Header.Add("Content-Type", MIMEPROTOBUF)
 	err := b.Bind(req, &obj)
 	assert.NoError(t, err)
-	assert.Equal(t, *obj.Label, "yes")
+	assert.Equal(t, "yes", *obj.Label)
 
 	obj = example.Test{}
 	req = requestWithBody("POST", badPath, badBody)
@@ -1066,7 +1066,7 @@ func (h hook) Read([]byte) (int, error) {
 }
 
 func testProtoBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
-	assert.Equal(t, b.Name(), name)
+	assert.Equal(t, name, b.Name())
 
 	obj := example.Test{}
 	req := requestWithBody("POST", path, body)
@@ -1084,14 +1084,14 @@ func testProtoBodyBindingFail(t *testing.T, b Binding, name, path, badPath, body
 }
 
 func testMsgPackBodyBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
-	assert.Equal(t, b.Name(), name)
+	assert.Equal(t, name, b.Name())
 
 	obj := FooStruct{}
 	req := requestWithBody("POST", path, body)
 	req.Header.Add("Content-Type", MIMEMSGPACK)
 	err := b.Bind(req, &obj)
 	assert.NoError(t, err)
-	assert.Equal(t, obj.Foo, "bar")
+	assert.Equal(t, "bar", obj.Foo)
 
 	obj = FooStruct{}
 	req = requestWithBody("POST", badPath, badBody)
diff --git a/binding/validate_test.go b/binding/validate_test.go
index cb76063c..2c76b6d6 100644
--- a/binding/validate_test.go
+++ b/binding/validate_test.go
@@ -176,7 +176,7 @@ func TestValidatePrimitives(t *testing.T) {
 	obj := Object{"foo": "bar", "bar": 1}
 	assert.NoError(t, validate(obj))
 	assert.NoError(t, validate(&obj))
-	assert.Equal(t, obj, Object{"foo": "bar", "bar": 1})
+	assert.Equal(t, Object{"foo": "bar", "bar": 1}, obj)
 
 	obj2 := []Object{{"foo": "bar", "bar": 1}, {"foo": "bar", "bar": 1}}
 	assert.NoError(t, validate(obj2))
@@ -185,12 +185,12 @@ func TestValidatePrimitives(t *testing.T) {
 	nu := 10
 	assert.NoError(t, validate(nu))
 	assert.NoError(t, validate(&nu))
-	assert.Equal(t, nu, 10)
+	assert.Equal(t, 10, nu)
 
 	str := "value"
 	assert.NoError(t, validate(str))
 	assert.NoError(t, validate(&str))
-	assert.Equal(t, str, "value")
+	assert.Equal(t, "value", str)
 }
 
 // structCustomValidation is a helper struct we use to check that
diff --git a/render/render_test.go b/render/render_test.go
index 530e222a..0dd4a7a2 100644
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -27,7 +27,7 @@ func TestRenderMsgPack(t *testing.T) {
 	}
 
 	(MsgPack{data}).WriteContentType(w)
-	assert.Equal(t, w.Header().Get("Content-Type"), "application/msgpack; charset=utf-8")
+	assert.Equal(t, "application/msgpack; charset=utf-8", w.Header().Get("Content-Type"))
 
 	err := (MsgPack{data}).Render(w)
 
@@ -41,7 +41,7 @@ func TestRenderMsgPack(t *testing.T) {
 
 	assert.NoError(t, err)
 	assert.Equal(t, w.Body.String(), string(buf.Bytes()))
-	assert.Equal(t, w.Header().Get("Content-Type"), "application/msgpack; charset=utf-8")
+	assert.Equal(t, "application/msgpack; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestRenderJSON(t *testing.T) {
@@ -78,8 +78,8 @@ func TestRenderIndentedJSON(t *testing.T) {
 	err := (IndentedJSON{data}).Render(w)
 
 	assert.NoError(t, err)
-	assert.Equal(t, w.Body.String(), "{\n    \"bar\": \"foo\",\n    \"foo\": \"bar\"\n}")
-	assert.Equal(t, w.Header().Get("Content-Type"), "application/json; charset=utf-8")
+	assert.Equal(t, "{\n    \"bar\": \"foo\",\n    \"foo\": \"bar\"\n}", w.Body.String())
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type")))
 }
 
 func TestRenderIndentedJSONPanics(t *testing.T) {
@@ -161,12 +161,12 @@ b:
 	d: [3, 4]
 	`
 	(YAML{data}).WriteContentType(w)
-	assert.Equal(t, w.Header().Get("Content-Type"), "application/x-yaml; charset=utf-8")
+	assert.Equal(t, "application/x-yaml; charset=utf-8", w.Header().Get("Content-Type"))
 
 	err := (YAML{data}).Render(w)
 	assert.NoError(t, err)
-	assert.Equal(t, w.Body.String(), "\"\\na : Easy!\\nb:\\n\\tc: 2\\n\\td: [3, 4]\\n\\t\"\n")
-	assert.Equal(t, w.Header().Get("Content-Type"), "application/x-yaml; charset=utf-8")
+	assert.Equal(t, "\"\\na : Easy!\\nb:\\n\\tc: 2\\n\\td: [3, 4]\\n\\t\"\n", w.Body.String())
+	assert.Equal(t, "application/x-yaml; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 type fail struct{}
@@ -189,13 +189,13 @@ func TestRenderXML(t *testing.T) {
 	}
 
 	(XML{data}).WriteContentType(w)
-	assert.Equal(t, w.Header().Get("Content-Type"), "application/xml; charset=utf-8")
+	assert.Equal(t, "application/xml; charset=utf-8", w.Header().Get("Content-Type"))
 
 	err := (XML{data}).Render(w)
 
 	assert.NoError(t, err)
-	assert.Equal(t, w.Body.String(), "<map><foo>bar</foo></map>")
-	assert.Equal(t, w.Header().Get("Content-Type"), "application/xml; charset=utf-8")
+	assert.Equal(t, "<map><foo>bar</foo></map>", w.Body.String())
+	assert.Equal(t, "application/xml; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestRenderRedirect(t *testing.T) {
@@ -235,8 +235,8 @@ func TestRenderData(t *testing.T) {
 	}).Render(w)
 
 	assert.NoError(t, err)
-	assert.Equal(t, w.Body.String(), "#!PNG some raw data")
-	assert.Equal(t, w.Header().Get("Content-Type"), "image/png")
+	assert.Equal(t, "#!PNG some raw data", w.Body.String())
+	assert.Equal(t, "image/png", w.Header().Get("Content-Type"))
 }
 
 func TestRenderString(t *testing.T) {
@@ -246,7 +246,7 @@ func TestRenderString(t *testing.T) {
 		Format: "hello %s %d",
 		Data:   []interface{}{},
 	}).WriteContentType(w)
-	assert.Equal(t, w.Header().Get("Content-Type"), "text/plain; charset=utf-8")
+	assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
 
 	err := (String{
 		Format: "hola %s %d",
@@ -254,8 +254,8 @@ func TestRenderString(t *testing.T) {
 	}).Render(w)
 
 	assert.NoError(t, err)
-	assert.Equal(t, w.Body.String(), "hola manu 2")
-	assert.Equal(t, w.Header().Get("Content-Type"), "text/plain; charset=utf-8")
+	assert.Equal(t, "hola manu 2", w.Body.String())
+	assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestRenderStringLenZero(t *testing.T) {
@@ -267,8 +267,8 @@ func TestRenderStringLenZero(t *testing.T) {
 	}).Render(w)
 
 	assert.NoError(t, err)
-	assert.Equal(t, w.Body.String(), "hola %s %d")
-	assert.Equal(t, w.Header().Get("Content-Type"), "text/plain; charset=utf-8")
+	assert.Equal(t, "hola %s %d", w.Body.String())
+	assert.Equal(t, "text/plain; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestRenderHTMLTemplate(t *testing.T) {
@@ -283,8 +283,8 @@ func TestRenderHTMLTemplate(t *testing.T) {
 	err := instance.Render(w)
 
 	assert.NoError(t, err)
-	assert.Equal(t, w.Body.String(), "Hello alexandernyquist")
-	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+	assert.Equal(t, "Hello alexandernyquist", w.Body.String())
+	assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestRenderHTMLTemplateEmptyName(t *testing.T) {
@@ -299,8 +299,8 @@ func TestRenderHTMLTemplateEmptyName(t *testing.T) {
 	err := instance.Render(w)
 
 	assert.NoError(t, err)
-	assert.Equal(t, w.Body.String(), "Hello alexandernyquist")
-	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+	assert.Equal(t, "Hello alexandernyquist", w.Body.String())
+	assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestRenderHTMLDebugFiles(t *testing.T) {
@@ -317,8 +317,8 @@ func TestRenderHTMLDebugFiles(t *testing.T) {
 	err := instance.Render(w)
 
 	assert.NoError(t, err)
-	assert.Equal(t, w.Body.String(), "<h1>Hello thinkerou</h1>")
-	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+	assert.Equal(t, "<h1>Hello thinkerou</h1>", w.Body.String())
+	assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestRenderHTMLDebugGlob(t *testing.T) {
@@ -335,8 +335,8 @@ func TestRenderHTMLDebugGlob(t *testing.T) {
 	err := instance.Render(w)
 
 	assert.NoError(t, err)
-	assert.Equal(t, w.Body.String(), "<h1>Hello thinkerou</h1>")
-	assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
+	assert.Equal(t, "<h1>Hello thinkerou</h1>", w.Body.String())
+	assert.Equal(t, "text/html; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestRenderHTMLDebugPanics(t *testing.T) {

From 68699d28dbf606ddeddedb12c234e52c0efff519 Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Fri, 20 Apr 2018 07:36:36 +0800
Subject: [PATCH 09/12] fix confilct

---
 binding/binding_test.go | 52 -----------------------------------------
 binding/form_mapping.go | 15 +-----------
 2 files changed, 1 insertion(+), 66 deletions(-)

diff --git a/binding/binding_test.go b/binding/binding_test.go
index 3c1d0d12..9607b920 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -29,11 +29,6 @@ type FooBarStruct struct {
 	Bar string `msgpack:"bar" json:"bar" form:"bar" xml:"bar" binding:"required"`
 }
 
-type FooDefaultBarStruct struct {
-	FooStruct
-	Bar string `msgpack:"bar" json:"bar" form:"bar,default=hello" xml:"bar" binding:"required"`
-}
-
 type FooStructUseNumber struct {
 	Foo interface{} `json:"foo" binding:"required"`
 }
@@ -200,18 +195,6 @@ func TestBindingForm2(t *testing.T) {
 		"", "")
 }
 
-func TestBindingFormDefaultValue(t *testing.T) {
-	testFormBindingDefaultValue(t, "POST",
-		"/", "/",
-		"foo=bar", "bar2=foo")
-}
-
-func TestBindingFormDefaultValue2(t *testing.T) {
-	testFormBindingDefaultValue(t, "GET",
-		"/?foo=bar", "/?bar2=foo",
-		"", "")
-}
-
 func TestBindingFormForTime(t *testing.T) {
 	testFormBindingForTime(t, "POST",
 		"/", "/",
@@ -424,12 +407,6 @@ func createFormPostRequest() *http.Request {
 	return req
 }
 
-func createDefaultFormPostRequest() *http.Request {
-	req, _ := http.NewRequest("POST", "/?foo=getfoo&bar=getbar", bytes.NewBufferString("foo=bar"))
-	req.Header.Set("Content-Type", MIMEPOSTForm)
-	return req
-}
-
 func createFormPostRequestFail() *http.Request {
 	req, _ := http.NewRequest("POST", "/?map_foo=getfoo", bytes.NewBufferString("map_foo=bar"))
 	req.Header.Set("Content-Type", MIMEPOSTForm)
@@ -473,15 +450,6 @@ func TestBindingFormPost(t *testing.T) {
 	assert.Equal(t, "foor", obj.Bar)
 }
 
-func TestBindingDefaultValueFormPost(t *testing.T) {
-	req := createDefaultFormPostRequest()
-	var obj FooDefaultBarStruct
-	FormPost.Bind(req, &obj)
-
-	assert.Equal(t, "bar", obj.Foo)
-	assert.Equal(t, "hello", obj.Bar)
-}
-
 func TestBindingFormPostFail(t *testing.T) {
 	req := createFormPostRequestFail()
 	var obj FooStructForMapType
@@ -610,26 +578,6 @@ func testFormBinding(t *testing.T, method, path, badPath, body, badBody string)
 	assert.Error(t, err)
 }
 
-func testFormBindingDefaultValue(t *testing.T, method, path, badPath, body, badBody string) {
-	b := Form
-	assert.Equal(t, "form", b.Name())
-
-	obj := FooDefaultBarStruct{}
-	req := requestWithBody(method, path, body)
-	if method == "POST" {
-		req.Header.Add("Content-Type", MIMEPOSTForm)
-	}
-	err := b.Bind(req, &obj)
-	assert.NoError(t, err)
-	assert.Equal(t, "bar", obj.Foo)
-	assert.Equal(t, "hello", obj.Bar)
-
-	obj = FooDefaultBarStruct{}
-	req = requestWithBody(method, badPath, badBody)
-	err = JSON.Bind(req, &obj)
-	assert.Error(t, err)
-}
-
 func TestFormBindingFail(t *testing.T) {
 	b := Form
 	assert.Equal(t, "form", b.Name())
diff --git a/binding/form_mapping.go b/binding/form_mapping.go
index 7c680d99..90be8059 100644
--- a/binding/form_mapping.go
+++ b/binding/form_mapping.go
@@ -24,15 +24,6 @@ func mapForm(ptr interface{}, form map[string][]string) error {
 
 		structFieldKind := structField.Kind()
 		inputFieldName := typeField.Tag.Get("form")
-		inputFieldNameList := strings.Split(inputFieldName, ",")
-		inputFieldName = inputFieldNameList[0]
-		var defaultValue string
-		if len(inputFieldNameList) > 1 {
-			defaultList := strings.SplitN(inputFieldNameList[1], "=", 2)
-			if defaultList[0] == "default" {
-				defaultValue = defaultList[1]
-			}
-		}
 		if inputFieldName == "" {
 			inputFieldName = typeField.Name
 
@@ -50,11 +41,7 @@ func mapForm(ptr interface{}, form map[string][]string) error {
 		inputValue, exists := form[inputFieldName]
 
 		if !exists {
-			if defaultValue == "" {
-				continue
-			}
-			inputValue = make([]string, 1)
-			inputValue[0] = defaultValue
+            continue
 		}
 
 		numElems := len(inputValue)

From e27d55411ec5ce2179861172d8b212b79053598d Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Fri, 20 Apr 2018 07:39:00 +0800
Subject: [PATCH 10/12] fix typo

---
 binding/binding_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/binding/binding_test.go b/binding/binding_test.go
index 9607b920..e3d9687b 100644
--- a/binding/binding_test.go
+++ b/binding/binding_test.go
@@ -447,7 +447,7 @@ func TestBindingFormPost(t *testing.T) {
 
 	assert.Equal(t, "form-urlencoded", FormPost.Name())
 	assert.Equal(t, "bar", obj.Foo)
-	assert.Equal(t, "foor", obj.Bar)
+	assert.Equal(t, "foo", obj.Bar)
 }
 
 func TestBindingFormPostFail(t *testing.T) {

From 7b94ff0523ce3ff9fbbd9aca503fd1115fcdc12f Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Fri, 20 Apr 2018 07:44:05 +0800
Subject: [PATCH 11/12] fix

---
 render/render_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/render/render_test.go b/render/render_test.go
index 0dd4a7a2..d825d041 100644
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -79,7 +79,7 @@ func TestRenderIndentedJSON(t *testing.T) {
 
 	assert.NoError(t, err)
 	assert.Equal(t, "{\n    \"bar\": \"foo\",\n    \"foo\": \"bar\"\n}", w.Body.String())
-	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type")))
+	assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type"))
 }
 
 func TestRenderIndentedJSONPanics(t *testing.T) {

From 3ce700d39f23dcc2254a7e7a418e2896de6b92f7 Mon Sep 17 00:00:00 2001
From: thinkerou <thinkerou@gmail.com>
Date: Fri, 20 Apr 2018 07:49:10 +0800
Subject: [PATCH 12/12] fix indent

---
 binding/form_mapping.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/binding/form_mapping.go b/binding/form_mapping.go
index 90be8059..d395f376 100644
--- a/binding/form_mapping.go
+++ b/binding/form_mapping.go
@@ -41,7 +41,7 @@ func mapForm(ptr interface{}, form map[string][]string) error {
 		inputValue, exists := form[inputFieldName]
 
 		if !exists {
-            continue
+			continue
 		}
 
 		numElems := len(inputValue)