Repository: gin-gonic/gin (go)

Issue:
how to binding for multi files upload
#1263's merged solution take no effect for multi files uploading.

my code:
```go
// MailUpload struct for e-mail
type MailUpload struct {
	Mail string 			     `json:"mail" form:"mail" binding:"required"`
	Attachments  []*multipart.FileHeader `json:"attachment,omitempty" form:"attachments" binding:"required"` // change form to "attachments[]" take no effect also.
}

func Mail(c *gin.Context) {
	var postData MailUpload
	err := c.Bind(&postData)
	if err != nil {
		fmt.Println(err)
		c.String(http.StatusBadRequest, err.Error())
	} else {
		fmt.Printf("%#v\n", postData)
		c.String(http.StatusOK, "ok")
	}
}
```

request send command by curl:
```bash
curl -v -H "Content-Type:multipart/form-data" -X POST http://localhost:8080/api/latest/newmail -F "attachments[]=@./2019-5-1_day_trends.png" -F mail=123
```

my error: `Key: 'MailUpload.Attachments' Error:Field validation for 'Attachments' failed on the 'required' tag`

Pull request description:
binding: add support of multipart multi files (#1878)
Fix #1878
Add support multi files on bind multipart requests.

Example:
```
type s struct {
	Files []*multipart.FileHeader `form:"files"`
}
```

Patch:
diff --git a/README.md b/README.md
index 092e91f..49b044a 100644
--- a/README.md
+++ b/README.md
@@ -959,32 +959,36 @@ result:
 ### Multipart/Urlencoded binding
 
 ```go
-package main
+type ProfileForm struct {
+	Name   string                `form:"name" binding:"required"`
+	Avatar *multipart.FileHeader `form:"avatar" binding:"required"`
 
-import (
-	"github.com/gin-gonic/gin"
-)
-
-type LoginForm struct {
-	User     string `form:"user" binding:"required"`
-	Password string `form:"password" binding:"required"`
+	// or for multiple files
+	// Avatars []*multipart.FileHeader `form:"avatar" binding:"required"`
 }
 
 func main() {
 	router := gin.Default()
-	router.POST("/login", func(c *gin.Context) {
+	router.POST("/profile", func(c *gin.Context) {
 		// you can bind multipart form with explicit binding declaration:
 		// c.ShouldBindWith(&form, binding.Form)
 		// or you can simply use autobinding with ShouldBind method:
-		var form LoginForm
+		var form ProfileForm
 		// in this case proper binding will be automatically selected
-		if c.ShouldBind(&form) == nil {
-			if form.User == "user" && form.Password == "password" {
-				c.JSON(200, gin.H{"status": "you are logged in"})
-			} else {
-				c.JSON(401, gin.H{"status": "unauthorized"})
-			}
+		if err := c.ShouldBind(&form); err != nil {
+			c.String(http.StatusBadRequest, "bad request")
+			return
 		}
+
+		err := c.SaveUploadedFile(form.Avatar, form.Avatar.Filename)
+		if err != nil {
+			c.String(http.StatusInternalServerError, "unknown error")
+			return
+		}
+
+		// db.Save(&form)
+
+		c.String(http.StatusOK, "ok")
 	})
 	router.Run(":8080")
 }
@@ -992,7 +996,7 @@ func main() {
 
 Test it with:
 ```sh
-$ curl -v --form user=user --form password=password http://localhost:8080/login
+$ curl -X POST -v --form name=user --form "avatar=@./avatar.png" http://localhost:8080/profile
 ```
 
 ### XML, JSON, YAML and ProtoBuf rendering
diff --git a/binding/form.go b/binding/form.go
index 0b28aa8..9e9fc3d 100644
--- a/binding/form.go
+++ b/binding/form.go
@@ -5,9 +5,7 @@
 package binding
 
 import (
-	"mime/multipart"
 	"net/http"
-	"reflect"
 )
 
 const defaultMemory = 32 * 1024 * 1024
@@ -63,27 +61,3 @@ func (formMultipartBinding) Bind(req *http.Request, obj interface{}) error {
 
 	return validate(obj)
 }
-
-type multipartRequest http.Request
-
-var _ setter = (*multipartRequest)(nil)
-
-var (
-	multipartFileHeaderStructType = reflect.TypeOf(multipart.FileHeader{})
-)
-
-// TrySet tries to set a value by the multipart request with the binding a form file
-func (r *multipartRequest) TrySet(value reflect.Value, field reflect.StructField, key string, opt setOptions) (isSetted bool, err error) {
-	if value.Type() == multipartFileHeaderStructType {
-		_, file, err := (*http.Request)(r).FormFile(key)
-		if err != nil {
-			return false, err
-		}
-		if file != nil {
-			value.Set(reflect.ValueOf(*file))
-			return true, nil
-		}
-	}
-
-	return setByForm(value, field, r.MultipartForm.Value, key, opt)
-}
diff --git a/binding/multipart_form_mapping.go b/binding/multipart_form_mapping.go
new file mode 100644
index 0000000..f85a1aa
--- /dev/null
+++ b/binding/multipart_form_mapping.go
@@ -0,0 +1,66 @@
+// Copyright 2019 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 binding
+
+import (
+	"errors"
+	"mime/multipart"
+	"net/http"
+	"reflect"
+)
+
+type multipartRequest http.Request
+
+var _ setter = (*multipartRequest)(nil)
+
+// TrySet tries to set a value by the multipart request with the binding a form file
+func (r *multipartRequest) TrySet(value reflect.Value, field reflect.StructField, key string, opt setOptions) (isSetted bool, err error) {
+	if files := r.MultipartForm.File[key]; len(files) != 0 {
+		return setByMultipartFormFile(value, field, files)
+	}
+
+	return setByForm(value, field, r.MultipartForm.Value, key, opt)
+}
+
+func setByMultipartFormFile(value reflect.Value, field reflect.StructField, files []*multipart.FileHeader) (isSetted bool, err error) {
+	switch value.Kind() {
+	case reflect.Ptr:
+		switch value.Interface().(type) {
+		case *multipart.FileHeader:
+			value.Set(reflect.ValueOf(files[0]))
+			return true, nil
+		}
+	case reflect.Struct:
+		switch value.Interface().(type) {
+		case multipart.FileHeader:
+			value.Set(reflect.ValueOf(*files[0]))
+			return true, nil
+		}
+	case reflect.Slice:
+		slice := reflect.MakeSlice(value.Type(), len(files), len(files))
+		isSetted, err = setArrayOfMultipartFormFiles(slice, field, files)
+		if err != nil || !isSetted {
+			return isSetted, err
+		}
+		value.Set(slice)
+		return true, nil
+	case reflect.Array:
+		return setArrayOfMultipartFormFiles(value, field, files)
+	}
+	return false, errors.New("unsupported field type for multipart.FileHeader")
+}
+
+func setArrayOfMultipartFormFiles(value reflect.Value, field reflect.StructField, files []*multipart.FileHeader) (isSetted bool, err error) {
+	if value.Len() != len(files) {
+		return false, errors.New("unsupported len of array for []*multipart.FileHeader")
+	}
+	for i := range files {
+		setted, err := setByMultipartFormFile(value.Index(i), field, files[i:i+1])
+		if err != nil || !setted {
+			return setted, err
+		}
+	}
+	return true, nil
+}


Test patch:
diff --git a/binding/multipart_form_mapping_test.go b/binding/multipart_form_mapping_test.go
new file mode 100644
index 0000000..4c75d1f
--- /dev/null
+++ b/binding/multipart_form_mapping_test.go
@@ -0,0 +1,138 @@
+// Copyright 2019 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 binding
+
+import (
+	"bytes"
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFormMultipartBindingBindOneFile(t *testing.T) {
+	var s struct {
+		FileValue   multipart.FileHeader     `form:"file"`
+		FilePtr     *multipart.FileHeader    `form:"file"`
+		SliceValues []multipart.FileHeader   `form:"file"`
+		SlicePtrs   []*multipart.FileHeader  `form:"file"`
+		ArrayValues [1]multipart.FileHeader  `form:"file"`
+		ArrayPtrs   [1]*multipart.FileHeader `form:"file"`
+	}
+	file := testFile{"file", "file1", []byte("hello")}
+
+	req := createRequestMultipartFiles(t, file)
+	err := FormMultipart.Bind(req, &s)
+	assert.NoError(t, err)
+
+	assertMultipartFileHeader(t, &s.FileValue, file)
+	assertMultipartFileHeader(t, s.FilePtr, file)
+	assert.Len(t, s.SliceValues, 1)
+	assertMultipartFileHeader(t, &s.SliceValues[0], file)
+	assert.Len(t, s.SlicePtrs, 1)
+	assertMultipartFileHeader(t, s.SlicePtrs[0], file)
+	assertMultipartFileHeader(t, &s.ArrayValues[0], file)
+	assertMultipartFileHeader(t, s.ArrayPtrs[0], file)
+}
+
+func TestFormMultipartBindingBindTwoFiles(t *testing.T) {
+	var s struct {
+		SliceValues []multipart.FileHeader   `form:"file"`
+		SlicePtrs   []*multipart.FileHeader  `form:"file"`
+		ArrayValues [2]multipart.FileHeader  `form:"file"`
+		ArrayPtrs   [2]*multipart.FileHeader `form:"file"`
+	}
+	files := []testFile{
+		{"file", "file1", []byte("hello")},
+		{"file", "file2", []byte("world")},
+	}
+
+	req := createRequestMultipartFiles(t, files...)
+	err := FormMultipart.Bind(req, &s)
+	assert.NoError(t, err)
+
+	assert.Len(t, s.SliceValues, len(files))
+	assert.Len(t, s.SlicePtrs, len(files))
+	assert.Len(t, s.ArrayValues, len(files))
+	assert.Len(t, s.ArrayPtrs, len(files))
+
+	for i, file := range files {
+		assertMultipartFileHeader(t, &s.SliceValues[i], file)
+		assertMultipartFileHeader(t, s.SlicePtrs[i], file)
+		assertMultipartFileHeader(t, &s.ArrayValues[i], file)
+		assertMultipartFileHeader(t, s.ArrayPtrs[i], file)
+	}
+}
+
+func TestFormMultipartBindingBindError(t *testing.T) {
+	files := []testFile{
+		{"file", "file1", []byte("hello")},
+		{"file", "file2", []byte("world")},
+	}
+
+	for _, tt := range []struct {
+		name string
+		s    interface{}
+	}{
+		{"wrong type", &struct {
+			Files int `form:"file"`
+		}{}},
+		{"wrong array size", &struct {
+			Files [1]*multipart.FileHeader `form:"file"`
+		}{}},
+		{"wrong slice type", &struct {
+			Files []int `form:"file"`
+		}{}},
+	} {
+		req := createRequestMultipartFiles(t, files...)
+		err := FormMultipart.Bind(req, tt.s)
+		assert.Error(t, err)
+	}
+}
+
+type testFile struct {
+	Fieldname string
+	Filename  string
+	Content   []byte
+}
+
+func createRequestMultipartFiles(t *testing.T, files ...testFile) *http.Request {
+	var body bytes.Buffer
+
+	mw := multipart.NewWriter(&body)
+	for _, file := range files {
+		fw, err := mw.CreateFormFile(file.Fieldname, file.Filename)
+		assert.NoError(t, err)
+
+		n, err := fw.Write(file.Content)
+		assert.NoError(t, err)
+		assert.Equal(t, len(file.Content), n)
+	}
+	err := mw.Close()
+	assert.NoError(t, err)
+
+	req, err := http.NewRequest("POST", "/", &body)
+	assert.NoError(t, err)
+
+	req.Header.Set("Content-Type", MIMEMultipartPOSTForm+"; boundary="+mw.Boundary())
+	return req
+}
+
+func assertMultipartFileHeader(t *testing.T, fh *multipart.FileHeader, file testFile) {
+	assert.Equal(t, file.Filename, fh.Filename)
+	// assert.Equal(t, int64(len(file.Content)), fh.Size) // fh.Size does not exist on go1.8
+
+	fl, err := fh.Open()
+	assert.NoError(t, err)
+
+	body, err := ioutil.ReadAll(fl)
+	assert.NoError(t, err)
+	assert.Equal(t, string(file.Content), string(body))
+
+	err = fl.Close()
+	assert.NoError(t, err)
+}