+
+[](https://travis-ci.org/gin-gonic/gin)
+ [](https://codecov.io/gh/gin-gonic/gin)
+ [](https://goreportcard.com/report/github.com/gin-gonic/gin)
+ [](https://godoc.org/github.com/gin-gonic/gin)
+ [](https://gitter.im/gin-gonic/gin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Gin is a web framework written in Go (Golang). It features a martini-like API with much better performance, up to 40 times faster thanks to [httprouter](https://github.com/julienschmidt/httprouter). If you need performance and good productivity, you will love Gin.
-```
+```sh
$ cat test.go
```
+
```go
package main
import "github.com/gin-gonic/gin"
func main() {
- router := gin.Default()
- router.GET("/", func(c *gin.Context) {
- c.String(200, "hello world")
- })
- router.GET("/ping", func(c *gin.Context) {
- c.String(200, "pong")
- })
- router.POST("/submit", func(c *gin.Context) {
- c.String(401, "not authorized")
- })
- router.PUT("/error", func(c *gin.Context) {
- c.String(500, "and error hapenned :(")
+ r := gin.Default()
+ r.GET("/ping", func(c *gin.Context) {
+ c.JSON(200, gin.H{
+ "message": "pong",
+ })
})
- router.Run(":8080")
+ r.Run() // listen and serve on 0.0.0.0:8080
}
```
-##Gin is new, will it be supported?
-
-Yes, Gin is an internal tool of [Manu](https://github.com/manucorporat) and [Javi](https://github.com/javierprovecho) for many of our projects/start-ups. We developed it and we are going to continue using and improve it.
-
-
-##Roadmap for v1.0
-- [ ] Ask our designer for a cool logo
-- [ ] Add tons of unit tests
-- [ ] Add internal benchmarks suite
-- [ ] More powerful validation API
-- [ ] Improve documentation
-- [ ] Add Swagger support
-- [x] Stable API
-- [x] Improve logging system
-- [x] Improve JSON/XML validation using bindings
-- [x] Improve XML support
-- [x] Flexible rendering system
-- [x] Add more cool middlewares, for example redis caching (this also helps developers to understand the framework).
-- [x] Continuous integration
-- [x] Performance improments, reduce allocation and garbage collection overhead
-- [x] Fix bugs
-
+## Benchmarks
+
+Gin uses a custom version of [HttpRouter](https://github.com/julienschmidt/httprouter)
+
+[See all benchmarks](/BENCHMARKS.md)
+
+
+Benchmark name | (1) | (2) | (3) | (4)
+--------------------------------|----------:|----------:|----------:|------:
+BenchmarkAce_GithubAll | 10000 | 109482 | 13792 | 167
+BenchmarkBear_GithubAll | 10000 | 287490 | 79952 | 943
+BenchmarkBeego_GithubAll | 3000 | 562184 | 146272 | 2092
+BenchmarkBone_GithubAll | 500 | 2578716 | 648016 | 8119
+BenchmarkDenco_GithubAll | 20000 | 94955 | 20224 | 167
+BenchmarkEcho_GithubAll | 30000 | 58705 | 0 | 0
+**BenchmarkGin_GithubAll** | **30000** | **50991** | **0** | **0**
+BenchmarkGocraftWeb_GithubAll | 5000 | 449648 | 133280 | 1889
+BenchmarkGoji_GithubAll | 2000 | 689748 | 56113 | 334
+BenchmarkGoJsonRest_GithubAll | 5000 | 537769 | 135995 | 2940
+BenchmarkGoRestful_GithubAll | 100 | 18410628 | 797236 | 7725
+BenchmarkGorillaMux_GithubAll | 200 | 8036360 | 153137 | 1791
+BenchmarkHttpRouter_GithubAll | 20000 | 63506 | 13792 | 167
+BenchmarkHttpTreeMux_GithubAll | 10000 | 165927 | 56112 | 334
+BenchmarkKocha_GithubAll | 10000 | 171362 | 23304 | 843
+BenchmarkMacaron_GithubAll | 2000 | 817008 | 224960 | 2315
+BenchmarkMartini_GithubAll | 100 | 12609209 | 237952 | 2686
+BenchmarkPat_GithubAll | 300 | 4830398 | 1504101 | 32222
+BenchmarkPossum_GithubAll | 10000 | 301716 | 97440 | 812
+BenchmarkR2router_GithubAll | 10000 | 270691 | 77328 | 1182
+BenchmarkRevel_GithubAll | 1000 | 1491919 | 345553 | 5918
+BenchmarkRivet_GithubAll | 10000 | 283860 | 84272 | 1079
+BenchmarkTango_GithubAll | 5000 | 473821 | 87078 | 2470
+BenchmarkTigerTonic_GithubAll | 2000 | 1120131 | 241088 | 6052
+BenchmarkTraffic_GithubAll | 200 | 8708979 | 2664762 | 22390
+BenchmarkVulcan_GithubAll | 5000 | 353392 | 19894 | 609
+BenchmarkZeus_GithubAll | 2000 | 944234 | 300688 | 2648
+
+(1): Total Repetitions
+(2): Single Repetition Duration (ns/op)
+(3): Heap Memory (B/op)
+(4): Average Allocations per Repetition (allocs/op)
+
+## Gin v1. stable
+
+- [x] Zero allocation router.
+- [x] Still the fastest http router and framework. From routing to writing.
+- [x] Complete suite of unit tests
+- [x] Battle tested
+- [x] API frozen, new releases will not break your code.
## Start using it
-Obviously, you need to have Git and Go already installed to run Gin.
-Run this in your terminal
-```
-go get github.com/gin-gonic/gin
-```
-Then import it in your Go code:
+1. Download and install it:
+```sh
+$ go get github.com/gin-gonic/gin
```
+
+2. Import it in your code:
+
+```go
import "github.com/gin-gonic/gin"
```
+3. (Optional) Import `net/http`. This is required for example if using constants such as `http.StatusOK`.
-##Community
-If you'd like to help out with the project, there's a mailing list and IRC channel where Gin discussions normally happen.
+```go
+import "net/http"
+```
-* IRC
- * [irc.freenode.net #getgin](irc://irc.freenode.net:6667/getgin)
- * [Webchat](http://webchat.freenode.net?randomnick=1&channels=%23getgin)
-* Mailing List
- * Subscribe: [getgin@librelist.org](mailto:getgin@librelist.org)
- * [Archives](http://librelist.com/browser/getgin/)
+## API Examples
+### Using GET, POST, PUT, PATCH, DELETE and OPTIONS
-##API Examples
+```go
+func main() {
+ // Disable Console Color
+ // gin.DisableConsoleColor()
-#### Create most basic PING/PONG HTTP endpoint
-```go
-package main
+ // Creates a gin router with default middleware:
+ // logger and recovery (crash-free) middleware
+ router := gin.Default()
-import "github.com/gin-gonic/gin"
+ router.GET("/someGet", getting)
+ router.POST("/somePost", posting)
+ router.PUT("/somePut", putting)
+ router.DELETE("/someDelete", deleting)
+ router.PATCH("/somePatch", patching)
+ router.HEAD("/someHead", head)
+ router.OPTIONS("/someOptions", options)
+
+ // By default it serves on :8080 unless a
+ // PORT environment variable was defined.
+ router.Run()
+ // router.Run(":3000") for a hard coded port
+}
+```
+
+### Parameters in path
+```go
func main() {
- r := gin.Default()
- r.GET("/ping", func(c *gin.Context) {
- c.String(200, "pong")
+ router := gin.Default()
+
+ // This handler will match /user/john but will not match neither /user/ or /user
+ router.GET("/user/:name", func(c *gin.Context) {
+ name := c.Param("name")
+ c.String(http.StatusOK, "Hello %s", name)
})
- // Listen and server on 0.0.0.0:8080
- r.Run(":8080")
+ // However, this one will match /user/john/ and also /user/john/send
+ // If no other routers match /user/john, it will redirect to /user/john/
+ router.GET("/user/:name/*action", func(c *gin.Context) {
+ name := c.Param("name")
+ action := c.Param("action")
+ message := name + " is " + action
+ c.String(http.StatusOK, message)
+ })
+
+ router.Run(":8080")
}
```
-#### Using GET, POST, PUT, PATCH, DELETE and OPTIONS
+### Querystring parameters
```go
func main() {
- // Creates a gin router + logger and recovery (crash-free) middlewares
- r := gin.Default()
+ router := gin.Default()
- r.GET("/someGet", getting)
- r.POST("/somePost", posting)
- r.PUT("/somePut", putting)
- r.DELETE("/someDelete", deleting)
- r.PATCH("/somePatch", patching)
- r.HEAD("/someHead", head)
- r.OPTIONS("/someOptions", options)
+ // Query string parameters are parsed using the existing underlying request object.
+ // The request responds to a url matching: /welcome?firstname=Jane&lastname=Doe
+ router.GET("/welcome", func(c *gin.Context) {
+ firstname := c.DefaultQuery("firstname", "Guest")
+ lastname := c.Query("lastname") // shortcut for c.Request.URL.Query().Get("lastname")
- // Listen and server on 0.0.0.0:8080
- r.Run(":8080")
+ c.String(http.StatusOK, "Hello %s %s", firstname, lastname)
+ })
+ router.Run(":8080")
}
```
-#### Parameters in path
+### Multipart/Urlencoded Form
```go
func main() {
- r := gin.Default()
-
- // This handler will match /user/john but will not match neither /user/ or /user
- r.GET("/user/:name", func(c *gin.Context) {
- name := c.Params.ByName("name")
- message := "Hello "+name
- c.String(200, message)
+ router := gin.Default()
+
+ router.POST("/form_post", func(c *gin.Context) {
+ message := c.PostForm("message")
+ nick := c.DefaultPostForm("nick", "anonymous")
+
+ c.JSON(200, gin.H{
+ "status": "posted",
+ "message": message,
+ "nick": nick,
+ })
})
+ router.Run(":8080")
+}
+```
- // However, this one will match /user/john/ and also /user/john/send
- // If no other routers match /user/john, it will redirect to /user/join/
- r.GET("/user/:name/*action", func(c *gin.Context) {
- name := c.Params.ByName("name")
- action := c.Params.ByName("action")
- message := name + " is " + action
- c.String(200, message)
+### Another example: query + post form
+
+```
+POST /post?id=1234&page=1 HTTP/1.1
+Content-Type: application/x-www-form-urlencoded
+
+name=manu&message=this_is_great
+```
+
+```go
+func main() {
+ router := gin.Default()
+
+ router.POST("/post", func(c *gin.Context) {
+
+ id := c.Query("id")
+ page := c.DefaultQuery("page", "0")
+ name := c.PostForm("name")
+ message := c.PostForm("message")
+
+ fmt.Printf("id: %s; page: %s; name: %s; message: %s", id, page, name, message)
})
-
- // Listen and server on 0.0.0.0:8080
- r.Run(":8080")
+ router.Run(":8080")
}
```
-###Form parameters
+
+```
+id: 1234; page: 1; name: manu; message: this_is_great
+```
+
+### Upload files
+
+#### Single file
+
+References issue [#774](https://github.com/gin-gonic/gin/issues/774) and detail [example code](examples/upload-file/single).
+
```go
func main() {
- r := gin.Default()
-
- // This will respond to urls like search?firstname=Jane&lastname=Doe
- r.GET("/search", func(c *gin.Context) {
- // You need to call ParseForm() on the request to receive url and form params first
- c.Request.ParseForm()
-
- firstname := c.Request.Form.Get("firstname")
- lastname := c.Request.Form.get("lastname")
-
- message := "Hello "+ firstname + lastname
- c.String(200, message)
+ router := gin.Default()
+ router.POST("/upload", func(c *gin.Context) {
+ // single file
+ file, _ := c.FormFile("file")
+ log.Println(file.Filename)
+
+ c.String(http.StatusOK, fmt.Printf("'%s' uploaded!", file.Filename))
})
- r.Run(":8080")
+ router.Run(":8080")
+}
+```
+
+How to `curl`:
+
+```bash
+curl -X POST http://localhost:8080/upload \
+ -F "file=@/Users/appleboy/test.zip" \
+ -H "Content-Type: multipart/form-data"
+```
+
+#### Multiple files
+
+See the detail [example code](examples/upload-file/multiple).
+
+```go
+func main() {
+ router := gin.Default()
+ router.POST("/upload", func(c *gin.Context) {
+ // Multipart form
+ form, _ := c.MultipartForm()
+ files := form.File["upload[]"]
+
+ for _, file := range files {
+ log.Println(file.Filename)
+ }
+ c.String(http.StatusOK, fmt.Printf("%d files uploaded!", len(files)))
+ })
+ router.Run(":8080")
}
```
-#### Grouping routes
+How to `curl`:
+
+```bash
+curl -X POST http://localhost:8080/upload \
+ -F "upload[]=@/Users/appleboy/test1.zip" \
+ -F "upload[]=@/Users/appleboy/test2.zip" \
+ -H "Content-Type: multipart/form-data"
+```
+
+### Grouping routes
+
```go
func main() {
- r := gin.Default()
+ router := gin.Default()
// Simple group: v1
- v1 := r.Group("/v1")
+ v1 := router.Group("/v1")
{
v1.POST("/login", loginEndpoint)
v1.POST("/submit", submitEndpoint)
@@ -178,26 +297,25 @@ func main() {
}
// Simple group: v2
- v2 := r.Group("/v2")
+ v2 := router.Group("/v2")
{
v2.POST("/login", loginEndpoint)
v2.POST("/submit", submitEndpoint)
v2.POST("/read", readEndpoint)
}
- // Listen and server on 0.0.0.0:8080
- r.Run(":8080")
+ router.Run(":8080")
}
```
-
-#### Blank Gin without middlewares by default
+### Blank Gin without middleware by default
Use
```go
r := gin.New()
```
+
instead of
```go
@@ -205,24 +323,24 @@ r := gin.Default()
```
-#### Using middlewares
+### Using middleware
```go
func main() {
// Creates a router without any middleware by default
r := gin.New()
- // Global middlewares
+ // Global middleware
r.Use(gin.Logger())
r.Use(gin.Recovery())
- // Per route middlewares, you can add as many as you desire.
+ // Per route middleware, you can add as many as you desire.
r.GET("/benchmark", MyBenchLogger(), benchEndpoint)
// Authorization group
// authorized := r.Group("/", AuthRequired())
- // exactly the same than:
+ // exactly the same as:
authorized := r.Group("/")
- // per group middlewares! in this case we use the custom created
+ // per group middleware! in this case we use the custom created
// AuthRequired() middleware just in the "authorized" group.
authorized.Use(AuthRequired())
{
@@ -235,67 +353,136 @@ func main() {
testing.GET("/analytics", analyticsEndpoint)
}
- // Listen and server on 0.0.0.0:8080
+ // Listen and serve on 0.0.0.0:8080
r.Run(":8080")
}
```
-#### Model binding and validation
+### Model binding and validation
To bind a request body into a type, use model binding. We currently support binding of JSON, XML and standard form values (foo=bar&boo=baz).
Note that you need to set the corresponding binding tag on all fields you want to bind. For example, when binding from JSON, set `json:"fieldname"`.
-When using the Bind-method, Gin tries to infer the binder depending on the Content-Type header. If you are sure what you are binding, you can use BindWith.
+When using the Bind-method, Gin tries to infer the binder depending on the Content-Type header. If you are sure what you are binding, you can use BindWith.
You can also specify that specific fields are required. If a field is decorated with `binding:"required"` and has a empty value when binding, the current request will fail with an error.
```go
// Binding from JSON
-type LoginJSON struct {
- User string `json:"user" binding:"required"`
- Password string `json:"password" binding:"required"`
+type Login struct {
+ User string `form:"user" json:"user" binding:"required"`
+ Password string `form:"password" json:"password" binding:"required"`
}
-// Binding from form values
-type LoginForm struct {
- User string `form:"user" binding:"required"`
- Password string `form:"password" binding:"required"`
+func main() {
+ router := gin.Default()
+
+ // Example for binding JSON ({"user": "manu", "password": "123"})
+ router.POST("/loginJSON", func(c *gin.Context) {
+ var json Login
+ if c.BindJSON(&json) == nil {
+ if json.User == "manu" && json.Password == "123" {
+ c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
+ } else {
+ c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
+ }
+ }
+ })
+
+ // Example for binding a HTML form (user=manu&password=123)
+ router.POST("/loginForm", func(c *gin.Context) {
+ var form Login
+ // This will infer what binder to use depending on the content-type header.
+ if c.Bind(&form) == nil {
+ if form.User == "manu" && form.Password == "123" {
+ c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
+ } else {
+ c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
+ }
+ }
+ })
+
+ // Listen and serve on 0.0.0.0:8080
+ router.Run(":8080")
+}
+```
+
+### Bind Query String
+
+See the [detail information](https://github.com/gin-gonic/gin/issues/742#issuecomment-264681292).
+
+```go
+package main
+
+import "log"
+import "github.com/gin-gonic/gin"
+
+type Person struct {
+ Name string `form:"name"`
+ Address string `form:"address"`
}
func main() {
- r := gin.Default()
+ route := gin.Default()
+ route.GET("/testing", startPage)
+ route.Run(":8085")
+}
- // Example for binding JSON ({"user": "manu", "password": "123"})
- r.POST("/loginJSON", func(c *gin.Context) {
- var json LoginJSON
+func startPage(c *gin.Context) {
+ var person Person
+ // If `GET`, only `Form` binding engine (`query`) used.
+ // If `POST`, first checks the `content-type` for `JSON` or `XML`, then uses `Form` (`form-data`).
+ // See more at https://github.com/gin-gonic/gin/blob/develop/binding/binding.go#L45
+ if c.Bind(&person) == nil {
+ log.Println(person.Name)
+ log.Println(person.Address)
+ }
- c.Bind(&json) // This will infer what binder to use depending on the content-type header.
- if json.User == "manu" && json.Password == "123" {
- c.JSON(200, gin.H{"status": "you are logged in"})
- } else {
- c.JSON(401, gin.H{"status": "unauthorized"})
- }
- })
+ c.String(200, "Success")
+}
+```
- // Example for binding a HTML form (user=manu&password=123)
- r.POST("/loginHTML", func(c *gin.Context) {
- var form LoginForm
+### Multipart/Urlencoded binding
- c.BindWith(&form, binding.Form) // You can also specify which binder to use. We support binding.Form, binding.JSON and binding.XML.
- if form.User == "manu" && form.Password == "123" {
- c.JSON(200, gin.H{"status": "you are logged in"})
- } else {
- c.JSON(401, gin.H{"status": "unauthorized"})
- }
- })
+```go
+package main
- // Listen and server on 0.0.0.0:8080
- r.Run(":8080")
+import (
+ "github.com/gin-gonic/gin"
+)
+
+type LoginForm struct {
+ User string `form:"user" binding:"required"`
+ Password string `form:"password" binding:"required"`
}
+
+func main() {
+ router := gin.Default()
+ router.POST("/login", func(c *gin.Context) {
+ // you can bind multipart form with explicit binding declaration:
+ // c.MustBindWith(&form, binding.Form)
+ // or you can simply use autobinding with Bind method:
+ var form LoginForm
+ // in this case proper binding will be automatically selected
+ if c.Bind(&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"})
+ }
+ }
+ })
+ router.Run(":8080")
+}
+```
+
+Test it with:
+```sh
+$ curl -v --form user=user --form password=password http://localhost:8080/login
```
-#### XML and JSON rendering
+### XML, JSON and YAML rendering
```go
func main() {
@@ -303,7 +490,7 @@ func main() {
// gin.H is a shortcut for map[string]interface{}
r.GET("/someJSON", func(c *gin.Context) {
- c.JSON(200, gin.H{"message": "hey", "status": 200})
+ c.JSON(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
})
r.GET("/moreJSON", func(c *gin.Context) {
@@ -318,55 +505,106 @@ func main() {
msg.Number = 123
// Note that msg.Name becomes "user" in the JSON
// Will output : {"user": "Lena", "Message": "hey", "Number": 123}
- c.JSON(200, msg)
+ c.JSON(http.StatusOK, msg)
})
r.GET("/someXML", func(c *gin.Context) {
- c.XML(200, gin.H{"message": "hey", "status": 200})
+ c.XML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
+ })
+
+ r.GET("/someYAML", func(c *gin.Context) {
+ c.YAML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
})
- // Listen and server on 0.0.0.0:8080
+ // Listen and serve on 0.0.0.0:8080
r.Run(":8080")
}
```
-####Serving static files
-
-Use Engine.ServeFiles(path string, root http.FileSystem):
+### Serving static files
```go
func main() {
- r := gin.Default()
- r.Static("/assets", "./assets")
+ router := gin.Default()
+ router.Static("/assets", "./assets")
+ router.StaticFS("/more_static", http.Dir("my_file_system"))
+ router.StaticFile("/favicon.ico", "./resources/favicon.ico")
- // Listen and server on 0.0.0.0:8080
- r.Run(":8080")
+ // Listen and serve on 0.0.0.0:8080
+ router.Run(":8080")
}
```
-Note: this will use `httpNotFound` instead of the Router's `NotFound` handler.
-
-####HTML rendering
+### HTML rendering
-Using LoadHTMLTemplates()
+Using LoadHTMLGlob() or LoadHTMLFiles()
```go
func main() {
- r := gin.Default()
- r.LoadHTMLGlob("templates/*")
- r.GET("/index", func(c *gin.Context) {
- obj := gin.H{"title": "Main website"}
- c.HTML(200, "index.tmpl", obj)
+ router := gin.Default()
+ router.LoadHTMLGlob("templates/*")
+ //router.LoadHTMLFiles("templates/template1.html", "templates/template2.html")
+ router.GET("/index", func(c *gin.Context) {
+ c.HTML(http.StatusOK, "index.tmpl", gin.H{
+ "title": "Main website",
+ })
})
+ router.Run(":8080")
+}
+```
- // Listen and server on 0.0.0.0:8080
- r.Run(":8080")
+templates/index.tmpl
+
+```html
+
+ Welcome to {{.roomid}} room
+ + + + +`)) diff --git a/vendor/github.com/gin-gonic/gin/examples/upload-file/multiple/main.go b/vendor/github.com/gin-gonic/gin/examples/upload-file/multiple/main.go new file mode 100644 index 000000000..2f4e9b529 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/examples/upload-file/multiple/main.go @@ -0,0 +1,39 @@ +package main + +import ( + "fmt" + "io" + "net/http" + "os" + + "github.com/gin-gonic/gin" +) + +func main() { + router := gin.Default() + router.Static("/", "./public") + router.POST("/upload", func(c *gin.Context) { + name := c.PostForm("name") + email := c.PostForm("email") + + // Multipart form + form, _ := c.MultipartForm() + files := form.File["files"] + + for _, file := range files { + // Source + src, _ := file.Open() + defer src.Close() + + // Destination + dst, _ := os.Create(file.Filename) + defer dst.Close() + + // Copy + io.Copy(dst, src) + } + + c.String(http.StatusOK, fmt.Sprintf("Uploaded successfully %d files with fields name=%s and email=%s.", len(files), name, email)) + }) + router.Run(":8080") +} diff --git a/vendor/github.com/gin-gonic/gin/examples/upload-file/multiple/public/index.html b/vendor/github.com/gin-gonic/gin/examples/upload-file/multiple/public/index.html new file mode 100644 index 000000000..b8463601a --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/examples/upload-file/multiple/public/index.html @@ -0,0 +1,17 @@ + + + + +Upload multiple files with fields
+ + + + diff --git a/vendor/github.com/gin-gonic/gin/examples/upload-file/single/main.go b/vendor/github.com/gin-gonic/gin/examples/upload-file/single/main.go new file mode 100644 index 000000000..9acf50092 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/examples/upload-file/single/main.go @@ -0,0 +1,34 @@ +package main + +import ( + "fmt" + "io" + "net/http" + "os" + + "github.com/gin-gonic/gin" +) + +func main() { + router := gin.Default() + router.Static("/", "./public") + router.POST("/upload", func(c *gin.Context) { + name := c.PostForm("name") + email := c.PostForm("email") + + // Source + file, _ := c.FormFile("file") + src, _ := file.Open() + defer src.Close() + + // Destination + dst, _ := os.Create(file.Filename) + defer dst.Close() + + // Copy + io.Copy(dst, src) + + c.String(http.StatusOK, fmt.Sprintf("File %s uploaded successfully with fields name=%s and email=%s.", file.Filename, name, email)) + }) + router.Run(":8080") +} diff --git a/vendor/github.com/gin-gonic/gin/examples/upload-file/single/public/index.html b/vendor/github.com/gin-gonic/gin/examples/upload-file/single/public/index.html new file mode 100644 index 000000000..b0c2a8084 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/examples/upload-file/single/public/index.html @@ -0,0 +1,16 @@ + + + + +Upload single file with fields
+ + + diff --git a/vendor/github.com/gin-gonic/gin/fixtures/basic/hello.tmpl b/vendor/github.com/gin-gonic/gin/fixtures/basic/hello.tmpl new file mode 100644 index 000000000..0767ef3f2 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/fixtures/basic/hello.tmpl @@ -0,0 +1 @@ +Hello {[{.name}]}
\ No newline at end of file diff --git a/vendor/github.com/gin-gonic/gin/fixtures/basic/raw.tmpl b/vendor/github.com/gin-gonic/gin/fixtures/basic/raw.tmpl new file mode 100644 index 000000000..8bc757030 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/fixtures/basic/raw.tmpl @@ -0,0 +1 @@ +Date: {[{.now | formatAsDate}]} diff --git a/vendor/github.com/gin-gonic/gin/fs.go b/vendor/github.com/gin-gonic/gin/fs.go new file mode 100644 index 000000000..12645826a --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/fs.go @@ -0,0 +1,46 @@ +// Copyright 2017 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package gin + +import ( + "net/http" + "os" +) + +type ( + onlyfilesFS struct { + fs http.FileSystem + } + neuteredReaddirFile struct { + http.File + } +) + +// Dir returns a http.Filesystem that can be used by http.FileServer(). It is used internally +// in router.Static(). +// if listDirectory == true, then it works the same as http.Dir() otherwise it returns +// a filesystem that prevents http.FileServer() to list the directory files. +func Dir(root string, listDirectory bool) http.FileSystem { + fs := http.Dir(root) + if listDirectory { + return fs + } + return &onlyfilesFS{fs} +} + +// Conforms to http.Filesystem +func (fs onlyfilesFS) Open(name string) (http.File, error) { + f, err := fs.fs.Open(name) + if err != nil { + return nil, err + } + return neuteredReaddirFile{f}, nil +} + +// Overrides the http.File default implementation +func (f neuteredReaddirFile) Readdir(count int) ([]os.FileInfo, error) { + // this disables directory listing + return nil, nil +} diff --git a/vendor/github.com/gin-gonic/gin/gin.go b/vendor/github.com/gin-gonic/gin/gin.go index 42c4b1f64..c4118a4ef 100644 --- a/vendor/github.com/gin-gonic/gin/gin.go +++ b/vendor/github.com/gin-gonic/gin/gin.go @@ -5,139 +5,414 @@ package gin import ( - "github.com/gin-gonic/gin/render" - "github.com/julienschmidt/httprouter" "html/template" - "math" + "net" "net/http" + "os" "sync" -) -const ( - AbortIndex = math.MaxInt8 / 2 - MIMEJSON = "application/json" - MIMEHTML = "text/html" - MIMEXML = "application/xml" - MIMEXML2 = "text/xml" - MIMEPlain = "text/plain" - MIMEPOSTForm = "application/x-www-form-urlencoded" + "github.com/gin-gonic/gin/render" ) +// Version is Framework's version +const Version = "v1.2" + +var default404Body = []byte("404 page not found") +var default405Body = []byte("405 method not allowed") +var defaultAppEngine bool + +type HandlerFunc func(*Context) +type HandlersChain []HandlerFunc + +// Last returns the last handler in the chain. ie. the last handler is the main own. +func (c HandlersChain) Last() HandlerFunc { + length := len(c) + if length > 0 { + return c[length-1] + } + return nil +} + type ( - HandlerFunc func(*Context) + RoutesInfo []RouteInfo + RouteInfo struct { + Method string + Path string + Handler string + } - // Represents the web framework, it wraps the blazing fast httprouter multiplexer and a list of global middlewares. + // Engine is the framework's instance, it contains the muxer, middleware and configuration settings. + // Create an instance of Engine, by using New() or Default() Engine struct { - *RouterGroup - HTMLRender render.Render - Default404Body []byte - pool sync.Pool - allNoRoute []HandlerFunc - noRoute []HandlerFunc - router *httprouter.Router + RouterGroup + delims render.Delims + HTMLRender render.HTMLRender + FuncMap template.FuncMap + allNoRoute HandlersChain + allNoMethod HandlersChain + noRoute HandlersChain + noMethod HandlersChain + pool sync.Pool + trees methodTrees + + // Enables automatic redirection if the current route can't be matched but a + // handler for the path with (without) the trailing slash exists. + // For example if /foo/ is requested but a route only exists for /foo, the + // client is redirected to /foo with http status code 301 for GET requests + // and 307 for all other request methods. + RedirectTrailingSlash bool + + // If enabled, the router tries to fix the current request path, if no + // handle is registered for it. + // First superfluous path elements like ../ or // are removed. + // Afterwards the router does a case-insensitive lookup of the cleaned path. + // If a handle can be found for this route, the router makes a redirection + // to the corrected path with status code 301 for GET requests and 307 for + // all other request methods. + // For example /FOO and /..//Foo could be redirected to /foo. + // RedirectTrailingSlash is independent of this option. + RedirectFixedPath bool + + // If enabled, the router checks if another method is allowed for the + // current route, if the current request can not be routed. + // If this is the case, the request is answered with 'Method Not Allowed' + // and HTTP status code 405. + // If no other Method is allowed, the request is delegated to the NotFound + // handler. + HandleMethodNotAllowed bool + ForwardedByClientIP bool + + // #726 #755 If enabled, it will thrust some headers starting with + // 'X-AppEngine...' for better integration with that PaaS. + AppEngine bool + + // If enabled, the url.RawPath will be used to find parameters. + UseRawPath bool + // If true, the path value will be unescaped. + // If UseRawPath is false (by default), the UnescapePathValues effectively is true, + // as url.Path gonna be used, which is already unescaped. + UnescapePathValues bool } ) -// Returns a new blank Engine instance without any middleware attached. -// The most basic configuration +var _ IRouter = &Engine{} + +// New returns a new blank Engine instance without any middleware attached. +// By default the configuration is: +// - RedirectTrailingSlash: true +// - RedirectFixedPath: false +// - HandleMethodNotAllowed: false +// - ForwardedByClientIP: true +// - UseRawPath: false +// - UnescapePathValues: true func New() *Engine { - engine := &Engine{} - engine.RouterGroup = &RouterGroup{ - Handlers: nil, - absolutePath: "/", - engine: engine, - } - engine.router = httprouter.New() - engine.Default404Body = []byte("404 page not found") - engine.router.NotFound = engine.handle404 + debugPrintWARNINGNew() + engine := &Engine{ + RouterGroup: RouterGroup{ + Handlers: nil, + basePath: "/", + root: true, + }, + FuncMap: template.FuncMap{}, + RedirectTrailingSlash: true, + RedirectFixedPath: false, + HandleMethodNotAllowed: false, + ForwardedByClientIP: true, + AppEngine: defaultAppEngine, + UseRawPath: false, + UnescapePathValues: true, + trees: make(methodTrees, 0, 9), + delims: render.Delims{"{{", "}}"}, + } + engine.RouterGroup.engine = engine engine.pool.New = func() interface{} { - c := &Context{Engine: engine} - c.Writer = &c.writermem - return c + return engine.allocateContext() } return engine } -// Returns a Engine instance with the Logger and Recovery already attached. +// Default returns an Engine instance with the Logger and Recovery middleware already attached. func Default() *Engine { engine := New() - engine.Use(Recovery(), Logger()) + engine.Use(Logger(), Recovery()) + return engine +} + +func (engine *Engine) allocateContext() *Context { + return &Context{engine: engine} +} + +func (engine *Engine) Delims(left, right string) *Engine { + engine.delims = render.Delims{left, right} return engine } func (engine *Engine) LoadHTMLGlob(pattern string) { if IsDebugging() { - render.HTMLDebug.AddGlob(pattern) - engine.HTMLRender = render.HTMLDebug + debugPrintLoadTemplate(template.Must(template.New("").Delims(engine.delims.Left, engine.delims.Right).Funcs(engine.FuncMap).ParseGlob(pattern))) + engine.HTMLRender = render.HTMLDebug{Glob: pattern, FuncMap: engine.FuncMap, Delims: engine.delims} } else { - templ := template.Must(template.ParseGlob(pattern)) + templ := template.Must(template.New("").Delims(engine.delims.Left, engine.delims.Right).Funcs(engine.FuncMap).ParseGlob(pattern)) engine.SetHTMLTemplate(templ) } } func (engine *Engine) LoadHTMLFiles(files ...string) { if IsDebugging() { - render.HTMLDebug.AddFiles(files...) - engine.HTMLRender = render.HTMLDebug + engine.HTMLRender = render.HTMLDebug{Files: files, FuncMap: engine.FuncMap, Delims: engine.delims} } else { - templ := template.Must(template.ParseFiles(files...)) + templ := template.Must(template.New("").Delims(engine.delims.Left, engine.delims.Right).Funcs(engine.FuncMap).ParseFiles(files...)) engine.SetHTMLTemplate(templ) } } func (engine *Engine) SetHTMLTemplate(templ *template.Template) { - engine.HTMLRender = render.HTMLRender{ - Template: templ, + if len(engine.trees) > 0 { + debugPrintWARNINGSetHTMLTemplate() } + + engine.HTMLRender = render.HTMLProduction{Template: templ.Funcs(engine.FuncMap)} +} + +func (engine *Engine) SetFuncMap(funcMap template.FuncMap) { + engine.FuncMap = funcMap } -// Adds handlers for NoRoute. It return a 404 code by default. +// NoRoute adds handlers for NoRoute. It return a 404 code by default. func (engine *Engine) NoRoute(handlers ...HandlerFunc) { engine.noRoute = handlers engine.rebuild404Handlers() } -func (engine *Engine) Use(middlewares ...HandlerFunc) { - engine.RouterGroup.Use(middlewares...) +// NoMethod sets the handlers called when... TODO +func (engine *Engine) NoMethod(handlers ...HandlerFunc) { + engine.noMethod = handlers + engine.rebuild405Handlers() +} + +// Use attachs a global middleware to the router. ie. the middleware attached though Use() will be +// included in the handlers chain for every single request. Even 404, 405, static files... +// For example, this is the right place for a logger or error management middleware. +func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes { + engine.RouterGroup.Use(middleware...) engine.rebuild404Handlers() + engine.rebuild405Handlers() + return engine } func (engine *Engine) rebuild404Handlers() { engine.allNoRoute = engine.combineHandlers(engine.noRoute) } -func (engine *Engine) handle404(w http.ResponseWriter, req *http.Request) { - c := engine.createContext(w, req, nil, engine.allNoRoute) - // set 404 by default, useful for logging - c.Writer.WriteHeader(404) +func (engine *Engine) rebuild405Handlers() { + engine.allNoMethod = engine.combineHandlers(engine.noMethod) +} + +func (engine *Engine) addRoute(method, path string, handlers HandlersChain) { + assert1(path[0] == '/', "path must begin with '/'") + assert1(len(method) > 0, "HTTP method can not be empty") + 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) + engine.trees = append(engine.trees, methodTree{method: method, root: root}) + } + root.addRoute(path, handlers) +} + +// Routes returns a slice of registered routes, including some useful information, such as: +// the http method, path and the handler name. +func (engine *Engine) Routes() (routes RoutesInfo) { + for _, tree := range engine.trees { + routes = iterate("", tree.method, routes, tree.root) + } + return routes +} + +func iterate(path, method string, routes RoutesInfo, root *node) RoutesInfo { + path += root.path + if len(root.handlers) > 0 { + routes = append(routes, RouteInfo{ + Method: method, + Path: path, + Handler: nameOfFunction(root.handlers.Last()), + }) + } + for _, child := range root.children { + routes = iterate(path, method, routes, child) + } + return routes +} + +// Run attaches the router to a http.Server and starts listening and serving HTTP requests. +// It is a shortcut for http.ListenAndServe(addr, router) +// Note: this method will block the calling goroutine indefinitely unless an error happens. +func (engine *Engine) Run(addr ...string) (err error) { + defer func() { debugPrintError(err) }() + + address := resolveAddress(addr) + debugPrint("Listening and serving HTTP on %s\n", address) + err = http.ListenAndServe(address, engine) + return +} + +// RunTLS attaches the router to a http.Server and starts listening and serving HTTPS (secure) requests. +// It is a shortcut for http.ListenAndServeTLS(addr, certFile, keyFile, router) +// Note: this method will block the calling goroutine indefinitely unless an error happens. +func (engine *Engine) RunTLS(addr string, certFile string, keyFile string) (err error) { + debugPrint("Listening and serving HTTPS on %s\n", addr) + defer func() { debugPrintError(err) }() + + err = http.ListenAndServeTLS(addr, certFile, keyFile, engine) + return +} + +// RunUnix attaches the router to a http.Server and starts listening and serving HTTP requests +// through the specified unix socket (ie. a file). +// Note: this method will block the calling goroutine indefinitely unless an error happens. +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 = http.Serve(listener, engine) + return +} + +// Conforms to the http.Handler interface. +func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) { + c := engine.pool.Get().(*Context) + c.writermem.reset(w) + c.Request = req + c.reset() + + engine.handleHTTPRequest(c) + + engine.pool.Put(c) +} + +// Re-enter a context that has been rewritten. +// This can be done by setting c.Request.Path to your new target. +// Disclaimer: You can loop yourself to death with this, use wisely. +func (engine *Engine) HandleContext(c *Context) { + c.reset() + engine.handleHTTPRequest(c) + engine.pool.Put(c) +} + +func (engine *Engine) handleHTTPRequest(context *Context) { + httpMethod := context.Request.Method + var path string + var unescape bool + if engine.UseRawPath && len(context.Request.URL.RawPath) > 0 { + path = context.Request.URL.RawPath + unescape = engine.UnescapePathValues + } else { + path = context.Request.URL.Path + unescape = false + } + + // Find root of the tree for the given HTTP method + t := engine.trees + for i, tl := 0, len(t); i < tl; i++ { + if t[i].method == httpMethod { + root := t[i].root + // Find route in tree + handlers, params, tsr := root.getValue(path, context.Params, unescape) + if handlers != nil { + context.handlers = handlers + context.Params = params + context.Next() + context.writermem.WriteHeaderNow() + return + } + if httpMethod != "CONNECT" && path != "/" { + if tsr && engine.RedirectTrailingSlash { + redirectTrailingSlash(context) + return + } + if engine.RedirectFixedPath && redirectFixedPath(context, root, engine.RedirectFixedPath) { + return + } + } + break + } + } + + // TODO: unit test + if engine.HandleMethodNotAllowed { + for _, tree := range engine.trees { + if tree.method != httpMethod { + if handlers, _, _ := tree.root.getValue(path, nil, unescape); handlers != nil { + context.handlers = engine.allNoMethod + serveError(context, 405, default405Body) + return + } + } + } + } + context.handlers = engine.allNoRoute + serveError(context, 404, default404Body) +} + +var mimePlain = []string{MIMEPlain} + +func serveError(c *Context, code int, defaultMessage []byte) { + c.writermem.status = code c.Next() - if !c.Writer.Written() { - if c.Writer.Status() == 404 { - c.Data(-1, MIMEPlain, engine.Default404Body) + if !c.writermem.Written() { + if c.writermem.Status() == code { + c.writermem.Header()["Content-Type"] = mimePlain + c.Writer.Write(defaultMessage) } else { - c.Writer.WriteHeaderNow() + c.writermem.WriteHeaderNow() } } - engine.reuseContext(c) } -// ServeHTTP makes the router implement the http.Handler interface. -func (engine *Engine) ServeHTTP(writer http.ResponseWriter, request *http.Request) { - engine.router.ServeHTTP(writer, request) -} +func redirectTrailingSlash(c *Context) { + req := c.Request + path := req.URL.Path + code := 301 // Permanent redirect, request with GET method + if req.Method != "GET" { + code = 307 + } -func (engine *Engine) Run(addr string) error { - debugPrint("Listening and serving HTTP on %s\n", addr) - if err := http.ListenAndServe(addr, engine); err != nil { - return err + if len(path) > 1 && path[len(path)-1] == '/' { + req.URL.Path = path[:len(path)-1] + } else { + req.URL.Path = path + "/" } - return nil + debugPrint("redirecting request %d: %s --> %s", code, path, req.URL.String()) + http.Redirect(c.Writer, req, req.URL.String(), code) + c.writermem.WriteHeaderNow() } -func (engine *Engine) RunTLS(addr string, cert string, key string) error { - debugPrint("Listening and serving HTTPS on %s\n", addr) - if err := http.ListenAndServeTLS(addr, cert, key, engine); err != nil { - return err +func redirectFixedPath(c *Context, root *node, trailingSlash bool) bool { + req := c.Request + path := req.URL.Path + + fixedPath, found := root.findCaseInsensitivePath( + cleanPath(path), + trailingSlash, + ) + if found { + code := 301 // Permanent redirect, request with GET method + if req.Method != "GET" { + code = 307 + } + req.URL.Path = string(fixedPath) + debugPrint("redirecting request %d: %s --> %s", code, path, req.URL.String()) + http.Redirect(c.Writer, req, req.URL.String(), code) + c.writermem.WriteHeaderNow() + return true } - return nil + return false } diff --git a/vendor/github.com/gin-gonic/gin/ginS/README.md b/vendor/github.com/gin-gonic/gin/ginS/README.md new file mode 100644 index 000000000..ef9225e49 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/ginS/README.md @@ -0,0 +1,17 @@ +# Gin Default Server + +This is API experiment for Gin. + +```go +package main + +import ( + "github.com/gin-gonic/gin" + "github.com/gin-gonic/gin/ginS" +) + +func main() { + ginS.GET("/", func(c *gin.Context) { c.String(200, "Hello World") }) + ginS.Run() +} +``` diff --git a/vendor/github.com/gin-gonic/gin/ginS/gins.go b/vendor/github.com/gin-gonic/gin/ginS/gins.go new file mode 100644 index 000000000..d40d1c3a3 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/ginS/gins.go @@ -0,0 +1,140 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package ginS + +import ( + "html/template" + "net/http" + "sync" + + . "github.com/gin-gonic/gin" +) + +var once sync.Once +var internalEngine *Engine + +func engine() *Engine { + once.Do(func() { + internalEngine = Default() + }) + return internalEngine +} + +func LoadHTMLGlob(pattern string) { + engine().LoadHTMLGlob(pattern) +} + +func LoadHTMLFiles(files ...string) { + engine().LoadHTMLFiles(files...) +} + +func SetHTMLTemplate(templ *template.Template) { + engine().SetHTMLTemplate(templ) +} + +// NoRoute adds handlers for NoRoute. It return a 404 code by default. +func NoRoute(handlers ...HandlerFunc) { + engine().NoRoute(handlers...) +} + +// NoMethod sets the handlers called when... TODO +func NoMethod(handlers ...HandlerFunc) { + engine().NoMethod(handlers...) +} + +// Group creates a new router group. You should add all the routes that have common middlwares or the same path prefix. +// For example, all the routes that use a common middlware for authorization could be grouped. +func Group(relativePath string, handlers ...HandlerFunc) *RouterGroup { + return engine().Group(relativePath, handlers...) +} + +func Handle(httpMethod, relativePath string, handlers ...HandlerFunc) IRoutes { + return engine().Handle(httpMethod, relativePath, handlers...) +} + +// POST is a shortcut for router.Handle("POST", path, handle) +func POST(relativePath string, handlers ...HandlerFunc) IRoutes { + return engine().POST(relativePath, handlers...) +} + +// GET is a shortcut for router.Handle("GET", path, handle) +func GET(relativePath string, handlers ...HandlerFunc) IRoutes { + return engine().GET(relativePath, handlers...) +} + +// DELETE is a shortcut for router.Handle("DELETE", path, handle) +func DELETE(relativePath string, handlers ...HandlerFunc) IRoutes { + return engine().DELETE(relativePath, handlers...) +} + +// PATCH is a shortcut for router.Handle("PATCH", path, handle) +func PATCH(relativePath string, handlers ...HandlerFunc) IRoutes { + return engine().PATCH(relativePath, handlers...) +} + +// PUT is a shortcut for router.Handle("PUT", path, handle) +func PUT(relativePath string, handlers ...HandlerFunc) IRoutes { + return engine().PUT(relativePath, handlers...) +} + +// OPTIONS is a shortcut for router.Handle("OPTIONS", path, handle) +func OPTIONS(relativePath string, handlers ...HandlerFunc) IRoutes { + return engine().OPTIONS(relativePath, handlers...) +} + +// HEAD is a shortcut for router.Handle("HEAD", path, handle) +func HEAD(relativePath string, handlers ...HandlerFunc) IRoutes { + return engine().HEAD(relativePath, handlers...) +} + +func Any(relativePath string, handlers ...HandlerFunc) IRoutes { + return engine().Any(relativePath, handlers...) +} + +func StaticFile(relativePath, filepath string) IRoutes { + return engine().StaticFile(relativePath, filepath) +} + +// Static serves files from the given file system root. +// Internally a http.FileServer is used, therefore http.NotFound is used instead +// of the Router's NotFound handler. +// To use the operating system's file system implementation, +// use : +// router.Static("/static", "/var/www") +func Static(relativePath, root string) IRoutes { + return engine().Static(relativePath, root) +} + +func StaticFS(relativePath string, fs http.FileSystem) IRoutes { + return engine().StaticFS(relativePath, fs) +} + +// Use attachs a global middleware to the router. ie. the middlewares attached though Use() will be +// included in the handlers chain for every single request. Even 404, 405, static files... +// For example, this is the right place for a logger or error management middleware. +func Use(middlewares ...HandlerFunc) IRoutes { + return engine().Use(middlewares...) +} + +// Run : The router is attached to a http.Server and starts listening and serving HTTP requests. +// It is a shortcut for http.ListenAndServe(addr, router) +// Note: this method will block the calling goroutine undefinitelly unless an error happens. +func Run(addr ...string) (err error) { + return engine().Run(addr...) +} + +// RunTLS : The router is attached to a http.Server and starts listening and serving HTTPS requests. +// It is a shortcut for http.ListenAndServeTLS(addr, certFile, keyFile, router) +// Note: this method will block the calling goroutine undefinitelly unless an error happens. +func RunTLS(addr string, certFile string, keyFile string) (err error) { + return engine().RunTLS(addr, certFile, keyFile) +} + +// RunUnix : The router is attached to a http.Server and starts listening and serving HTTP requests +// through the specified unix socket (ie. a file) +// Note: this method will block the calling goroutine undefinitelly unless an error happens. +func RunUnix(file string) (err error) { + return engine().RunUnix(file) +} diff --git a/vendor/github.com/gin-gonic/gin/gin_integration_test.go b/vendor/github.com/gin-gonic/gin/gin_integration_test.go new file mode 100644 index 000000000..f45dd6c17 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/gin_integration_test.go @@ -0,0 +1,135 @@ +// Copyright 2017 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package gin + +import ( + "bufio" + "fmt" + "io/ioutil" + "net" + "net/http" + "net/http/httptest" + "os" + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +func testRequest(t *testing.T, url string) { + resp, err := http.Get(url) + assert.NoError(t, err) + defer resp.Body.Close() + + body, ioerr := ioutil.ReadAll(resp.Body) + assert.NoError(t, ioerr) + assert.Equal(t, "it worked", string(body), "resp body should match") + assert.Equal(t, "200 OK", resp.Status, "should get a 200") +} + +func TestRunEmpty(t *testing.T) { + os.Setenv("PORT", "") + router := New() + go func() { + router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") }) + assert.NoError(t, router.Run()) + }() + // have to wait for the goroutine to start and run the server + // otherwise the main thread will complete + time.Sleep(5 * time.Millisecond) + + assert.Error(t, router.Run(":8080")) + testRequest(t, "http://localhost:8080/example") +} + +func TestRunEmptyWithEnv(t *testing.T) { + os.Setenv("PORT", "3123") + router := New() + go func() { + router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") }) + assert.NoError(t, router.Run()) + }() + // have to wait for the goroutine to start and run the server + // otherwise the main thread will complete + time.Sleep(5 * time.Millisecond) + + assert.Error(t, router.Run(":3123")) + testRequest(t, "http://localhost:3123/example") +} + +func TestRunTooMuchParams(t *testing.T) { + router := New() + assert.Panics(t, func() { + router.Run("2", "2") + }) +} + +func TestRunWithPort(t *testing.T) { + router := New() + go func() { + router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") }) + assert.NoError(t, router.Run(":5150")) + }() + // have to wait for the goroutine to start and run the server + // otherwise the main thread will complete + time.Sleep(5 * time.Millisecond) + + assert.Error(t, router.Run(":5150")) + testRequest(t, "http://localhost:5150/example") +} + +func TestUnixSocket(t *testing.T) { + router := New() + + go func() { + router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") }) + assert.NoError(t, router.RunUnix("/tmp/unix_unit_test")) + }() + // 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") + assert.NoError(t, err) + + fmt.Fprintf(c, "GET /example HTTP/1.0\r\n\r\n") + scanner := bufio.NewScanner(c) + var response string + for scanner.Scan() { + response += scanner.Text() + } + assert.Contains(t, response, "HTTP/1.0 200", "should get a 200") + assert.Contains(t, response, "it worked", "resp body should match") +} + +func TestBadUnixSocket(t *testing.T) { + router := New() + assert.Error(t, router.RunUnix("#/tmp/unix_unit_test")) +} + +func TestWithHttptestWithAutoSelectedPort(t *testing.T) { + router := New() + router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") }) + + ts := httptest.NewServer(router) + defer ts.Close() + + testRequest(t, ts.URL+"/example") +} + +// func TestWithHttptestWithSpecifiedPort(t *testing.T) { +// router := New() +// router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") }) + +// l, _ := net.Listen("tcp", ":8033") +// ts := httptest.Server{ +// Listener: l, +// Config: &http.Server{Handler: router}, +// } +// ts.Start() +// defer ts.Close() + +// testRequest(t, "http://localhost:8033/example") +// } diff --git a/vendor/github.com/gin-gonic/gin/gin_test.go b/vendor/github.com/gin-gonic/gin/gin_test.go index ba74c1599..bdf5a9a9e 100644 --- a/vendor/github.com/gin-gonic/gin/gin_test.go +++ b/vendor/github.com/gin-gonic/gin/gin_test.go @@ -5,202 +5,361 @@ package gin import ( + "fmt" + "html/template" "io/ioutil" "net/http" - "net/http/httptest" - "os" - "path" - "strings" + "reflect" "testing" + "time" + + "github.com/stretchr/testify/assert" ) -func init() { - SetMode(TestMode) +func formatAsDate(t time.Time) string { + year, month, day := t.Date() + return fmt.Sprintf("%d/%02d/%02d", year, month, day) } -func PerformRequest(r http.Handler, method, path string) *httptest.ResponseRecorder { - req, _ := http.NewRequest(method, path, nil) - w := httptest.NewRecorder() - r.ServeHTTP(w, req) - return w +func setupHTMLFiles(t *testing.T) func() { + go func() { + SetMode(TestMode) + router := New() + router.Delims("{[{", "}]}") + router.SetFuncMap(template.FuncMap{ + "formatAsDate": formatAsDate, + }) + router.LoadHTMLFiles("./fixtures/basic/hello.tmpl", "./fixtures/basic/raw.tmpl") + router.GET("/test", func(c *Context) { + c.HTML(http.StatusOK, "hello.tmpl", map[string]string{"name": "world"}) + }) + router.GET("/raw", func(c *Context) { + c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{ + "now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC), + }) + }) + router.Run(":8888") + }() + t.Log("waiting 1 second for server startup") + time.Sleep(1 * time.Second) + return func() {} } -// TestSingleRouteOK tests that POST route is correctly invoked. -func testRouteOK(method string, t *testing.T) { - // SETUP - passed := false - r := New() - r.Handle(method, "/test", []HandlerFunc{func(c *Context) { - passed = true - }}) - - // RUN - w := PerformRequest(r, method, "/test") +func setupHTMLGlob(t *testing.T) func() { + go func() { + SetMode(DebugMode) + router := New() + router.Delims("{[{", "}]}") + router.SetFuncMap(template.FuncMap{ + "formatAsDate": formatAsDate, + }) + router.LoadHTMLGlob("./fixtures/basic/*") + router.GET("/test", func(c *Context) { + c.HTML(http.StatusOK, "hello.tmpl", map[string]string{"name": "world"}) + }) + router.GET("/raw", func(c *Context) { + c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{ + "now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC), + }) + }) + router.Run(":8888") + }() + t.Log("waiting 1 second for server startup") + time.Sleep(1 * time.Second) + return func() {} +} - // TEST - if passed == false { - t.Errorf(method + " route handler was not invoked.") - } - if w.Code != http.StatusOK { - t.Errorf("Status code should be %v, was %d", http.StatusOK, w.Code) +//TODO +func TestLoadHTMLGlob(t *testing.T) { + td := setupHTMLGlob(t) + res, err := http.Get("http://127.0.0.1:8888/test") + if err != nil { + fmt.Println(err) } + + resp, _ := ioutil.ReadAll(res.Body) + assert.Equal(t, "Hello world
", string(resp[:])) + + td() } -func TestRouterGroupRouteOK(t *testing.T) { - testRouteOK("POST", t) - testRouteOK("DELETE", t) - testRouteOK("PATCH", t) - testRouteOK("PUT", t) - testRouteOK("OPTIONS", t) - testRouteOK("HEAD", t) -} - -// TestSingleRouteOK tests that POST route is correctly invoked. -func testRouteNotOK(method string, t *testing.T) { - // SETUP - passed := false - r := New() - r.Handle(method, "/test_2", []HandlerFunc{func(c *Context) { - passed = true - }}) - - // RUN - w := PerformRequest(r, method, "/test") - - // TEST - if passed == true { - t.Errorf(method + " route handler was invoked, when it should not") - } - if w.Code != http.StatusNotFound { - // If this fails, it's because httprouter needs to be updated to at least f78f58a0db - t.Errorf("Status code should be %v, was %d. Location: %s", http.StatusNotFound, w.Code, w.HeaderMap.Get("Location")) + +func TestLoadHTMLGlobFromFuncMap(t *testing.T) { + time.Now() + td := setupHTMLGlob(t) + res, err := http.Get("http://127.0.0.1:8888/raw") + if err != nil { + fmt.Println(err) } + + resp, _ := ioutil.ReadAll(res.Body) + assert.Equal(t, "Date: 2017/07/01\n", string(resp[:])) + + td() } -// TestSingleRouteOK tests that POST route is correctly invoked. -func TestRouteNotOK(t *testing.T) { - testRouteNotOK("POST", t) - testRouteNotOK("DELETE", t) - testRouteNotOK("PATCH", t) - testRouteNotOK("PUT", t) - testRouteNotOK("OPTIONS", t) - testRouteNotOK("HEAD", t) -} - -// TestSingleRouteOK tests that POST route is correctly invoked. -func testRouteNotOK2(method string, t *testing.T) { - // SETUP - passed := false - r := New() - var methodRoute string - if method == "POST" { - methodRoute = "GET" - } else { - methodRoute = "POST" - } - r.Handle(methodRoute, "/test", []HandlerFunc{func(c *Context) { - passed = true - }}) +// func (engine *Engine) LoadHTMLFiles(files ...string) { +// func (engine *Engine) RunTLS(addr string, cert string, key string) error { - // RUN - w := PerformRequest(r, method, "/test") +func init() { + SetMode(TestMode) +} - // TEST - if passed == true { - t.Errorf(method + " route handler was invoked, when it should not") - } - if w.Code != http.StatusMethodNotAllowed { - t.Errorf("Status code should be %v, was %d. Location: %s", http.StatusMethodNotAllowed, w.Code, w.HeaderMap.Get("Location")) - } +func TestCreateEngine(t *testing.T) { + router := New() + assert.Equal(t, "/", router.basePath) + assert.Equal(t, router.engine, router) + assert.Empty(t, router.Handlers) } -// TestSingleRouteOK tests that POST route is correctly invoked. -func TestRouteNotOK2(t *testing.T) { - testRouteNotOK2("POST", t) - testRouteNotOK2("DELETE", t) - testRouteNotOK2("PATCH", t) - testRouteNotOK2("PUT", t) - testRouteNotOK2("OPTIONS", t) - testRouteNotOK2("HEAD", t) +// func TestLoadHTMLDebugMode(t *testing.T) { +// router := New() +// SetMode(DebugMode) +// router.LoadHTMLGlob("*.testtmpl") +// r := router.HTMLRender.(render.HTMLDebug) +// assert.Empty(t, r.Files) +// assert.Equal(t, r.Glob, "*.testtmpl") +// +// router.LoadHTMLFiles("index.html.testtmpl", "login.html.testtmpl") +// r = router.HTMLRender.(render.HTMLDebug) +// assert.Empty(t, r.Glob) +// assert.Equal(t, r.Files, []string{"index.html", "login.html"}) +// SetMode(TestMode) +// } + +func TestLoadHTMLFiles(t *testing.T) { + td := setupHTMLFiles(t) + res, err := http.Get("http://127.0.0.1:8888/test") + if err != nil { + fmt.Println(err) + } + + resp, _ := ioutil.ReadAll(res.Body) + assert.Equal(t, "Hello world
", string(resp[:])) + td() } -// TestHandleStaticFile - ensure the static file handles properly -func TestHandleStaticFile(t *testing.T) { - // SETUP file - testRoot, _ := os.Getwd() - f, err := ioutil.TempFile(testRoot, "") +func TestLoadHTMLFilesFuncMap(t *testing.T) { + time.Now() + td := setupHTMLFiles(t) + res, err := http.Get("http://127.0.0.1:8888/raw") if err != nil { - t.Error(err) + fmt.Println(err) } - defer os.Remove(f.Name()) - filePath := path.Join("/", path.Base(f.Name())) - f.WriteString("Gin Web Framework") - f.Close() - // SETUP gin - r := New() - r.Static("./", testRoot) + resp, _ := ioutil.ReadAll(res.Body) + assert.Equal(t, "Date: 2017/07/01\n", string(resp[:])) - // RUN - w := PerformRequest(r, "GET", filePath) + td() +} + +func TestLoadHTMLReleaseMode(t *testing.T) { - // TEST - if w.Code != 200 { - t.Errorf("Response code should be 200, was: %d", w.Code) - } - if w.Body.String() != "Gin Web Framework" { - t.Errorf("Response should be test, was: %s", w.Body.String()) - } - if w.HeaderMap.Get("Content-Type") != "text/plain; charset=utf-8" { - t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type")) - } } -// TestHandleStaticDir - ensure the root/sub dir handles properly -func TestHandleStaticDir(t *testing.T) { - // SETUP - r := New() - r.Static("/", "./") +func TestAddRoute(t *testing.T) { + router := New() + router.addRoute("GET", "/", HandlersChain{func(_ *Context) {}}) - // RUN - w := PerformRequest(r, "GET", "/") + assert.Len(t, router.trees, 1) + assert.NotNil(t, router.trees.get("GET")) + assert.Nil(t, router.trees.get("POST")) - // TEST - bodyAsString := w.Body.String() - if w.Code != 200 { - t.Errorf("Response code should be 200, was: %d", w.Code) - } - if len(bodyAsString) == 0 { - t.Errorf("Got empty body instead of file tree") - } - if !strings.Contains(bodyAsString, "gin.go") { - t.Errorf("Can't find:`gin.go` in file tree: %s", bodyAsString) - } - if w.HeaderMap.Get("Content-Type") != "text/html; charset=utf-8" { - t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type")) - } + router.addRoute("POST", "/", HandlersChain{func(_ *Context) {}}) + + assert.Len(t, router.trees, 2) + assert.NotNil(t, router.trees.get("GET")) + assert.NotNil(t, router.trees.get("POST")) + + router.addRoute("POST", "/post", HandlersChain{func(_ *Context) {}}) + assert.Len(t, router.trees, 2) } -// TestHandleHeadToDir - ensure the root/sub dir handles properly -func TestHandleHeadToDir(t *testing.T) { - // SETUP - r := New() - r.Static("/", "./") +func TestAddRouteFails(t *testing.T) { + router := New() + assert.Panics(t, func() { router.addRoute("", "/", HandlersChain{func(_ *Context) {}}) }) + assert.Panics(t, func() { router.addRoute("GET", "a", HandlersChain{func(_ *Context) {}}) }) + assert.Panics(t, func() { router.addRoute("GET", "/", HandlersChain{}) }) - // RUN - w := PerformRequest(r, "HEAD", "/") + router.addRoute("POST", "/post", HandlersChain{func(_ *Context) {}}) + assert.Panics(t, func() { + router.addRoute("POST", "/post", HandlersChain{func(_ *Context) {}}) + }) +} - // TEST - bodyAsString := w.Body.String() - if w.Code != 200 { - t.Errorf("Response code should be Ok, was: %s", w.Code) - } - if len(bodyAsString) == 0 { - t.Errorf("Got empty body instead of file tree") +func TestCreateDefaultRouter(t *testing.T) { + router := Default() + assert.Len(t, router.Handlers, 2) +} + +func TestNoRouteWithoutGlobalHandlers(t *testing.T) { + var middleware0 HandlerFunc = func(c *Context) {} + var middleware1 HandlerFunc = func(c *Context) {} + + router := New() + + router.NoRoute(middleware0) + assert.Nil(t, router.Handlers) + assert.Len(t, router.noRoute, 1) + assert.Len(t, router.allNoRoute, 1) + compareFunc(t, router.noRoute[0], middleware0) + compareFunc(t, router.allNoRoute[0], middleware0) + + router.NoRoute(middleware1, middleware0) + assert.Len(t, router.noRoute, 2) + assert.Len(t, router.allNoRoute, 2) + compareFunc(t, router.noRoute[0], middleware1) + compareFunc(t, router.allNoRoute[0], middleware1) + compareFunc(t, router.noRoute[1], middleware0) + compareFunc(t, router.allNoRoute[1], middleware0) +} + +func TestNoRouteWithGlobalHandlers(t *testing.T) { + var middleware0 HandlerFunc = func(c *Context) {} + var middleware1 HandlerFunc = func(c *Context) {} + var middleware2 HandlerFunc = func(c *Context) {} + + router := New() + router.Use(middleware2) + + router.NoRoute(middleware0) + assert.Len(t, router.allNoRoute, 2) + assert.Len(t, router.Handlers, 1) + assert.Len(t, router.noRoute, 1) + + compareFunc(t, router.Handlers[0], middleware2) + compareFunc(t, router.noRoute[0], middleware0) + compareFunc(t, router.allNoRoute[0], middleware2) + compareFunc(t, router.allNoRoute[1], middleware0) + + router.Use(middleware1) + assert.Len(t, router.allNoRoute, 3) + assert.Len(t, router.Handlers, 2) + assert.Len(t, router.noRoute, 1) + + compareFunc(t, router.Handlers[0], middleware2) + compareFunc(t, router.Handlers[1], middleware1) + compareFunc(t, router.noRoute[0], middleware0) + compareFunc(t, router.allNoRoute[0], middleware2) + compareFunc(t, router.allNoRoute[1], middleware1) + compareFunc(t, router.allNoRoute[2], middleware0) +} + +func TestNoMethodWithoutGlobalHandlers(t *testing.T) { + var middleware0 HandlerFunc = func(c *Context) {} + var middleware1 HandlerFunc = func(c *Context) {} + + router := New() + + router.NoMethod(middleware0) + assert.Empty(t, router.Handlers) + assert.Len(t, router.noMethod, 1) + assert.Len(t, router.allNoMethod, 1) + compareFunc(t, router.noMethod[0], middleware0) + compareFunc(t, router.allNoMethod[0], middleware0) + + router.NoMethod(middleware1, middleware0) + assert.Len(t, router.noMethod, 2) + assert.Len(t, router.allNoMethod, 2) + compareFunc(t, router.noMethod[0], middleware1) + compareFunc(t, router.allNoMethod[0], middleware1) + compareFunc(t, router.noMethod[1], middleware0) + compareFunc(t, router.allNoMethod[1], middleware0) +} + +func TestRebuild404Handlers(t *testing.T) { + +} + +func TestNoMethodWithGlobalHandlers(t *testing.T) { + var middleware0 HandlerFunc = func(c *Context) {} + var middleware1 HandlerFunc = func(c *Context) {} + var middleware2 HandlerFunc = func(c *Context) {} + + router := New() + router.Use(middleware2) + + router.NoMethod(middleware0) + assert.Len(t, router.allNoMethod, 2) + assert.Len(t, router.Handlers, 1) + assert.Len(t, router.noMethod, 1) + + compareFunc(t, router.Handlers[0], middleware2) + compareFunc(t, router.noMethod[0], middleware0) + compareFunc(t, router.allNoMethod[0], middleware2) + compareFunc(t, router.allNoMethod[1], middleware0) + + router.Use(middleware1) + assert.Len(t, router.allNoMethod, 3) + assert.Len(t, router.Handlers, 2) + assert.Len(t, router.noMethod, 1) + + compareFunc(t, router.Handlers[0], middleware2) + compareFunc(t, router.Handlers[1], middleware1) + compareFunc(t, router.noMethod[0], middleware0) + compareFunc(t, router.allNoMethod[0], middleware2) + compareFunc(t, router.allNoMethod[1], middleware1) + compareFunc(t, router.allNoMethod[2], middleware0) +} + +func compareFunc(t *testing.T, a, b interface{}) { + sf1 := reflect.ValueOf(a) + sf2 := reflect.ValueOf(b) + if sf1.Pointer() != sf2.Pointer() { + t.Error("different functions") } - if !strings.Contains(bodyAsString, "gin.go") { - t.Errorf("Can't find:`gin.go` in file tree: %s", bodyAsString) +} + +func TestListOfRoutes(t *testing.T) { + router := New() + router.GET("/favicon.ico", handlerTest1) + router.GET("/", handlerTest1) + group := router.Group("/users") + { + group.GET("/", handlerTest2) + group.GET("/:id", handlerTest1) + group.POST("/:id", handlerTest2) } - if w.HeaderMap.Get("Content-Type") != "text/html; charset=utf-8" { - t.Errorf("Content-Type should be text/plain, was %s", w.HeaderMap.Get("Content-Type")) + router.Static("/static", ".") + + list := router.Routes() + + assert.Len(t, list, 7) + assertRoutePresent(t, list, RouteInfo{ + Method: "GET", + Path: "/favicon.ico", + Handler: "^(.*/vendor/)?github.com/gin-gonic/gin.handlerTest1$", + }) + assertRoutePresent(t, list, RouteInfo{ + Method: "GET", + Path: "/", + Handler: "^(.*/vendor/)?github.com/gin-gonic/gin.handlerTest1$", + }) + assertRoutePresent(t, list, RouteInfo{ + Method: "GET", + Path: "/users/", + Handler: "^(.*/vendor/)?github.com/gin-gonic/gin.handlerTest2$", + }) + assertRoutePresent(t, list, RouteInfo{ + Method: "GET", + Path: "/users/:id", + Handler: "^(.*/vendor/)?github.com/gin-gonic/gin.handlerTest1$", + }) + assertRoutePresent(t, list, RouteInfo{ + Method: "POST", + Path: "/users/:id", + Handler: "^(.*/vendor/)?github.com/gin-gonic/gin.handlerTest2$", + }) +} + +func assertRoutePresent(t *testing.T, gotRoutes RoutesInfo, wantRoute RouteInfo) { + for _, gotRoute := range gotRoutes { + if gotRoute.Path == wantRoute.Path && gotRoute.Method == wantRoute.Method { + assert.Regexp(t, wantRoute.Handler, gotRoute.Handler) + return + } } + t.Errorf("route not found: %v", wantRoute) } + +func handlerTest1(c *Context) {} +func handlerTest2(c *Context) {} diff --git a/vendor/github.com/gin-gonic/gin/githubapi_test.go b/vendor/github.com/gin-gonic/gin/githubapi_test.go new file mode 100644 index 000000000..a08c264d7 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/githubapi_test.go @@ -0,0 +1,390 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package gin + +import ( + "bytes" + "fmt" + "math/rand" + "net/http" + "net/http/httptest" + "os" + "testing" + + "github.com/stretchr/testify/assert" +) + +type route struct { + method string + path string +} + +// http://developer.github.com/v3/ +var githubAPI = []route{ + // OAuth Authorizations + {"GET", "/authorizations"}, + {"GET", "/authorizations/:id"}, + {"POST", "/authorizations"}, + //{"PUT", "/authorizations/clients/:client_id"}, + //{"PATCH", "/authorizations/:id"}, + {"DELETE", "/authorizations/:id"}, + {"GET", "/applications/:client_id/tokens/:access_token"}, + {"DELETE", "/applications/:client_id/tokens"}, + {"DELETE", "/applications/:client_id/tokens/:access_token"}, + + // Activity + {"GET", "/events"}, + {"GET", "/repos/:owner/:repo/events"}, + {"GET", "/networks/:owner/:repo/events"}, + {"GET", "/orgs/:org/events"}, + {"GET", "/users/:user/received_events"}, + {"GET", "/users/:user/received_events/public"}, + {"GET", "/users/:user/events"}, + {"GET", "/users/:user/events/public"}, + {"GET", "/users/:user/events/orgs/:org"}, + {"GET", "/feeds"}, + {"GET", "/notifications"}, + {"GET", "/repos/:owner/:repo/notifications"}, + {"PUT", "/notifications"}, + {"PUT", "/repos/:owner/:repo/notifications"}, + {"GET", "/notifications/threads/:id"}, + //{"PATCH", "/notifications/threads/:id"}, + {"GET", "/notifications/threads/:id/subscription"}, + {"PUT", "/notifications/threads/:id/subscription"}, + {"DELETE", "/notifications/threads/:id/subscription"}, + {"GET", "/repos/:owner/:repo/stargazers"}, + {"GET", "/users/:user/starred"}, + {"GET", "/user/starred"}, + {"GET", "/user/starred/:owner/:repo"}, + {"PUT", "/user/starred/:owner/:repo"}, + {"DELETE", "/user/starred/:owner/:repo"}, + {"GET", "/repos/:owner/:repo/subscribers"}, + {"GET", "/users/:user/subscriptions"}, + {"GET", "/user/subscriptions"}, + {"GET", "/repos/:owner/:repo/subscription"}, + {"PUT", "/repos/:owner/:repo/subscription"}, + {"DELETE", "/repos/:owner/:repo/subscription"}, + {"GET", "/user/subscriptions/:owner/:repo"}, + {"PUT", "/user/subscriptions/:owner/:repo"}, + {"DELETE", "/user/subscriptions/:owner/:repo"}, + + // Gists + {"GET", "/users/:user/gists"}, + {"GET", "/gists"}, + //{"GET", "/gists/public"}, + //{"GET", "/gists/starred"}, + {"GET", "/gists/:id"}, + {"POST", "/gists"}, + //{"PATCH", "/gists/:id"}, + {"PUT", "/gists/:id/star"}, + {"DELETE", "/gists/:id/star"}, + {"GET", "/gists/:id/star"}, + {"POST", "/gists/:id/forks"}, + {"DELETE", "/gists/:id"}, + + // Git Data + {"GET", "/repos/:owner/:repo/git/blobs/:sha"}, + {"POST", "/repos/:owner/:repo/git/blobs"}, + {"GET", "/repos/:owner/:repo/git/commits/:sha"}, + {"POST", "/repos/:owner/:repo/git/commits"}, + //{"GET", "/repos/:owner/:repo/git/refs/*ref"}, + {"GET", "/repos/:owner/:repo/git/refs"}, + {"POST", "/repos/:owner/:repo/git/refs"}, + //{"PATCH", "/repos/:owner/:repo/git/refs/*ref"}, + //{"DELETE", "/repos/:owner/:repo/git/refs/*ref"}, + {"GET", "/repos/:owner/:repo/git/tags/:sha"}, + {"POST", "/repos/:owner/:repo/git/tags"}, + {"GET", "/repos/:owner/:repo/git/trees/:sha"}, + {"POST", "/repos/:owner/:repo/git/trees"}, + + // Issues + {"GET", "/issues"}, + {"GET", "/user/issues"}, + {"GET", "/orgs/:org/issues"}, + {"GET", "/repos/:owner/:repo/issues"}, + {"GET", "/repos/:owner/:repo/issues/:number"}, + {"POST", "/repos/:owner/:repo/issues"}, + //{"PATCH", "/repos/:owner/:repo/issues/:number"}, + {"GET", "/repos/:owner/:repo/assignees"}, + {"GET", "/repos/:owner/:repo/assignees/:assignee"}, + {"GET", "/repos/:owner/:repo/issues/:number/comments"}, + //{"GET", "/repos/:owner/:repo/issues/comments"}, + //{"GET", "/repos/:owner/:repo/issues/comments/:id"}, + {"POST", "/repos/:owner/:repo/issues/:number/comments"}, + //{"PATCH", "/repos/:owner/:repo/issues/comments/:id"}, + //{"DELETE", "/repos/:owner/:repo/issues/comments/:id"}, + {"GET", "/repos/:owner/:repo/issues/:number/events"}, + //{"GET", "/repos/:owner/:repo/issues/events"}, + //{"GET", "/repos/:owner/:repo/issues/events/:id"}, + {"GET", "/repos/:owner/:repo/labels"}, + {"GET", "/repos/:owner/:repo/labels/:name"}, + {"POST", "/repos/:owner/:repo/labels"}, + //{"PATCH", "/repos/:owner/:repo/labels/:name"}, + {"DELETE", "/repos/:owner/:repo/labels/:name"}, + {"GET", "/repos/:owner/:repo/issues/:number/labels"}, + {"POST", "/repos/:owner/:repo/issues/:number/labels"}, + {"DELETE", "/repos/:owner/:repo/issues/:number/labels/:name"}, + {"PUT", "/repos/:owner/:repo/issues/:number/labels"}, + {"DELETE", "/repos/:owner/:repo/issues/:number/labels"}, + {"GET", "/repos/:owner/:repo/milestones/:number/labels"}, + {"GET", "/repos/:owner/:repo/milestones"}, + {"GET", "/repos/:owner/:repo/milestones/:number"}, + {"POST", "/repos/:owner/:repo/milestones"}, + //{"PATCH", "/repos/:owner/:repo/milestones/:number"}, + {"DELETE", "/repos/:owner/:repo/milestones/:number"}, + + // Miscellaneous + {"GET", "/emojis"}, + {"GET", "/gitignore/templates"}, + {"GET", "/gitignore/templates/:name"}, + {"POST", "/markdown"}, + {"POST", "/markdown/raw"}, + {"GET", "/meta"}, + {"GET", "/rate_limit"}, + + // Organizations + {"GET", "/users/:user/orgs"}, + {"GET", "/user/orgs"}, + {"GET", "/orgs/:org"}, + //{"PATCH", "/orgs/:org"}, + {"GET", "/orgs/:org/members"}, + {"GET", "/orgs/:org/members/:user"}, + {"DELETE", "/orgs/:org/members/:user"}, + {"GET", "/orgs/:org/public_members"}, + {"GET", "/orgs/:org/public_members/:user"}, + {"PUT", "/orgs/:org/public_members/:user"}, + {"DELETE", "/orgs/:org/public_members/:user"}, + {"GET", "/orgs/:org/teams"}, + {"GET", "/teams/:id"}, + {"POST", "/orgs/:org/teams"}, + //{"PATCH", "/teams/:id"}, + {"DELETE", "/teams/:id"}, + {"GET", "/teams/:id/members"}, + {"GET", "/teams/:id/members/:user"}, + {"PUT", "/teams/:id/members/:user"}, + {"DELETE", "/teams/:id/members/:user"}, + {"GET", "/teams/:id/repos"}, + {"GET", "/teams/:id/repos/:owner/:repo"}, + {"PUT", "/teams/:id/repos/:owner/:repo"}, + {"DELETE", "/teams/:id/repos/:owner/:repo"}, + {"GET", "/user/teams"}, + + // Pull Requests + {"GET", "/repos/:owner/:repo/pulls"}, + {"GET", "/repos/:owner/:repo/pulls/:number"}, + {"POST", "/repos/:owner/:repo/pulls"}, + //{"PATCH", "/repos/:owner/:repo/pulls/:number"}, + {"GET", "/repos/:owner/:repo/pulls/:number/commits"}, + {"GET", "/repos/:owner/:repo/pulls/:number/files"}, + {"GET", "/repos/:owner/:repo/pulls/:number/merge"}, + {"PUT", "/repos/:owner/:repo/pulls/:number/merge"}, + {"GET", "/repos/:owner/:repo/pulls/:number/comments"}, + //{"GET", "/repos/:owner/:repo/pulls/comments"}, + //{"GET", "/repos/:owner/:repo/pulls/comments/:number"}, + {"PUT", "/repos/:owner/:repo/pulls/:number/comments"}, + //{"PATCH", "/repos/:owner/:repo/pulls/comments/:number"}, + //{"DELETE", "/repos/:owner/:repo/pulls/comments/:number"}, + + // Repositories + {"GET", "/user/repos"}, + {"GET", "/users/:user/repos"}, + {"GET", "/orgs/:org/repos"}, + {"GET", "/repositories"}, + {"POST", "/user/repos"}, + {"POST", "/orgs/:org/repos"}, + {"GET", "/repos/:owner/:repo"}, + //{"PATCH", "/repos/:owner/:repo"}, + {"GET", "/repos/:owner/:repo/contributors"}, + {"GET", "/repos/:owner/:repo/languages"}, + {"GET", "/repos/:owner/:repo/teams"}, + {"GET", "/repos/:owner/:repo/tags"}, + {"GET", "/repos/:owner/:repo/branches"}, + {"GET", "/repos/:owner/:repo/branches/:branch"}, + {"DELETE", "/repos/:owner/:repo"}, + {"GET", "/repos/:owner/:repo/collaborators"}, + {"GET", "/repos/:owner/:repo/collaborators/:user"}, + {"PUT", "/repos/:owner/:repo/collaborators/:user"}, + {"DELETE", "/repos/:owner/:repo/collaborators/:user"}, + {"GET", "/repos/:owner/:repo/comments"}, + {"GET", "/repos/:owner/:repo/commits/:sha/comments"}, + {"POST", "/repos/:owner/:repo/commits/:sha/comments"}, + {"GET", "/repos/:owner/:repo/comments/:id"}, + //{"PATCH", "/repos/:owner/:repo/comments/:id"}, + {"DELETE", "/repos/:owner/:repo/comments/:id"}, + {"GET", "/repos/:owner/:repo/commits"}, + {"GET", "/repos/:owner/:repo/commits/:sha"}, + {"GET", "/repos/:owner/:repo/readme"}, + //{"GET", "/repos/:owner/:repo/contents/*path"}, + //{"PUT", "/repos/:owner/:repo/contents/*path"}, + //{"DELETE", "/repos/:owner/:repo/contents/*path"}, + //{"GET", "/repos/:owner/:repo/:archive_format/:ref"}, + {"GET", "/repos/:owner/:repo/keys"}, + {"GET", "/repos/:owner/:repo/keys/:id"}, + {"POST", "/repos/:owner/:repo/keys"}, + //{"PATCH", "/repos/:owner/:repo/keys/:id"}, + {"DELETE", "/repos/:owner/:repo/keys/:id"}, + {"GET", "/repos/:owner/:repo/downloads"}, + {"GET", "/repos/:owner/:repo/downloads/:id"}, + {"DELETE", "/repos/:owner/:repo/downloads/:id"}, + {"GET", "/repos/:owner/:repo/forks"}, + {"POST", "/repos/:owner/:repo/forks"}, + {"GET", "/repos/:owner/:repo/hooks"}, + {"GET", "/repos/:owner/:repo/hooks/:id"}, + {"POST", "/repos/:owner/:repo/hooks"}, + //{"PATCH", "/repos/:owner/:repo/hooks/:id"}, + {"POST", "/repos/:owner/:repo/hooks/:id/tests"}, + {"DELETE", "/repos/:owner/:repo/hooks/:id"}, + {"POST", "/repos/:owner/:repo/merges"}, + {"GET", "/repos/:owner/:repo/releases"}, + {"GET", "/repos/:owner/:repo/releases/:id"}, + {"POST", "/repos/:owner/:repo/releases"}, + //{"PATCH", "/repos/:owner/:repo/releases/:id"}, + {"DELETE", "/repos/:owner/:repo/releases/:id"}, + {"GET", "/repos/:owner/:repo/releases/:id/assets"}, + {"GET", "/repos/:owner/:repo/stats/contributors"}, + {"GET", "/repos/:owner/:repo/stats/commit_activity"}, + {"GET", "/repos/:owner/:repo/stats/code_frequency"}, + {"GET", "/repos/:owner/:repo/stats/participation"}, + {"GET", "/repos/:owner/:repo/stats/punch_card"}, + {"GET", "/repos/:owner/:repo/statuses/:ref"}, + {"POST", "/repos/:owner/:repo/statuses/:ref"}, + + // Search + {"GET", "/search/repositories"}, + {"GET", "/search/code"}, + {"GET", "/search/issues"}, + {"GET", "/search/users"}, + {"GET", "/legacy/issues/search/:owner/:repository/:state/:keyword"}, + {"GET", "/legacy/repos/search/:keyword"}, + {"GET", "/legacy/user/search/:keyword"}, + {"GET", "/legacy/user/email/:email"}, + + // Users + {"GET", "/users/:user"}, + {"GET", "/user"}, + //{"PATCH", "/user"}, + {"GET", "/users"}, + {"GET", "/user/emails"}, + {"POST", "/user/emails"}, + {"DELETE", "/user/emails"}, + {"GET", "/users/:user/followers"}, + {"GET", "/user/followers"}, + {"GET", "/users/:user/following"}, + {"GET", "/user/following"}, + {"GET", "/user/following/:user"}, + {"GET", "/users/:user/following/:target_user"}, + {"PUT", "/user/following/:user"}, + {"DELETE", "/user/following/:user"}, + {"GET", "/users/:user/keys"}, + {"GET", "/user/keys"}, + {"GET", "/user/keys/:id"}, + {"POST", "/user/keys"}, + //{"PATCH", "/user/keys/:id"}, + {"DELETE", "/user/keys/:id"}, +} + +func githubConfigRouter(router *Engine) { + for _, route := range githubAPI { + router.Handle(route.method, route.path, func(c *Context) { + output := make(map[string]string, len(c.Params)+1) + output["status"] = "good" + for _, param := range c.Params { + output[param.Key] = param.Value + } + c.JSON(200, output) + }) + } +} + +func TestGithubAPI(t *testing.T) { + DefaultWriter = os.Stdout + router := Default() + githubConfigRouter(router) + + for _, route := range githubAPI { + path, values := exampleFromPath(route.path) + w := performRequest(router, route.method, path) + + // TEST + assert.Contains(t, w.Body.String(), "\"status\":\"good\"") + for _, value := range values { + str := fmt.Sprintf("\"%s\":\"%s\"", value.Key, value.Value) + assert.Contains(t, w.Body.String(), str) + } + } +} + +func exampleFromPath(path string) (string, Params) { + output := new(bytes.Buffer) + params := make(Params, 0, 6) + start := -1 + for i, c := range path { + if c == ':' { + start = i + 1 + } + if start >= 0 { + if c == '/' { + value := fmt.Sprint(rand.Intn(100000)) + params = append(params, Param{ + Key: path[start:i], + Value: value, + }) + output.WriteString(value) + output.WriteRune(c) + start = -1 + } + } else { + output.WriteRune(c) + } + } + if start >= 0 { + value := fmt.Sprint(rand.Intn(100000)) + params = append(params, Param{ + Key: path[start:], + Value: value, + }) + output.WriteString(value) + } + + return output.String(), params +} + +func BenchmarkGithub(b *testing.B) { + router := New() + githubConfigRouter(router) + runRequest(b, router, "GET", "/legacy/issues/search/:owner/:repository/:state/:keyword") +} + +func BenchmarkParallelGithub(b *testing.B) { + DefaultWriter = os.Stdout + router := New() + githubConfigRouter(router) + + req, _ := http.NewRequest("POST", "/repos/manucorporat/sse/git/blobs", nil) + + b.RunParallel(func(pb *testing.PB) { + // Each goroutine has its own bytes.Buffer. + for pb.Next() { + w := httptest.NewRecorder() + router.ServeHTTP(w, req) + } + }) +} + +func BenchmarkParallelGithubDefault(b *testing.B) { + DefaultWriter = os.Stdout + router := Default() + githubConfigRouter(router) + + req, _ := http.NewRequest("POST", "/repos/manucorporat/sse/git/blobs", nil) + + b.RunParallel(func(pb *testing.PB) { + // Each goroutine has its own bytes.Buffer. + for pb.Next() { + w := httptest.NewRecorder() + router.ServeHTTP(w, req) + } + }) +} diff --git a/vendor/github.com/gin-gonic/gin/logger.go b/vendor/github.com/gin-gonic/gin/logger.go index 5054f6ec2..dc6f14154 100644 --- a/vendor/github.com/gin-gonic/gin/logger.go +++ b/vendor/github.com/gin-gonic/gin/logger.go @@ -5,78 +5,115 @@ package gin import ( - "log" + "fmt" + "io" "os" "time" + + "github.com/mattn/go-isatty" ) var ( - green = string([]byte{27, 91, 57, 55, 59, 52, 50, 109}) - white = string([]byte{27, 91, 57, 48, 59, 52, 55, 109}) - yellow = string([]byte{27, 91, 57, 55, 59, 52, 51, 109}) - red = string([]byte{27, 91, 57, 55, 59, 52, 49, 109}) - blue = string([]byte{27, 91, 57, 55, 59, 52, 52, 109}) - magenta = string([]byte{27, 91, 57, 55, 59, 52, 53, 109}) - cyan = string([]byte{27, 91, 57, 55, 59, 52, 54, 109}) - reset = string([]byte{27, 91, 48, 109}) + green = string([]byte{27, 91, 57, 55, 59, 52, 50, 109}) + white = string([]byte{27, 91, 57, 48, 59, 52, 55, 109}) + yellow = string([]byte{27, 91, 57, 55, 59, 52, 51, 109}) + red = string([]byte{27, 91, 57, 55, 59, 52, 49, 109}) + blue = string([]byte{27, 91, 57, 55, 59, 52, 52, 109}) + magenta = string([]byte{27, 91, 57, 55, 59, 52, 53, 109}) + cyan = string([]byte{27, 91, 57, 55, 59, 52, 54, 109}) + reset = string([]byte{27, 91, 48, 109}) + disableColor = false ) +func DisableConsoleColor() { + disableColor = true +} + func ErrorLogger() HandlerFunc { - return ErrorLoggerT(ErrorTypeAll) + return ErrorLoggerT(ErrorTypeAny) } -func ErrorLoggerT(typ uint32) HandlerFunc { +func ErrorLoggerT(typ ErrorType) HandlerFunc { return func(c *Context) { c.Next() - - errs := c.Errors.ByType(typ) - if len(errs) > 0 { - // -1 status code = do not change current one - c.JSON(-1, c.Errors) + errors := c.Errors.ByType(typ) + if len(errors) > 0 { + c.JSON(-1, errors) } } } +// Logger instances a Logger middleware that will write the logs to gin.DefaultWriter +// By default gin.DefaultWriter = os.Stdout func Logger() HandlerFunc { - stdlogger := log.New(os.Stdout, "", 0) - //errlogger := log.New(os.Stderr, "", 0) + return LoggerWithWriter(DefaultWriter) +} + +// LoggerWithWriter instance a Logger middleware with the specified writter buffer. +// Example: os.Stdout, a file opened in write mode, a socket... +func LoggerWithWriter(out io.Writer, notlogged ...string) HandlerFunc { + isTerm := true + + if w, ok := out.(*os.File); !ok || + (os.Getenv("TERM") == "dumb" || (!isatty.IsTerminal(w.Fd()) && !isatty.IsCygwinTerminal(w.Fd()))) || + disableColor { + isTerm = false + } + + var skip map[string]struct{} + + if length := len(notlogged); length > 0 { + skip = make(map[string]struct{}, length) + + for _, path := range notlogged { + skip[path] = struct{}{} + } + } return func(c *Context) { // Start timer start := time.Now() + path := c.Request.URL.Path // Process request c.Next() - // Stop timer - end := time.Now() - latency := end.Sub(start) - - clientIP := c.ClientIP() - method := c.Request.Method - statusCode := c.Writer.Status() - statusColor := colorForStatus(statusCode) - methodColor := colorForMethod(method) - - stdlogger.Printf("[GIN] %v |%s %3d %s| %12v | %s |%s %s %-7s %s\n%s", - end.Format("2006/01/02 - 15:04:05"), - statusColor, statusCode, reset, - latency, - clientIP, - methodColor, reset, method, - c.Request.URL.Path, - c.Errors.String(), - ) + // Log only when path is not being skipped + if _, ok := skip[path]; !ok { + // Stop timer + end := time.Now() + latency := end.Sub(start) + + clientIP := c.ClientIP() + method := c.Request.Method + statusCode := c.Writer.Status() + var statusColor, methodColor string + if isTerm { + statusColor = colorForStatus(statusCode) + methodColor = colorForMethod(method) + } + comment := c.Errors.ByType(ErrorTypePrivate).String() + + fmt.Fprintf(out, "[GIN] %v |%s %3d %s| %13v | %15s |%s %s %-7s %s\n%s", + end.Format("2006/01/02 - 15:04:05"), + statusColor, statusCode, reset, + latency, + clientIP, + methodColor, method, reset, + path, + comment, + ) + } } } func colorForStatus(code int) string { switch { - case code >= 200 && code <= 299: + case code >= 200 && code < 300: return green - case code >= 300 && code <= 399: + case code >= 300 && code < 400: return white - case code >= 400 && code <= 499: + case code >= 400 && code < 500: return yellow default: return red @@ -84,20 +121,20 @@ func colorForStatus(code int) string { } func colorForMethod(method string) string { - switch { - case method == "GET": + switch method { + case "GET": return blue - case method == "POST": + case "POST": return cyan - case method == "PUT": + case "PUT": return yellow - case method == "DELETE": + case "DELETE": return red - case method == "PATCH": + case "PATCH": return green - case method == "HEAD": + case "HEAD": return magenta - case method == "OPTIONS": + case "OPTIONS": return white default: return reset diff --git a/vendor/github.com/gin-gonic/gin/logger_test.go b/vendor/github.com/gin-gonic/gin/logger_test.go new file mode 100644 index 000000000..15d6ee9c0 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/logger_test.go @@ -0,0 +1,148 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package gin + +import ( + "bytes" + "errors" + "testing" + + "github.com/stretchr/testify/assert" +) + +func init() { + SetMode(TestMode) +} + +func TestLogger(t *testing.T) { + buffer := new(bytes.Buffer) + router := New() + router.Use(LoggerWithWriter(buffer)) + router.GET("/example", func(c *Context) {}) + router.POST("/example", func(c *Context) {}) + router.PUT("/example", func(c *Context) {}) + router.DELETE("/example", func(c *Context) {}) + router.PATCH("/example", func(c *Context) {}) + router.HEAD("/example", func(c *Context) {}) + router.OPTIONS("/example", func(c *Context) {}) + + performRequest(router, "GET", "/example") + assert.Contains(t, buffer.String(), "200") + assert.Contains(t, buffer.String(), "GET") + assert.Contains(t, buffer.String(), "/example") + + // I wrote these first (extending the above) but then realized they are more + // like integration tests because they test the whole logging process rather + // than individual functions. Im not sure where these should go. + buffer.Reset() + performRequest(router, "POST", "/example") + assert.Contains(t, buffer.String(), "200") + assert.Contains(t, buffer.String(), "POST") + assert.Contains(t, buffer.String(), "/example") + + buffer.Reset() + performRequest(router, "PUT", "/example") + assert.Contains(t, buffer.String(), "200") + assert.Contains(t, buffer.String(), "PUT") + assert.Contains(t, buffer.String(), "/example") + + buffer.Reset() + performRequest(router, "DELETE", "/example") + assert.Contains(t, buffer.String(), "200") + assert.Contains(t, buffer.String(), "DELETE") + assert.Contains(t, buffer.String(), "/example") + + buffer.Reset() + performRequest(router, "PATCH", "/example") + assert.Contains(t, buffer.String(), "200") + assert.Contains(t, buffer.String(), "PATCH") + assert.Contains(t, buffer.String(), "/example") + + buffer.Reset() + performRequest(router, "HEAD", "/example") + assert.Contains(t, buffer.String(), "200") + assert.Contains(t, buffer.String(), "HEAD") + assert.Contains(t, buffer.String(), "/example") + + buffer.Reset() + performRequest(router, "OPTIONS", "/example") + assert.Contains(t, buffer.String(), "200") + assert.Contains(t, buffer.String(), "OPTIONS") + assert.Contains(t, buffer.String(), "/example") + + buffer.Reset() + performRequest(router, "GET", "/notfound") + assert.Contains(t, buffer.String(), "404") + assert.Contains(t, buffer.String(), "GET") + assert.Contains(t, buffer.String(), "/notfound") + +} + +func TestColorForMethod(t *testing.T) { + assert.Equal(t, colorForMethod("GET"), string([]byte{27, 91, 57, 55, 59, 52, 52, 109}), "get should be blue") + assert.Equal(t, colorForMethod("POST"), string([]byte{27, 91, 57, 55, 59, 52, 54, 109}), "post should be cyan") + assert.Equal(t, colorForMethod("PUT"), string([]byte{27, 91, 57, 55, 59, 52, 51, 109}), "put should be yellow") + assert.Equal(t, colorForMethod("DELETE"), string([]byte{27, 91, 57, 55, 59, 52, 49, 109}), "delete should be red") + assert.Equal(t, colorForMethod("PATCH"), string([]byte{27, 91, 57, 55, 59, 52, 50, 109}), "patch should be green") + assert.Equal(t, colorForMethod("HEAD"), string([]byte{27, 91, 57, 55, 59, 52, 53, 109}), "head should be magenta") + assert.Equal(t, colorForMethod("OPTIONS"), string([]byte{27, 91, 57, 48, 59, 52, 55, 109}), "options should be white") + assert.Equal(t, colorForMethod("TRACE"), string([]byte{27, 91, 48, 109}), "trace is not defined and should be the reset color") +} + +func TestColorForStatus(t *testing.T) { + assert.Equal(t, colorForStatus(200), string([]byte{27, 91, 57, 55, 59, 52, 50, 109}), "2xx should be green") + assert.Equal(t, colorForStatus(301), string([]byte{27, 91, 57, 48, 59, 52, 55, 109}), "3xx should be white") + assert.Equal(t, colorForStatus(404), string([]byte{27, 91, 57, 55, 59, 52, 51, 109}), "4xx should be yellow") + assert.Equal(t, colorForStatus(2), string([]byte{27, 91, 57, 55, 59, 52, 49, 109}), "other things should be red") +} + +func TestErrorLogger(t *testing.T) { + router := New() + router.Use(ErrorLogger()) + router.GET("/error", func(c *Context) { + c.Error(errors.New("this is an error")) + }) + router.GET("/abort", func(c *Context) { + c.AbortWithError(401, errors.New("no authorized")) + }) + router.GET("/print", func(c *Context) { + c.Error(errors.New("this is an error")) + c.String(500, "hola!") + }) + + w := performRequest(router, "GET", "/error") + assert.Equal(t, 200, w.Code) + assert.Equal(t, "{\"error\":\"this is an error\"}", w.Body.String()) + + w = performRequest(router, "GET", "/abort") + assert.Equal(t, 401, w.Code) + assert.Equal(t, "{\"error\":\"no authorized\"}", w.Body.String()) + + w = performRequest(router, "GET", "/print") + assert.Equal(t, 500, w.Code) + assert.Equal(t, "hola!{\"error\":\"this is an error\"}", w.Body.String()) +} + +func TestSkippingPaths(t *testing.T) { + buffer := new(bytes.Buffer) + router := New() + router.Use(LoggerWithWriter(buffer, "/skipped")) + router.GET("/logged", func(c *Context) {}) + router.GET("/skipped", func(c *Context) {}) + + performRequest(router, "GET", "/logged") + assert.Contains(t, buffer.String(), "200") + + buffer.Reset() + performRequest(router, "GET", "/skipped") + assert.Contains(t, buffer.String(), "") +} + +func TestDisableConsoleColor(t *testing.T) { + New() + assert.False(t, disableColor) + DisableConsoleColor() + assert.True(t, disableColor) +} diff --git a/vendor/github.com/gin-gonic/gin/logo.jpg b/vendor/github.com/gin-gonic/gin/logo.jpg new file mode 100644 index 000000000..bb51852e4 Binary files /dev/null and b/vendor/github.com/gin-gonic/gin/logo.jpg differ diff --git a/vendor/github.com/gin-gonic/gin/middleware_test.go b/vendor/github.com/gin-gonic/gin/middleware_test.go new file mode 100644 index 000000000..5572e7905 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/middleware_test.go @@ -0,0 +1,249 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package gin + +import ( + "errors" + "strings" + "testing" + + "github.com/gin-contrib/sse" + "github.com/stretchr/testify/assert" +) + +func TestMiddlewareGeneralCase(t *testing.T) { + signature := "" + router := New() + router.Use(func(c *Context) { + signature += "A" + c.Next() + signature += "B" + }) + router.Use(func(c *Context) { + signature += "C" + }) + router.GET("/", func(c *Context) { + signature += "D" + }) + router.NoRoute(func(c *Context) { + signature += " X " + }) + router.NoMethod(func(c *Context) { + signature += " XX " + }) + // RUN + w := performRequest(router, "GET", "/") + + // TEST + assert.Equal(t, w.Code, 200) + assert.Equal(t, signature, "ACDB") +} + +func TestMiddlewareNoRoute(t *testing.T) { + signature := "" + router := New() + router.Use(func(c *Context) { + signature += "A" + c.Next() + signature += "B" + }) + router.Use(func(c *Context) { + signature += "C" + c.Next() + c.Next() + c.Next() + c.Next() + signature += "D" + }) + router.NoRoute(func(c *Context) { + signature += "E" + c.Next() + signature += "F" + }, func(c *Context) { + signature += "G" + c.Next() + signature += "H" + }) + router.NoMethod(func(c *Context) { + signature += " X " + }) + // RUN + w := performRequest(router, "GET", "/") + + // TEST + assert.Equal(t, w.Code, 404) + assert.Equal(t, signature, "ACEGHFDB") +} + +func TestMiddlewareNoMethodEnabled(t *testing.T) { + signature := "" + router := New() + router.HandleMethodNotAllowed = true + router.Use(func(c *Context) { + signature += "A" + c.Next() + signature += "B" + }) + router.Use(func(c *Context) { + signature += "C" + c.Next() + signature += "D" + }) + router.NoMethod(func(c *Context) { + signature += "E" + c.Next() + signature += "F" + }, func(c *Context) { + signature += "G" + c.Next() + signature += "H" + }) + router.NoRoute(func(c *Context) { + signature += " X " + }) + router.POST("/", func(c *Context) { + signature += " XX " + }) + // RUN + w := performRequest(router, "GET", "/") + + // TEST + assert.Equal(t, w.Code, 405) + assert.Equal(t, signature, "ACEGHFDB") +} + +func TestMiddlewareNoMethodDisabled(t *testing.T) { + signature := "" + router := New() + router.HandleMethodNotAllowed = false + router.Use(func(c *Context) { + signature += "A" + c.Next() + signature += "B" + }) + router.Use(func(c *Context) { + signature += "C" + c.Next() + signature += "D" + }) + router.NoMethod(func(c *Context) { + signature += "E" + c.Next() + signature += "F" + }, func(c *Context) { + signature += "G" + c.Next() + signature += "H" + }) + router.NoRoute(func(c *Context) { + signature += " X " + }) + router.POST("/", func(c *Context) { + signature += " XX " + }) + // RUN + w := performRequest(router, "GET", "/") + + // TEST + assert.Equal(t, w.Code, 404) + assert.Equal(t, signature, "AC X DB") +} + +func TestMiddlewareAbort(t *testing.T) { + signature := "" + router := New() + router.Use(func(c *Context) { + signature += "A" + }) + router.Use(func(c *Context) { + signature += "C" + c.AbortWithStatus(401) + c.Next() + signature += "D" + }) + router.GET("/", func(c *Context) { + signature += " X " + c.Next() + signature += " XX " + }) + + // RUN + w := performRequest(router, "GET", "/") + + // TEST + assert.Equal(t, w.Code, 401) + assert.Equal(t, signature, "ACD") +} + +func TestMiddlewareAbortHandlersChainAndNext(t *testing.T) { + signature := "" + router := New() + router.Use(func(c *Context) { + signature += "A" + c.Next() + c.AbortWithStatus(410) + signature += "B" + + }) + router.GET("/", func(c *Context) { + signature += "C" + c.Next() + }) + // RUN + w := performRequest(router, "GET", "/") + + // TEST + assert.Equal(t, w.Code, 410) + assert.Equal(t, signature, "ACB") +} + +// TestFailHandlersChain - ensure that Fail interrupt used middleware in fifo order as +// as well as Abort +func TestMiddlewareFailHandlersChain(t *testing.T) { + // SETUP + signature := "" + router := New() + router.Use(func(context *Context) { + signature += "A" + context.AbortWithError(500, errors.New("foo")) + }) + router.Use(func(context *Context) { + signature += "B" + context.Next() + signature += "C" + }) + // RUN + w := performRequest(router, "GET", "/") + + // TEST + assert.Equal(t, w.Code, 500) + assert.Equal(t, signature, "A") +} + +func TestMiddlewareWrite(t *testing.T) { + router := New() + router.Use(func(c *Context) { + c.String(400, "hola\n") + }) + router.Use(func(c *Context) { + c.XML(400, H{"foo": "bar"}) + }) + router.Use(func(c *Context) { + c.JSON(400, H{"foo": "bar"}) + }) + router.GET("/", func(c *Context) { + c.JSON(400, H{"foo": "bar"}) + }, func(c *Context) { + c.Render(400, sse.Event{ + Event: "test", + Data: "message", + }) + }) + + w := performRequest(router, "GET", "/") + + assert.Equal(t, 400, w.Code) + assert.Equal(t, strings.Replace("hola\n{\"foo\":\"bar\"}{\"foo\":\"bar\"}event:test\ndata:message\n\n", " ", "", -1), strings.Replace(w.Body.String(), " ", "", -1)) +} diff --git a/vendor/github.com/gin-gonic/gin/mode.go b/vendor/github.com/gin-gonic/gin/mode.go index 0495b8301..e24dbdc2c 100644 --- a/vendor/github.com/gin-gonic/gin/mode.go +++ b/vendor/github.com/gin-gonic/gin/mode.go @@ -5,11 +5,13 @@ package gin import ( - "fmt" + "io" "os" + + "github.com/gin-gonic/gin/binding" ) -const GIN_MODE = "GIN_MODE" +const ENV_GIN_MODE = "GIN_MODE" const ( DebugMode string = "debug" @@ -17,47 +19,51 @@ const ( TestMode string = "test" ) const ( - debugCode = iota - releaseCode = iota - testCode = iota + debugCode = iota + releaseCode + testCode ) -var gin_mode int = debugCode -var mode_name string = DebugMode +// DefaultWriter is the default io.Writer used the Gin for debug output and +// middleware output like Logger() or Recovery(). +// Note that both Logger and Recovery provides custom ways to configure their +// output io.Writer. +// To support coloring in Windows use: +// import "github.com/mattn/go-colorable" +// gin.DefaultWriter = colorable.NewColorableStdout() +var DefaultWriter io.Writer = os.Stdout +var DefaultErrorWriter io.Writer = os.Stderr + +var ginMode = debugCode +var modeName = DebugMode func init() { - value := os.Getenv(GIN_MODE) - if len(value) == 0 { + mode := os.Getenv(ENV_GIN_MODE) + if len(mode) == 0 { SetMode(DebugMode) } else { - SetMode(value) + SetMode(mode) } } func SetMode(value string) { switch value { case DebugMode: - gin_mode = debugCode + ginMode = debugCode case ReleaseMode: - gin_mode = releaseCode + ginMode = releaseCode case TestMode: - gin_mode = testCode + ginMode = testCode default: panic("gin mode unknown: " + value) } - mode_name = value + modeName = value } -func Mode() string { - return mode_name +func DisableBindValidation() { + binding.Validator = nil } -func IsDebugging() bool { - return gin_mode == debugCode -} - -func debugPrint(format string, values ...interface{}) { - if IsDebugging() { - fmt.Printf("[GIN-debug] "+format, values...) - } +func Mode() string { + return modeName } diff --git a/vendor/github.com/gin-gonic/gin/mode_test.go b/vendor/github.com/gin-gonic/gin/mode_test.go new file mode 100644 index 000000000..2a23d85e9 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/mode_test.go @@ -0,0 +1,31 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package gin + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func init() { + SetMode(TestMode) +} + +func TestSetMode(t *testing.T) { + SetMode(DebugMode) + assert.Equal(t, ginMode, debugCode) + assert.Equal(t, Mode(), DebugMode) + + SetMode(ReleaseMode) + assert.Equal(t, ginMode, releaseCode) + assert.Equal(t, Mode(), ReleaseMode) + + SetMode(TestMode) + assert.Equal(t, ginMode, testCode) + assert.Equal(t, Mode(), TestMode) + + assert.Panics(t, func() { SetMode("unknown") }) +} diff --git a/vendor/github.com/julienschmidt/httprouter/path.go b/vendor/github.com/gin-gonic/gin/path.go similarity index 95% rename from vendor/github.com/julienschmidt/httprouter/path.go rename to vendor/github.com/gin-gonic/gin/path.go index 486134db3..d7e7458b5 100644 --- a/vendor/github.com/julienschmidt/httprouter/path.go +++ b/vendor/github.com/gin-gonic/gin/path.go @@ -1,9 +1,9 @@ // Copyright 2013 Julien Schmidt. All rights reserved. // Based on the path package, Copyright 2009 The Go Authors. // Use of this source code is governed by a BSD-style license that can be found -// in the LICENSE file. +// at https://github.com/julienschmidt/httprouter/blob/master/LICENSE. -package httprouter +package gin // CleanPath is the URL version of path.Clean, it returns a canonical URL path // for p, eliminating . and .. elements. @@ -18,7 +18,7 @@ package httprouter // that is, replace "/.." by "/" at the beginning of a path. // // If the result of this process is an empty string, "/" is returned -func CleanPath(p string) string { +func cleanPath(p string) string { // Turn empty string into "/" if p == "" { return "/" diff --git a/vendor/github.com/julienschmidt/httprouter/path_test.go b/vendor/github.com/gin-gonic/gin/path_test.go similarity index 78% rename from vendor/github.com/julienschmidt/httprouter/path_test.go rename to vendor/github.com/gin-gonic/gin/path_test.go index c4ceda5da..bf2e5f62a 100644 --- a/vendor/github.com/julienschmidt/httprouter/path_test.go +++ b/vendor/github.com/gin-gonic/gin/path_test.go @@ -1,13 +1,15 @@ // Copyright 2013 Julien Schmidt. All rights reserved. // Based on the path package, Copyright 2009 The Go Authors. // Use of this source code is governed by a BSD-style license that can be found -// in the LICENSE file. +// at https://github.com/julienschmidt/httprouter/blob/master/LICENSE -package httprouter +package gin import ( "runtime" "testing" + + "github.com/stretchr/testify/assert" ) var cleanTests = []struct { @@ -65,12 +67,8 @@ var cleanTests = []struct { func TestPathClean(t *testing.T) { for _, test := range cleanTests { - if s := CleanPath(test.path); s != test.result { - t.Errorf("CleanPath(%q) = %q, want %q", test.path, s, test.result) - } - if s := CleanPath(test.result); s != test.result { - t.Errorf("CleanPath(%q) = %q, want %q", test.result, s, test.result) - } + assert.Equal(t, cleanPath(test.path), test.result) + assert.Equal(t, cleanPath(test.result), test.result) } } @@ -84,9 +82,7 @@ func TestPathCleanMallocs(t *testing.T) { } for _, test := range cleanTests { - allocs := testing.AllocsPerRun(100, func() { CleanPath(test.result) }) - if allocs > 0 { - t.Errorf("CleanPath(%q): %v allocs, want zero", test.result, allocs) - } + allocs := testing.AllocsPerRun(100, func() { cleanPath(test.result) }) + assert.EqualValues(t, allocs, 0) } } diff --git a/vendor/github.com/gin-gonic/gin/recovery.go b/vendor/github.com/gin-gonic/gin/recovery.go index a8d537e4c..c502f3553 100644 --- a/vendor/github.com/gin-gonic/gin/recovery.go +++ b/vendor/github.com/gin-gonic/gin/recovery.go @@ -7,9 +7,10 @@ package gin import ( "bytes" "fmt" + "io" "io/ioutil" "log" - "net/http" + "net/http/httputil" "runtime" ) @@ -20,6 +21,31 @@ var ( slash = []byte("/") ) +// Recovery returns a middleware that recovers from any panics and writes a 500 if there was one. +func Recovery() HandlerFunc { + return RecoveryWithWriter(DefaultErrorWriter) +} + +func RecoveryWithWriter(out io.Writer) HandlerFunc { + var logger *log.Logger + if out != nil { + logger = log.New(out, "\n\n\x1b[31m", log.LstdFlags) + } + return func(c *Context) { + defer func() { + if err := recover(); err != nil { + if logger != nil { + stack := stack(3) + httprequest, _ := httputil.DumpRequest(c.Request, false) + logger.Printf("[Recovery] panic recovered:\n%s\n%s\n%s%s", string(httprequest), err, stack, reset) + } + c.AbortWithStatus(500) + } + }() + c.Next() + } +} + // stack returns a nicely formated stack frame, skipping skip frames func stack(skip int) []byte { buf := new(bytes.Buffer) // the returned data @@ -80,19 +106,3 @@ func function(pc uintptr) []byte { name = bytes.Replace(name, centerDot, dot, -1) return name } - -// Recovery returns a middleware that recovers from any panics and writes a 500 if there was one. -// While Martini is in development mode, Recovery will also output the panic as HTML. -func Recovery() HandlerFunc { - return func(c *Context) { - defer func() { - if err := recover(); err != nil { - stack := stack(3) - log.Printf("PANIC: %s\n%s", err, stack) - c.Writer.WriteHeader(http.StatusInternalServerError) - } - }() - - c.Next() - } -} diff --git a/vendor/github.com/gin-gonic/gin/recovery_test.go b/vendor/github.com/gin-gonic/gin/recovery_test.go index f9047e245..4545ba3ca 100644 --- a/vendor/github.com/gin-gonic/gin/recovery_test.go +++ b/vendor/github.com/gin-gonic/gin/recovery_test.go @@ -6,51 +6,38 @@ package gin import ( "bytes" - "log" - "os" "testing" + + "github.com/stretchr/testify/assert" ) // TestPanicInHandler assert that panic has been recovered. func TestPanicInHandler(t *testing.T) { - // SETUP - log.SetOutput(bytes.NewBuffer(nil)) // Disable panic logs for testing - r := New() - r.Use(Recovery()) - r.GET("/recovery", func(_ *Context) { + buffer := new(bytes.Buffer) + router := New() + router.Use(RecoveryWithWriter(buffer)) + router.GET("/recovery", func(_ *Context) { panic("Oupps, Houston, we have a problem") }) - // RUN - w := PerformRequest(r, "GET", "/recovery") - - // restore logging - log.SetOutput(os.Stderr) - - if w.Code != 500 { - t.Errorf("Response code should be Internal Server Error, was: %s", w.Code) - } + w := performRequest(router, "GET", "/recovery") + // TEST + assert.Equal(t, w.Code, 500) + assert.Contains(t, buffer.String(), "GET /recovery") + assert.Contains(t, buffer.String(), "Oupps, Houston, we have a problem") + assert.Contains(t, buffer.String(), "TestPanicInHandler") } // TestPanicWithAbort assert that panic has been recovered even if context.Abort was used. func TestPanicWithAbort(t *testing.T) { - // SETUP - log.SetOutput(bytes.NewBuffer(nil)) - r := New() - r.Use(Recovery()) - r.GET("/recovery", func(c *Context) { + router := New() + router.Use(RecoveryWithWriter(nil)) + router.GET("/recovery", func(c *Context) { c.AbortWithStatus(400) panic("Oupps, Houston, we have a problem") }) - // RUN - w := PerformRequest(r, "GET", "/recovery") - - // restore logging - log.SetOutput(os.Stderr) - + w := performRequest(router, "GET", "/recovery") // TEST - if w.Code != 500 { - t.Errorf("Response code should be Bad request, was: %s", w.Code) - } + assert.Equal(t, w.Code, 400) } diff --git a/vendor/github.com/gin-gonic/gin/render/data.go b/vendor/github.com/gin-gonic/gin/render/data.go new file mode 100644 index 000000000..c296042c9 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/render/data.go @@ -0,0 +1,23 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package render + +import "net/http" + +type Data struct { + ContentType string + Data []byte +} + +// Render (Data) writes data with custom ContentType +func (r Data) Render(w http.ResponseWriter) (err error) { + r.WriteContentType(w) + _, err = w.Write(r.Data) + return +} + +func (r Data) WriteContentType(w http.ResponseWriter) { + writeContentType(w, []string{r.ContentType}) +} diff --git a/vendor/github.com/gin-gonic/gin/render/html.go b/vendor/github.com/gin-gonic/gin/render/html.go new file mode 100644 index 000000000..cf91219cc --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/render/html.go @@ -0,0 +1,82 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package render + +import ( + "html/template" + "net/http" +) + +type ( + Delims struct { + Left string + Right string + } + + HTMLRender interface { + Instance(string, interface{}) Render + } + + HTMLProduction struct { + Template *template.Template + Delims Delims + } + + HTMLDebug struct { + Files []string + Glob string + Delims Delims + FuncMap template.FuncMap + } + + HTML struct { + Template *template.Template + Name string + Data interface{} + } +) + +var htmlContentType = []string{"text/html; charset=utf-8"} + +func (r HTMLProduction) Instance(name string, data interface{}) Render { + return HTML{ + Template: r.Template, + Name: name, + Data: data, + } +} + +func (r HTMLDebug) Instance(name string, data interface{}) Render { + return HTML{ + Template: r.loadTemplate(), + Name: name, + Data: data, + } +} +func (r HTMLDebug) loadTemplate() *template.Template { + if r.FuncMap == nil { + r.FuncMap = template.FuncMap{} + } + if len(r.Files) > 0 { + return template.Must(template.New("").Delims(r.Delims.Left, r.Delims.Right).Funcs(r.FuncMap).ParseFiles(r.Files...)) + } + if len(r.Glob) > 0 { + return template.Must(template.New("").Delims(r.Delims.Left, r.Delims.Right).Funcs(r.FuncMap).ParseGlob(r.Glob)) + } + panic("the HTML debug render was created without files or glob pattern") +} + +func (r HTML) Render(w http.ResponseWriter) error { + r.WriteContentType(w) + + if len(r.Name) == 0 { + return r.Template.Execute(w, r.Data) + } + return r.Template.ExecuteTemplate(w, r.Name, r.Data) +} + +func (r HTML) WriteContentType(w http.ResponseWriter) { + writeContentType(w, htmlContentType) +} diff --git a/vendor/github.com/gin-gonic/gin/render/json.go b/vendor/github.com/gin-gonic/gin/render/json.go new file mode 100644 index 000000000..3ee8b1326 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/render/json.go @@ -0,0 +1,57 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package render + +import ( + "encoding/json" + "net/http" +) + +type ( + JSON struct { + Data interface{} + } + + IndentedJSON struct { + Data interface{} + } +) + +var jsonContentType = []string{"application/json; charset=utf-8"} + +func (r JSON) Render(w http.ResponseWriter) (err error) { + if err = WriteJSON(w, r.Data); err != nil { + panic(err) + } + return +} + +func (r JSON) WriteContentType(w http.ResponseWriter) { + writeContentType(w, jsonContentType) +} + +func WriteJSON(w http.ResponseWriter, obj interface{}) error { + writeContentType(w, jsonContentType) + jsonBytes, err := json.Marshal(obj) + if err != nil { + return err + } + w.Write(jsonBytes) + return nil +} + +func (r IndentedJSON) Render(w http.ResponseWriter) error { + r.WriteContentType(w) + jsonBytes, err := json.MarshalIndent(r.Data, "", " ") + if err != nil { + return err + } + w.Write(jsonBytes) + return nil +} + +func (r IndentedJSON) WriteContentType(w http.ResponseWriter) { + writeContentType(w, jsonContentType) +} diff --git a/vendor/github.com/gin-gonic/gin/render/msgpack.go b/vendor/github.com/gin-gonic/gin/render/msgpack.go new file mode 100644 index 000000000..e6c13e588 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/render/msgpack.go @@ -0,0 +1,31 @@ +// Copyright 2017 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package render + +import ( + "net/http" + + "github.com/ugorji/go/codec" +) + +type MsgPack struct { + Data interface{} +} + +var msgpackContentType = []string{"application/msgpack; charset=utf-8"} + +func (r MsgPack) WriteContentType(w http.ResponseWriter) { + writeContentType(w, msgpackContentType) +} + +func (r MsgPack) Render(w http.ResponseWriter) error { + return WriteMsgPack(w, r.Data) +} + +func WriteMsgPack(w http.ResponseWriter, obj interface{}) error { + writeContentType(w, msgpackContentType) + var h codec.Handle = new(codec.MsgpackHandle) + return codec.NewEncoder(w, h).Encode(obj) +} diff --git a/vendor/github.com/gin-gonic/gin/render/redirect.go b/vendor/github.com/gin-gonic/gin/render/redirect.go new file mode 100644 index 000000000..f874a3515 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/render/redirect.go @@ -0,0 +1,26 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package render + +import ( + "fmt" + "net/http" +) + +type Redirect struct { + Code int + Request *http.Request + Location string +} + +func (r Redirect) Render(w http.ResponseWriter) error { + if (r.Code < 300 || r.Code > 308) && r.Code != 201 { + panic(fmt.Sprintf("Cannot redirect with status code %d", r.Code)) + } + http.Redirect(w, r.Request, r.Location, r.Code) + return nil +} + +func (r Redirect) WriteContentType(http.ResponseWriter) {} diff --git a/vendor/github.com/gin-gonic/gin/render/render.go b/vendor/github.com/gin-gonic/gin/render/render.go index 467a32993..462914214 100644 --- a/vendor/github.com/gin-gonic/gin/render/render.go +++ b/vendor/github.com/gin-gonic/gin/render/render.go @@ -4,120 +4,31 @@ package render -import ( - "encoding/json" - "encoding/xml" - "fmt" - "html/template" - "net/http" -) - -type ( - Render interface { - Render(http.ResponseWriter, int, ...interface{}) error - } - - // JSON binding - jsonRender struct{} - - // XML binding - xmlRender struct{} - - // Plain text - plainRender struct{} - - // Redirects - redirectRender struct{} - - // Redirects - htmlDebugRender struct { - files []string - globs []string - } +import "net/http" - // form binding - HTMLRender struct { - Template *template.Template - } -) +type Render interface { + Render(http.ResponseWriter) error + WriteContentType(w http.ResponseWriter) +} var ( - JSON = jsonRender{} - XML = xmlRender{} - Plain = plainRender{} - Redirect = redirectRender{} - HTMLDebug = &htmlDebugRender{} + _ Render = JSON{} + _ Render = IndentedJSON{} + _ Render = XML{} + _ Render = String{} + _ Render = Redirect{} + _ Render = Data{} + _ Render = HTML{} + _ HTMLRender = HTMLDebug{} + _ HTMLRender = HTMLProduction{} + _ Render = YAML{} + _ Render = MsgPack{} + _ Render = MsgPack{} ) -func writeHeader(w http.ResponseWriter, code int, contentType string) { - w.Header().Set("Content-Type", contentType+"; charset=utf-8") - w.WriteHeader(code) -} - -func (_ jsonRender) Render(w http.ResponseWriter, code int, data ...interface{}) error { - writeHeader(w, code, "application/json") - encoder := json.NewEncoder(w) - return encoder.Encode(data[0]) -} - -func (_ redirectRender) Render(w http.ResponseWriter, code int, data ...interface{}) error { - w.Header().Set("Location", data[0].(string)) - w.WriteHeader(code) - return nil -} - -func (_ xmlRender) Render(w http.ResponseWriter, code int, data ...interface{}) error { - writeHeader(w, code, "application/xml") - encoder := xml.NewEncoder(w) - return encoder.Encode(data[0]) -} - -func (_ plainRender) Render(w http.ResponseWriter, code int, data ...interface{}) error { - writeHeader(w, code, "text/plain") - format := data[0].(string) - args := data[1].([]interface{}) - var err error - if len(args) > 0 { - _, err = w.Write([]byte(fmt.Sprintf(format, args...))) - } else { - _, err = w.Write([]byte(format)) +func writeContentType(w http.ResponseWriter, value []string) { + header := w.Header() + if val := header["Content-Type"]; len(val) == 0 { + header["Content-Type"] = value } - return err -} - -func (r *htmlDebugRender) AddGlob(pattern string) { - r.globs = append(r.globs, pattern) -} - -func (r *htmlDebugRender) AddFiles(files ...string) { - r.files = append(r.files, files...) -} - -func (r *htmlDebugRender) Render(w http.ResponseWriter, code int, data ...interface{}) error { - writeHeader(w, code, "text/html") - file := data[0].(string) - obj := data[1] - - t := template.New("") - - if len(r.files) > 0 { - if _, err := t.ParseFiles(r.files...); err != nil { - return err - } - } - - for _, glob := range r.globs { - if _, err := t.ParseGlob(glob); err != nil { - return err - } - } - - return t.ExecuteTemplate(w, file, obj) -} - -func (html HTMLRender) Render(w http.ResponseWriter, code int, data ...interface{}) error { - writeHeader(w, code, "text/html") - file := data[0].(string) - obj := data[1] - return html.Template.ExecuteTemplate(w, file, obj) } diff --git a/vendor/github.com/gin-gonic/gin/render/render_test.go b/vendor/github.com/gin-gonic/gin/render/render_test.go new file mode 100644 index 000000000..c48235c3b --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/render/render_test.go @@ -0,0 +1,153 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package render + +import ( + "bytes" + "encoding/xml" + "html/template" + "net/http/httptest" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/ugorji/go/codec" +) + +// TODO unit tests +// test errors + +func TestRenderMsgPack(t *testing.T) { + w := httptest.NewRecorder() + data := map[string]interface{}{ + "foo": "bar", + } + + err := (MsgPack{data}).Render(w) + + assert.NoError(t, err) + + h := new(codec.MsgpackHandle) + assert.NotNil(t, h) + buf := bytes.NewBuffer([]byte{}) + assert.NotNil(t, buf) + err = codec.NewEncoder(buf, h).Encode(data) + + 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") +} + +func TestRenderJSON(t *testing.T) { + w := httptest.NewRecorder() + data := map[string]interface{}{ + "foo": "bar", + } + + err := (JSON{data}).Render(w) + + assert.NoError(t, err) + assert.Equal(t, "{\"foo\":\"bar\"}", w.Body.String()) + assert.Equal(t, "application/json; charset=utf-8", w.Header().Get("Content-Type")) +} + +func TestRenderIndentedJSON(t *testing.T) { + w := httptest.NewRecorder() + data := map[string]interface{}{ + "foo": "bar", + "bar": "foo", + } + + 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") +} + +type xmlmap map[string]interface{} + +// Allows type H to be used with xml.Marshal +func (h xmlmap) MarshalXML(e *xml.Encoder, start xml.StartElement) error { + start.Name = xml.Name{ + Space: "", + Local: "map", + } + if err := e.EncodeToken(start); err != nil { + return err + } + for key, value := range h { + elem := xml.StartElement{ + Name: xml.Name{Space: "", Local: key}, + Attr: []xml.Attr{}, + } + if err := e.EncodeElement(value, elem); err != nil { + return err + } + } + if err := e.EncodeToken(xml.EndElement{Name: start.Name}); err != nil { + return err + } + return nil +} + +func TestRenderXML(t *testing.T) { + w := httptest.NewRecorder() + data := xmlmap{ + "foo": "bar", + } + + err := (XML{data}).Render(w) + + assert.NoError(t, err) + assert.Equal(t, w.Body.String(), "") + assert.Equal(t, w.Header().Get("Content-Type"), "application/xml; charset=utf-8") +} + +func TestRenderRedirect(t *testing.T) { + // TODO +} + +func TestRenderData(t *testing.T) { + w := httptest.NewRecorder() + data := []byte("#!PNG some raw data") + + err := (Data{ + ContentType: "image/png", + Data: data, + }).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") +} + +func TestRenderString(t *testing.T) { + w := httptest.NewRecorder() + + err := (String{ + Format: "hola %s %d", + Data: []interface{}{"manu", 2}, + }).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") +} + +func TestRenderHTMLTemplate(t *testing.T) { + w := httptest.NewRecorder() + templ := template.Must(template.New("t").Parse(`Hello {{.name}}`)) + + htmlRender := HTMLProduction{Template: templ} + instance := htmlRender.Instance("t", map[string]interface{}{ + "name": "alexandernyquist", + }) + + err := instance.Render(w) + + assert.NoError(t, err) + assert.Equal(t, w.Body.String(), "Hello alexandernyquist") + assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8") +} diff --git a/vendor/github.com/gin-gonic/gin/render/text.go b/vendor/github.com/gin-gonic/gin/render/text.go new file mode 100644 index 000000000..74cd26bee --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/render/text.go @@ -0,0 +1,36 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package render + +import ( + "fmt" + "io" + "net/http" +) + +type String struct { + Format string + Data []interface{} +} + +var plainContentType = []string{"text/plain; charset=utf-8"} + +func (r String) Render(w http.ResponseWriter) error { + WriteString(w, r.Format, r.Data) + return nil +} + +func (r String) WriteContentType(w http.ResponseWriter) { + writeContentType(w, plainContentType) +} + +func WriteString(w http.ResponseWriter, format string, data []interface{}) { + writeContentType(w, plainContentType) + if len(data) > 0 { + fmt.Fprintf(w, format, data...) + } else { + io.WriteString(w, format) + } +} diff --git a/vendor/github.com/gin-gonic/gin/render/xml.go b/vendor/github.com/gin-gonic/gin/render/xml.go new file mode 100644 index 000000000..cff1ac3e8 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/render/xml.go @@ -0,0 +1,25 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package render + +import ( + "encoding/xml" + "net/http" +) + +type XML struct { + Data interface{} +} + +var xmlContentType = []string{"application/xml; charset=utf-8"} + +func (r XML) Render(w http.ResponseWriter) error { + r.WriteContentType(w) + return xml.NewEncoder(w).Encode(r.Data) +} + +func (r XML) WriteContentType(w http.ResponseWriter) { + writeContentType(w, xmlContentType) +} diff --git a/vendor/github.com/gin-gonic/gin/render/yaml.go b/vendor/github.com/gin-gonic/gin/render/yaml.go new file mode 100644 index 000000000..25d0ebd47 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/render/yaml.go @@ -0,0 +1,33 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package render + +import ( + "net/http" + + "gopkg.in/yaml.v2" +) + +type YAML struct { + Data interface{} +} + +var yamlContentType = []string{"application/x-yaml; charset=utf-8"} + +func (r YAML) Render(w http.ResponseWriter) error { + r.WriteContentType(w) + + bytes, err := yaml.Marshal(r.Data) + if err != nil { + return err + } + + w.Write(bytes) + return nil +} + +func (r YAML) WriteContentType(w http.ResponseWriter) { + writeContentType(w, yamlContentType) +} diff --git a/vendor/github.com/gin-gonic/gin/response_writer.go b/vendor/github.com/gin-gonic/gin/response_writer.go index 989939581..fcbe230d0 100644 --- a/vendor/github.com/gin-gonic/gin/response_writer.go +++ b/vendor/github.com/gin-gonic/gin/response_writer.go @@ -6,14 +6,14 @@ package gin import ( "bufio" - "errors" - "log" + "io" "net" "net/http" ) const ( - NoWritten = -1 + noWritten = -1 + defaultStatus = 200 ) type ( @@ -23,31 +23,44 @@ type ( http.Flusher http.CloseNotifier + // Returns the HTTP response status code of the current request. Status() int + + // Returns the number of bytes already written into the response http body. + // See Written() Size() int + + // Writes the string into the response body. + WriteString(string) (int, error) + + // Returns true if the response body was already written. Written() bool + + // Forces to write the http header (status code + headers). WriteHeaderNow() } responseWriter struct { http.ResponseWriter - status int size int + status int } ) +var _ ResponseWriter = &responseWriter{} + func (w *responseWriter) reset(writer http.ResponseWriter) { w.ResponseWriter = writer - w.status = 200 - w.size = NoWritten + w.size = noWritten + w.status = defaultStatus } func (w *responseWriter) WriteHeader(code int) { - if code > 0 { - w.status = code + if code > 0 && w.status != code { if w.Written() { - log.Println("[GIN] WARNING. Headers were already written!") + debugPrint("[WARNING] Headers were already written. Wanted to override status code %d with %d", w.status, code) } + w.status = code } } @@ -65,6 +78,13 @@ func (w *responseWriter) Write(data []byte) (n int, err error) { return } +func (w *responseWriter) WriteString(s string) (n int, err error) { + w.WriteHeaderNow() + n, err = io.WriteString(w.ResponseWriter, s) + w.size += n + return +} + func (w *responseWriter) Status() int { return w.status } @@ -74,16 +94,15 @@ func (w *responseWriter) Size() int { } func (w *responseWriter) Written() bool { - return w.size != NoWritten + return w.size != noWritten } // Implements the http.Hijacker interface func (w *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) { - hijacker, ok := w.ResponseWriter.(http.Hijacker) - if !ok { - return nil, nil, errors.New("the ResponseWriter doesn't support the Hijacker interface") + if w.size < 0 { + w.size = 0 } - return hijacker.Hijack() + return w.ResponseWriter.(http.Hijacker).Hijack() } // Implements the http.CloseNotify interface @@ -93,8 +112,5 @@ func (w *responseWriter) CloseNotify() <-chan bool { // Implements the http.Flush interface func (w *responseWriter) Flush() { - flusher, ok := w.ResponseWriter.(http.Flusher) - if ok { - flusher.Flush() - } + w.ResponseWriter.(http.Flusher).Flush() } diff --git a/vendor/github.com/gin-gonic/gin/response_writer_test.go b/vendor/github.com/gin-gonic/gin/response_writer_test.go new file mode 100644 index 000000000..7306d1925 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/response_writer_test.go @@ -0,0 +1,115 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package gin + +import ( + "net/http" + "net/http/httptest" + "testing" + + "github.com/stretchr/testify/assert" +) + +// TODO +// func (w *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) { +// func (w *responseWriter) CloseNotify() <-chan bool { +// func (w *responseWriter) Flush() { + +var _ ResponseWriter = &responseWriter{} +var _ http.ResponseWriter = &responseWriter{} +var _ http.ResponseWriter = ResponseWriter(&responseWriter{}) +var _ http.Hijacker = ResponseWriter(&responseWriter{}) +var _ http.Flusher = ResponseWriter(&responseWriter{}) +var _ http.CloseNotifier = ResponseWriter(&responseWriter{}) + +func init() { + SetMode(TestMode) +} + +func TestResponseWriterReset(t *testing.T) { + testWritter := httptest.NewRecorder() + writer := &responseWriter{} + var w ResponseWriter = writer + + writer.reset(testWritter) + assert.Equal(t, writer.size, -1) + assert.Equal(t, writer.status, 200) + assert.Equal(t, writer.ResponseWriter, testWritter) + assert.Equal(t, w.Size(), -1) + assert.Equal(t, w.Status(), 200) + assert.False(t, w.Written()) +} + +func TestResponseWriterWriteHeader(t *testing.T) { + testWritter := httptest.NewRecorder() + writer := &responseWriter{} + writer.reset(testWritter) + w := ResponseWriter(writer) + + w.WriteHeader(300) + assert.False(t, w.Written()) + assert.Equal(t, w.Status(), 300) + assert.NotEqual(t, testWritter.Code, 300) + + w.WriteHeader(-1) + assert.Equal(t, w.Status(), 300) +} + +func TestResponseWriterWriteHeadersNow(t *testing.T) { + testWritter := httptest.NewRecorder() + writer := &responseWriter{} + writer.reset(testWritter) + w := ResponseWriter(writer) + + w.WriteHeader(300) + w.WriteHeaderNow() + + assert.True(t, w.Written()) + assert.Equal(t, w.Size(), 0) + assert.Equal(t, testWritter.Code, 300) + + writer.size = 10 + w.WriteHeaderNow() + assert.Equal(t, w.Size(), 10) +} + +func TestResponseWriterWrite(t *testing.T) { + testWritter := httptest.NewRecorder() + writer := &responseWriter{} + writer.reset(testWritter) + w := ResponseWriter(writer) + + n, err := w.Write([]byte("hola")) + assert.Equal(t, n, 4) + assert.Equal(t, w.Size(), 4) + assert.Equal(t, w.Status(), 200) + assert.Equal(t, testWritter.Code, 200) + assert.Equal(t, testWritter.Body.String(), "hola") + assert.NoError(t, err) + + n, err = w.Write([]byte(" adios")) + assert.Equal(t, n, 6) + assert.Equal(t, w.Size(), 10) + assert.Equal(t, testWritter.Body.String(), "hola adios") + assert.NoError(t, err) +} + +func TestResponseWriterHijack(t *testing.T) { + testWritter := httptest.NewRecorder() + writer := &responseWriter{} + writer.reset(testWritter) + w := ResponseWriter(writer) + + assert.Panics(t, func() { + w.Hijack() + }) + assert.True(t, w.Written()) + + assert.Panics(t, func() { + w.CloseNotify() + }) + + w.Flush() +} diff --git a/vendor/github.com/gin-gonic/gin/routergroup.go b/vendor/github.com/gin-gonic/gin/routergroup.go index 8e02a402b..f22729bbd 100644 --- a/vendor/github.com/gin-gonic/gin/routergroup.go +++ b/vendor/github.com/gin-gonic/gin/routergroup.go @@ -5,36 +5,77 @@ package gin import ( - "github.com/julienschmidt/httprouter" "net/http" "path" + "regexp" + "strings" ) -// Used internally to configure router, a RouterGroup is associated with a prefix -// and an array of handlers (middlewares) -type RouterGroup struct { - Handlers []HandlerFunc - absolutePath string - engine *Engine -} +type ( + IRouter interface { + IRoutes + Group(string, ...HandlerFunc) *RouterGroup + } + + IRoutes interface { + Use(...HandlerFunc) IRoutes + + Handle(string, string, ...HandlerFunc) IRoutes + Any(string, ...HandlerFunc) IRoutes + GET(string, ...HandlerFunc) IRoutes + POST(string, ...HandlerFunc) IRoutes + DELETE(string, ...HandlerFunc) IRoutes + PATCH(string, ...HandlerFunc) IRoutes + PUT(string, ...HandlerFunc) IRoutes + OPTIONS(string, ...HandlerFunc) IRoutes + HEAD(string, ...HandlerFunc) IRoutes + + StaticFile(string, string) IRoutes + Static(string, string) IRoutes + StaticFS(string, http.FileSystem) IRoutes + } + + // RouterGroup is used internally to configure router, a RouterGroup is associated with a prefix + // and an array of handlers (middleware) + RouterGroup struct { + Handlers HandlersChain + basePath string + engine *Engine + root bool + } +) + +var _ IRouter = &RouterGroup{} -// Adds middlewares to the group, see example code in github. -func (group *RouterGroup) Use(middlewares ...HandlerFunc) { - group.Handlers = append(group.Handlers, middlewares...) +// 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() } -// Creates a new router group. You should add all the routes that have common middlwares or the same path prefix. +// Group creates a new router group. You should add all the routes that have common middlwares or the same path prefix. // For example, all the routes that use a common middlware for authorization could be grouped. func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup { return &RouterGroup{ - Handlers: group.combineHandlers(handlers), - absolutePath: group.calculateAbsolutePath(relativePath), - engine: group.engine, + Handlers: group.combineHandlers(handlers), + basePath: group.calculateAbsolutePath(relativePath), + engine: group.engine, } } -// Handle registers a new request handle and middlewares with the given path and method. -// The last handler should be the real handler, the other ones should be middlewares that can and should be shared among different routes. +func (group *RouterGroup) BasePath() string { + return group.basePath +} + +func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) IRoutes { + absolutePath := group.calculateAbsolutePath(relativePath) + handlers = group.combineHandlers(handlers) + group.engine.addRoute(httpMethod, absolutePath, handlers) + return group.returnObj() +} + +// 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. // // For GET, POST, PUT, PATCH and DELETE requests the respective shortcut @@ -43,66 +84,75 @@ func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *R // This function is intended for bulk loading and to allow the usage of less // frequently used, non-standardized or custom methods (e.g. for internal // communication with a proxy). -func (group *RouterGroup) Handle(httpMethod, relativePath string, handlers []HandlerFunc) { - absolutePath := group.calculateAbsolutePath(relativePath) - handlers = group.combineHandlers(handlers) - if IsDebugging() { - nuHandlers := len(handlers) - handlerName := nameOfFunction(handlers[nuHandlers-1]) - debugPrint("%-5s %-25s --> %s (%d handlers)\n", httpMethod, absolutePath, handlerName, nuHandlers) +func (group *RouterGroup) Handle(httpMethod, relativePath string, handlers ...HandlerFunc) IRoutes { + if matches, err := regexp.MatchString("^[A-Z]+$", httpMethod); !matches || err != nil { + panic("http method " + httpMethod + " is not valid") } - - group.engine.router.Handle(httpMethod, absolutePath, func(w http.ResponseWriter, req *http.Request, params httprouter.Params) { - context := group.engine.createContext(w, req, params, handlers) - context.Next() - context.Writer.WriteHeaderNow() - group.engine.reuseContext(context) - }) + return group.handle(httpMethod, relativePath, handlers) } // POST is a shortcut for router.Handle("POST", path, handle) -func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) { - group.Handle("POST", relativePath, handlers) +func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes { + return group.handle("POST", relativePath, handlers) } // GET is a shortcut for router.Handle("GET", path, handle) -func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) { - group.Handle("GET", relativePath, handlers) +func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes { + return group.handle("GET", relativePath, handlers) } // DELETE is a shortcut for router.Handle("DELETE", path, handle) -func (group *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) { - group.Handle("DELETE", relativePath, handlers) +func (group *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) IRoutes { + return group.handle("DELETE", relativePath, handlers) } // PATCH is a shortcut for router.Handle("PATCH", path, handle) -func (group *RouterGroup) PATCH(relativePath string, handlers ...HandlerFunc) { - group.Handle("PATCH", relativePath, handlers) +func (group *RouterGroup) PATCH(relativePath string, handlers ...HandlerFunc) IRoutes { + return group.handle("PATCH", relativePath, handlers) } // PUT is a shortcut for router.Handle("PUT", path, handle) -func (group *RouterGroup) PUT(relativePath string, handlers ...HandlerFunc) { - group.Handle("PUT", relativePath, handlers) +func (group *RouterGroup) PUT(relativePath string, handlers ...HandlerFunc) IRoutes { + return group.handle("PUT", relativePath, handlers) } // OPTIONS is a shortcut for router.Handle("OPTIONS", path, handle) -func (group *RouterGroup) OPTIONS(relativePath string, handlers ...HandlerFunc) { - group.Handle("OPTIONS", relativePath, handlers) +func (group *RouterGroup) OPTIONS(relativePath string, handlers ...HandlerFunc) IRoutes { + return group.handle("OPTIONS", relativePath, handlers) } // HEAD is a shortcut for router.Handle("HEAD", path, handle) -func (group *RouterGroup) HEAD(relativePath string, handlers ...HandlerFunc) { - group.Handle("HEAD", relativePath, handlers) -} - -// LINK is a shortcut for router.Handle("LINK", path, handle) -func (group *RouterGroup) LINK(relativePath string, handlers ...HandlerFunc) { - group.Handle("LINK", relativePath, handlers) -} - -// UNLINK is a shortcut for router.Handle("UNLINK", path, handle) -func (group *RouterGroup) UNLINK(relativePath string, handlers ...HandlerFunc) { - group.Handle("UNLINK", relativePath, handlers) +func (group *RouterGroup) HEAD(relativePath string, handlers ...HandlerFunc) IRoutes { + return group.handle("HEAD", relativePath, handlers) +} + +// Any registers a route that matches all the HTTP methods. +// GET, POST, PUT, PATCH, HEAD, OPTIONS, DELETE, CONNECT, TRACE +func (group *RouterGroup) Any(relativePath string, handlers ...HandlerFunc) IRoutes { + group.handle("GET", relativePath, handlers) + group.handle("POST", relativePath, handlers) + group.handle("PUT", relativePath, handlers) + group.handle("PATCH", relativePath, handlers) + group.handle("HEAD", relativePath, handlers) + group.handle("OPTIONS", relativePath, handlers) + group.handle("DELETE", relativePath, handlers) + group.handle("CONNECT", relativePath, handlers) + group.handle("TRACE", relativePath, handlers) + return group.returnObj() +} + +// StaticFile registers a single route in order to server a single file of the local filesystem. +// router.StaticFile("favicon.ico", "./resources/favicon.ico") +func (group *RouterGroup) StaticFile(relativePath, filepath string) IRoutes { + if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") { + panic("URL parameters can not be used when serving a static file") + } + handler := func(c *Context) { + c.File(filepath) + } + group.GET(relativePath, handler) + group.HEAD(relativePath, handler) + return group.returnObj() } // Static serves files from the given file system root. @@ -111,38 +161,55 @@ func (group *RouterGroup) UNLINK(relativePath string, handlers ...HandlerFunc) { // To use the operating system's file system implementation, // use : // router.Static("/static", "/var/www") -func (group *RouterGroup) Static(relativePath, root string) { - absolutePath := group.calculateAbsolutePath(relativePath) - handler := group.createStaticHandler(absolutePath, root) - absolutePath = path.Join(absolutePath, "/*filepath") +func (group *RouterGroup) Static(relativePath, root string) IRoutes { + return group.StaticFS(relativePath, Dir(root, false)) +} + +// StaticFS works just like `Static()` but a custom `http.FileSystem` can be used instead. +// Gin by default user: gin.Dir() +func (group *RouterGroup) StaticFS(relativePath string, fs http.FileSystem) IRoutes { + if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") { + panic("URL parameters can not be used when serving a static folder") + } + handler := group.createStaticHandler(relativePath, fs) + urlPattern := path.Join(relativePath, "/*filepath") // Register GET and HEAD handlers - group.GET(absolutePath, handler) - group.HEAD(absolutePath, handler) + group.GET(urlPattern, handler) + group.HEAD(urlPattern, handler) + return group.returnObj() } -func (group *RouterGroup) createStaticHandler(absolutePath, root string) func(*Context) { - fileServer := http.StripPrefix(absolutePath, http.FileServer(http.Dir(root))) +func (group *RouterGroup) createStaticHandler(relativePath string, fs http.FileSystem) HandlerFunc { + absolutePath := group.calculateAbsolutePath(relativePath) + fileServer := http.StripPrefix(absolutePath, http.FileServer(fs)) + _, nolisting := fs.(*onlyfilesFS) return func(c *Context) { + if nolisting { + c.Writer.WriteHeader(404) + } fileServer.ServeHTTP(c.Writer, c.Request) } } -func (group *RouterGroup) combineHandlers(handlers []HandlerFunc) []HandlerFunc { +func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain { finalSize := len(group.Handlers) + len(handlers) - mergedHandlers := make([]HandlerFunc, 0, finalSize) - mergedHandlers = append(mergedHandlers, group.Handlers...) - return append(mergedHandlers, handlers...) + if finalSize >= int(abortIndex) { + panic("too many handlers") + } + mergedHandlers := make(HandlersChain, finalSize) + copy(mergedHandlers, group.Handlers) + copy(mergedHandlers[len(group.Handlers):], handlers) + return mergedHandlers } func (group *RouterGroup) calculateAbsolutePath(relativePath string) string { - if len(relativePath) == 0 { - return group.absolutePath - } - absolutePath := path.Join(group.absolutePath, relativePath) - appendSlash := lastChar(relativePath) == '/' && lastChar(absolutePath) != '/' - if appendSlash { - return absolutePath + "/" + return joinPaths(group.basePath, relativePath) +} + +func (group *RouterGroup) returnObj() IRoutes { + if group.root { + return group.engine } - return absolutePath + return group } diff --git a/vendor/github.com/gin-gonic/gin/routergroup_test.go b/vendor/github.com/gin-gonic/gin/routergroup_test.go new file mode 100644 index 000000000..b0589b52e --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/routergroup_test.go @@ -0,0 +1,177 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package gin + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func init() { + SetMode(TestMode) +} + +func TestRouterGroupBasic(t *testing.T) { + router := New() + group := router.Group("/hola", func(c *Context) {}) + group.Use(func(c *Context) {}) + + assert.Len(t, group.Handlers, 2) + assert.Equal(t, group.BasePath(), "/hola") + assert.Equal(t, group.engine, router) + + group2 := group.Group("manu") + group2.Use(func(c *Context) {}, func(c *Context) {}) + + assert.Len(t, group2.Handlers, 4) + assert.Equal(t, group2.BasePath(), "/hola/manu") + assert.Equal(t, group2.engine, router) +} + +func TestRouterGroupBasicHandle(t *testing.T) { + performRequestInGroup(t, "GET") + performRequestInGroup(t, "POST") + performRequestInGroup(t, "PUT") + performRequestInGroup(t, "PATCH") + performRequestInGroup(t, "DELETE") + performRequestInGroup(t, "HEAD") + performRequestInGroup(t, "OPTIONS") +} + +func performRequestInGroup(t *testing.T, method string) { + router := New() + v1 := router.Group("v1", func(c *Context) {}) + assert.Equal(t, v1.BasePath(), "/v1") + + login := v1.Group("/login/", func(c *Context) {}, func(c *Context) {}) + assert.Equal(t, login.BasePath(), "/v1/login/") + + handler := func(c *Context) { + c.String(400, "the method was %s and index %d", c.Request.Method, c.index) + } + + switch method { + case "GET": + v1.GET("/test", handler) + login.GET("/test", handler) + case "POST": + v1.POST("/test", handler) + login.POST("/test", handler) + case "PUT": + v1.PUT("/test", handler) + login.PUT("/test", handler) + case "PATCH": + v1.PATCH("/test", handler) + login.PATCH("/test", handler) + case "DELETE": + v1.DELETE("/test", handler) + login.DELETE("/test", handler) + case "HEAD": + v1.HEAD("/test", handler) + login.HEAD("/test", handler) + case "OPTIONS": + v1.OPTIONS("/test", handler) + login.OPTIONS("/test", handler) + default: + panic("unknown method") + } + + w := performRequest(router, method, "/v1/login/test") + assert.Equal(t, w.Code, 400) + assert.Equal(t, w.Body.String(), "the method was "+method+" and index 3") + + w = performRequest(router, method, "/v1/test") + assert.Equal(t, w.Code, 400) + assert.Equal(t, w.Body.String(), "the method was "+method+" and index 1") +} + +func TestRouterGroupInvalidStatic(t *testing.T) { + router := New() + assert.Panics(t, func() { + router.Static("/path/:param", "/") + }) + + assert.Panics(t, func() { + router.Static("/path/*param", "/") + }) +} + +func TestRouterGroupInvalidStaticFile(t *testing.T) { + router := New() + assert.Panics(t, func() { + router.StaticFile("/path/:param", "favicon.ico") + }) + + assert.Panics(t, func() { + router.StaticFile("/path/*param", "favicon.ico") + }) +} + +func TestRouterGroupTooManyHandlers(t *testing.T) { + router := New() + handlers1 := make([]HandlerFunc, 40) + router.Use(handlers1...) + + handlers2 := make([]HandlerFunc, 26) + assert.Panics(t, func() { + router.Use(handlers2...) + }) + assert.Panics(t, func() { + router.GET("/", handlers2...) + }) +} + +func TestRouterGroupBadMethod(t *testing.T) { + router := New() + assert.Panics(t, func() { + router.Handle("get", "/") + }) + assert.Panics(t, func() { + router.Handle(" GET", "/") + }) + assert.Panics(t, func() { + router.Handle("GET ", "/") + }) + assert.Panics(t, func() { + router.Handle("", "/") + }) + assert.Panics(t, func() { + router.Handle("PO ST", "/") + }) + assert.Panics(t, func() { + router.Handle("1GET", "/") + }) + assert.Panics(t, func() { + router.Handle("PATCh", "/") + }) +} + +func TestRouterGroupPipeline(t *testing.T) { + router := New() + testRoutesInterface(t, router) + + v1 := router.Group("/v1") + testRoutesInterface(t, v1) +} + +func testRoutesInterface(t *testing.T, r IRoutes) { + handler := func(c *Context) {} + assert.Equal(t, r, r.Use(handler)) + + assert.Equal(t, r, r.Handle("GET", "/handler", handler)) + assert.Equal(t, r, r.Any("/any", handler)) + assert.Equal(t, r, r.GET("/", handler)) + assert.Equal(t, r, r.POST("/", handler)) + assert.Equal(t, r, r.DELETE("/", handler)) + assert.Equal(t, r, r.PATCH("/", handler)) + assert.Equal(t, r, r.PUT("/", handler)) + assert.Equal(t, r, r.OPTIONS("/", handler)) + assert.Equal(t, r, r.HEAD("/", handler)) + + assert.Equal(t, r, r.StaticFile("/file", ".")) + assert.Equal(t, r, r.Static("/static", ".")) + assert.Equal(t, r, r.StaticFS("/static2", Dir(".", false))) +} diff --git a/vendor/github.com/gin-gonic/gin/routes_test.go b/vendor/github.com/gin-gonic/gin/routes_test.go new file mode 100644 index 000000000..7464d5d0f --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/routes_test.go @@ -0,0 +1,441 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package gin + +import ( + "fmt" + "io/ioutil" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/assert" +) + +func performRequest(r http.Handler, method, path string) *httptest.ResponseRecorder { + req, _ := http.NewRequest(method, path, nil) + w := httptest.NewRecorder() + r.ServeHTTP(w, req) + return w +} + +func testRouteOK(method string, t *testing.T) { + passed := false + passedAny := false + r := New() + r.Any("/test2", func(c *Context) { + passedAny = true + }) + r.Handle(method, "/test", func(c *Context) { + passed = true + }) + + w := performRequest(r, method, "/test") + assert.True(t, passed) + assert.Equal(t, w.Code, http.StatusOK) + + performRequest(r, method, "/test2") + assert.True(t, passedAny) +} + +// TestSingleRouteOK tests that POST route is correctly invoked. +func testRouteNotOK(method string, t *testing.T) { + passed := false + router := New() + router.Handle(method, "/test_2", func(c *Context) { + passed = true + }) + + w := performRequest(router, method, "/test") + + assert.False(t, passed) + assert.Equal(t, w.Code, http.StatusNotFound) +} + +// TestSingleRouteOK tests that POST route is correctly invoked. +func testRouteNotOK2(method string, t *testing.T) { + passed := false + router := New() + router.HandleMethodNotAllowed = true + var methodRoute string + if method == "POST" { + methodRoute = "GET" + } else { + methodRoute = "POST" + } + router.Handle(methodRoute, "/test", func(c *Context) { + passed = true + }) + + w := performRequest(router, method, "/test") + + assert.False(t, passed) + assert.Equal(t, w.Code, http.StatusMethodNotAllowed) +} + +func TestRouterMethod(t *testing.T) { + router := New() + router.PUT("/hey2", func(c *Context) { + c.String(200, "sup2") + }) + + router.PUT("/hey", func(c *Context) { + c.String(200, "called") + }) + + router.PUT("/hey3", func(c *Context) { + c.String(200, "sup3") + }) + + w := performRequest(router, "PUT", "/hey") + + assert.Equal(t, w.Code, 200) + assert.Equal(t, w.Body.String(), "called") +} + +func TestRouterGroupRouteOK(t *testing.T) { + testRouteOK("GET", t) + testRouteOK("POST", t) + testRouteOK("PUT", t) + testRouteOK("PATCH", t) + testRouteOK("HEAD", t) + testRouteOK("OPTIONS", t) + testRouteOK("DELETE", t) + testRouteOK("CONNECT", t) + testRouteOK("TRACE", t) +} + +func TestRouteNotOK(t *testing.T) { + testRouteNotOK("GET", t) + testRouteNotOK("POST", t) + testRouteNotOK("PUT", t) + testRouteNotOK("PATCH", t) + testRouteNotOK("HEAD", t) + testRouteNotOK("OPTIONS", t) + testRouteNotOK("DELETE", t) + testRouteNotOK("CONNECT", t) + testRouteNotOK("TRACE", t) +} + +func TestRouteNotOK2(t *testing.T) { + testRouteNotOK2("GET", t) + testRouteNotOK2("POST", t) + testRouteNotOK2("PUT", t) + testRouteNotOK2("PATCH", t) + testRouteNotOK2("HEAD", t) + testRouteNotOK2("OPTIONS", t) + testRouteNotOK2("DELETE", t) + testRouteNotOK2("CONNECT", t) + testRouteNotOK2("TRACE", t) +} + +func TestRouteRedirectTrailingSlash(t *testing.T) { + router := New() + router.RedirectFixedPath = false + router.RedirectTrailingSlash = true + router.GET("/path", func(c *Context) {}) + router.GET("/path2/", func(c *Context) {}) + router.POST("/path3", func(c *Context) {}) + router.PUT("/path4/", func(c *Context) {}) + + w := performRequest(router, "GET", "/path/") + assert.Equal(t, w.Header().Get("Location"), "/path") + assert.Equal(t, w.Code, 301) + + w = performRequest(router, "GET", "/path2") + assert.Equal(t, w.Header().Get("Location"), "/path2/") + assert.Equal(t, w.Code, 301) + + w = performRequest(router, "POST", "/path3/") + assert.Equal(t, w.Header().Get("Location"), "/path3") + assert.Equal(t, w.Code, 307) + + w = performRequest(router, "PUT", "/path4") + assert.Equal(t, w.Header().Get("Location"), "/path4/") + assert.Equal(t, w.Code, 307) + + w = performRequest(router, "GET", "/path") + assert.Equal(t, w.Code, 200) + + w = performRequest(router, "GET", "/path2/") + assert.Equal(t, w.Code, 200) + + w = performRequest(router, "POST", "/path3") + assert.Equal(t, w.Code, 200) + + w = performRequest(router, "PUT", "/path4/") + assert.Equal(t, w.Code, 200) + + router.RedirectTrailingSlash = false + + w = performRequest(router, "GET", "/path/") + assert.Equal(t, w.Code, 404) + w = performRequest(router, "GET", "/path2") + assert.Equal(t, w.Code, 404) + w = performRequest(router, "POST", "/path3/") + assert.Equal(t, w.Code, 404) + w = performRequest(router, "PUT", "/path4") + assert.Equal(t, w.Code, 404) +} + +func TestRouteRedirectFixedPath(t *testing.T) { + router := New() + router.RedirectFixedPath = true + router.RedirectTrailingSlash = false + + router.GET("/path", func(c *Context) {}) + router.GET("/Path2", func(c *Context) {}) + router.POST("/PATH3", func(c *Context) {}) + router.POST("/Path4/", func(c *Context) {}) + + w := performRequest(router, "GET", "/PATH") + assert.Equal(t, w.Header().Get("Location"), "/path") + assert.Equal(t, w.Code, 301) + + w = performRequest(router, "GET", "/path2") + assert.Equal(t, w.Header().Get("Location"), "/Path2") + assert.Equal(t, w.Code, 301) + + w = performRequest(router, "POST", "/path3") + assert.Equal(t, w.Header().Get("Location"), "/PATH3") + assert.Equal(t, w.Code, 307) + + w = performRequest(router, "POST", "/path4") + assert.Equal(t, w.Header().Get("Location"), "/Path4/") + assert.Equal(t, w.Code, 307) +} + +// TestContextParamsGet tests that a parameter can be parsed from the URL. +func TestRouteParamsByName(t *testing.T) { + name := "" + lastName := "" + wild := "" + router := New() + router.GET("/test/:name/:last_name/*wild", func(c *Context) { + name = c.Params.ByName("name") + lastName = c.Params.ByName("last_name") + var ok bool + wild, ok = c.Params.Get("wild") + + assert.True(t, ok) + assert.Equal(t, name, c.Param("name")) + assert.Equal(t, name, c.Param("name")) + assert.Equal(t, lastName, c.Param("last_name")) + + assert.Empty(t, c.Param("wtf")) + assert.Empty(t, c.Params.ByName("wtf")) + + wtf, ok := c.Params.Get("wtf") + assert.Empty(t, wtf) + assert.False(t, ok) + }) + + w := performRequest(router, "GET", "/test/john/smith/is/super/great") + + assert.Equal(t, w.Code, 200) + assert.Equal(t, name, "john") + assert.Equal(t, lastName, "smith") + assert.Equal(t, wild, "/is/super/great") +} + +// TestHandleStaticFile - ensure the static file handles properly +func TestRouteStaticFile(t *testing.T) { + // SETUP file + testRoot, _ := os.Getwd() + f, err := ioutil.TempFile(testRoot, "") + if err != nil { + t.Error(err) + } + defer os.Remove(f.Name()) + f.WriteString("Gin Web Framework") + f.Close() + + dir, filename := filepath.Split(f.Name()) + + // SETUP gin + router := New() + router.Static("/using_static", dir) + router.StaticFile("/result", f.Name()) + + w := performRequest(router, "GET", "/using_static/"+filename) + w2 := performRequest(router, "GET", "/result") + + assert.Equal(t, w, w2) + assert.Equal(t, w.Code, 200) + assert.Equal(t, w.Body.String(), "Gin Web Framework") + assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8") + + w3 := performRequest(router, "HEAD", "/using_static/"+filename) + w4 := performRequest(router, "HEAD", "/result") + + assert.Equal(t, w3, w4) + assert.Equal(t, w3.Code, 200) +} + +// TestHandleStaticDir - ensure the root/sub dir handles properly +func TestRouteStaticListingDir(t *testing.T) { + router := New() + router.StaticFS("/", Dir("./", true)) + + w := performRequest(router, "GET", "/") + + assert.Equal(t, w.Code, 200) + assert.Contains(t, w.Body.String(), "gin.go") + assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/html; charset=utf-8") +} + +// TestHandleHeadToDir - ensure the root/sub dir handles properly +func TestRouteStaticNoListing(t *testing.T) { + router := New() + router.Static("/", "./") + + w := performRequest(router, "GET", "/") + + assert.Equal(t, w.Code, 404) + assert.NotContains(t, w.Body.String(), "gin.go") +} + +func TestRouterMiddlewareAndStatic(t *testing.T) { + router := New() + static := router.Group("/", func(c *Context) { + c.Writer.Header().Add("Last-Modified", "Mon, 02 Jan 2006 15:04:05 MST") + c.Writer.Header().Add("Expires", "Mon, 02 Jan 2006 15:04:05 MST") + c.Writer.Header().Add("X-GIN", "Gin Framework") + }) + static.Static("/", "./") + + w := performRequest(router, "GET", "/gin.go") + + assert.Equal(t, w.Code, 200) + assert.Contains(t, w.Body.String(), "package gin") + assert.Equal(t, w.HeaderMap.Get("Content-Type"), "text/plain; charset=utf-8") + assert.NotEqual(t, w.HeaderMap.Get("Last-Modified"), "Mon, 02 Jan 2006 15:04:05 MST") + assert.Equal(t, w.HeaderMap.Get("Expires"), "Mon, 02 Jan 2006 15:04:05 MST") + assert.Equal(t, w.HeaderMap.Get("x-GIN"), "Gin Framework") +} + +func TestRouteNotAllowedEnabled(t *testing.T) { + router := New() + router.HandleMethodNotAllowed = true + router.POST("/path", func(c *Context) {}) + w := performRequest(router, "GET", "/path") + assert.Equal(t, w.Code, http.StatusMethodNotAllowed) + + router.NoMethod(func(c *Context) { + c.String(http.StatusTeapot, "responseText") + }) + w = performRequest(router, "GET", "/path") + assert.Equal(t, w.Body.String(), "responseText") + assert.Equal(t, w.Code, http.StatusTeapot) +} + +func TestRouteNotAllowedDisabled(t *testing.T) { + router := New() + router.HandleMethodNotAllowed = false + router.POST("/path", func(c *Context) {}) + w := performRequest(router, "GET", "/path") + assert.Equal(t, w.Code, 404) + + router.NoMethod(func(c *Context) { + c.String(http.StatusTeapot, "responseText") + }) + w = performRequest(router, "GET", "/path") + assert.Equal(t, w.Body.String(), "404 page not found") + assert.Equal(t, w.Code, 404) +} + +func TestRouterNotFound(t *testing.T) { + router := New() + router.RedirectFixedPath = true + router.GET("/path", func(c *Context) {}) + router.GET("/dir/", func(c *Context) {}) + router.GET("/", func(c *Context) {}) + + testRoutes := []struct { + route string + code int + header string + }{ + {"/path/", 301, "map[Location:[/path]]"}, // TSR -/ + {"/dir", 301, "map[Location:[/dir/]]"}, // TSR +/ + {"", 301, "map[Location:[/]]"}, // TSR +/ + {"/PATH", 301, "map[Location:[/path]]"}, // Fixed Case + {"/DIR/", 301, "map[Location:[/dir/]]"}, // Fixed Case + {"/PATH/", 301, "map[Location:[/path]]"}, // Fixed Case -/ + {"/DIR", 301, "map[Location:[/dir/]]"}, // Fixed Case +/ + {"/../path", 301, "map[Location:[/path]]"}, // CleanPath + {"/nope", 404, ""}, // NotFound + } + for _, tr := range testRoutes { + w := performRequest(router, "GET", tr.route) + assert.Equal(t, w.Code, tr.code) + if w.Code != 404 { + assert.Equal(t, fmt.Sprint(w.Header()), tr.header) + } + } + + // Test custom not found handler + var notFound bool + router.NoRoute(func(c *Context) { + c.AbortWithStatus(404) + notFound = true + }) + w := performRequest(router, "GET", "/nope") + assert.Equal(t, w.Code, 404) + assert.True(t, notFound) + + // Test other method than GET (want 307 instead of 301) + router.PATCH("/path", func(c *Context) {}) + w = performRequest(router, "PATCH", "/path/") + assert.Equal(t, w.Code, 307) + assert.Equal(t, fmt.Sprint(w.Header()), "map[Location:[/path]]") + + // Test special case where no node for the prefix "/" exists + router = New() + router.GET("/a", func(c *Context) {}) + w = performRequest(router, "GET", "/") + assert.Equal(t, w.Code, 404) +} + +func TestRouteRawPath(t *testing.T) { + route := New() + route.UseRawPath = true + + route.POST("/project/:name/build/:num", func(c *Context) { + name := c.Params.ByName("name") + num := c.Params.ByName("num") + + assert.Equal(t, c.Param("name"), name) + assert.Equal(t, c.Param("num"), num) + + assert.Equal(t, "Some/Other/Project", name) + assert.Equal(t, "222", num) + }) + + w := performRequest(route, "POST", "/project/Some%2FOther%2FProject/build/222") + assert.Equal(t, w.Code, 200) +} + +func TestRouteRawPathNoUnescape(t *testing.T) { + route := New() + route.UseRawPath = true + route.UnescapePathValues = false + + route.POST("/project/:name/build/:num", func(c *Context) { + name := c.Params.ByName("name") + num := c.Params.ByName("num") + + assert.Equal(t, c.Param("name"), name) + assert.Equal(t, c.Param("num"), num) + + assert.Equal(t, "Some%2FOther%2FProject", name) + assert.Equal(t, "333", num) + }) + + w := performRequest(route, "POST", "/project/Some%2FOther%2FProject/build/333") + assert.Equal(t, w.Code, 200) +} diff --git a/vendor/github.com/gin-gonic/gin/test_helpers.go b/vendor/github.com/gin-gonic/gin/test_helpers.go new file mode 100644 index 000000000..e7dd55f77 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/test_helpers.go @@ -0,0 +1,17 @@ +// Copyright 2017 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package gin + +import ( + "net/http" +) + +func CreateTestContext(w http.ResponseWriter) (c *Context, r *Engine) { + r = New() + c = r.allocateContext() + c.reset() + c.writermem.reset(w) + return +} diff --git a/vendor/github.com/julienschmidt/httprouter/tree.go b/vendor/github.com/gin-gonic/gin/tree.go similarity index 79% rename from vendor/github.com/julienschmidt/httprouter/tree.go rename to vendor/github.com/gin-gonic/gin/tree.go index a15bc2cbc..a39f43bf2 100644 --- a/vendor/github.com/julienschmidt/httprouter/tree.go +++ b/vendor/github.com/gin-gonic/gin/tree.go @@ -1,14 +1,60 @@ // Copyright 2013 Julien Schmidt. All rights reserved. // Use of this source code is governed by a BSD-style license that can be found -// in the LICENSE file. +// at https://github.com/julienschmidt/httprouter/blob/master/LICENSE -package httprouter +package gin import ( + "net/url" "strings" "unicode" ) +// Param is a single URL parameter, consisting of a key and a value. +type Param struct { + Key string + Value string +} + +// Params is a Param-slice, as returned by the router. +// The slice is ordered, the first URL parameter is also the first slice value. +// It is therefore safe to read values by the index. +type Params []Param + +// Get returns the value of the first Param which key matches the given name. +// If no matching Param is found, an empty string is returned. +func (ps Params) Get(name string) (string, bool) { + for _, entry := range ps { + if entry.Key == name { + return entry.Value, true + } + } + return "", false +} + +// ByName returns the value of the first Param which key matches the given name. +// If no matching Param is found, an empty string is returned. +func (ps Params) ByName(name string) (va string) { + va, _ = ps.Get(name) + return +} + +type methodTree struct { + method string + root *node +} + +type methodTrees []methodTree + +func (trees methodTrees) get(method string) *node { + for _, tree := range trees { + if tree.method == method { + return tree.root + } + } + return nil +} + func min(a, b int) int { if a <= b { return a @@ -33,9 +79,10 @@ func countParams(path string) uint8 { type nodeType uint8 const ( - static nodeType = 0 - param nodeType = 1 - catchAll nodeType = 2 + static nodeType = iota // default + root + param + catchAll ) type node struct { @@ -45,7 +92,7 @@ type node struct { maxParams uint8 indices string children []*node - handle Handle + handlers HandlersChain priority uint32 } @@ -77,7 +124,7 @@ func (n *node) incrementChildPrio(pos int) int { // addRoute adds a node with the given handle to the path. // Not concurrency-safe! -func (n *node) addRoute(path string, handle Handle) { +func (n *node) addRoute(path string, handlers HandlersChain) { fullPath := path n.priority++ numParams := countParams(path) @@ -107,7 +154,7 @@ func (n *node) addRoute(path string, handle Handle) { wildChild: n.wildChild, indices: n.indices, children: n.children, - handle: n.handle, + handlers: n.handlers, priority: n.priority - 1, } @@ -122,7 +169,7 @@ func (n *node) addRoute(path string, handle Handle) { // []byte for proper unicode char conversion, see #65 n.indices = string([]byte{n.path[i]}) n.path = path[:i] - n.handle = nil + n.handlers = nil n.wildChild = false } @@ -182,23 +229,24 @@ func (n *node) addRoute(path string, handle Handle) { n.incrementChildPrio(len(n.indices) - 1) n = child } - n.insertChild(numParams, path, fullPath, handle) + n.insertChild(numParams, path, fullPath, handlers) return } else if i == len(path) { // Make node a (in-path) leaf - if n.handle != nil { - panic("a handle is already registered for path ''" + fullPath + "'") + if n.handlers != nil { + panic("handlers are already registered for path ''" + fullPath + "'") } - n.handle = handle + n.handlers = handlers } return } } else { // Empty tree - n.insertChild(numParams, path, fullPath, handle) + n.insertChild(numParams, path, fullPath, handlers) + n.nType = root } } -func (n *node) insertChild(numParams uint8, path, fullPath string, handle Handle) { +func (n *node) insertChild(numParams uint8, path string, fullPath string, handlers HandlersChain) { var offset int // already handled bytes of the path // find prefix until first wildcard (beginning with ':'' or '*'') @@ -297,7 +345,7 @@ func (n *node) insertChild(numParams uint8, path, fullPath string, handle Handle path: path[i:], nType: catchAll, maxParams: 1, - handle: handle, + handlers: handlers, priority: 1, } n.children = []*node{child} @@ -308,7 +356,7 @@ func (n *node) insertChild(numParams uint8, path, fullPath string, handle Handle // insert remaining path part and handle to the leaf n.path = path[offset:] - n.handle = handle + n.handlers = handlers } // Returns the handle registered with the given path (key). The values of @@ -316,7 +364,8 @@ func (n *node) insertChild(numParams uint8, path, fullPath string, handle Handle // 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) (handle Handle, p Params, tsr bool) { +func (n *node) getValue(path string, po Params, unescape bool) (handlers HandlersChain, p Params, tsr bool) { + p = po walk: // Outer loop for walking the tree for { if len(path) > len(n.path) { @@ -337,9 +386,8 @@ walk: // Outer loop for walking the tree // Nothing found. // We can recommend to redirect to the same URL without a // trailing slash if a leaf exists for that path. - tsr = (path == "/" && n.handle != nil) + tsr = (path == "/" && n.handlers != nil) return - } // handle wildcard child @@ -353,14 +401,21 @@ walk: // Outer loop for walking the tree } // save param value - if p == nil { - // lazy allocation + if cap(p) < int(n.maxParams) { p = make(Params, 0, n.maxParams) } i := len(p) p = p[:i+1] // expand slice within preallocated capacity p[i].Key = n.path[1:] - p[i].Value = path[:end] + val := path[:end] + if unescape { + var err error + if p[i].Value, err = url.QueryUnescape(val); err != nil { + p[i].Value = val // fallback, in case of error + } + } else { + p[i].Value = val + } // we need to go deeper! if end < len(path) { @@ -375,29 +430,36 @@ walk: // Outer loop for walking the tree return } - if handle = n.handle; handle != nil { + if handlers = n.handlers; handlers != nil { return - } else if len(n.children) == 1 { + } + 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] - tsr = (n.path == "/" && n.handle != nil) + tsr = (n.path == "/" && n.handlers != nil) } return case catchAll: // save param value - if p == nil { - // lazy allocation + if cap(p) < int(n.maxParams) { p = make(Params, 0, n.maxParams) } i := len(p) p = p[:i+1] // expand slice within preallocated capacity p[i].Key = n.path[2:] - p[i].Value = path + if unescape { + var err error + if p[i].Value, err = url.QueryUnescape(path); err != nil { + p[i].Value = path // fallback, in case of error + } + } else { + p[i].Value = path + } - handle = n.handle + handlers = n.handlers return default: @@ -407,7 +469,12 @@ walk: // Outer loop for walking the tree } else if path == n.path { // We should have reached the node containing the handle. // Check if this node has a handle registered. - if handle = n.handle; handle != nil { + if handlers = n.handlers; handlers != nil { + return + } + + if path == "/" && n.wildChild && n.nType != root { + tsr = true return } @@ -416,8 +483,8 @@ walk: // Outer loop for walking the tree for i := 0; i < len(n.indices); i++ { if n.indices[i] == '/' { n = n.children[i] - tsr = (len(n.path) == 1 && n.handle != nil) || - (n.nType == catchAll && n.children[0].handle != nil) + tsr = (len(n.path) == 1 && n.handlers != nil) || + (n.nType == catchAll && n.children[0].handlers != nil) return } } @@ -429,7 +496,7 @@ walk: // Outer loop for walking the tree // extra trailing slash if a leaf exists for that path tsr = (path == "/") || (len(n.path) == len(path)+1 && n.path[len(path)] == '/' && - path == n.path[:len(n.path)-1] && n.handle != nil) + path == n.path[:len(n.path)-1] && n.handlers != nil) return } } @@ -465,7 +532,7 @@ func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPa // Nothing found. We can recommend to redirect to the same URL // without a trailing slash if a leaf exists for that path - found = (fixTrailingSlash && path == "/" && n.handle != nil) + found = (fixTrailingSlash && path == "/" && n.handlers != nil) return } @@ -496,13 +563,13 @@ func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPa return } - if n.handle != nil { + if n.handlers != nil { return ciPath, true } else 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.handle != nil { + if n.path == "/" && n.handlers != nil { return append(ciPath, '/'), true } } @@ -517,7 +584,7 @@ func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPa } else { // We should have reached the node containing the handle. // Check if this node has a handle registered. - if n.handle != nil { + if n.handlers != nil { return ciPath, true } @@ -527,8 +594,8 @@ func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPa for i := 0; i < len(n.indices); i++ { if n.indices[i] == '/' { n = n.children[i] - if (len(n.path) == 1 && n.handle != nil) || - (n.nType == catchAll && n.children[0].handle != nil) { + if (len(n.path) == 1 && n.handlers != nil) || + (n.nType == catchAll && n.children[0].handlers != nil) { return append(ciPath, '/'), true } return @@ -547,7 +614,7 @@ func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPa } if len(path)+1 == len(n.path) && n.path[len(path)] == '/' && strings.ToLower(path) == strings.ToLower(n.path[:len(path)]) && - n.handle != nil { + n.handlers != nil { return append(ciPath, n.path...), true } } diff --git a/vendor/github.com/julienschmidt/httprouter/tree_test.go b/vendor/github.com/gin-gonic/gin/tree_test.go similarity index 82% rename from vendor/github.com/julienschmidt/httprouter/tree_test.go rename to vendor/github.com/gin-gonic/gin/tree_test.go index 64f26d1a3..c0edd42b5 100644 --- a/vendor/github.com/julienschmidt/httprouter/tree_test.go +++ b/vendor/github.com/gin-gonic/gin/tree_test.go @@ -1,19 +1,18 @@ // Copyright 2013 Julien Schmidt. All rights reserved. // Use of this source code is governed by a BSD-style license that can be found -// in the LICENSE file. +// at https://github.com/julienschmidt/httprouter/blob/master/LICENSE -package httprouter +package gin import ( "fmt" - "net/http" "reflect" "strings" "testing" ) func printChildren(n *node, prefix string) { - fmt.Printf(" %02d:%02d %s%s[%d] %v %t %d \r\n", n.priority, n.maxParams, prefix, n.path, len(n.children), n.handle, n.wildChild, n.nType) + fmt.Printf(" %02d:%02d %s%s[%d] %v %t %d \r\n", n.priority, n.maxParams, prefix, n.path, len(n.children), n.handlers, n.wildChild, n.nType) for l := len(n.path); l > 0; l-- { prefix += " " } @@ -22,13 +21,13 @@ func printChildren(n *node, prefix string) { } } -// Used as a workaround since we can't compare functions or their adresses +// Used as a workaround since we can't compare functions or their addressses var fakeHandlerValue string -func fakeHandler(val string) Handle { - return func(http.ResponseWriter, *http.Request, Params) { +func fakeHandler(val string) HandlersChain { + return HandlersChain{func(c *Context) { fakeHandlerValue = val - } + }} } type testRequests []struct { @@ -38,9 +37,14 @@ type testRequests []struct { ps Params } -func checkRequests(t *testing.T, tree *node, requests testRequests) { +func checkRequests(t *testing.T, tree *node, requests testRequests, unescapes ...bool) { + unescape := false + if len(unescapes) >= 1 { + unescape = unescapes[0] + } + for _, request := range requests { - handler, ps, _ := tree.getValue(request.path) + handler, ps, _ := tree.getValue(request.path, nil, unescape) if handler == nil { if !request.nilHandler { @@ -49,7 +53,7 @@ func checkRequests(t *testing.T, tree *node, requests testRequests) { } else if request.nilHandler { t.Errorf("handle mismatch for route '%s': Expected nil handle", request.path) } else { - handler(nil, nil, nil) + handler[0](nil) if fakeHandlerValue != request.route { t.Errorf("handle mismatch for route '%s': Wrong handle (%s != %s)", request.path, fakeHandlerValue, request.route) } @@ -67,7 +71,7 @@ func checkPriorities(t *testing.T, n *node) uint32 { prio += checkPriorities(t, n.children[i]) } - if n.handle != nil { + if n.handlers != nil { prio++ } @@ -89,7 +93,7 @@ func checkMaxParams(t *testing.T, n *node) uint8 { maxParams = params } } - if n.nType != static && !n.wildChild { + if n.nType > root && !n.wildChild { maxParams++ } @@ -198,6 +202,45 @@ func TestTreeWildcard(t *testing.T) { checkMaxParams(t, tree) } +func TestUnescapeParameters(t *testing.T) { + tree := &node{} + + routes := [...]string{ + "/", + "/cmd/:tool/:sub", + "/cmd/:tool/", + "/src/*filepath", + "/search/:query", + "/files/:dir/*filepath", + "/info/:user/project/:project", + "/info/:user", + } + for _, route := range routes { + tree.addRoute(route, fakeHandler(route)) + } + + //printChildren(tree, "") + unescape := true + checkRequests(t, tree, testRequests{ + {"/", false, "/", nil}, + {"/cmd/test/", false, "/cmd/:tool/", Params{Param{"tool", "test"}}}, + {"/cmd/test", true, "", Params{Param{"tool", "test"}}}, + {"/src/some/file.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file.png"}}}, + {"/src/some/file+test.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file test.png"}}}, + {"/src/some/file++++%%%%test.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file++++%%%%test.png"}}}, + {"/src/some/file%2Ftest.png", false, "/src/*filepath", Params{Param{"filepath", "/some/file/test.png"}}}, + {"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{"query", "someth!ng in ünìcodé"}}}, + {"/info/gordon/project/go", false, "/info/:user/project/:project", Params{Param{"user", "gordon"}, Param{"project", "go"}}}, + {"/info/slash%2Fgordon", false, "/info/:user", Params{Param{"user", "slash/gordon"}}}, + {"/info/slash%2Fgordon/project/Project%20%231", false, "/info/:user/project/:project", Params{Param{"user", "slash/gordon"}, Param{"project", "Project #1"}}}, + {"/info/slash%%%%", false, "/info/:user", Params{Param{"user", "slash%%%%"}}}, + {"/info/slash%%%%2Fgordon/project/Project%%%%20%231", false, "/info/:user/project/:project", Params{Param{"user", "slash%%%%2Fgordon"}, Param{"project", "Project%%%%20%231"}}}, + }, unescape) + + checkPriorities(t, tree) + checkMaxParams(t, tree) +} + func catchPanic(testFunc func()) (recv interface{}) { defer func() { recv = recover() @@ -366,7 +409,6 @@ func TestTreeDoubleWildcard(t *testing.T) { /*func TestTreeDuplicateWildcard(t *testing.T) { tree := &node{} - routes := [...]string{ "/:id/:name/:id", } @@ -394,6 +436,9 @@ func TestTreeTrailingSlashRedirect(t *testing.T) { "/1/:id/2", "/aa", "/a/", + "/admin", + "/admin/:category", + "/admin/:category/:page", "/doc", "/doc/go_faq.html", "/doc/go1.html", @@ -423,10 +468,13 @@ func TestTreeTrailingSlashRedirect(t *testing.T) { "/0/go/", "/1/go", "/a", + "/admin/", + "/admin/config/", + "/admin/config/permissions/", "/doc/", } for _, route := range tsrRoutes { - handler, _, tsr := tree.getValue(route) + handler, _, tsr := tree.getValue(route, nil, false) if handler != nil { t.Fatalf("non-nil handler for TSR route '%s", route) } else if !tsr { @@ -443,7 +491,7 @@ func TestTreeTrailingSlashRedirect(t *testing.T) { "/api/world/abc", } for _, route := range noTsrRoutes { - handler, _, tsr := tree.getValue(route) + handler, _, tsr := tree.getValue(route, nil, false) if handler != nil { t.Fatalf("non-nil handler for No-TSR route '%s", route) } else if tsr { @@ -452,6 +500,24 @@ func TestTreeTrailingSlashRedirect(t *testing.T) { } } +func TestTreeRootTrailingSlashRedirect(t *testing.T) { + tree := &node{} + + recv := catchPanic(func() { + tree.addRoute("/:test", fakeHandler("/:test")) + }) + if recv != nil { + t.Fatalf("panic inserting test route: %v", recv) + } + + handler, _, tsr := tree.getValue("/", nil, false) + if handler != nil { + t.Fatalf("non-nil handler") + } else if tsr { + t.Errorf("expected no TSR recommendation") + } +} + func TestTreeFindCaseInsensitivePath(t *testing.T) { tree := &node{} @@ -595,7 +661,7 @@ func TestTreeInvalidNodeType(t *testing.T) { // normal lookup recv := catchPanic(func() { - tree.getValue("/test") + tree.getValue("/test", nil, false) }) if rs, ok := recv.(string); !ok || rs != panicMsg { t.Fatalf("Expected panic '"+panicMsg+"', got '%v'", recv) diff --git a/vendor/github.com/gin-gonic/gin/utils.go b/vendor/github.com/gin-gonic/gin/utils.go index 43ddaecd5..18064fb53 100644 --- a/vendor/github.com/gin-gonic/gin/utils.go +++ b/vendor/github.com/gin-gonic/gin/utils.go @@ -6,14 +6,48 @@ package gin import ( "encoding/xml" + "net/http" + "os" + "path" "reflect" "runtime" "strings" ) +const BindKey = "_gin-gonic/gin/bindkey" + +func Bind(val interface{}) HandlerFunc { + value := reflect.ValueOf(val) + if value.Kind() == reflect.Ptr { + panic(`Bind struct can not be a pointer. Example: + Use: gin.Bind(Struct{}) instead of gin.Bind(&Struct{}) +`) + } + typ := value.Type() + + return func(c *Context) { + obj := reflect.New(typ).Interface() + if c.Bind(obj) == nil { + c.Set(BindKey, obj) + } + } +} + +func WrapF(f http.HandlerFunc) HandlerFunc { + return func(c *Context) { + f(c.Writer, c.Request) + } +} + +func WrapH(h http.Handler) HandlerFunc { + return func(c *Context) { + h.ServeHTTP(c.Writer, c.Request) + } +} + type H map[string]interface{} -// Allows type H to be used with xml.Marshal +// MarshalXML allows type H to be used with xml.Marshal func (h H) MarshalXML(e *xml.Encoder, start xml.StartElement) error { start.Name = xml.Name{ Space: "", @@ -37,6 +71,12 @@ func (h H) MarshalXML(e *xml.Encoder, start xml.StartElement) error { return nil } +func assert1(guard bool, text string) { + if !guard { + panic(text) + } +} + func filterFlags(content string) string { for i, char := range content { if char == ' ' || char == ';' { @@ -56,17 +96,20 @@ func chooseData(custom, wildcard interface{}) interface{} { return custom } -func parseAccept(accept string) []string { - parts := strings.Split(accept, ",") - for i, part := range parts { +func parseAccept(acceptHeader string) []string { + parts := strings.Split(acceptHeader, ",") + out := make([]string, 0, len(parts)) + for _, part := range parts { index := strings.IndexByte(part, ';') if index >= 0 { part = part[0:index] } part = strings.TrimSpace(part) - parts[i] = part + if len(part) > 0 { + out = append(out, part) + } } - return parts + return out } func lastChar(str string) uint8 { @@ -80,3 +123,32 @@ func lastChar(str string) uint8 { func nameOfFunction(f interface{}) string { return runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name() } + +func joinPaths(absolutePath, relativePath string) string { + if len(relativePath) == 0 { + return absolutePath + } + + finalPath := path.Join(absolutePath, relativePath) + appendSlash := lastChar(relativePath) == '/' && lastChar(finalPath) != '/' + if appendSlash { + return finalPath + "/" + } + return finalPath +} + +func resolveAddress(addr []string) string { + switch len(addr) { + case 0: + if port := os.Getenv("PORT"); len(port) > 0 { + debugPrint("Environment variable PORT=\"%s\"", port) + return ":" + port + } + debugPrint("Environment variable PORT is undefined. Using port :8080 by default") + return ":8080" + case 1: + return addr[0] + default: + panic("too much parameters") + } +} diff --git a/vendor/github.com/gin-gonic/gin/utils_test.go b/vendor/github.com/gin-gonic/gin/utils_test.go new file mode 100644 index 000000000..599172fe5 --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/utils_test.go @@ -0,0 +1,126 @@ +// Copyright 2014 Manu Martinez-Almeida. All rights reserved. +// Use of this source code is governed by a MIT style +// license that can be found in the LICENSE file. + +package gin + +import ( + "fmt" + "net/http" + "testing" + + "github.com/stretchr/testify/assert" +) + +func init() { + SetMode(TestMode) +} + +type testStruct struct { + T *testing.T +} + +func (t *testStruct) ServeHTTP(w http.ResponseWriter, req *http.Request) { + assert.Equal(t.T, req.Method, "POST") + assert.Equal(t.T, req.URL.Path, "/path") + w.WriteHeader(500) + fmt.Fprint(w, "hello") +} + +func TestWrap(t *testing.T) { + router := New() + router.POST("/path", WrapH(&testStruct{t})) + router.GET("/path2", WrapF(func(w http.ResponseWriter, req *http.Request) { + assert.Equal(t, req.Method, "GET") + assert.Equal(t, req.URL.Path, "/path2") + w.WriteHeader(400) + fmt.Fprint(w, "hola!") + })) + + w := performRequest(router, "POST", "/path") + assert.Equal(t, w.Code, 500) + assert.Equal(t, w.Body.String(), "hello") + + w = performRequest(router, "GET", "/path2") + assert.Equal(t, w.Code, 400) + assert.Equal(t, w.Body.String(), "hola!") +} + +func TestLastChar(t *testing.T) { + assert.Equal(t, lastChar("hola"), uint8('a')) + assert.Equal(t, lastChar("adios"), uint8('s')) + assert.Panics(t, func() { lastChar("") }) +} + +func TestParseAccept(t *testing.T) { + parts := parseAccept("text/html , application/xhtml+xml,application/xml;q=0.9, */* ;q=0.8") + assert.Len(t, parts, 4) + assert.Equal(t, parts[0], "text/html") + assert.Equal(t, parts[1], "application/xhtml+xml") + assert.Equal(t, parts[2], "application/xml") + assert.Equal(t, parts[3], "*/*") +} + +func TestChooseData(t *testing.T) { + A := "a" + B := "b" + assert.Equal(t, chooseData(A, B), A) + assert.Equal(t, chooseData(nil, B), B) + assert.Panics(t, func() { chooseData(nil, nil) }) +} + +func TestFilterFlags(t *testing.T) { + result := filterFlags("text/html ") + assert.Equal(t, result, "text/html") + + result = filterFlags("text/html;") + assert.Equal(t, result, "text/html") +} + +func TestFunctionName(t *testing.T) { + assert.Regexp(t, `^(.*/vendor/)?github.com/gin-gonic/gin.somefunction$`, nameOfFunction(somefunction)) +} + +func somefunction() { + // this empty function is used by TestFunctionName() +} + +func TestJoinPaths(t *testing.T) { + assert.Equal(t, joinPaths("", ""), "") + assert.Equal(t, joinPaths("", "/"), "/") + assert.Equal(t, joinPaths("/a", ""), "/a") + assert.Equal(t, joinPaths("/a/", ""), "/a/") + assert.Equal(t, joinPaths("/a/", "/"), "/a/") + assert.Equal(t, joinPaths("/a", "/"), "/a/") + assert.Equal(t, joinPaths("/a", "/hola"), "/a/hola") + assert.Equal(t, joinPaths("/a/", "/hola"), "/a/hola") + assert.Equal(t, joinPaths("/a/", "/hola/"), "/a/hola/") + assert.Equal(t, joinPaths("/a/", "/hola//"), "/a/hola/") +} + +type bindTestStruct struct { + Foo string `form:"foo" binding:"required"` + Bar int `form:"bar" binding:"min=4"` +} + +func TestBindMiddleware(t *testing.T) { + var value *bindTestStruct + var called bool + router := New() + router.GET("/", Bind(bindTestStruct{}), func(c *Context) { + called = true + value = c.MustGet(BindKey).(*bindTestStruct) + }) + performRequest(router, "GET", "/?foo=hola&bar=10") + assert.True(t, called) + assert.Equal(t, value.Foo, "hola") + assert.Equal(t, value.Bar, 10) + + called = false + performRequest(router, "GET", "/?foo=hola&bar=1") + assert.False(t, called) + + assert.Panics(t, func() { + Bind(&bindTestStruct{}) + }) +} diff --git a/vendor/github.com/gin-gonic/gin/wercker.yml b/vendor/github.com/gin-gonic/gin/wercker.yml new file mode 100644 index 000000000..3ab8084cc --- /dev/null +++ b/vendor/github.com/gin-gonic/gin/wercker.yml @@ -0,0 +1 @@ +box: wercker/default \ No newline at end of file diff --git a/vendor/github.com/golang/protobuf/.gitignore b/vendor/github.com/golang/protobuf/.gitignore new file mode 100644 index 000000000..8f5b596b1 --- /dev/null +++ b/vendor/github.com/golang/protobuf/.gitignore @@ -0,0 +1,16 @@ +.DS_Store +*.[568ao] +*.ao +*.so +*.pyc +._* +.nfs.* +[568a].out +*~ +*.orig +core +_obj +_test +_testmain.go +protoc-gen-go/testdata/multi/*.pb.go +_conformance/_conformance diff --git a/vendor/github.com/golang/protobuf/.travis.yml b/vendor/github.com/golang/protobuf/.travis.yml new file mode 100644 index 000000000..93c67805b --- /dev/null +++ b/vendor/github.com/golang/protobuf/.travis.yml @@ -0,0 +1,18 @@ +sudo: false +language: go +go: +- 1.6.x +- 1.7.x +- 1.8.x +- 1.9.x + +install: + - go get -v -d -t github.com/golang/protobuf/... + - curl -L https://github.com/google/protobuf/releases/download/v3.3.0/protoc-3.3.0-linux-x86_64.zip -o /tmp/protoc.zip + - unzip /tmp/protoc.zip -d $HOME/protoc + +env: + - PATH=$HOME/protoc/bin:$PATH + +script: + - make all test diff --git a/vendor/github.com/golang/protobuf/AUTHORS b/vendor/github.com/golang/protobuf/AUTHORS new file mode 100644 index 000000000..15167cd74 --- /dev/null +++ b/vendor/github.com/golang/protobuf/AUTHORS @@ -0,0 +1,3 @@ +# This source code refers to The Go Authors for copyright purposes. +# The master list of authors is in the main Go distribution, +# visible at http://tip.golang.org/AUTHORS. diff --git a/vendor/github.com/golang/protobuf/CONTRIBUTORS b/vendor/github.com/golang/protobuf/CONTRIBUTORS new file mode 100644 index 000000000..1c4577e96 --- /dev/null +++ b/vendor/github.com/golang/protobuf/CONTRIBUTORS @@ -0,0 +1,3 @@ +# This source code was written by the Go contributors. +# The master list of contributors is in the main Go distribution, +# visible at http://tip.golang.org/CONTRIBUTORS. diff --git a/vendor/github.com/golang/protobuf/LICENSE b/vendor/github.com/golang/protobuf/LICENSE new file mode 100644 index 000000000..1b1b1921e --- /dev/null +++ b/vendor/github.com/golang/protobuf/LICENSE @@ -0,0 +1,31 @@ +Go support for Protocol Buffers - Google's data interchange format + +Copyright 2010 The Go Authors. All rights reserved. +https://github.com/golang/protobuf + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/vendor/github.com/golang/protobuf/Make.protobuf b/vendor/github.com/golang/protobuf/Make.protobuf new file mode 100644 index 000000000..15071de10 --- /dev/null +++ b/vendor/github.com/golang/protobuf/Make.protobuf @@ -0,0 +1,40 @@ +# Go support for Protocol Buffers - Google's data interchange format +# +# Copyright 2010 The Go Authors. All rights reserved. +# https://github.com/golang/protobuf +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +# Includable Makefile to add a rule for generating .pb.go files from .proto files +# (Google protocol buffer descriptions). +# Typical use if myproto.proto is a file in package mypackage in this directory: +# +# include $(GOROOT)/src/pkg/github.com/golang/protobuf/Make.protobuf + +%.pb.go: %.proto + protoc --go_out=. $< + diff --git a/vendor/github.com/golang/protobuf/Makefile b/vendor/github.com/golang/protobuf/Makefile new file mode 100644 index 000000000..a1421d8b7 --- /dev/null +++ b/vendor/github.com/golang/protobuf/Makefile @@ -0,0 +1,55 @@ +# Go support for Protocol Buffers - Google's data interchange format +# +# Copyright 2010 The Go Authors. All rights reserved. +# https://github.com/golang/protobuf +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +all: install + +install: + go install ./proto ./jsonpb ./ptypes + go install ./protoc-gen-go + +test: + go test ./proto ./jsonpb ./ptypes + make -C protoc-gen-go/testdata test + +clean: + go clean ./... + +nuke: + go clean -i ./... + +regenerate: + make -C protoc-gen-go/descriptor regenerate + make -C protoc-gen-go/plugin regenerate + make -C protoc-gen-go/testdata regenerate + make -C proto/testdata regenerate + make -C jsonpb/jsonpb_test_proto regenerate + make -C _conformance regenerate diff --git a/vendor/github.com/golang/protobuf/README.md b/vendor/github.com/golang/protobuf/README.md new file mode 100644 index 000000000..207eb6b48 --- /dev/null +++ b/vendor/github.com/golang/protobuf/README.md @@ -0,0 +1,243 @@ +# Go support for Protocol Buffers + +[](https://travis-ci.org/golang/protobuf) + +Google's data interchange format. +Copyright 2010 The Go Authors. +https://github.com/golang/protobuf + +This package and the code it generates requires at least Go 1.4. + +This software implements Go bindings for protocol buffers. For +information about protocol buffers themselves, see + https://developers.google.com/protocol-buffers/ + +## Installation ## + +To use this software, you must: +- Install the standard C++ implementation of protocol buffers from + https://developers.google.com/protocol-buffers/ +- Of course, install the Go compiler and tools from + https://golang.org/ + See + https://golang.org/doc/install + for details or, if you are using gccgo, follow the instructions at + https://golang.org/doc/install/gccgo +- Grab the code from the repository and install the proto package. + The simplest way is to run `go get -u github.com/golang/protobuf/protoc-gen-go`. + The compiler plugin, protoc-gen-go, will be installed in $GOBIN, + defaulting to $GOPATH/bin. It must be in your $PATH for the protocol + compiler, protoc, to find it. + +This software has two parts: a 'protocol compiler plugin' that +generates Go source files that, once compiled, can access and manage +protocol buffers; and a library that implements run-time support for +encoding (marshaling), decoding (unmarshaling), and accessing protocol +buffers. + +There is support for gRPC in Go using protocol buffers. +See the note at the bottom of this file for details. + +There are no insertion points in the plugin. + + +## Using protocol buffers with Go ## + +Once the software is installed, there are two steps to using it. +First you must compile the protocol buffer definitions and then import +them, with the support library, into your program. + +To compile the protocol buffer definition, run protoc with the --go_out +parameter set to the directory you want to output the Go code to. + + protoc --go_out=. *.proto + +The generated files will be suffixed .pb.go. See the Test code below +for an example using such a file. + + +The package comment for the proto library contains text describing +the interface provided in Go for protocol buffers. Here is an edited +version. + +========== + +The proto package converts data structures to and from the +wire format of protocol buffers. It works in concert with the +Go source code generated for .proto files by the protocol compiler. + +A summary of the properties of the protocol buffer interface +for a protocol buffer variable v: + + - Names are turned from camel_case to CamelCase for export. + - There are no methods on v to set fields; just treat + them as structure fields. + - There are getters that return a field's value if set, + and return the field's default value if unset. + The getters work even if the receiver is a nil message. + - The zero value for a struct is its correct initialization state. + All desired fields must be set before marshaling. + - A Reset() method will restore a protobuf struct to its zero state. + - Non-repeated fields are pointers to the values; nil means unset. + That is, optional or required field int32 f becomes F *int32. + - Repeated fields are slices. + - Helper functions are available to aid the setting of fields. + Helpers for getting values are superseded by the + GetFoo methods and their use is deprecated. + msg.Foo = proto.String("hello") // set field + - Constants are defined to hold the default values of all fields that + have them. They have the form Default_StructName_FieldName. + Because the getter methods handle defaulted values, + direct use of these constants should be rare. + - Enums are given type names and maps from names to values. + Enum values are prefixed with the enum's type name. Enum types have + a String method, and a Enum method to assist in message construction. + - Nested groups and enums have type names prefixed with the name of + the surrounding message type. + - Extensions are given descriptor names that start with E_, + followed by an underscore-delimited list of the nested messages + that contain it (if any) followed by the CamelCased name of the + extension field itself. HasExtension, ClearExtension, GetExtension + and SetExtension are functions for manipulating extensions. + - Oneof field sets are given a single field in their message, + with distinguished wrapper types for each possible field value. + - Marshal and Unmarshal are functions to encode and decode the wire format. + +When the .proto file specifies `syntax="proto3"`, there are some differences: + + - Non-repeated fields of non-message type are values instead of pointers. + - Enum types do not get an Enum method. + +Consider file test.proto, containing + +```proto + syntax = "proto2"; + package example; + + enum FOO { X = 17; }; + + message Test { + required string label = 1; + optional int32 type = 2 [default=77]; + repeated int64 reps = 3; + optional group OptionalGroup = 4 { + required string RequiredField = 5; + } + } +``` + +To create and play with a Test object from the example package, + +```go + package main + + import ( + "log" + + "github.com/golang/protobuf/proto" + "path/to/example" + ) + + func main() { + test := &example.Test { + Label: proto.String("hello"), + Type: proto.Int32(17), + Reps: []int64{1, 2, 3}, + Optionalgroup: &example.Test_OptionalGroup { + RequiredField: proto.String("good bye"), + }, + } + data, err := proto.Marshal(test) + if err != nil { + log.Fatal("marshaling error: ", err) + } + newTest := &example.Test{} + err = proto.Unmarshal(data, newTest) + if err != nil { + log.Fatal("unmarshaling error: ", err) + } + // Now test and newTest contain the same data. + if test.GetLabel() != newTest.GetLabel() { + log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel()) + } + // etc. + } +``` + +## Parameters ## + +To pass extra parameters to the plugin, use a comma-separated +parameter list separated from the output directory by a colon: + + + protoc --go_out=plugins=grpc,import_path=mypackage:. *.proto + + +- `import_prefix=xxx` - a prefix that is added onto the beginning of + all imports. Useful for things like generating protos in a + subdirectory, or regenerating vendored protobufs in-place. +- `import_path=foo/bar` - used as the package if no input files + declare `go_package`. If it contains slashes, everything up to the + rightmost slash is ignored. +- `plugins=plugin1+plugin2` - specifies the list of sub-plugins to + load. The only plugin in this repo is `grpc`. +- `Mfoo/bar.proto=quux/shme` - declares that foo/bar.proto is + associated with Go package quux/shme. This is subject to the + import_prefix parameter. + +## gRPC Support ## + +If a proto file specifies RPC services, protoc-gen-go can be instructed to +generate code compatible with gRPC (http://www.grpc.io/). To do this, pass +the `plugins` parameter to protoc-gen-go; the usual way is to insert it into +the --go_out argument to protoc: + + protoc --go_out=plugins=grpc:. *.proto + +## Compatibility ## + +The library and the generated code are expected to be stable over time. +However, we reserve the right to make breaking changes without notice for the +following reasons: + +- Security. A security issue in the specification or implementation may come to + light whose resolution requires breaking compatibility. We reserve the right + to address such security issues. +- Unspecified behavior. There are some aspects of the Protocol Buffers + specification that are undefined. Programs that depend on such unspecified + behavior may break in future releases. +- Specification errors or changes. If it becomes necessary to address an + inconsistency, incompleteness, or change in the Protocol Buffers + specification, resolving the issue could affect the meaning or legality of + existing programs. We reserve the right to address such issues, including + updating the implementations. +- Bugs. If the library has a bug that violates the specification, a program + that depends on the buggy behavior may break if the bug is fixed. We reserve + the right to fix such bugs. +- Adding methods or fields to generated structs. These may conflict with field + names that already exist in a schema, causing applications to break. When the + code generator encounters a field in the schema that would collide with a + generated field or method name, the code generator will append an underscore + to the generated field or method name. +- Adding, removing, or changing methods or fields in generated structs that + start with `XXX`. These parts of the generated code are exported out of + necessity, but should not be considered part of the public API. +- Adding, removing, or changing unexported symbols in generated code. + +Any breaking changes outside of these will be announced 6 months in advance to +protobuf@googlegroups.com. + +You should, whenever possible, use generated code created by the `protoc-gen-go` +tool built at the same commit as the `proto` package. The `proto` package +declares package-level constants in the form `ProtoPackageIsVersionX`. +Application code and generated code may depend on one of these constants to +ensure that compilation will fail if the available version of the proto library +is too old. Whenever we make a change to the generated code that requires newer +library support, in the same commit we will increment the version number of the +generated code and declare a new package-level constant whose name incorporates +the latest version number. Removing a compatibility constant is considered a +breaking change and would be subject to the announcement policy stated above. + +The `protoc-gen-go/generator` package exposes a plugin interface, +which is used by the gRPC code generation. This interface is not +supported and is subject to incompatible changes without notice. diff --git a/vendor/github.com/golang/protobuf/_conformance/Makefile b/vendor/github.com/golang/protobuf/_conformance/Makefile new file mode 100644 index 000000000..89800e2d9 --- /dev/null +++ b/vendor/github.com/golang/protobuf/_conformance/Makefile @@ -0,0 +1,33 @@ +# Go support for Protocol Buffers - Google's data interchange format +# +# Copyright 2016 The Go Authors. All rights reserved. +# https://github.com/golang/protobuf +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +regenerate: + protoc --go_out=Mgoogle/protobuf/any.proto=github.com/golang/protobuf/ptypes/any,Mgoogle/protobuf/duration.proto=github.com/golang/protobuf/ptypes/duration,Mgoogle/protobuf/struct.proto=github.com/golang/protobuf/ptypes/struct,Mgoogle/protobuf/timestamp.proto=github.com/golang/protobuf/ptypes/timestamp,Mgoogle/protobuf/wrappers.proto=github.com/golang/protobuf/ptypes/wrappers,Mgoogle/protobuf/field_mask.proto=google.golang.org/genproto/protobuf:. conformance_proto/conformance.proto diff --git a/vendor/github.com/golang/protobuf/_conformance/conformance.go b/vendor/github.com/golang/protobuf/_conformance/conformance.go new file mode 100644 index 000000000..c54212c80 --- /dev/null +++ b/vendor/github.com/golang/protobuf/_conformance/conformance.go @@ -0,0 +1,161 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2016 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// conformance implements the conformance test subprocess protocol as +// documented in conformance.proto. +package main + +import ( + "encoding/binary" + "fmt" + "io" + "os" + + pb "github.com/golang/protobuf/_conformance/conformance_proto" + "github.com/golang/protobuf/jsonpb" + "github.com/golang/protobuf/proto" +) + +func main() { + var sizeBuf [4]byte + inbuf := make([]byte, 0, 4096) + outbuf := proto.NewBuffer(nil) + for { + if _, err := io.ReadFull(os.Stdin, sizeBuf[:]); err == io.EOF { + break + } else if err != nil { + fmt.Fprintln(os.Stderr, "go conformance: read request:", err) + os.Exit(1) + } + size := binary.LittleEndian.Uint32(sizeBuf[:]) + if int(size) > cap(inbuf) { + inbuf = make([]byte, size) + } + inbuf = inbuf[:size] + if _, err := io.ReadFull(os.Stdin, inbuf); err != nil { + fmt.Fprintln(os.Stderr, "go conformance: read request:", err) + os.Exit(1) + } + + req := new(pb.ConformanceRequest) + if err := proto.Unmarshal(inbuf, req); err != nil { + fmt.Fprintln(os.Stderr, "go conformance: parse request:", err) + os.Exit(1) + } + res := handle(req) + + if err := outbuf.Marshal(res); err != nil { + fmt.Fprintln(os.Stderr, "go conformance: marshal response:", err) + os.Exit(1) + } + binary.LittleEndian.PutUint32(sizeBuf[:], uint32(len(outbuf.Bytes()))) + if _, err := os.Stdout.Write(sizeBuf[:]); err != nil { + fmt.Fprintln(os.Stderr, "go conformance: write response:", err) + os.Exit(1) + } + if _, err := os.Stdout.Write(outbuf.Bytes()); err != nil { + fmt.Fprintln(os.Stderr, "go conformance: write response:", err) + os.Exit(1) + } + outbuf.Reset() + } +} + +var jsonMarshaler = jsonpb.Marshaler{ + OrigName: true, +} + +func handle(req *pb.ConformanceRequest) *pb.ConformanceResponse { + var err error + var msg pb.TestAllTypes + switch p := req.Payload.(type) { + case *pb.ConformanceRequest_ProtobufPayload: + err = proto.Unmarshal(p.ProtobufPayload, &msg) + case *pb.ConformanceRequest_JsonPayload: + err = jsonpb.UnmarshalString(p.JsonPayload, &msg) + if err != nil && err.Error() == "unmarshaling Any not supported yet" { + return &pb.ConformanceResponse{ + Result: &pb.ConformanceResponse_Skipped{ + Skipped: err.Error(), + }, + } + } + default: + return &pb.ConformanceResponse{ + Result: &pb.ConformanceResponse_RuntimeError{ + RuntimeError: "unknown request payload type", + }, + } + } + if err != nil { + return &pb.ConformanceResponse{ + Result: &pb.ConformanceResponse_ParseError{ + ParseError: err.Error(), + }, + } + } + switch req.RequestedOutputFormat { + case pb.WireFormat_PROTOBUF: + p, err := proto.Marshal(&msg) + if err != nil { + return &pb.ConformanceResponse{ + Result: &pb.ConformanceResponse_SerializeError{ + SerializeError: err.Error(), + }, + } + } + return &pb.ConformanceResponse{ + Result: &pb.ConformanceResponse_ProtobufPayload{ + ProtobufPayload: p, + }, + } + case pb.WireFormat_JSON: + p, err := jsonMarshaler.MarshalToString(&msg) + if err != nil { + return &pb.ConformanceResponse{ + Result: &pb.ConformanceResponse_SerializeError{ + SerializeError: err.Error(), + }, + } + } + return &pb.ConformanceResponse{ + Result: &pb.ConformanceResponse_JsonPayload{ + JsonPayload: p, + }, + } + default: + return &pb.ConformanceResponse{ + Result: &pb.ConformanceResponse_RuntimeError{ + RuntimeError: "unknown output format", + }, + } + } +} diff --git a/vendor/github.com/golang/protobuf/_conformance/conformance_proto/conformance.pb.go b/vendor/github.com/golang/protobuf/_conformance/conformance_proto/conformance.pb.go new file mode 100644 index 000000000..ec354eada --- /dev/null +++ b/vendor/github.com/golang/protobuf/_conformance/conformance_proto/conformance.pb.go @@ -0,0 +1,1885 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: conformance_proto/conformance.proto + +/* +Package conformance is a generated protocol buffer package. + +It is generated from these files: + conformance_proto/conformance.proto + +It has these top-level messages: + ConformanceRequest + ConformanceResponse + TestAllTypes + ForeignMessage +*/ +package conformance + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import google_protobuf "github.com/golang/protobuf/ptypes/any" +import google_protobuf1 "github.com/golang/protobuf/ptypes/duration" +import google_protobuf2 "google.golang.org/genproto/protobuf" +import google_protobuf3 "github.com/golang/protobuf/ptypes/struct" +import google_protobuf4 "github.com/golang/protobuf/ptypes/timestamp" +import google_protobuf5 "github.com/golang/protobuf/ptypes/wrappers" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +type WireFormat int32 + +const ( + WireFormat_UNSPECIFIED WireFormat = 0 + WireFormat_PROTOBUF WireFormat = 1 + WireFormat_JSON WireFormat = 2 +) + +var WireFormat_name = map[int32]string{ + 0: "UNSPECIFIED", + 1: "PROTOBUF", + 2: "JSON", +} +var WireFormat_value = map[string]int32{ + "UNSPECIFIED": 0, + "PROTOBUF": 1, + "JSON": 2, +} + +func (x WireFormat) String() string { + return proto.EnumName(WireFormat_name, int32(x)) +} +func (WireFormat) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + +type ForeignEnum int32 + +const ( + ForeignEnum_FOREIGN_FOO ForeignEnum = 0 + ForeignEnum_FOREIGN_BAR ForeignEnum = 1 + ForeignEnum_FOREIGN_BAZ ForeignEnum = 2 +) + +var ForeignEnum_name = map[int32]string{ + 0: "FOREIGN_FOO", + 1: "FOREIGN_BAR", + 2: "FOREIGN_BAZ", +} +var ForeignEnum_value = map[string]int32{ + "FOREIGN_FOO": 0, + "FOREIGN_BAR": 1, + "FOREIGN_BAZ": 2, +} + +func (x ForeignEnum) String() string { + return proto.EnumName(ForeignEnum_name, int32(x)) +} +func (ForeignEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + +type TestAllTypes_NestedEnum int32 + +const ( + TestAllTypes_FOO TestAllTypes_NestedEnum = 0 + TestAllTypes_BAR TestAllTypes_NestedEnum = 1 + TestAllTypes_BAZ TestAllTypes_NestedEnum = 2 + TestAllTypes_NEG TestAllTypes_NestedEnum = -1 +) + +var TestAllTypes_NestedEnum_name = map[int32]string{ + 0: "FOO", + 1: "BAR", + 2: "BAZ", + -1: "NEG", +} +var TestAllTypes_NestedEnum_value = map[string]int32{ + "FOO": 0, + "BAR": 1, + "BAZ": 2, + "NEG": -1, +} + +func (x TestAllTypes_NestedEnum) String() string { + return proto.EnumName(TestAllTypes_NestedEnum_name, int32(x)) +} +func (TestAllTypes_NestedEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} } + +// Represents a single test case's input. The testee should: +// +// 1. parse this proto (which should always succeed) +// 2. parse the protobuf or JSON payload in "payload" (which may fail) +// 3. if the parse succeeded, serialize the message in the requested format. +type ConformanceRequest struct { + // The payload (whether protobuf of JSON) is always for a TestAllTypes proto + // (see below). + // + // Types that are valid to be assigned to Payload: + // *ConformanceRequest_ProtobufPayload + // *ConformanceRequest_JsonPayload + Payload isConformanceRequest_Payload `protobuf_oneof:"payload"` + // Which format should the testee serialize its message to? + RequestedOutputFormat WireFormat `protobuf:"varint,3,opt,name=requested_output_format,json=requestedOutputFormat,enum=conformance.WireFormat" json:"requested_output_format,omitempty"` +} + +func (m *ConformanceRequest) Reset() { *m = ConformanceRequest{} } +func (m *ConformanceRequest) String() string { return proto.CompactTextString(m) } +func (*ConformanceRequest) ProtoMessage() {} +func (*ConformanceRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + +type isConformanceRequest_Payload interface { + isConformanceRequest_Payload() +} + +type ConformanceRequest_ProtobufPayload struct { + ProtobufPayload []byte `protobuf:"bytes,1,opt,name=protobuf_payload,json=protobufPayload,proto3,oneof"` +} +type ConformanceRequest_JsonPayload struct { + JsonPayload string `protobuf:"bytes,2,opt,name=json_payload,json=jsonPayload,oneof"` +} + +func (*ConformanceRequest_ProtobufPayload) isConformanceRequest_Payload() {} +func (*ConformanceRequest_JsonPayload) isConformanceRequest_Payload() {} + +func (m *ConformanceRequest) GetPayload() isConformanceRequest_Payload { + if m != nil { + return m.Payload + } + return nil +} + +func (m *ConformanceRequest) GetProtobufPayload() []byte { + if x, ok := m.GetPayload().(*ConformanceRequest_ProtobufPayload); ok { + return x.ProtobufPayload + } + return nil +} + +func (m *ConformanceRequest) GetJsonPayload() string { + if x, ok := m.GetPayload().(*ConformanceRequest_JsonPayload); ok { + return x.JsonPayload + } + return "" +} + +func (m *ConformanceRequest) GetRequestedOutputFormat() WireFormat { + if m != nil { + return m.RequestedOutputFormat + } + return WireFormat_UNSPECIFIED +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*ConformanceRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _ConformanceRequest_OneofMarshaler, _ConformanceRequest_OneofUnmarshaler, _ConformanceRequest_OneofSizer, []interface{}{ + (*ConformanceRequest_ProtobufPayload)(nil), + (*ConformanceRequest_JsonPayload)(nil), + } +} + +func _ConformanceRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*ConformanceRequest) + // payload + switch x := m.Payload.(type) { + case *ConformanceRequest_ProtobufPayload: + b.EncodeVarint(1<<3 | proto.WireBytes) + b.EncodeRawBytes(x.ProtobufPayload) + case *ConformanceRequest_JsonPayload: + b.EncodeVarint(2<<3 | proto.WireBytes) + b.EncodeStringBytes(x.JsonPayload) + case nil: + default: + return fmt.Errorf("ConformanceRequest.Payload has unexpected type %T", x) + } + return nil +} + +func _ConformanceRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*ConformanceRequest) + switch tag { + case 1: // payload.protobuf_payload + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.Payload = &ConformanceRequest_ProtobufPayload{x} + return true, err + case 2: // payload.json_payload + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Payload = &ConformanceRequest_JsonPayload{x} + return true, err + default: + return false, nil + } +} + +func _ConformanceRequest_OneofSizer(msg proto.Message) (n int) { + m := msg.(*ConformanceRequest) + // payload + switch x := m.Payload.(type) { + case *ConformanceRequest_ProtobufPayload: + n += proto.SizeVarint(1<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(len(x.ProtobufPayload))) + n += len(x.ProtobufPayload) + case *ConformanceRequest_JsonPayload: + n += proto.SizeVarint(2<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(len(x.JsonPayload))) + n += len(x.JsonPayload) + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// Represents a single test case's output. +type ConformanceResponse struct { + // Types that are valid to be assigned to Result: + // *ConformanceResponse_ParseError + // *ConformanceResponse_SerializeError + // *ConformanceResponse_RuntimeError + // *ConformanceResponse_ProtobufPayload + // *ConformanceResponse_JsonPayload + // *ConformanceResponse_Skipped + Result isConformanceResponse_Result `protobuf_oneof:"result"` +} + +func (m *ConformanceResponse) Reset() { *m = ConformanceResponse{} } +func (m *ConformanceResponse) String() string { return proto.CompactTextString(m) } +func (*ConformanceResponse) ProtoMessage() {} +func (*ConformanceResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + +type isConformanceResponse_Result interface { + isConformanceResponse_Result() +} + +type ConformanceResponse_ParseError struct { + ParseError string `protobuf:"bytes,1,opt,name=parse_error,json=parseError,oneof"` +} +type ConformanceResponse_SerializeError struct { + SerializeError string `protobuf:"bytes,6,opt,name=serialize_error,json=serializeError,oneof"` +} +type ConformanceResponse_RuntimeError struct { + RuntimeError string `protobuf:"bytes,2,opt,name=runtime_error,json=runtimeError,oneof"` +} +type ConformanceResponse_ProtobufPayload struct { + ProtobufPayload []byte `protobuf:"bytes,3,opt,name=protobuf_payload,json=protobufPayload,proto3,oneof"` +} +type ConformanceResponse_JsonPayload struct { + JsonPayload string `protobuf:"bytes,4,opt,name=json_payload,json=jsonPayload,oneof"` +} +type ConformanceResponse_Skipped struct { + Skipped string `protobuf:"bytes,5,opt,name=skipped,oneof"` +} + +func (*ConformanceResponse_ParseError) isConformanceResponse_Result() {} +func (*ConformanceResponse_SerializeError) isConformanceResponse_Result() {} +func (*ConformanceResponse_RuntimeError) isConformanceResponse_Result() {} +func (*ConformanceResponse_ProtobufPayload) isConformanceResponse_Result() {} +func (*ConformanceResponse_JsonPayload) isConformanceResponse_Result() {} +func (*ConformanceResponse_Skipped) isConformanceResponse_Result() {} + +func (m *ConformanceResponse) GetResult() isConformanceResponse_Result { + if m != nil { + return m.Result + } + return nil +} + +func (m *ConformanceResponse) GetParseError() string { + if x, ok := m.GetResult().(*ConformanceResponse_ParseError); ok { + return x.ParseError + } + return "" +} + +func (m *ConformanceResponse) GetSerializeError() string { + if x, ok := m.GetResult().(*ConformanceResponse_SerializeError); ok { + return x.SerializeError + } + return "" +} + +func (m *ConformanceResponse) GetRuntimeError() string { + if x, ok := m.GetResult().(*ConformanceResponse_RuntimeError); ok { + return x.RuntimeError + } + return "" +} + +func (m *ConformanceResponse) GetProtobufPayload() []byte { + if x, ok := m.GetResult().(*ConformanceResponse_ProtobufPayload); ok { + return x.ProtobufPayload + } + return nil +} + +func (m *ConformanceResponse) GetJsonPayload() string { + if x, ok := m.GetResult().(*ConformanceResponse_JsonPayload); ok { + return x.JsonPayload + } + return "" +} + +func (m *ConformanceResponse) GetSkipped() string { + if x, ok := m.GetResult().(*ConformanceResponse_Skipped); ok { + return x.Skipped + } + return "" +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*ConformanceResponse) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _ConformanceResponse_OneofMarshaler, _ConformanceResponse_OneofUnmarshaler, _ConformanceResponse_OneofSizer, []interface{}{ + (*ConformanceResponse_ParseError)(nil), + (*ConformanceResponse_SerializeError)(nil), + (*ConformanceResponse_RuntimeError)(nil), + (*ConformanceResponse_ProtobufPayload)(nil), + (*ConformanceResponse_JsonPayload)(nil), + (*ConformanceResponse_Skipped)(nil), + } +} + +func _ConformanceResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*ConformanceResponse) + // result + switch x := m.Result.(type) { + case *ConformanceResponse_ParseError: + b.EncodeVarint(1<<3 | proto.WireBytes) + b.EncodeStringBytes(x.ParseError) + case *ConformanceResponse_SerializeError: + b.EncodeVarint(6<<3 | proto.WireBytes) + b.EncodeStringBytes(x.SerializeError) + case *ConformanceResponse_RuntimeError: + b.EncodeVarint(2<<3 | proto.WireBytes) + b.EncodeStringBytes(x.RuntimeError) + case *ConformanceResponse_ProtobufPayload: + b.EncodeVarint(3<<3 | proto.WireBytes) + b.EncodeRawBytes(x.ProtobufPayload) + case *ConformanceResponse_JsonPayload: + b.EncodeVarint(4<<3 | proto.WireBytes) + b.EncodeStringBytes(x.JsonPayload) + case *ConformanceResponse_Skipped: + b.EncodeVarint(5<<3 | proto.WireBytes) + b.EncodeStringBytes(x.Skipped) + case nil: + default: + return fmt.Errorf("ConformanceResponse.Result has unexpected type %T", x) + } + return nil +} + +func _ConformanceResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*ConformanceResponse) + switch tag { + case 1: // result.parse_error + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Result = &ConformanceResponse_ParseError{x} + return true, err + case 6: // result.serialize_error + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Result = &ConformanceResponse_SerializeError{x} + return true, err + case 2: // result.runtime_error + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Result = &ConformanceResponse_RuntimeError{x} + return true, err + case 3: // result.protobuf_payload + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.Result = &ConformanceResponse_ProtobufPayload{x} + return true, err + case 4: // result.json_payload + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Result = &ConformanceResponse_JsonPayload{x} + return true, err + case 5: // result.skipped + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Result = &ConformanceResponse_Skipped{x} + return true, err + default: + return false, nil + } +} + +func _ConformanceResponse_OneofSizer(msg proto.Message) (n int) { + m := msg.(*ConformanceResponse) + // result + switch x := m.Result.(type) { + case *ConformanceResponse_ParseError: + n += proto.SizeVarint(1<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(len(x.ParseError))) + n += len(x.ParseError) + case *ConformanceResponse_SerializeError: + n += proto.SizeVarint(6<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(len(x.SerializeError))) + n += len(x.SerializeError) + case *ConformanceResponse_RuntimeError: + n += proto.SizeVarint(2<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(len(x.RuntimeError))) + n += len(x.RuntimeError) + case *ConformanceResponse_ProtobufPayload: + n += proto.SizeVarint(3<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(len(x.ProtobufPayload))) + n += len(x.ProtobufPayload) + case *ConformanceResponse_JsonPayload: + n += proto.SizeVarint(4<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(len(x.JsonPayload))) + n += len(x.JsonPayload) + case *ConformanceResponse_Skipped: + n += proto.SizeVarint(5<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(len(x.Skipped))) + n += len(x.Skipped) + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// This proto includes every type of field in both singular and repeated +// forms. +type TestAllTypes struct { + // Singular + OptionalInt32 int32 `protobuf:"varint,1,opt,name=optional_int32,json=optionalInt32" json:"optional_int32,omitempty"` + OptionalInt64 int64 `protobuf:"varint,2,opt,name=optional_int64,json=optionalInt64" json:"optional_int64,omitempty"` + OptionalUint32 uint32 `protobuf:"varint,3,opt,name=optional_uint32,json=optionalUint32" json:"optional_uint32,omitempty"` + OptionalUint64 uint64 `protobuf:"varint,4,opt,name=optional_uint64,json=optionalUint64" json:"optional_uint64,omitempty"` + OptionalSint32 int32 `protobuf:"zigzag32,5,opt,name=optional_sint32,json=optionalSint32" json:"optional_sint32,omitempty"` + OptionalSint64 int64 `protobuf:"zigzag64,6,opt,name=optional_sint64,json=optionalSint64" json:"optional_sint64,omitempty"` + OptionalFixed32 uint32 `protobuf:"fixed32,7,opt,name=optional_fixed32,json=optionalFixed32" json:"optional_fixed32,omitempty"` + OptionalFixed64 uint64 `protobuf:"fixed64,8,opt,name=optional_fixed64,json=optionalFixed64" json:"optional_fixed64,omitempty"` + OptionalSfixed32 int32 `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32" json:"optional_sfixed32,omitempty"` + OptionalSfixed64 int64 `protobuf:"fixed64,10,opt,name=optional_sfixed64,json=optionalSfixed64" json:"optional_sfixed64,omitempty"` + OptionalFloat float32 `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat" json:"optional_float,omitempty"` + OptionalDouble float64 `protobuf:"fixed64,12,opt,name=optional_double,json=optionalDouble" json:"optional_double,omitempty"` + OptionalBool bool `protobuf:"varint,13,opt,name=optional_bool,json=optionalBool" json:"optional_bool,omitempty"` + OptionalString string `protobuf:"bytes,14,opt,name=optional_string,json=optionalString" json:"optional_string,omitempty"` + OptionalBytes []byte `protobuf:"bytes,15,opt,name=optional_bytes,json=optionalBytes,proto3" json:"optional_bytes,omitempty"` + OptionalNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,18,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"` + OptionalForeignMessage *ForeignMessage `protobuf:"bytes,19,opt,name=optional_foreign_message,json=optionalForeignMessage" json:"optional_foreign_message,omitempty"` + OptionalNestedEnum TestAllTypes_NestedEnum `protobuf:"varint,21,opt,name=optional_nested_enum,json=optionalNestedEnum,enum=conformance.TestAllTypes_NestedEnum" json:"optional_nested_enum,omitempty"` + OptionalForeignEnum ForeignEnum `protobuf:"varint,22,opt,name=optional_foreign_enum,json=optionalForeignEnum,enum=conformance.ForeignEnum" json:"optional_foreign_enum,omitempty"` + OptionalStringPiece string `protobuf:"bytes,24,opt,name=optional_string_piece,json=optionalStringPiece" json:"optional_string_piece,omitempty"` + OptionalCord string `protobuf:"bytes,25,opt,name=optional_cord,json=optionalCord" json:"optional_cord,omitempty"` + RecursiveMessage *TestAllTypes `protobuf:"bytes,27,opt,name=recursive_message,json=recursiveMessage" json:"recursive_message,omitempty"` + // Repeated + RepeatedInt32 []int32 `protobuf:"varint,31,rep,packed,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"` + RepeatedInt64 []int64 `protobuf:"varint,32,rep,packed,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"` + RepeatedUint32 []uint32 `protobuf:"varint,33,rep,packed,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"` + RepeatedUint64 []uint64 `protobuf:"varint,34,rep,packed,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"` + RepeatedSint32 []int32 `protobuf:"zigzag32,35,rep,packed,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"` + RepeatedSint64 []int64 `protobuf:"zigzag64,36,rep,packed,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"` + RepeatedFixed32 []uint32 `protobuf:"fixed32,37,rep,packed,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"` + RepeatedFixed64 []uint64 `protobuf:"fixed64,38,rep,packed,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"` + RepeatedSfixed32 []int32 `protobuf:"fixed32,39,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"` + RepeatedSfixed64 []int64 `protobuf:"fixed64,40,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"` + RepeatedFloat []float32 `protobuf:"fixed32,41,rep,packed,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"` + RepeatedDouble []float64 `protobuf:"fixed64,42,rep,packed,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"` + RepeatedBool []bool `protobuf:"varint,43,rep,packed,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"` + RepeatedString []string `protobuf:"bytes,44,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"` + RepeatedBytes [][]byte `protobuf:"bytes,45,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"` + RepeatedNestedMessage []*TestAllTypes_NestedMessage `protobuf:"bytes,48,rep,name=repeated_nested_message,json=repeatedNestedMessage" json:"repeated_nested_message,omitempty"` + RepeatedForeignMessage []*ForeignMessage `protobuf:"bytes,49,rep,name=repeated_foreign_message,json=repeatedForeignMessage" json:"repeated_foreign_message,omitempty"` + RepeatedNestedEnum []TestAllTypes_NestedEnum `protobuf:"varint,51,rep,packed,name=repeated_nested_enum,json=repeatedNestedEnum,enum=conformance.TestAllTypes_NestedEnum" json:"repeated_nested_enum,omitempty"` + RepeatedForeignEnum []ForeignEnum `protobuf:"varint,52,rep,packed,name=repeated_foreign_enum,json=repeatedForeignEnum,enum=conformance.ForeignEnum" json:"repeated_foreign_enum,omitempty"` + RepeatedStringPiece []string `protobuf:"bytes,54,rep,name=repeated_string_piece,json=repeatedStringPiece" json:"repeated_string_piece,omitempty"` + RepeatedCord []string `protobuf:"bytes,55,rep,name=repeated_cord,json=repeatedCord" json:"repeated_cord,omitempty"` + // Map + MapInt32Int32 map[int32]int32 `protobuf:"bytes,56,rep,name=map_int32_int32,json=mapInt32Int32" json:"map_int32_int32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + MapInt64Int64 map[int64]int64 `protobuf:"bytes,57,rep,name=map_int64_int64,json=mapInt64Int64" json:"map_int64_int64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + MapUint32Uint32 map[uint32]uint32 `protobuf:"bytes,58,rep,name=map_uint32_uint32,json=mapUint32Uint32" json:"map_uint32_uint32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + MapUint64Uint64 map[uint64]uint64 `protobuf:"bytes,59,rep,name=map_uint64_uint64,json=mapUint64Uint64" json:"map_uint64_uint64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + MapSint32Sint32 map[int32]int32 `protobuf:"bytes,60,rep,name=map_sint32_sint32,json=mapSint32Sint32" json:"map_sint32_sint32,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"` + MapSint64Sint64 map[int64]int64 `protobuf:"bytes,61,rep,name=map_sint64_sint64,json=mapSint64Sint64" json:"map_sint64_sint64,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"` + MapFixed32Fixed32 map[uint32]uint32 `protobuf:"bytes,62,rep,name=map_fixed32_fixed32,json=mapFixed32Fixed32" json:"map_fixed32_fixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + MapFixed64Fixed64 map[uint64]uint64 `protobuf:"bytes,63,rep,name=map_fixed64_fixed64,json=mapFixed64Fixed64" json:"map_fixed64_fixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + MapSfixed32Sfixed32 map[int32]int32 `protobuf:"bytes,64,rep,name=map_sfixed32_sfixed32,json=mapSfixed32Sfixed32" json:"map_sfixed32_sfixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + MapSfixed64Sfixed64 map[int64]int64 `protobuf:"bytes,65,rep,name=map_sfixed64_sfixed64,json=mapSfixed64Sfixed64" json:"map_sfixed64_sfixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + MapInt32Float map[int32]float32 `protobuf:"bytes,66,rep,name=map_int32_float,json=mapInt32Float" json:"map_int32_float,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + MapInt32Double map[int32]float64 `protobuf:"bytes,67,rep,name=map_int32_double,json=mapInt32Double" json:"map_int32_double,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + MapBoolBool map[bool]bool `protobuf:"bytes,68,rep,name=map_bool_bool,json=mapBoolBool" json:"map_bool_bool,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + MapStringString map[string]string `protobuf:"bytes,69,rep,name=map_string_string,json=mapStringString" json:"map_string_string,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + MapStringBytes map[string][]byte `protobuf:"bytes,70,rep,name=map_string_bytes,json=mapStringBytes" json:"map_string_bytes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value,proto3"` + MapStringNestedMessage map[string]*TestAllTypes_NestedMessage `protobuf:"bytes,71,rep,name=map_string_nested_message,json=mapStringNestedMessage" json:"map_string_nested_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + MapStringForeignMessage map[string]*ForeignMessage `protobuf:"bytes,72,rep,name=map_string_foreign_message,json=mapStringForeignMessage" json:"map_string_foreign_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + MapStringNestedEnum map[string]TestAllTypes_NestedEnum `protobuf:"bytes,73,rep,name=map_string_nested_enum,json=mapStringNestedEnum" json:"map_string_nested_enum,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=conformance.TestAllTypes_NestedEnum"` + MapStringForeignEnum map[string]ForeignEnum `protobuf:"bytes,74,rep,name=map_string_foreign_enum,json=mapStringForeignEnum" json:"map_string_foreign_enum,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=conformance.ForeignEnum"` + // Types that are valid to be assigned to OneofField: + // *TestAllTypes_OneofUint32 + // *TestAllTypes_OneofNestedMessage + // *TestAllTypes_OneofString + // *TestAllTypes_OneofBytes + // *TestAllTypes_OneofBool + // *TestAllTypes_OneofUint64 + // *TestAllTypes_OneofFloat + // *TestAllTypes_OneofDouble + // *TestAllTypes_OneofEnum + OneofField isTestAllTypes_OneofField `protobuf_oneof:"oneof_field"` + // Well-known types + OptionalBoolWrapper *google_protobuf5.BoolValue `protobuf:"bytes,201,opt,name=optional_bool_wrapper,json=optionalBoolWrapper" json:"optional_bool_wrapper,omitempty"` + OptionalInt32Wrapper *google_protobuf5.Int32Value `protobuf:"bytes,202,opt,name=optional_int32_wrapper,json=optionalInt32Wrapper" json:"optional_int32_wrapper,omitempty"` + OptionalInt64Wrapper *google_protobuf5.Int64Value `protobuf:"bytes,203,opt,name=optional_int64_wrapper,json=optionalInt64Wrapper" json:"optional_int64_wrapper,omitempty"` + OptionalUint32Wrapper *google_protobuf5.UInt32Value `protobuf:"bytes,204,opt,name=optional_uint32_wrapper,json=optionalUint32Wrapper" json:"optional_uint32_wrapper,omitempty"` + OptionalUint64Wrapper *google_protobuf5.UInt64Value `protobuf:"bytes,205,opt,name=optional_uint64_wrapper,json=optionalUint64Wrapper" json:"optional_uint64_wrapper,omitempty"` + OptionalFloatWrapper *google_protobuf5.FloatValue `protobuf:"bytes,206,opt,name=optional_float_wrapper,json=optionalFloatWrapper" json:"optional_float_wrapper,omitempty"` + OptionalDoubleWrapper *google_protobuf5.DoubleValue `protobuf:"bytes,207,opt,name=optional_double_wrapper,json=optionalDoubleWrapper" json:"optional_double_wrapper,omitempty"` + OptionalStringWrapper *google_protobuf5.StringValue `protobuf:"bytes,208,opt,name=optional_string_wrapper,json=optionalStringWrapper" json:"optional_string_wrapper,omitempty"` + OptionalBytesWrapper *google_protobuf5.BytesValue `protobuf:"bytes,209,opt,name=optional_bytes_wrapper,json=optionalBytesWrapper" json:"optional_bytes_wrapper,omitempty"` + RepeatedBoolWrapper []*google_protobuf5.BoolValue `protobuf:"bytes,211,rep,name=repeated_bool_wrapper,json=repeatedBoolWrapper" json:"repeated_bool_wrapper,omitempty"` + RepeatedInt32Wrapper []*google_protobuf5.Int32Value `protobuf:"bytes,212,rep,name=repeated_int32_wrapper,json=repeatedInt32Wrapper" json:"repeated_int32_wrapper,omitempty"` + RepeatedInt64Wrapper []*google_protobuf5.Int64Value `protobuf:"bytes,213,rep,name=repeated_int64_wrapper,json=repeatedInt64Wrapper" json:"repeated_int64_wrapper,omitempty"` + RepeatedUint32Wrapper []*google_protobuf5.UInt32Value `protobuf:"bytes,214,rep,name=repeated_uint32_wrapper,json=repeatedUint32Wrapper" json:"repeated_uint32_wrapper,omitempty"` + RepeatedUint64Wrapper []*google_protobuf5.UInt64Value `protobuf:"bytes,215,rep,name=repeated_uint64_wrapper,json=repeatedUint64Wrapper" json:"repeated_uint64_wrapper,omitempty"` + RepeatedFloatWrapper []*google_protobuf5.FloatValue `protobuf:"bytes,216,rep,name=repeated_float_wrapper,json=repeatedFloatWrapper" json:"repeated_float_wrapper,omitempty"` + RepeatedDoubleWrapper []*google_protobuf5.DoubleValue `protobuf:"bytes,217,rep,name=repeated_double_wrapper,json=repeatedDoubleWrapper" json:"repeated_double_wrapper,omitempty"` + RepeatedStringWrapper []*google_protobuf5.StringValue `protobuf:"bytes,218,rep,name=repeated_string_wrapper,json=repeatedStringWrapper" json:"repeated_string_wrapper,omitempty"` + RepeatedBytesWrapper []*google_protobuf5.BytesValue `protobuf:"bytes,219,rep,name=repeated_bytes_wrapper,json=repeatedBytesWrapper" json:"repeated_bytes_wrapper,omitempty"` + OptionalDuration *google_protobuf1.Duration `protobuf:"bytes,301,opt,name=optional_duration,json=optionalDuration" json:"optional_duration,omitempty"` + OptionalTimestamp *google_protobuf4.Timestamp `protobuf:"bytes,302,opt,name=optional_timestamp,json=optionalTimestamp" json:"optional_timestamp,omitempty"` + OptionalFieldMask *google_protobuf2.FieldMask `protobuf:"bytes,303,opt,name=optional_field_mask,json=optionalFieldMask" json:"optional_field_mask,omitempty"` + OptionalStruct *google_protobuf3.Struct `protobuf:"bytes,304,opt,name=optional_struct,json=optionalStruct" json:"optional_struct,omitempty"` + OptionalAny *google_protobuf.Any `protobuf:"bytes,305,opt,name=optional_any,json=optionalAny" json:"optional_any,omitempty"` + OptionalValue *google_protobuf3.Value `protobuf:"bytes,306,opt,name=optional_value,json=optionalValue" json:"optional_value,omitempty"` + RepeatedDuration []*google_protobuf1.Duration `protobuf:"bytes,311,rep,name=repeated_duration,json=repeatedDuration" json:"repeated_duration,omitempty"` + RepeatedTimestamp []*google_protobuf4.Timestamp `protobuf:"bytes,312,rep,name=repeated_timestamp,json=repeatedTimestamp" json:"repeated_timestamp,omitempty"` + RepeatedFieldmask []*google_protobuf2.FieldMask `protobuf:"bytes,313,rep,name=repeated_fieldmask,json=repeatedFieldmask" json:"repeated_fieldmask,omitempty"` + RepeatedStruct []*google_protobuf3.Struct `protobuf:"bytes,324,rep,name=repeated_struct,json=repeatedStruct" json:"repeated_struct,omitempty"` + RepeatedAny []*google_protobuf.Any `protobuf:"bytes,315,rep,name=repeated_any,json=repeatedAny" json:"repeated_any,omitempty"` + RepeatedValue []*google_protobuf3.Value `protobuf:"bytes,316,rep,name=repeated_value,json=repeatedValue" json:"repeated_value,omitempty"` + // Test field-name-to-JSON-name convention. + // (protobuf says names can be any valid C/C++ identifier.) + Fieldname1 int32 `protobuf:"varint,401,opt,name=fieldname1" json:"fieldname1,omitempty"` + FieldName2 int32 `protobuf:"varint,402,opt,name=field_name2,json=fieldName2" json:"field_name2,omitempty"` + XFieldName3 int32 `protobuf:"varint,403,opt,name=_field_name3,json=FieldName3" json:"_field_name3,omitempty"` + Field_Name4_ int32 `protobuf:"varint,404,opt,name=field__name4_,json=fieldName4" json:"field__name4_,omitempty"` + Field0Name5 int32 `protobuf:"varint,405,opt,name=field0name5" json:"field0name5,omitempty"` + Field_0Name6 int32 `protobuf:"varint,406,opt,name=field_0_name6,json=field0Name6" json:"field_0_name6,omitempty"` + FieldName7 int32 `protobuf:"varint,407,opt,name=fieldName7" json:"fieldName7,omitempty"` + FieldName8 int32 `protobuf:"varint,408,opt,name=FieldName8" json:"FieldName8,omitempty"` + Field_Name9 int32 `protobuf:"varint,409,opt,name=field_Name9,json=fieldName9" json:"field_Name9,omitempty"` + Field_Name10 int32 `protobuf:"varint,410,opt,name=Field_Name10,json=FieldName10" json:"Field_Name10,omitempty"` + FIELD_NAME11 int32 `protobuf:"varint,411,opt,name=FIELD_NAME11,json=FIELDNAME11" json:"FIELD_NAME11,omitempty"` + FIELDName12 int32 `protobuf:"varint,412,opt,name=FIELD_name12,json=FIELDName12" json:"FIELD_name12,omitempty"` + XFieldName13 int32 `protobuf:"varint,413,opt,name=__field_name13,json=FieldName13" json:"__field_name13,omitempty"` + X_FieldName14 int32 `protobuf:"varint,414,opt,name=__Field_name14,json=FieldName14" json:"__Field_name14,omitempty"` + Field_Name15 int32 `protobuf:"varint,415,opt,name=field__name15,json=fieldName15" json:"field__name15,omitempty"` + Field__Name16 int32 `protobuf:"varint,416,opt,name=field__Name16,json=fieldName16" json:"field__Name16,omitempty"` + FieldName17__ int32 `protobuf:"varint,417,opt,name=field_name17__,json=fieldName17" json:"field_name17__,omitempty"` + FieldName18__ int32 `protobuf:"varint,418,opt,name=Field_name18__,json=FieldName18" json:"Field_name18__,omitempty"` +} + +func (m *TestAllTypes) Reset() { *m = TestAllTypes{} } +func (m *TestAllTypes) String() string { return proto.CompactTextString(m) } +func (*TestAllTypes) ProtoMessage() {} +func (*TestAllTypes) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } + +type isTestAllTypes_OneofField interface { + isTestAllTypes_OneofField() +} + +type TestAllTypes_OneofUint32 struct { + OneofUint32 uint32 `protobuf:"varint,111,opt,name=oneof_uint32,json=oneofUint32,oneof"` +} +type TestAllTypes_OneofNestedMessage struct { + OneofNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,112,opt,name=oneof_nested_message,json=oneofNestedMessage,oneof"` +} +type TestAllTypes_OneofString struct { + OneofString string `protobuf:"bytes,113,opt,name=oneof_string,json=oneofString,oneof"` +} +type TestAllTypes_OneofBytes struct { + OneofBytes []byte `protobuf:"bytes,114,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"` +} +type TestAllTypes_OneofBool struct { + OneofBool bool `protobuf:"varint,115,opt,name=oneof_bool,json=oneofBool,oneof"` +} +type TestAllTypes_OneofUint64 struct { + OneofUint64 uint64 `protobuf:"varint,116,opt,name=oneof_uint64,json=oneofUint64,oneof"` +} +type TestAllTypes_OneofFloat struct { + OneofFloat float32 `protobuf:"fixed32,117,opt,name=oneof_float,json=oneofFloat,oneof"` +} +type TestAllTypes_OneofDouble struct { + OneofDouble float64 `protobuf:"fixed64,118,opt,name=oneof_double,json=oneofDouble,oneof"` +} +type TestAllTypes_OneofEnum struct { + OneofEnum TestAllTypes_NestedEnum `protobuf:"varint,119,opt,name=oneof_enum,json=oneofEnum,enum=conformance.TestAllTypes_NestedEnum,oneof"` +} + +func (*TestAllTypes_OneofUint32) isTestAllTypes_OneofField() {} +func (*TestAllTypes_OneofNestedMessage) isTestAllTypes_OneofField() {} +func (*TestAllTypes_OneofString) isTestAllTypes_OneofField() {} +func (*TestAllTypes_OneofBytes) isTestAllTypes_OneofField() {} +func (*TestAllTypes_OneofBool) isTestAllTypes_OneofField() {} +func (*TestAllTypes_OneofUint64) isTestAllTypes_OneofField() {} +func (*TestAllTypes_OneofFloat) isTestAllTypes_OneofField() {} +func (*TestAllTypes_OneofDouble) isTestAllTypes_OneofField() {} +func (*TestAllTypes_OneofEnum) isTestAllTypes_OneofField() {} + +func (m *TestAllTypes) GetOneofField() isTestAllTypes_OneofField { + if m != nil { + return m.OneofField + } + return nil +} + +func (m *TestAllTypes) GetOptionalInt32() int32 { + if m != nil { + return m.OptionalInt32 + } + return 0 +} + +func (m *TestAllTypes) GetOptionalInt64() int64 { + if m != nil { + return m.OptionalInt64 + } + return 0 +} + +func (m *TestAllTypes) GetOptionalUint32() uint32 { + if m != nil { + return m.OptionalUint32 + } + return 0 +} + +func (m *TestAllTypes) GetOptionalUint64() uint64 { + if m != nil { + return m.OptionalUint64 + } + return 0 +} + +func (m *TestAllTypes) GetOptionalSint32() int32 { + if m != nil { + return m.OptionalSint32 + } + return 0 +} + +func (m *TestAllTypes) GetOptionalSint64() int64 { + if m != nil { + return m.OptionalSint64 + } + return 0 +} + +func (m *TestAllTypes) GetOptionalFixed32() uint32 { + if m != nil { + return m.OptionalFixed32 + } + return 0 +} + +func (m *TestAllTypes) GetOptionalFixed64() uint64 { + if m != nil { + return m.OptionalFixed64 + } + return 0 +} + +func (m *TestAllTypes) GetOptionalSfixed32() int32 { + if m != nil { + return m.OptionalSfixed32 + } + return 0 +} + +func (m *TestAllTypes) GetOptionalSfixed64() int64 { + if m != nil { + return m.OptionalSfixed64 + } + return 0 +} + +func (m *TestAllTypes) GetOptionalFloat() float32 { + if m != nil { + return m.OptionalFloat + } + return 0 +} + +func (m *TestAllTypes) GetOptionalDouble() float64 { + if m != nil { + return m.OptionalDouble + } + return 0 +} + +func (m *TestAllTypes) GetOptionalBool() bool { + if m != nil { + return m.OptionalBool + } + return false +} + +func (m *TestAllTypes) GetOptionalString() string { + if m != nil { + return m.OptionalString + } + return "" +} + +func (m *TestAllTypes) GetOptionalBytes() []byte { + if m != nil { + return m.OptionalBytes + } + return nil +} + +func (m *TestAllTypes) GetOptionalNestedMessage() *TestAllTypes_NestedMessage { + if m != nil { + return m.OptionalNestedMessage + } + return nil +} + +func (m *TestAllTypes) GetOptionalForeignMessage() *ForeignMessage { + if m != nil { + return m.OptionalForeignMessage + } + return nil +} + +func (m *TestAllTypes) GetOptionalNestedEnum() TestAllTypes_NestedEnum { + if m != nil { + return m.OptionalNestedEnum + } + return TestAllTypes_FOO +} + +func (m *TestAllTypes) GetOptionalForeignEnum() ForeignEnum { + if m != nil { + return m.OptionalForeignEnum + } + return ForeignEnum_FOREIGN_FOO +} + +func (m *TestAllTypes) GetOptionalStringPiece() string { + if m != nil { + return m.OptionalStringPiece + } + return "" +} + +func (m *TestAllTypes) GetOptionalCord() string { + if m != nil { + return m.OptionalCord + } + return "" +} + +func (m *TestAllTypes) GetRecursiveMessage() *TestAllTypes { + if m != nil { + return m.RecursiveMessage + } + return nil +} + +func (m *TestAllTypes) GetRepeatedInt32() []int32 { + if m != nil { + return m.RepeatedInt32 + } + return nil +} + +func (m *TestAllTypes) GetRepeatedInt64() []int64 { + if m != nil { + return m.RepeatedInt64 + } + return nil +} + +func (m *TestAllTypes) GetRepeatedUint32() []uint32 { + if m != nil { + return m.RepeatedUint32 + } + return nil +} + +func (m *TestAllTypes) GetRepeatedUint64() []uint64 { + if m != nil { + return m.RepeatedUint64 + } + return nil +} + +func (m *TestAllTypes) GetRepeatedSint32() []int32 { + if m != nil { + return m.RepeatedSint32 + } + return nil +} + +func (m *TestAllTypes) GetRepeatedSint64() []int64 { + if m != nil { + return m.RepeatedSint64 + } + return nil +} + +func (m *TestAllTypes) GetRepeatedFixed32() []uint32 { + if m != nil { + return m.RepeatedFixed32 + } + return nil +} + +func (m *TestAllTypes) GetRepeatedFixed64() []uint64 { + if m != nil { + return m.RepeatedFixed64 + } + return nil +} + +func (m *TestAllTypes) GetRepeatedSfixed32() []int32 { + if m != nil { + return m.RepeatedSfixed32 + } + return nil +} + +func (m *TestAllTypes) GetRepeatedSfixed64() []int64 { + if m != nil { + return m.RepeatedSfixed64 + } + return nil +} + +func (m *TestAllTypes) GetRepeatedFloat() []float32 { + if m != nil { + return m.RepeatedFloat + } + return nil +} + +func (m *TestAllTypes) GetRepeatedDouble() []float64 { + if m != nil { + return m.RepeatedDouble + } + return nil +} + +func (m *TestAllTypes) GetRepeatedBool() []bool { + if m != nil { + return m.RepeatedBool + } + return nil +} + +func (m *TestAllTypes) GetRepeatedString() []string { + if m != nil { + return m.RepeatedString + } + return nil +} + +func (m *TestAllTypes) GetRepeatedBytes() [][]byte { + if m != nil { + return m.RepeatedBytes + } + return nil +} + +func (m *TestAllTypes) GetRepeatedNestedMessage() []*TestAllTypes_NestedMessage { + if m != nil { + return m.RepeatedNestedMessage + } + return nil +} + +func (m *TestAllTypes) GetRepeatedForeignMessage() []*ForeignMessage { + if m != nil { + return m.RepeatedForeignMessage + } + return nil +} + +func (m *TestAllTypes) GetRepeatedNestedEnum() []TestAllTypes_NestedEnum { + if m != nil { + return m.RepeatedNestedEnum + } + return nil +} + +func (m *TestAllTypes) GetRepeatedForeignEnum() []ForeignEnum { + if m != nil { + return m.RepeatedForeignEnum + } + return nil +} + +func (m *TestAllTypes) GetRepeatedStringPiece() []string { + if m != nil { + return m.RepeatedStringPiece + } + return nil +} + +func (m *TestAllTypes) GetRepeatedCord() []string { + if m != nil { + return m.RepeatedCord + } + return nil +} + +func (m *TestAllTypes) GetMapInt32Int32() map[int32]int32 { + if m != nil { + return m.MapInt32Int32 + } + return nil +} + +func (m *TestAllTypes) GetMapInt64Int64() map[int64]int64 { + if m != nil { + return m.MapInt64Int64 + } + return nil +} + +func (m *TestAllTypes) GetMapUint32Uint32() map[uint32]uint32 { + if m != nil { + return m.MapUint32Uint32 + } + return nil +} + +func (m *TestAllTypes) GetMapUint64Uint64() map[uint64]uint64 { + if m != nil { + return m.MapUint64Uint64 + } + return nil +} + +func (m *TestAllTypes) GetMapSint32Sint32() map[int32]int32 { + if m != nil { + return m.MapSint32Sint32 + } + return nil +} + +func (m *TestAllTypes) GetMapSint64Sint64() map[int64]int64 { + if m != nil { + return m.MapSint64Sint64 + } + return nil +} + +func (m *TestAllTypes) GetMapFixed32Fixed32() map[uint32]uint32 { + if m != nil { + return m.MapFixed32Fixed32 + } + return nil +} + +func (m *TestAllTypes) GetMapFixed64Fixed64() map[uint64]uint64 { + if m != nil { + return m.MapFixed64Fixed64 + } + return nil +} + +func (m *TestAllTypes) GetMapSfixed32Sfixed32() map[int32]int32 { + if m != nil { + return m.MapSfixed32Sfixed32 + } + return nil +} + +func (m *TestAllTypes) GetMapSfixed64Sfixed64() map[int64]int64 { + if m != nil { + return m.MapSfixed64Sfixed64 + } + return nil +} + +func (m *TestAllTypes) GetMapInt32Float() map[int32]float32 { + if m != nil { + return m.MapInt32Float + } + return nil +} + +func (m *TestAllTypes) GetMapInt32Double() map[int32]float64 { + if m != nil { + return m.MapInt32Double + } + return nil +} + +func (m *TestAllTypes) GetMapBoolBool() map[bool]bool { + if m != nil { + return m.MapBoolBool + } + return nil +} + +func (m *TestAllTypes) GetMapStringString() map[string]string { + if m != nil { + return m.MapStringString + } + return nil +} + +func (m *TestAllTypes) GetMapStringBytes() map[string][]byte { + if m != nil { + return m.MapStringBytes + } + return nil +} + +func (m *TestAllTypes) GetMapStringNestedMessage() map[string]*TestAllTypes_NestedMessage { + if m != nil { + return m.MapStringNestedMessage + } + return nil +} + +func (m *TestAllTypes) GetMapStringForeignMessage() map[string]*ForeignMessage { + if m != nil { + return m.MapStringForeignMessage + } + return nil +} + +func (m *TestAllTypes) GetMapStringNestedEnum() map[string]TestAllTypes_NestedEnum { + if m != nil { + return m.MapStringNestedEnum + } + return nil +} + +func (m *TestAllTypes) GetMapStringForeignEnum() map[string]ForeignEnum { + if m != nil { + return m.MapStringForeignEnum + } + return nil +} + +func (m *TestAllTypes) GetOneofUint32() uint32 { + if x, ok := m.GetOneofField().(*TestAllTypes_OneofUint32); ok { + return x.OneofUint32 + } + return 0 +} + +func (m *TestAllTypes) GetOneofNestedMessage() *TestAllTypes_NestedMessage { + if x, ok := m.GetOneofField().(*TestAllTypes_OneofNestedMessage); ok { + return x.OneofNestedMessage + } + return nil +} + +func (m *TestAllTypes) GetOneofString() string { + if x, ok := m.GetOneofField().(*TestAllTypes_OneofString); ok { + return x.OneofString + } + return "" +} + +func (m *TestAllTypes) GetOneofBytes() []byte { + if x, ok := m.GetOneofField().(*TestAllTypes_OneofBytes); ok { + return x.OneofBytes + } + return nil +} + +func (m *TestAllTypes) GetOneofBool() bool { + if x, ok := m.GetOneofField().(*TestAllTypes_OneofBool); ok { + return x.OneofBool + } + return false +} + +func (m *TestAllTypes) GetOneofUint64() uint64 { + if x, ok := m.GetOneofField().(*TestAllTypes_OneofUint64); ok { + return x.OneofUint64 + } + return 0 +} + +func (m *TestAllTypes) GetOneofFloat() float32 { + if x, ok := m.GetOneofField().(*TestAllTypes_OneofFloat); ok { + return x.OneofFloat + } + return 0 +} + +func (m *TestAllTypes) GetOneofDouble() float64 { + if x, ok := m.GetOneofField().(*TestAllTypes_OneofDouble); ok { + return x.OneofDouble + } + return 0 +} + +func (m *TestAllTypes) GetOneofEnum() TestAllTypes_NestedEnum { + if x, ok := m.GetOneofField().(*TestAllTypes_OneofEnum); ok { + return x.OneofEnum + } + return TestAllTypes_FOO +} + +func (m *TestAllTypes) GetOptionalBoolWrapper() *google_protobuf5.BoolValue { + if m != nil { + return m.OptionalBoolWrapper + } + return nil +} + +func (m *TestAllTypes) GetOptionalInt32Wrapper() *google_protobuf5.Int32Value { + if m != nil { + return m.OptionalInt32Wrapper + } + return nil +} + +func (m *TestAllTypes) GetOptionalInt64Wrapper() *google_protobuf5.Int64Value { + if m != nil { + return m.OptionalInt64Wrapper + } + return nil +} + +func (m *TestAllTypes) GetOptionalUint32Wrapper() *google_protobuf5.UInt32Value { + if m != nil { + return m.OptionalUint32Wrapper + } + return nil +} + +func (m *TestAllTypes) GetOptionalUint64Wrapper() *google_protobuf5.UInt64Value { + if m != nil { + return m.OptionalUint64Wrapper + } + return nil +} + +func (m *TestAllTypes) GetOptionalFloatWrapper() *google_protobuf5.FloatValue { + if m != nil { + return m.OptionalFloatWrapper + } + return nil +} + +func (m *TestAllTypes) GetOptionalDoubleWrapper() *google_protobuf5.DoubleValue { + if m != nil { + return m.OptionalDoubleWrapper + } + return nil +} + +func (m *TestAllTypes) GetOptionalStringWrapper() *google_protobuf5.StringValue { + if m != nil { + return m.OptionalStringWrapper + } + return nil +} + +func (m *TestAllTypes) GetOptionalBytesWrapper() *google_protobuf5.BytesValue { + if m != nil { + return m.OptionalBytesWrapper + } + return nil +} + +func (m *TestAllTypes) GetRepeatedBoolWrapper() []*google_protobuf5.BoolValue { + if m != nil { + return m.RepeatedBoolWrapper + } + return nil +} + +func (m *TestAllTypes) GetRepeatedInt32Wrapper() []*google_protobuf5.Int32Value { + if m != nil { + return m.RepeatedInt32Wrapper + } + return nil +} + +func (m *TestAllTypes) GetRepeatedInt64Wrapper() []*google_protobuf5.Int64Value { + if m != nil { + return m.RepeatedInt64Wrapper + } + return nil +} + +func (m *TestAllTypes) GetRepeatedUint32Wrapper() []*google_protobuf5.UInt32Value { + if m != nil { + return m.RepeatedUint32Wrapper + } + return nil +} + +func (m *TestAllTypes) GetRepeatedUint64Wrapper() []*google_protobuf5.UInt64Value { + if m != nil { + return m.RepeatedUint64Wrapper + } + return nil +} + +func (m *TestAllTypes) GetRepeatedFloatWrapper() []*google_protobuf5.FloatValue { + if m != nil { + return m.RepeatedFloatWrapper + } + return nil +} + +func (m *TestAllTypes) GetRepeatedDoubleWrapper() []*google_protobuf5.DoubleValue { + if m != nil { + return m.RepeatedDoubleWrapper + } + return nil +} + +func (m *TestAllTypes) GetRepeatedStringWrapper() []*google_protobuf5.StringValue { + if m != nil { + return m.RepeatedStringWrapper + } + return nil +} + +func (m *TestAllTypes) GetRepeatedBytesWrapper() []*google_protobuf5.BytesValue { + if m != nil { + return m.RepeatedBytesWrapper + } + return nil +} + +func (m *TestAllTypes) GetOptionalDuration() *google_protobuf1.Duration { + if m != nil { + return m.OptionalDuration + } + return nil +} + +func (m *TestAllTypes) GetOptionalTimestamp() *google_protobuf4.Timestamp { + if m != nil { + return m.OptionalTimestamp + } + return nil +} + +func (m *TestAllTypes) GetOptionalFieldMask() *google_protobuf2.FieldMask { + if m != nil { + return m.OptionalFieldMask + } + return nil +} + +func (m *TestAllTypes) GetOptionalStruct() *google_protobuf3.Struct { + if m != nil { + return m.OptionalStruct + } + return nil +} + +func (m *TestAllTypes) GetOptionalAny() *google_protobuf.Any { + if m != nil { + return m.OptionalAny + } + return nil +} + +func (m *TestAllTypes) GetOptionalValue() *google_protobuf3.Value { + if m != nil { + return m.OptionalValue + } + return nil +} + +func (m *TestAllTypes) GetRepeatedDuration() []*google_protobuf1.Duration { + if m != nil { + return m.RepeatedDuration + } + return nil +} + +func (m *TestAllTypes) GetRepeatedTimestamp() []*google_protobuf4.Timestamp { + if m != nil { + return m.RepeatedTimestamp + } + return nil +} + +func (m *TestAllTypes) GetRepeatedFieldmask() []*google_protobuf2.FieldMask { + if m != nil { + return m.RepeatedFieldmask + } + return nil +} + +func (m *TestAllTypes) GetRepeatedStruct() []*google_protobuf3.Struct { + if m != nil { + return m.RepeatedStruct + } + return nil +} + +func (m *TestAllTypes) GetRepeatedAny() []*google_protobuf.Any { + if m != nil { + return m.RepeatedAny + } + return nil +} + +func (m *TestAllTypes) GetRepeatedValue() []*google_protobuf3.Value { + if m != nil { + return m.RepeatedValue + } + return nil +} + +func (m *TestAllTypes) GetFieldname1() int32 { + if m != nil { + return m.Fieldname1 + } + return 0 +} + +func (m *TestAllTypes) GetFieldName2() int32 { + if m != nil { + return m.FieldName2 + } + return 0 +} + +func (m *TestAllTypes) GetXFieldName3() int32 { + if m != nil { + return m.XFieldName3 + } + return 0 +} + +func (m *TestAllTypes) GetField_Name4_() int32 { + if m != nil { + return m.Field_Name4_ + } + return 0 +} + +func (m *TestAllTypes) GetField0Name5() int32 { + if m != nil { + return m.Field0Name5 + } + return 0 +} + +func (m *TestAllTypes) GetField_0Name6() int32 { + if m != nil { + return m.Field_0Name6 + } + return 0 +} + +func (m *TestAllTypes) GetFieldName7() int32 { + if m != nil { + return m.FieldName7 + } + return 0 +} + +func (m *TestAllTypes) GetFieldName8() int32 { + if m != nil { + return m.FieldName8 + } + return 0 +} + +func (m *TestAllTypes) GetField_Name9() int32 { + if m != nil { + return m.Field_Name9 + } + return 0 +} + +func (m *TestAllTypes) GetField_Name10() int32 { + if m != nil { + return m.Field_Name10 + } + return 0 +} + +func (m *TestAllTypes) GetFIELD_NAME11() int32 { + if m != nil { + return m.FIELD_NAME11 + } + return 0 +} + +func (m *TestAllTypes) GetFIELDName12() int32 { + if m != nil { + return m.FIELDName12 + } + return 0 +} + +func (m *TestAllTypes) GetXFieldName13() int32 { + if m != nil { + return m.XFieldName13 + } + return 0 +} + +func (m *TestAllTypes) GetX_FieldName14() int32 { + if m != nil { + return m.X_FieldName14 + } + return 0 +} + +func (m *TestAllTypes) GetField_Name15() int32 { + if m != nil { + return m.Field_Name15 + } + return 0 +} + +func (m *TestAllTypes) GetField__Name16() int32 { + if m != nil { + return m.Field__Name16 + } + return 0 +} + +func (m *TestAllTypes) GetFieldName17__() int32 { + if m != nil { + return m.FieldName17__ + } + return 0 +} + +func (m *TestAllTypes) GetFieldName18__() int32 { + if m != nil { + return m.FieldName18__ + } + return 0 +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*TestAllTypes) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _TestAllTypes_OneofMarshaler, _TestAllTypes_OneofUnmarshaler, _TestAllTypes_OneofSizer, []interface{}{ + (*TestAllTypes_OneofUint32)(nil), + (*TestAllTypes_OneofNestedMessage)(nil), + (*TestAllTypes_OneofString)(nil), + (*TestAllTypes_OneofBytes)(nil), + (*TestAllTypes_OneofBool)(nil), + (*TestAllTypes_OneofUint64)(nil), + (*TestAllTypes_OneofFloat)(nil), + (*TestAllTypes_OneofDouble)(nil), + (*TestAllTypes_OneofEnum)(nil), + } +} + +func _TestAllTypes_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*TestAllTypes) + // oneof_field + switch x := m.OneofField.(type) { + case *TestAllTypes_OneofUint32: + b.EncodeVarint(111<<3 | proto.WireVarint) + b.EncodeVarint(uint64(x.OneofUint32)) + case *TestAllTypes_OneofNestedMessage: + b.EncodeVarint(112<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.OneofNestedMessage); err != nil { + return err + } + case *TestAllTypes_OneofString: + b.EncodeVarint(113<<3 | proto.WireBytes) + b.EncodeStringBytes(x.OneofString) + case *TestAllTypes_OneofBytes: + b.EncodeVarint(114<<3 | proto.WireBytes) + b.EncodeRawBytes(x.OneofBytes) + case *TestAllTypes_OneofBool: + t := uint64(0) + if x.OneofBool { + t = 1 + } + b.EncodeVarint(115<<3 | proto.WireVarint) + b.EncodeVarint(t) + case *TestAllTypes_OneofUint64: + b.EncodeVarint(116<<3 | proto.WireVarint) + b.EncodeVarint(uint64(x.OneofUint64)) + case *TestAllTypes_OneofFloat: + b.EncodeVarint(117<<3 | proto.WireFixed32) + b.EncodeFixed32(uint64(math.Float32bits(x.OneofFloat))) + case *TestAllTypes_OneofDouble: + b.EncodeVarint(118<<3 | proto.WireFixed64) + b.EncodeFixed64(math.Float64bits(x.OneofDouble)) + case *TestAllTypes_OneofEnum: + b.EncodeVarint(119<<3 | proto.WireVarint) + b.EncodeVarint(uint64(x.OneofEnum)) + case nil: + default: + return fmt.Errorf("TestAllTypes.OneofField has unexpected type %T", x) + } + return nil +} + +func _TestAllTypes_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*TestAllTypes) + switch tag { + case 111: // oneof_field.oneof_uint32 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.OneofField = &TestAllTypes_OneofUint32{uint32(x)} + return true, err + case 112: // oneof_field.oneof_nested_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(TestAllTypes_NestedMessage) + err := b.DecodeMessage(msg) + m.OneofField = &TestAllTypes_OneofNestedMessage{msg} + return true, err + case 113: // oneof_field.oneof_string + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.OneofField = &TestAllTypes_OneofString{x} + return true, err + case 114: // oneof_field.oneof_bytes + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.OneofField = &TestAllTypes_OneofBytes{x} + return true, err + case 115: // oneof_field.oneof_bool + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.OneofField = &TestAllTypes_OneofBool{x != 0} + return true, err + case 116: // oneof_field.oneof_uint64 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.OneofField = &TestAllTypes_OneofUint64{x} + return true, err + case 117: // oneof_field.oneof_float + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.OneofField = &TestAllTypes_OneofFloat{math.Float32frombits(uint32(x))} + return true, err + case 118: // oneof_field.oneof_double + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.OneofField = &TestAllTypes_OneofDouble{math.Float64frombits(x)} + return true, err + case 119: // oneof_field.oneof_enum + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.OneofField = &TestAllTypes_OneofEnum{TestAllTypes_NestedEnum(x)} + return true, err + default: + return false, nil + } +} + +func _TestAllTypes_OneofSizer(msg proto.Message) (n int) { + m := msg.(*TestAllTypes) + // oneof_field + switch x := m.OneofField.(type) { + case *TestAllTypes_OneofUint32: + n += proto.SizeVarint(111<<3 | proto.WireVarint) + n += proto.SizeVarint(uint64(x.OneofUint32)) + case *TestAllTypes_OneofNestedMessage: + s := proto.Size(x.OneofNestedMessage) + n += proto.SizeVarint(112<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case *TestAllTypes_OneofString: + n += proto.SizeVarint(113<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(len(x.OneofString))) + n += len(x.OneofString) + case *TestAllTypes_OneofBytes: + n += proto.SizeVarint(114<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(len(x.OneofBytes))) + n += len(x.OneofBytes) + case *TestAllTypes_OneofBool: + n += proto.SizeVarint(115<<3 | proto.WireVarint) + n += 1 + case *TestAllTypes_OneofUint64: + n += proto.SizeVarint(116<<3 | proto.WireVarint) + n += proto.SizeVarint(uint64(x.OneofUint64)) + case *TestAllTypes_OneofFloat: + n += proto.SizeVarint(117<<3 | proto.WireFixed32) + n += 4 + case *TestAllTypes_OneofDouble: + n += proto.SizeVarint(118<<3 | proto.WireFixed64) + n += 8 + case *TestAllTypes_OneofEnum: + n += proto.SizeVarint(119<<3 | proto.WireVarint) + n += proto.SizeVarint(uint64(x.OneofEnum)) + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +type TestAllTypes_NestedMessage struct { + A int32 `protobuf:"varint,1,opt,name=a" json:"a,omitempty"` + Corecursive *TestAllTypes `protobuf:"bytes,2,opt,name=corecursive" json:"corecursive,omitempty"` +} + +func (m *TestAllTypes_NestedMessage) Reset() { *m = TestAllTypes_NestedMessage{} } +func (m *TestAllTypes_NestedMessage) String() string { return proto.CompactTextString(m) } +func (*TestAllTypes_NestedMessage) ProtoMessage() {} +func (*TestAllTypes_NestedMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} } + +func (m *TestAllTypes_NestedMessage) GetA() int32 { + if m != nil { + return m.A + } + return 0 +} + +func (m *TestAllTypes_NestedMessage) GetCorecursive() *TestAllTypes { + if m != nil { + return m.Corecursive + } + return nil +} + +type ForeignMessage struct { + C int32 `protobuf:"varint,1,opt,name=c" json:"c,omitempty"` +} + +func (m *ForeignMessage) Reset() { *m = ForeignMessage{} } +func (m *ForeignMessage) String() string { return proto.CompactTextString(m) } +func (*ForeignMessage) ProtoMessage() {} +func (*ForeignMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } + +func (m *ForeignMessage) GetC() int32 { + if m != nil { + return m.C + } + return 0 +} + +func init() { + proto.RegisterType((*ConformanceRequest)(nil), "conformance.ConformanceRequest") + proto.RegisterType((*ConformanceResponse)(nil), "conformance.ConformanceResponse") + proto.RegisterType((*TestAllTypes)(nil), "conformance.TestAllTypes") + proto.RegisterType((*TestAllTypes_NestedMessage)(nil), "conformance.TestAllTypes.NestedMessage") + proto.RegisterType((*ForeignMessage)(nil), "conformance.ForeignMessage") + proto.RegisterEnum("conformance.WireFormat", WireFormat_name, WireFormat_value) + proto.RegisterEnum("conformance.ForeignEnum", ForeignEnum_name, ForeignEnum_value) + proto.RegisterEnum("conformance.TestAllTypes_NestedEnum", TestAllTypes_NestedEnum_name, TestAllTypes_NestedEnum_value) +} + +func init() { proto.RegisterFile("conformance_proto/conformance.proto", fileDescriptor0) } + +var fileDescriptor0 = []byte{ + // 2737 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x5a, 0xd9, 0x72, 0xdb, 0xc8, + 0xd5, 0x16, 0x08, 0x59, 0x4b, 0x93, 0x92, 0xa8, 0xd6, 0xd6, 0x96, 0x5d, 0x63, 0x58, 0xb2, 0x7f, + 0xd3, 0xf6, 0x8c, 0xac, 0x05, 0x86, 0x65, 0xcf, 0x3f, 0x8e, 0x45, 0x9b, 0xb4, 0xe4, 0x8c, 0x25, + 0x17, 0x64, 0x8d, 0xab, 0x9c, 0x0b, 0x06, 0xa6, 0x20, 0x15, 0xc7, 0x24, 0xc1, 0x01, 0x48, 0x4f, + 0x94, 0xcb, 0xbc, 0x41, 0xf6, 0x7d, 0xbd, 0xcf, 0x7a, 0x93, 0xa4, 0x92, 0xab, 0x54, 0x6e, 0xb2, + 0x27, 0x95, 0x3d, 0x79, 0x85, 0xbc, 0x43, 0x52, 0xbd, 0xa2, 0xbb, 0x01, 0x50, 0xf4, 0x54, 0x0d, + 0x25, 0x1e, 0x7c, 0xfd, 0x9d, 0xd3, 0xe7, 0x1c, 0x7c, 0x2d, 0x1c, 0x18, 0x2c, 0xd7, 0x83, 0xf6, + 0x51, 0x10, 0xb6, 0xbc, 0x76, 0xdd, 0xaf, 0x75, 0xc2, 0xa0, 0x1b, 0xdc, 0x90, 0x2c, 0x2b, 0xc4, + 0x02, 0xf3, 0x92, 0x69, 0xf1, 0xec, 0x71, 0x10, 0x1c, 0x37, 0xfd, 0x1b, 0xe4, 0xd2, 0x8b, 0xde, + 0xd1, 0x0d, 0xaf, 0x7d, 0x42, 0x71, 0x8b, 0x6f, 0xe8, 0x97, 0x0e, 0x7b, 0xa1, 0xd7, 0x6d, 0x04, + 0x6d, 0x76, 0xdd, 0xd2, 0xaf, 0x1f, 0x35, 0xfc, 0xe6, 0x61, 0xad, 0xe5, 0x45, 0x2f, 0x19, 0xe2, + 0xbc, 0x8e, 0x88, 0xba, 0x61, 0xaf, 0xde, 0x65, 0x57, 0x2f, 0xe8, 0x57, 0xbb, 0x8d, 0x96, 0x1f, + 0x75, 0xbd, 0x56, 0x27, 0x2b, 0x80, 0x0f, 0x43, 0xaf, 0xd3, 0xf1, 0xc3, 0x88, 0x5e, 0x5f, 0xfa, + 0x85, 0x01, 0xe0, 0xfd, 0x78, 0x2f, 0xae, 0xff, 0x41, 0xcf, 0x8f, 0xba, 0xf0, 0x3a, 0x28, 0xf2, + 0x15, 0xb5, 0x8e, 0x77, 0xd2, 0x0c, 0xbc, 0x43, 0x64, 0x58, 0x46, 0xa9, 0xb0, 0x3d, 0xe4, 0x4e, + 0xf1, 0x2b, 0x4f, 0xe8, 0x05, 0xb8, 0x0c, 0x0a, 0xef, 0x47, 0x41, 0x5b, 0x00, 0x73, 0x96, 0x51, + 0x1a, 0xdf, 0x1e, 0x72, 0xf3, 0xd8, 0xca, 0x41, 0x7b, 0x60, 0x21, 0xa4, 0xe4, 0xfe, 0x61, 0x2d, + 0xe8, 0x75, 0x3b, 0xbd, 0x6e, 0x8d, 0x78, 0xed, 0x22, 0xd3, 0x32, 0x4a, 0x93, 0xeb, 0x0b, 0x2b, + 0x72, 0x9a, 0x9f, 0x35, 0x42, 0xbf, 0x4a, 0x2e, 0xbb, 0x73, 0x62, 0xdd, 0x1e, 0x59, 0x46, 0xcd, + 0xe5, 0x71, 0x30, 0xca, 0x1c, 0x2e, 0x7d, 0x2a, 0x07, 0x66, 0x94, 0x4d, 0x44, 0x9d, 0xa0, 0x1d, + 0xf9, 0xf0, 0x22, 0xc8, 0x77, 0xbc, 0x30, 0xf2, 0x6b, 0x7e, 0x18, 0x06, 0x21, 0xd9, 0x00, 0x8e, + 0x0b, 0x10, 0x63, 0x05, 0xdb, 0xe0, 0x55, 0x30, 0x15, 0xf9, 0x61, 0xc3, 0x6b, 0x36, 0x3e, 0xc9, + 0x61, 0x23, 0x0c, 0x36, 0x29, 0x2e, 0x50, 0xe8, 0x65, 0x30, 0x11, 0xf6, 0xda, 0x38, 0xc1, 0x0c, + 0xc8, 0xf7, 0x59, 0x60, 0x66, 0x0a, 0x4b, 0x4b, 0x9d, 0x39, 0x68, 0xea, 0x86, 0xd3, 0x52, 0xb7, + 0x08, 0x46, 0xa3, 0x97, 0x8d, 0x4e, 0xc7, 0x3f, 0x44, 0x67, 0xd8, 0x75, 0x6e, 0x28, 0x8f, 0x81, + 0x91, 0xd0, 0x8f, 0x7a, 0xcd, 0xee, 0xd2, 0x7f, 0xaa, 0xa0, 0xf0, 0xd4, 0x8f, 0xba, 0x5b, 0xcd, + 0xe6, 0xd3, 0x93, 0x8e, 0x1f, 0xc1, 0xcb, 0x60, 0x32, 0xe8, 0xe0, 0x5e, 0xf3, 0x9a, 0xb5, 0x46, + 0xbb, 0xbb, 0xb1, 0x4e, 0x12, 0x70, 0xc6, 0x9d, 0xe0, 0xd6, 0x1d, 0x6c, 0xd4, 0x61, 0x8e, 0x4d, + 0xf6, 0x65, 0x2a, 0x30, 0xc7, 0x86, 0x57, 0xc0, 0x94, 0x80, 0xf5, 0x28, 0x1d, 0xde, 0xd5, 0x84, + 0x2b, 0x56, 0x1f, 0x10, 0x6b, 0x02, 0xe8, 0xd8, 0x64, 0x57, 0xc3, 0x2a, 0x50, 0x63, 0x8c, 0x28, + 0x23, 0xde, 0xde, 0x74, 0x0c, 0xdc, 0x4f, 0x32, 0x46, 0x94, 0x11, 0xd7, 0x08, 0xaa, 0x40, 0xc7, + 0x86, 0x57, 0x41, 0x51, 0x00, 0x8f, 0x1a, 0x9f, 0xf0, 0x0f, 0x37, 0xd6, 0xd1, 0xa8, 0x65, 0x94, + 0x46, 0x5d, 0x41, 0x50, 0xa5, 0xe6, 0x24, 0xd4, 0xb1, 0xd1, 0x98, 0x65, 0x94, 0x46, 0x34, 0xa8, + 0x63, 0xc3, 0xeb, 0x60, 0x3a, 0x76, 0xcf, 0x69, 0xc7, 0x2d, 0xa3, 0x34, 0xe5, 0x0a, 0x8e, 0x7d, + 0x66, 0x4f, 0x01, 0x3b, 0x36, 0x02, 0x96, 0x51, 0x2a, 0xea, 0x60, 0xc7, 0x56, 0x52, 0x7f, 0xd4, + 0x0c, 0xbc, 0x2e, 0xca, 0x5b, 0x46, 0x29, 0x17, 0xa7, 0xbe, 0x8a, 0x8d, 0xca, 0xfe, 0x0f, 0x83, + 0xde, 0x8b, 0xa6, 0x8f, 0x0a, 0x96, 0x51, 0x32, 0xe2, 0xfd, 0x3f, 0x20, 0x56, 0xb8, 0x0c, 0xc4, + 0xca, 0xda, 0x8b, 0x20, 0x68, 0xa2, 0x09, 0xcb, 0x28, 0x8d, 0xb9, 0x05, 0x6e, 0x2c, 0x07, 0x41, + 0x53, 0xcd, 0x66, 0x37, 0x6c, 0xb4, 0x8f, 0xd1, 0x24, 0xee, 0x2a, 0x29, 0x9b, 0xc4, 0xaa, 0x44, + 0xf7, 0xe2, 0xa4, 0xeb, 0x47, 0x68, 0x0a, 0xb7, 0x71, 0x1c, 0x5d, 0x19, 0x1b, 0x61, 0x0d, 0x2c, + 0x08, 0x58, 0x9b, 0xde, 0xde, 0x2d, 0x3f, 0x8a, 0xbc, 0x63, 0x1f, 0x41, 0xcb, 0x28, 0xe5, 0xd7, + 0xaf, 0x28, 0x37, 0xb6, 0xdc, 0xa2, 0x2b, 0xbb, 0x04, 0xff, 0x98, 0xc2, 0xdd, 0x39, 0xce, 0xa3, + 0x98, 0xe1, 0x01, 0x40, 0x71, 0x96, 0x82, 0xd0, 0x6f, 0x1c, 0xb7, 0x85, 0x87, 0x19, 0xe2, 0xe1, + 0x9c, 0xe2, 0xa1, 0x4a, 0x31, 0x9c, 0x75, 0x5e, 0x24, 0x53, 0xb1, 0xc3, 0xf7, 0xc0, 0xac, 0x1e, + 0xb7, 0xdf, 0xee, 0xb5, 0xd0, 0x1c, 0x51, 0xa3, 0x4b, 0xa7, 0x05, 0x5d, 0x69, 0xf7, 0x5a, 0x2e, + 0x54, 0x23, 0xc6, 0x36, 0xf8, 0x2e, 0x98, 0x4b, 0x84, 0x4b, 0x88, 0xe7, 0x09, 0x31, 0x4a, 0x8b, + 0x95, 0x90, 0xcd, 0x68, 0x81, 0x12, 0x36, 0x47, 0x62, 0xa3, 0xd5, 0xaa, 0x75, 0x1a, 0x7e, 0xdd, + 0x47, 0x08, 0xd7, 0xac, 0x9c, 0x1b, 0xcb, 0xc5, 0xeb, 0x68, 0xdd, 0x9e, 0xe0, 0xcb, 0xf0, 0x8a, + 0xd4, 0x0a, 0xf5, 0x20, 0x3c, 0x44, 0x67, 0x19, 0xde, 0x88, 0xdb, 0xe1, 0x7e, 0x10, 0x1e, 0xc2, + 0x2a, 0x98, 0x0e, 0xfd, 0x7a, 0x2f, 0x8c, 0x1a, 0xaf, 0x7c, 0x91, 0xd6, 0x73, 0x24, 0xad, 0x67, + 0x33, 0x73, 0xe0, 0x16, 0xc5, 0x1a, 0x9e, 0xce, 0xcb, 0x60, 0x32, 0xf4, 0x3b, 0xbe, 0x87, 0xf3, + 0x48, 0x6f, 0xe6, 0x0b, 0x96, 0x89, 0xd5, 0x86, 0x5b, 0x85, 0xda, 0xc8, 0x30, 0xc7, 0x46, 0x96, + 0x65, 0x62, 0xb5, 0x91, 0x60, 0x54, 0x1b, 0x04, 0x8c, 0xa9, 0xcd, 0x45, 0xcb, 0xc4, 0x6a, 0xc3, + 0xcd, 0xb1, 0xda, 0x28, 0x40, 0xc7, 0x46, 0x4b, 0x96, 0x89, 0xd5, 0x46, 0x06, 0x6a, 0x8c, 0x4c, + 0x6d, 0x96, 0x2d, 0x13, 0xab, 0x0d, 0x37, 0xef, 0x27, 0x19, 0x99, 0xda, 0x5c, 0xb2, 0x4c, 0xac, + 0x36, 0x32, 0x90, 0xaa, 0x8d, 0x00, 0x72, 0x59, 0xb8, 0x6c, 0x99, 0x58, 0x6d, 0xb8, 0x5d, 0x52, + 0x1b, 0x15, 0xea, 0xd8, 0xe8, 0xff, 0x2c, 0x13, 0xab, 0x8d, 0x02, 0xa5, 0x6a, 0x13, 0xbb, 0xe7, + 0xb4, 0x57, 0x2c, 0x13, 0xab, 0x8d, 0x08, 0x40, 0x52, 0x1b, 0x0d, 0xec, 0xd8, 0xa8, 0x64, 0x99, + 0x58, 0x6d, 0x54, 0x30, 0x55, 0x9b, 0x38, 0x08, 0xa2, 0x36, 0x57, 0x2d, 0x13, 0xab, 0x8d, 0x08, + 0x81, 0xab, 0x8d, 0x80, 0x31, 0xb5, 0xb9, 0x66, 0x99, 0x58, 0x6d, 0xb8, 0x39, 0x56, 0x1b, 0x01, + 0x24, 0x6a, 0x73, 0xdd, 0x32, 0xb1, 0xda, 0x70, 0x23, 0x57, 0x9b, 0x38, 0x42, 0xaa, 0x36, 0x6f, + 0x5a, 0x26, 0x56, 0x1b, 0x11, 0x9f, 0x50, 0x9b, 0x98, 0x8d, 0xa8, 0xcd, 0x5b, 0x96, 0x89, 0xd5, + 0x46, 0xd0, 0x71, 0xb5, 0x11, 0x30, 0x4d, 0x6d, 0x56, 0x2d, 0xf3, 0xb5, 0xd4, 0x86, 0xf3, 0x24, + 0xd4, 0x26, 0xce, 0x92, 0xa6, 0x36, 0x6b, 0xc4, 0x43, 0x7f, 0xb5, 0x11, 0xc9, 0x4c, 0xa8, 0x8d, + 0x1e, 0x37, 0x11, 0x85, 0x0d, 0xcb, 0x1c, 0x5c, 0x6d, 0xd4, 0x88, 0xb9, 0xda, 0x24, 0xc2, 0x25, + 0xc4, 0x36, 0x21, 0xee, 0xa3, 0x36, 0x5a, 0xa0, 0x5c, 0x6d, 0xb4, 0x6a, 0x31, 0xb5, 0x71, 0x70, + 0xcd, 0xa8, 0xda, 0xa8, 0x75, 0x13, 0x6a, 0x23, 0xd6, 0x11, 0xb5, 0xb9, 0xc5, 0xf0, 0x46, 0xdc, + 0x0e, 0x44, 0x6d, 0x9e, 0x82, 0xa9, 0x96, 0xd7, 0xa1, 0x02, 0xc1, 0x64, 0x62, 0x93, 0x24, 0xf5, + 0xcd, 0xec, 0x0c, 0x3c, 0xf6, 0x3a, 0x44, 0x3b, 0xc8, 0x47, 0xa5, 0xdd, 0x0d, 0x4f, 0xdc, 0x89, + 0x96, 0x6c, 0x93, 0x58, 0x1d, 0x9b, 0xa9, 0xca, 0xed, 0xc1, 0x58, 0x1d, 0x9b, 0x7c, 0x28, 0xac, + 0xcc, 0x06, 0x9f, 0x83, 0x69, 0xcc, 0x4a, 0xe5, 0x87, 0xab, 0xd0, 0x1d, 0xc2, 0xbb, 0xd2, 0x97, + 0x97, 0x4a, 0x13, 0xfd, 0xa4, 0xcc, 0x38, 0x3c, 0xd9, 0x2a, 0x73, 0x3b, 0x36, 0x17, 0xae, 0xb7, + 0x07, 0xe4, 0x76, 0x6c, 0xfa, 0xa9, 0x72, 0x73, 0x2b, 0xe7, 0xa6, 0x22, 0xc7, 0xb5, 0xee, 0xff, + 0x07, 0xe0, 0xa6, 0x02, 0xb8, 0xaf, 0xc5, 0x2d, 0x5b, 0x65, 0x6e, 0xc7, 0xe6, 0xf2, 0xf8, 0xce, + 0x80, 0xdc, 0x8e, 0xbd, 0xaf, 0xc5, 0x2d, 0x5b, 0xe1, 0xc7, 0xc1, 0x0c, 0xe6, 0x66, 0xda, 0x26, + 0x24, 0xf5, 0x2e, 0x61, 0x5f, 0xed, 0xcb, 0xce, 0x74, 0x96, 0xfd, 0xa0, 0xfc, 0x38, 0x50, 0xd5, + 0xae, 0x78, 0x70, 0x6c, 0xa1, 0xc4, 0x1f, 0x19, 0xd4, 0x83, 0x63, 0xb3, 0x1f, 0x9a, 0x07, 0x61, + 0x87, 0x47, 0x60, 0x8e, 0xe4, 0x87, 0x6f, 0x42, 0x28, 0xf8, 0x3d, 0xe2, 0x63, 0xbd, 0x7f, 0x8e, + 0x18, 0x98, 0xff, 0xa4, 0x5e, 0x70, 0xc8, 0xfa, 0x15, 0xd5, 0x0f, 0xae, 0x04, 0xdf, 0xcb, 0xd6, + 0xc0, 0x7e, 0x1c, 0x9b, 0xff, 0xd4, 0xfd, 0xc4, 0x57, 0xd4, 0xfb, 0x95, 0x1e, 0x1a, 0xe5, 0x41, + 0xef, 0x57, 0x72, 0x9c, 0x68, 0xf7, 0x2b, 0x3d, 0x62, 0x9e, 0x81, 0x62, 0xcc, 0xca, 0xce, 0x98, + 0xfb, 0x84, 0xf6, 0xad, 0xd3, 0x69, 0xe9, 0xe9, 0x43, 0x79, 0x27, 0x5b, 0x8a, 0x11, 0xee, 0x02, + 0xec, 0x89, 0x9c, 0x46, 0xf4, 0x48, 0x7a, 0x40, 0x58, 0xaf, 0xf5, 0x65, 0xc5, 0xe7, 0x14, 0xfe, + 0x9f, 0x52, 0xe6, 0x5b, 0xb1, 0x45, 0xb4, 0x3b, 0x95, 0x42, 0x76, 0x7e, 0x55, 0x06, 0x69, 0x77, + 0x02, 0xa5, 0x9f, 0x52, 0xbb, 0x4b, 0x56, 0x9e, 0x04, 0xc6, 0x4d, 0x8f, 0xbc, 0xea, 0x00, 0x49, + 0xa0, 0xcb, 0xc9, 0x69, 0x18, 0x27, 0x41, 0x32, 0xc2, 0x0e, 0x38, 0x2b, 0x11, 0x6b, 0x87, 0xe4, + 0x43, 0xe2, 0xe1, 0xe6, 0x00, 0x1e, 0x94, 0x63, 0x91, 0x7a, 0x9a, 0x6f, 0xa5, 0x5e, 0x84, 0x11, + 0x58, 0x94, 0x3c, 0xea, 0xa7, 0xe6, 0x36, 0x71, 0xe9, 0x0c, 0xe0, 0x52, 0x3d, 0x33, 0xa9, 0xcf, + 0x85, 0x56, 0xfa, 0x55, 0x78, 0x0c, 0xe6, 0x93, 0xdb, 0x24, 0x47, 0xdf, 0xce, 0x20, 0xf7, 0x80, + 0xb4, 0x0d, 0x7c, 0xf4, 0x49, 0xf7, 0x80, 0x76, 0x05, 0xbe, 0x0f, 0x16, 0x52, 0x76, 0x47, 0x3c, + 0x3d, 0x22, 0x9e, 0x36, 0x06, 0xdf, 0x5a, 0xec, 0x6a, 0xb6, 0x95, 0x72, 0x09, 0x2e, 0x83, 0x42, + 0xd0, 0xf6, 0x83, 0x23, 0x7e, 0xdc, 0x04, 0xf8, 0x11, 0x7b, 0x7b, 0xc8, 0xcd, 0x13, 0x2b, 0x3b, + 0x3c, 0x3e, 0x06, 0x66, 0x29, 0x48, 0xab, 0x6d, 0xe7, 0xb5, 0x1e, 0xb7, 0xb6, 0x87, 0x5c, 0x48, + 0x68, 0xd4, 0x5a, 0x8a, 0x08, 0x58, 0xb7, 0x7f, 0xc0, 0x27, 0x12, 0xc4, 0xca, 0x7a, 0xf7, 0x22, + 0xa0, 0x5f, 0x59, 0xdb, 0x86, 0x6c, 0xbc, 0x01, 0x88, 0x91, 0x76, 0xe1, 0x05, 0x00, 0x18, 0x04, + 0xdf, 0x87, 0x11, 0x7e, 0x10, 0xdd, 0x1e, 0x72, 0xc7, 0x29, 0x02, 0xdf, 0x5b, 0xca, 0x56, 0x1d, + 0x1b, 0x75, 0x2d, 0xa3, 0x34, 0xac, 0x6c, 0xd5, 0xb1, 0x63, 0x47, 0x54, 0x7b, 0x7a, 0xf8, 0xf1, + 0x58, 0x38, 0xa2, 0x62, 0x22, 0x78, 0x98, 0x90, 0xbc, 0xc2, 0x8f, 0xc6, 0x82, 0x87, 0x09, 0x43, + 0x85, 0x47, 0x43, 0xca, 0xf6, 0xe1, 0xe0, 0x8f, 0x78, 0x22, 0x66, 0x52, 0x9e, 0x3d, 0xe9, 0x69, + 0x8c, 0x88, 0x0c, 0x9b, 0xa6, 0xa1, 0x5f, 0x19, 0x24, 0xf7, 0x8b, 0x2b, 0x74, 0xdc, 0xb6, 0xc2, + 0xe7, 0x3c, 0x2b, 0x78, 0xab, 0xef, 0x79, 0xcd, 0x9e, 0x1f, 0x3f, 0xa6, 0x61, 0xd3, 0x33, 0xba, + 0x0e, 0xba, 0x60, 0x5e, 0x9d, 0xd1, 0x08, 0xc6, 0x5f, 0x1b, 0xec, 0xd1, 0x56, 0x67, 0x24, 0x7a, + 0x47, 0x29, 0x67, 0x95, 0x49, 0x4e, 0x06, 0xa7, 0x63, 0x0b, 0xce, 0xdf, 0xf4, 0xe1, 0x74, 0xec, + 0x24, 0xa7, 0x63, 0x73, 0xce, 0x03, 0xe9, 0x21, 0xbf, 0xa7, 0x06, 0xfa, 0x5b, 0x4a, 0x7a, 0x3e, + 0x41, 0x7a, 0x20, 0x45, 0x3a, 0xa7, 0x0e, 0x89, 0xb2, 0x68, 0xa5, 0x58, 0x7f, 0xd7, 0x8f, 0x96, + 0x07, 0x3b, 0xa7, 0x8e, 0x94, 0xd2, 0x32, 0x40, 0x1a, 0x47, 0xb0, 0xfe, 0x3e, 0x2b, 0x03, 0xa4, + 0x97, 0xb4, 0x0c, 0x10, 0x5b, 0x5a, 0xa8, 0xb4, 0xd3, 0x04, 0xe9, 0x1f, 0xb2, 0x42, 0xa5, 0xcd, + 0xa7, 0x85, 0x4a, 0x8d, 0x69, 0xb4, 0x4c, 0x61, 0x38, 0xed, 0x1f, 0xb3, 0x68, 0xe9, 0x4d, 0xa8, + 0xd1, 0x52, 0x63, 0x5a, 0x06, 0xc8, 0x3d, 0x2a, 0x58, 0xff, 0x94, 0x95, 0x01, 0x72, 0xdb, 0x6a, + 0x19, 0x20, 0x36, 0xce, 0xb9, 0x27, 0x3d, 0x1c, 0x28, 0xcd, 0xff, 0x67, 0x83, 0xc8, 0x60, 0xdf, + 0xe6, 0x97, 0x1f, 0x0a, 0xa5, 0x20, 0xd5, 0x91, 0x81, 0x60, 0xfc, 0x8b, 0xc1, 0x9e, 0xb4, 0xfa, + 0x35, 0xbf, 0x32, 0x58, 0xc8, 0xe0, 0x94, 0x1a, 0xea, 0xaf, 0x7d, 0x38, 0x45, 0xf3, 0x2b, 0x53, + 0x08, 0xa9, 0x46, 0xda, 0x30, 0x42, 0x90, 0xfe, 0x8d, 0x92, 0x9e, 0xd2, 0xfc, 0xea, 0xcc, 0x22, + 0x8b, 0x56, 0x8a, 0xf5, 0xef, 0xfd, 0x68, 0x45, 0xf3, 0xab, 0x13, 0x8e, 0xb4, 0x0c, 0xa8, 0xcd, + 0xff, 0x8f, 0xac, 0x0c, 0xc8, 0xcd, 0xaf, 0x0c, 0x03, 0xd2, 0x42, 0xd5, 0x9a, 0xff, 0x9f, 0x59, + 0xa1, 0x2a, 0xcd, 0xaf, 0x8e, 0x0e, 0xd2, 0x68, 0xb5, 0xe6, 0xff, 0x57, 0x16, 0xad, 0xd2, 0xfc, + 0xea, 0xb3, 0x68, 0x5a, 0x06, 0xd4, 0xe6, 0xff, 0x77, 0x56, 0x06, 0xe4, 0xe6, 0x57, 0x06, 0x0e, + 0x9c, 0xf3, 0xa1, 0x34, 0xd7, 0xe5, 0xef, 0x70, 0xd0, 0x77, 0x73, 0x6c, 0x4e, 0x96, 0xd8, 0x3b, + 0x43, 0xc4, 0x33, 0x5f, 0x6e, 0x81, 0x8f, 0x80, 0x18, 0x1a, 0xd6, 0xc4, 0xcb, 0x1a, 0xf4, 0xbd, + 0x5c, 0xc6, 0xf9, 0xf1, 0x94, 0x43, 0x5c, 0xe1, 0x5f, 0x98, 0xe0, 0x47, 0xc1, 0x8c, 0x34, 0xc4, + 0xe6, 0x2f, 0x8e, 0xd0, 0xf7, 0xb3, 0xc8, 0xaa, 0x18, 0xf3, 0xd8, 0x8b, 0x5e, 0xc6, 0x64, 0xc2, + 0x04, 0xb7, 0xd4, 0xb9, 0x70, 0xaf, 0xde, 0x45, 0x3f, 0xa0, 0x44, 0x0b, 0x69, 0x45, 0xe8, 0xd5, + 0xbb, 0xca, 0xc4, 0xb8, 0x57, 0xef, 0xc2, 0x4d, 0x20, 0x66, 0x8b, 0x35, 0xaf, 0x7d, 0x82, 0x7e, + 0x48, 0xd7, 0xcf, 0x26, 0xd6, 0x6f, 0xb5, 0x4f, 0xdc, 0x3c, 0x87, 0x6e, 0xb5, 0x4f, 0xe0, 0x5d, + 0x69, 0xd6, 0xfc, 0x0a, 0x97, 0x01, 0xfd, 0x88, 0xae, 0x9d, 0x4f, 0xac, 0xa5, 0x55, 0x12, 0xd3, + 0x4d, 0xf2, 0x15, 0x97, 0x27, 0x6e, 0x50, 0x5e, 0x9e, 0x1f, 0xe7, 0x48, 0xb5, 0xfb, 0x95, 0x47, + 0xf4, 0xa5, 0x54, 0x1e, 0x41, 0x14, 0x97, 0xe7, 0x27, 0xb9, 0x0c, 0x85, 0x93, 0xca, 0xc3, 0x97, + 0xc5, 0xe5, 0x91, 0xb9, 0x48, 0x79, 0x48, 0x75, 0x7e, 0x9a, 0xc5, 0x25, 0x55, 0x27, 0x1e, 0x0a, + 0xb2, 0x55, 0xb8, 0x3a, 0xf2, 0xad, 0x82, 0xab, 0xf3, 0x4b, 0x4a, 0x94, 0x5d, 0x1d, 0xe9, 0xee, + 0x60, 0xd5, 0x11, 0x14, 0xb8, 0x3a, 0x3f, 0xa3, 0xeb, 0x33, 0xaa, 0xc3, 0xa1, 0xac, 0x3a, 0x62, + 0x25, 0xad, 0xce, 0xcf, 0xe9, 0xda, 0xcc, 0xea, 0x70, 0x38, 0xad, 0xce, 0x05, 0x00, 0xc8, 0xfe, + 0xdb, 0x5e, 0xcb, 0x5f, 0x43, 0x9f, 0x36, 0xc9, 0x6b, 0x28, 0xc9, 0x04, 0x2d, 0x90, 0xa7, 0xfd, + 0x8b, 0xbf, 0xae, 0xa3, 0xcf, 0xc8, 0x88, 0x5d, 0x6c, 0x82, 0x17, 0x41, 0xa1, 0x16, 0x43, 0x36, + 0xd0, 0x67, 0x19, 0xa4, 0xca, 0x21, 0x1b, 0x70, 0x09, 0x4c, 0x50, 0x04, 0x81, 0xd8, 0x35, 0xf4, + 0x39, 0x9d, 0x86, 0xfc, 0x3d, 0x49, 0xbe, 0xad, 0x62, 0xc8, 0x4d, 0xf4, 0x79, 0x8a, 0x90, 0x6d, + 0x70, 0x99, 0xd3, 0xac, 0x12, 0x1e, 0x07, 0x7d, 0x41, 0x01, 0x61, 0x1e, 0x47, 0xec, 0x08, 0x7f, + 0xbb, 0x85, 0xbe, 0xa8, 0x3b, 0xba, 0x85, 0x01, 0x22, 0xb4, 0x4d, 0xf4, 0x25, 0x3d, 0xda, 0xcd, + 0x78, 0xcb, 0xf8, 0xeb, 0x6d, 0xf4, 0x65, 0x9d, 0xe2, 0x36, 0x5c, 0x02, 0x85, 0xaa, 0x40, 0xac, + 0xad, 0xa2, 0xaf, 0xb0, 0x38, 0x04, 0xc9, 0xda, 0x2a, 0xc1, 0xec, 0x54, 0xde, 0x7d, 0x50, 0xdb, + 0xdd, 0x7a, 0x5c, 0x59, 0x5b, 0x43, 0x5f, 0xe5, 0x18, 0x6c, 0xa4, 0xb6, 0x18, 0x43, 0x72, 0xbd, + 0x8e, 0xbe, 0xa6, 0x60, 0x88, 0x0d, 0x5e, 0x02, 0x93, 0x35, 0x29, 0xbf, 0x6b, 0x1b, 0xe8, 0xeb, + 0x09, 0x6f, 0x1b, 0x14, 0x55, 0x8d, 0x51, 0x36, 0xfa, 0x46, 0x02, 0x65, 0xc7, 0x09, 0xa4, 0xa0, + 0x9b, 0xe8, 0x9b, 0x72, 0x02, 0x09, 0x48, 0xca, 0x32, 0xdd, 0x9d, 0x83, 0xbe, 0x95, 0x00, 0x39, + 0xd8, 0x9f, 0x14, 0xd3, 0xad, 0x5a, 0x0d, 0x7d, 0x3b, 0x81, 0xba, 0x85, 0x51, 0x52, 0x4c, 0x9b, + 0xb5, 0x1a, 0xfa, 0x4e, 0x22, 0xaa, 0xcd, 0xc5, 0xe7, 0x60, 0x42, 0x7d, 0xd0, 0x29, 0x00, 0xc3, + 0x63, 0x6f, 0x44, 0x0d, 0x0f, 0xbe, 0x0d, 0xf2, 0xf5, 0x40, 0xbc, 0xd4, 0x40, 0xb9, 0xd3, 0x5e, + 0x80, 0xc8, 0xe8, 0xc5, 0x7b, 0x00, 0x26, 0x87, 0x94, 0xb0, 0x08, 0xcc, 0x97, 0xfe, 0x09, 0x73, + 0x81, 0x7f, 0x85, 0xb3, 0xe0, 0x0c, 0xbd, 0x7d, 0x72, 0xc4, 0x46, 0xbf, 0xdc, 0xc9, 0x6d, 0x1a, + 0x31, 0x83, 0x3c, 0x90, 0x94, 0x19, 0xcc, 0x14, 0x06, 0x53, 0x66, 0x28, 0x83, 0xd9, 0xb4, 0xd1, + 0xa3, 0xcc, 0x31, 0x91, 0xc2, 0x31, 0x91, 0xce, 0xa1, 0x8c, 0x18, 0x65, 0x8e, 0xe1, 0x14, 0x8e, + 0xe1, 0x24, 0x47, 0x62, 0x94, 0x28, 0x73, 0x4c, 0xa7, 0x70, 0x4c, 0xa7, 0x73, 0x28, 0x23, 0x43, + 0x99, 0x03, 0xa6, 0x70, 0x40, 0x99, 0xe3, 0x01, 0x98, 0x4f, 0x1f, 0x0c, 0xca, 0x2c, 0xa3, 0x29, + 0x2c, 0xa3, 0x19, 0x2c, 0xea, 0xf0, 0x4f, 0x66, 0x19, 0x49, 0x61, 0x19, 0x91, 0x59, 0xaa, 0x00, + 0x65, 0x8d, 0xf7, 0x64, 0x9e, 0xa9, 0x14, 0x9e, 0xa9, 0x2c, 0x1e, 0x6d, 0x7c, 0x27, 0xf3, 0x14, + 0x53, 0x78, 0x8a, 0xa9, 0xdd, 0x26, 0x0f, 0xe9, 0x4e, 0xeb, 0xd7, 0x9c, 0xcc, 0xb0, 0x05, 0x66, + 0x52, 0xe6, 0x71, 0xa7, 0x51, 0x18, 0x32, 0xc5, 0x5d, 0x50, 0xd4, 0x87, 0x6f, 0xf2, 0xfa, 0xb1, + 0x94, 0xf5, 0x63, 0x29, 0x4d, 0xa2, 0x0f, 0xda, 0x64, 0x8e, 0xf1, 0x14, 0x8e, 0xf1, 0xe4, 0x36, + 0xf4, 0x89, 0xda, 0x69, 0x14, 0x05, 0x99, 0x22, 0x04, 0xe7, 0xfa, 0x8c, 0xcc, 0x52, 0xa8, 0xde, + 0x91, 0xa9, 0x5e, 0xe3, 0x7d, 0x95, 0xe4, 0xf3, 0x18, 0x9c, 0xef, 0x37, 0x33, 0x4b, 0x71, 0xba, + 0xa6, 0x3a, 0xed, 0xfb, 0x0a, 0x4b, 0x72, 0xd4, 0xa4, 0x0d, 0x97, 0x36, 0x2b, 0x4b, 0x71, 0x72, + 0x47, 0x76, 0x32, 0xe8, 0x4b, 0x2d, 0xc9, 0x9b, 0x07, 0xce, 0x66, 0xce, 0xcb, 0x52, 0xdc, 0xad, + 0xa8, 0xee, 0xb2, 0x5f, 0x75, 0xc5, 0x2e, 0x96, 0x6e, 0x03, 0x20, 0x4d, 0xf6, 0x46, 0x81, 0x59, + 0xdd, 0xdb, 0x2b, 0x0e, 0xe1, 0x5f, 0xca, 0x5b, 0x6e, 0xd1, 0xa0, 0xbf, 0x3c, 0x2f, 0xe6, 0xb0, + 0xbb, 0xdd, 0xca, 0xc3, 0xe2, 0x7f, 0xf9, 0x7f, 0x46, 0x79, 0x42, 0x8c, 0xa2, 0xf0, 0xa9, 0xb2, + 0xf4, 0x06, 0x98, 0xd4, 0x06, 0x92, 0x05, 0x60, 0xd4, 0xf9, 0x81, 0x52, 0xbf, 0x76, 0x13, 0x80, + 0xf8, 0xdf, 0x30, 0xc1, 0x29, 0x90, 0x3f, 0xd8, 0xdd, 0x7f, 0x52, 0xb9, 0xbf, 0x53, 0xdd, 0xa9, + 0x3c, 0x28, 0x0e, 0xc1, 0x02, 0x18, 0x7b, 0xe2, 0xee, 0x3d, 0xdd, 0x2b, 0x1f, 0x54, 0x8b, 0x06, + 0x1c, 0x03, 0xc3, 0x8f, 0xf6, 0xf7, 0x76, 0x8b, 0xb9, 0x6b, 0xf7, 0x40, 0x5e, 0x9e, 0x07, 0x4e, + 0x81, 0x7c, 0x75, 0xcf, 0xad, 0xec, 0x3c, 0xdc, 0xad, 0xd1, 0x48, 0x25, 0x03, 0x8d, 0x58, 0x31, + 0x3c, 0x2f, 0xe6, 0xca, 0x17, 0xc1, 0x85, 0x7a, 0xd0, 0x4a, 0xfc, 0x61, 0x26, 0x25, 0xe7, 0xc5, + 0x08, 0xb1, 0x6e, 0xfc, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x33, 0xc2, 0x0c, 0xb6, 0xeb, 0x26, 0x00, + 0x00, +} diff --git a/vendor/github.com/golang/protobuf/_conformance/conformance_proto/conformance.proto b/vendor/github.com/golang/protobuf/_conformance/conformance_proto/conformance.proto new file mode 100644 index 000000000..95a8fd135 --- /dev/null +++ b/vendor/github.com/golang/protobuf/_conformance/conformance_proto/conformance.proto @@ -0,0 +1,285 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; +package conformance; +option java_package = "com.google.protobuf.conformance"; + +import "google/protobuf/any.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/field_mask.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +// This defines the conformance testing protocol. This protocol exists between +// the conformance test suite itself and the code being tested. For each test, +// the suite will send a ConformanceRequest message and expect a +// ConformanceResponse message. +// +// You can either run the tests in two different ways: +// +// 1. in-process (using the interface in conformance_test.h). +// +// 2. as a sub-process communicating over a pipe. Information about how to +// do this is in conformance_test_runner.cc. +// +// Pros/cons of the two approaches: +// +// - running as a sub-process is much simpler for languages other than C/C++. +// +// - running as a sub-process may be more tricky in unusual environments like +// iOS apps, where fork/stdin/stdout are not available. + +enum WireFormat { + UNSPECIFIED = 0; + PROTOBUF = 1; + JSON = 2; +} + +// Represents a single test case's input. The testee should: +// +// 1. parse this proto (which should always succeed) +// 2. parse the protobuf or JSON payload in "payload" (which may fail) +// 3. if the parse succeeded, serialize the message in the requested format. +message ConformanceRequest { + // The payload (whether protobuf of JSON) is always for a TestAllTypes proto + // (see below). + oneof payload { + bytes protobuf_payload = 1; + string json_payload = 2; + } + + // Which format should the testee serialize its message to? + WireFormat requested_output_format = 3; +} + +// Represents a single test case's output. +message ConformanceResponse { + oneof result { + // This string should be set to indicate parsing failed. The string can + // provide more information about the parse error if it is available. + // + // Setting this string does not necessarily mean the testee failed the + // test. Some of the test cases are intentionally invalid input. + string parse_error = 1; + + // If the input was successfully parsed but errors occurred when + // serializing it to the requested output format, set the error message in + // this field. + string serialize_error = 6; + + // This should be set if some other error occurred. This will always + // indicate that the test failed. The string can provide more information + // about the failure. + string runtime_error = 2; + + // If the input was successfully parsed and the requested output was + // protobuf, serialize it to protobuf and set it in this field. + bytes protobuf_payload = 3; + + // If the input was successfully parsed and the requested output was JSON, + // serialize to JSON and set it in this field. + string json_payload = 4; + + // For when the testee skipped the test, likely because a certain feature + // wasn't supported, like JSON input/output. + string skipped = 5; + } +} + +// This proto includes every type of field in both singular and repeated +// forms. +message TestAllTypes { + message NestedMessage { + int32 a = 1; + TestAllTypes corecursive = 2; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + + NestedMessage optional_nested_message = 18; + ForeignMessage optional_foreign_message = 19; + + NestedEnum optional_nested_enum = 21; + ForeignEnum optional_foreign_enum = 22; + + string optional_string_piece = 24 [ctype=STRING_PIECE]; + string optional_cord = 25 [ctype=CORD]; + + TestAllTypes recursive_message = 27; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessage repeated_foreign_message = 49; + + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnum repeated_foreign_enum = 52; + + repeated string repeated_string_piece = 54 [ctype=STRING_PIECE]; + repeated string repeated_cord = 55 [ctype=CORD]; + + // Map + map < int32, int32> map_int32_int32 = 56; + map < int64, int64> map_int64_int64 = 57; + map < uint32, uint32> map_uint32_uint32 = 58; + map < uint64, uint64> map_uint64_uint64 = 59; + map < sint32, sint32> map_sint32_sint32 = 60; + map < sint64, sint64> map_sint64_sint64 = 61; + map < fixed32, fixed32> map_fixed32_fixed32 = 62; + map < fixed64, fixed64> map_fixed64_fixed64 = 63; + map
[](https://gitter.im/go-playground/validator?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+[](https://semaphoreci.com/joeybloggs/validator)
+[](https://coveralls.io/github/go-playground/validator?branch=v8)
+[](https://goreportcard.com/report/github.com/go-playground/validator)
+[](https://godoc.org/gopkg.in/go-playground/validator.v8)
+
+
+Package validator implements value validations for structs and individual fields based on tags.
+
+It has the following **unique** features:
+
+- Cross Field and Cross Struct validations by using validation tags or custom validators.
+- Slice, Array and Map diving, which allows any or all levels of a multidimensional field to be validated.
+- Handles type interface by determining it's underlying type prior to validation.
+- Handles custom field types such as sql driver Valuer see [Valuer](https://golang.org/src/database/sql/driver/types.go?s=1210:1293#L29)
+- Alias validation tags, which allows for mapping of several validations to a single tag for easier defining of validations on structs
+- Extraction of custom defined Field Name e.g. can specify to extract the JSON name while validating and have it available in the resulting FieldError
+
+Installation
+------------
+
+Use go get.
+
+ go get gopkg.in/go-playground/validator.v8
+
+or to update
+
+ go get -u gopkg.in/go-playground/validator.v8
+
+Then import the validator package into your own code.
+
+ import "gopkg.in/go-playground/validator.v8"
+
+Error Return Value
+-------
+
+Validation functions return type error
+
+They return type error to avoid the issue discussed in the following, where err is always != nil:
+
+* http://stackoverflow.com/a/29138676/3158232
+* https://github.com/go-playground/validator/issues/134
+
+validator only returns nil or ValidationErrors as type error; so in you code all you need to do
+is check if the error returned is not nil, and if it's not type cast it to type ValidationErrors
+like so:
+
+```go
+err := validate.Struct(mystruct)
+validationErrors := err.(validator.ValidationErrors)
+ ```
+
+Usage and documentation
+------
+
+Please see http://godoc.org/gopkg.in/go-playground/validator.v8 for detailed usage docs.
+
+##### Examples:
+
+Struct & Field validation
+```go
+package main
+
+import (
+ "fmt"
+
+ "gopkg.in/go-playground/validator.v8"
+)
+
+// User contains user information
+type User struct {
+ FirstName string `validate:"required"`
+ LastName string `validate:"required"`
+ Age uint8 `validate:"gte=0,lte=130"`
+ Email string `validate:"required,email"`
+ FavouriteColor string `validate:"hexcolor|rgb|rgba"`
+ Addresses []*Address `validate:"required,dive,required"` // a person can have a home and cottage...
+}
+
+// Address houses a users address information
+type Address struct {
+ Street string `validate:"required"`
+ City string `validate:"required"`
+ Planet string `validate:"required"`
+ Phone string `validate:"required"`
+}
+
+var validate *validator.Validate
+
+func main() {
+
+ config := &validator.Config{TagName: "validate"}
+
+ validate = validator.New(config)
+
+ validateStruct()
+ validateField()
+}
+
+func validateStruct() {
+
+ address := &Address{
+ Street: "Eavesdown Docks",
+ Planet: "Persphone",
+ Phone: "none",
+ }
+
+ user := &User{
+ FirstName: "Badger",
+ LastName: "Smith",
+ Age: 135,
+ Email: "Badger.Smith@gmail.com",
+ FavouriteColor: "#000",
+ Addresses: []*Address{address},
+ }
+
+ // returns nil or ValidationErrors ( map[string]*FieldError )
+ errs := validate.Struct(user)
+
+ if errs != nil {
+
+ fmt.Println(errs) // output: Key: "User.Age" Error:Field validation for "Age" failed on the "lte" tag
+ // Key: "User.Addresses[0].City" Error:Field validation for "City" failed on the "required" tag
+ err := errs.(validator.ValidationErrors)["User.Addresses[0].City"]
+ fmt.Println(err.Field) // output: City
+ fmt.Println(err.Tag) // output: required
+ fmt.Println(err.Kind) // output: string
+ fmt.Println(err.Type) // output: string
+ fmt.Println(err.Param) // output:
+ fmt.Println(err.Value) // output:
+
+ // from here you can create your own error messages in whatever language you wish
+ return
+ }
+
+ // save user to database
+}
+
+func validateField() {
+ myEmail := "joeybloggs.gmail.com"
+
+ errs := validate.Field(myEmail, "required,email")
+
+ if errs != nil {
+ fmt.Println(errs) // output: Key: "" Error:Field validation for "" failed on the "email" tag
+ return
+ }
+
+ // email ok, move on
+}
+```
+
+Custom Field Type
+```go
+package main
+
+import (
+ "database/sql"
+ "database/sql/driver"
+ "fmt"
+ "reflect"
+
+ "gopkg.in/go-playground/validator.v8"
+)
+
+// DbBackedUser User struct
+type DbBackedUser struct {
+ Name sql.NullString `validate:"required"`
+ Age sql.NullInt64 `validate:"required"`
+}
+
+func main() {
+
+ config := &validator.Config{TagName: "validate"}
+
+ validate := validator.New(config)
+
+ // register all sql.Null* types to use the ValidateValuer CustomTypeFunc
+ validate.RegisterCustomTypeFunc(ValidateValuer, sql.NullString{}, sql.NullInt64{}, sql.NullBool{}, sql.NullFloat64{})
+
+ x := DbBackedUser{Name: sql.NullString{String: "", Valid: true}, Age: sql.NullInt64{Int64: 0, Valid: false}}
+ errs := validate.Struct(x)
+
+ if len(errs.(validator.ValidationErrors)) > 0 {
+ fmt.Printf("Errs:\n%+v\n", errs)
+ }
+}
+
+// ValidateValuer implements validator.CustomTypeFunc
+func ValidateValuer(field reflect.Value) interface{} {
+ if valuer, ok := field.Interface().(driver.Valuer); ok {
+ val, err := valuer.Value()
+ if err == nil {
+ return val
+ }
+ // handle the error how you want
+ }
+ return nil
+}
+```
+
+Struct Level Validation
+```go
+package main
+
+import (
+ "fmt"
+ "reflect"
+
+ "gopkg.in/go-playground/validator.v8"
+)
+
+// User contains user information
+type User struct {
+ FirstName string `json:"fname"`
+ LastName string `json:"lname"`
+ Age uint8 `validate:"gte=0,lte=130"`
+ Email string `validate:"required,email"`
+ FavouriteColor string `validate:"hexcolor|rgb|rgba"`
+ Addresses []*Address `validate:"required,dive,required"` // a person can have a home and cottage...
+}
+
+// Address houses a users address information
+type Address struct {
+ Street string `validate:"required"`
+ City string `validate:"required"`
+ Planet string `validate:"required"`
+ Phone string `validate:"required"`
+}
+
+var validate *validator.Validate
+
+func main() {
+
+ config := &validator.Config{TagName: "validate"}
+
+ validate = validator.New(config)
+ validate.RegisterStructValidation(UserStructLevelValidation, User{})
+
+ validateStruct()
+}
+
+// UserStructLevelValidation contains custom struct level validations that don't always
+// make sense at the field validation level. For Example this function validates that either
+// FirstName or LastName exist; could have done that with a custom field validation but then
+// would have had to add it to both fields duplicating the logic + overhead, this way it's
+// only validated once.
+//
+// NOTE: you may ask why wouldn't I just do this outside of validator, because doing this way
+// hooks right into validator and you can combine with validation tags and still have a
+// common error output format.
+func UserStructLevelValidation(v *validator.Validate, structLevel *validator.StructLevel) {
+
+ user := structLevel.CurrentStruct.Interface().(User)
+
+ if len(user.FirstName) == 0 && len(user.LastName) == 0 {
+ structLevel.ReportError(reflect.ValueOf(user.FirstName), "FirstName", "fname", "fnameorlname")
+ structLevel.ReportError(reflect.ValueOf(user.LastName), "LastName", "lname", "fnameorlname")
+ }
+
+ // plus can to more, even with different tag than "fnameorlname"
+}
+
+func validateStruct() {
+
+ address := &Address{
+ Street: "Eavesdown Docks",
+ Planet: "Persphone",
+ Phone: "none",
+ City: "Unknown",
+ }
+
+ user := &User{
+ FirstName: "",
+ LastName: "",
+ Age: 45,
+ Email: "Badger.Smith@gmail.com",
+ FavouriteColor: "#000",
+ Addresses: []*Address{address},
+ }
+
+ // returns nil or ValidationErrors ( map[string]*FieldError )
+ errs := validate.Struct(user)
+
+ if errs != nil {
+
+ fmt.Println(errs) // output: Key: 'User.LastName' Error:Field validation for 'LastName' failed on the 'fnameorlname' tag
+ // Key: 'User.FirstName' Error:Field validation for 'FirstName' failed on the 'fnameorlname' tag
+ err := errs.(validator.ValidationErrors)["User.FirstName"]
+ fmt.Println(err.Field) // output: FirstName
+ fmt.Println(err.Tag) // output: fnameorlname
+ fmt.Println(err.Kind) // output: string
+ fmt.Println(err.Type) // output: string
+ fmt.Println(err.Param) // output:
+ fmt.Println(err.Value) // output:
+
+ // from here you can create your own error messages in whatever language you wish
+ return
+ }
+
+ // save user to database
+}
+```
+
+Benchmarks
+------
+###### Run on MacBook Pro (Retina, 15-inch, Late 2013) 2.6 GHz Intel Core i7 16 GB 1600 MHz DDR3 using Go version go1.5.3 darwin/amd64
+```go
+PASS
+BenchmarkFieldSuccess-8 20000000 118 ns/op 0 B/op 0 allocs/op
+BenchmarkFieldFailure-8 2000000 758 ns/op 432 B/op 4 allocs/op
+BenchmarkFieldDiveSuccess-8 500000 2471 ns/op 464 B/op 28 allocs/op
+BenchmarkFieldDiveFailure-8 500000 3172 ns/op 896 B/op 32 allocs/op
+BenchmarkFieldCustomTypeSuccess-8 5000000 300 ns/op 32 B/op 2 allocs/op
+BenchmarkFieldCustomTypeFailure-8 2000000 775 ns/op 432 B/op 4 allocs/op
+BenchmarkFieldOrTagSuccess-8 1000000 1122 ns/op 4 B/op 1 allocs/op
+BenchmarkFieldOrTagFailure-8 1000000 1167 ns/op 448 B/op 6 allocs/op
+BenchmarkStructLevelValidationSuccess-8 3000000 548 ns/op 160 B/op 5 allocs/op
+BenchmarkStructLevelValidationFailure-8 3000000 558 ns/op 160 B/op 5 allocs/op
+BenchmarkStructSimpleCustomTypeSuccess-8 2000000 623 ns/op 36 B/op 3 allocs/op
+BenchmarkStructSimpleCustomTypeFailure-8 1000000 1381 ns/op 640 B/op 9 allocs/op
+BenchmarkStructPartialSuccess-8 1000000 1036 ns/op 272 B/op 9 allocs/op
+BenchmarkStructPartialFailure-8 1000000 1734 ns/op 730 B/op 14 allocs/op
+BenchmarkStructExceptSuccess-8 2000000 888 ns/op 250 B/op 7 allocs/op
+BenchmarkStructExceptFailure-8 1000000 1036 ns/op 272 B/op 9 allocs/op
+BenchmarkStructSimpleCrossFieldSuccess-8 2000000 773 ns/op 80 B/op 4 allocs/op
+BenchmarkStructSimpleCrossFieldFailure-8 1000000 1487 ns/op 536 B/op 9 allocs/op
+BenchmarkStructSimpleCrossStructCrossFieldSuccess-8 1000000 1261 ns/op 112 B/op 7 allocs/op
+BenchmarkStructSimpleCrossStructCrossFieldFailure-8 1000000 2055 ns/op 576 B/op 12 allocs/op
+BenchmarkStructSimpleSuccess-8 3000000 519 ns/op 4 B/op 1 allocs/op
+BenchmarkStructSimpleFailure-8 1000000 1429 ns/op 640 B/op 9 allocs/op
+BenchmarkStructSimpleSuccessParallel-8 10000000 146 ns/op 4 B/op 1 allocs/op
+BenchmarkStructSimpleFailureParallel-8 2000000 551 ns/op 640 B/op 9 allocs/op
+BenchmarkStructComplexSuccess-8 500000 3269 ns/op 244 B/op 15 allocs/op
+BenchmarkStructComplexFailure-8 200000 8436 ns/op 3609 B/op 60 allocs/op
+BenchmarkStructComplexSuccessParallel-8 1000000 1024 ns/op 244 B/op 15 allocs/op
+BenchmarkStructComplexFailureParallel-8 500000 3536 ns/op 3609 B/op 60 allocs/op
+```
+
+Complimentary Software
+----------------------
+
+Here is a list of software that compliments using this library either pre or post validation.
+
+* [form](https://github.com/go-playground/form) - Decodes url.Values into Go value(s) and Encodes Go value(s) into url.Values. Dual Array and Full map support.
+* [Conform](https://github.com/leebenson/conform) - Trims, sanitizes & scrubs data based on struct tags.
+
+How to Contribute
+------
+
+There will always be a development branch for each version i.e. `v1-development`. In order to contribute,
+please make your pull requests against those branches.
+
+If the changes being proposed or requested are breaking changes, please create an issue, for discussion
+or create a pull request against the highest development branch for example this package has a
+v1 and v1-development branch however, there will also be a v2-development branch even though v2 doesn't exist yet.
+
+I strongly encourage everyone whom creates a custom validation function to contribute them and
+help make this package even better.
+
+License
+------
+Distributed under MIT License, please see license file in code for more details.
diff --git a/vendor/gopkg.in/go-playground/validator.v8/baked_in.go b/vendor/gopkg.in/go-playground/validator.v8/baked_in.go
new file mode 100644
index 000000000..44aaa0851
--- /dev/null
+++ b/vendor/gopkg.in/go-playground/validator.v8/baked_in.go
@@ -0,0 +1,1410 @@
+package validator
+
+import (
+ "fmt"
+ "net"
+ "net/url"
+ "reflect"
+ "strings"
+ "time"
+ "unicode/utf8"
+)
+
+// BakedInAliasValidators is a default mapping of a single validationstag that
+// defines a common or complex set of validation(s) to simplify
+// adding validation to structs. i.e. set key "_ageok" and the tags
+// are "gt=0,lte=130" or key "_preferredname" and tags "omitempty,gt=0,lte=60"
+var bakedInAliasValidators = map[string]string{
+ "iscolor": "hexcolor|rgb|rgba|hsl|hsla",
+}
+
+// BakedInValidators is the default map of ValidationFunc
+// you can add, remove or even replace items to suite your needs,
+// or even disregard and use your own map if so desired.
+var bakedInValidators = map[string]Func{
+ "required": HasValue,
+ "len": HasLengthOf,
+ "min": HasMinOf,
+ "max": HasMaxOf,
+ "eq": IsEq,
+ "ne": IsNe,
+ "lt": IsLt,
+ "lte": IsLte,
+ "gt": IsGt,
+ "gte": IsGte,
+ "eqfield": IsEqField,
+ "eqcsfield": IsEqCrossStructField,
+ "necsfield": IsNeCrossStructField,
+ "gtcsfield": IsGtCrossStructField,
+ "gtecsfield": IsGteCrossStructField,
+ "ltcsfield": IsLtCrossStructField,
+ "ltecsfield": IsLteCrossStructField,
+ "nefield": IsNeField,
+ "gtefield": IsGteField,
+ "gtfield": IsGtField,
+ "ltefield": IsLteField,
+ "ltfield": IsLtField,
+ "alpha": IsAlpha,
+ "alphanum": IsAlphanum,
+ "numeric": IsNumeric,
+ "number": IsNumber,
+ "hexadecimal": IsHexadecimal,
+ "hexcolor": IsHEXColor,
+ "rgb": IsRGB,
+ "rgba": IsRGBA,
+ "hsl": IsHSL,
+ "hsla": IsHSLA,
+ "email": IsEmail,
+ "url": IsURL,
+ "uri": IsURI,
+ "base64": IsBase64,
+ "contains": Contains,
+ "containsany": ContainsAny,
+ "containsrune": ContainsRune,
+ "excludes": Excludes,
+ "excludesall": ExcludesAll,
+ "excludesrune": ExcludesRune,
+ "isbn": IsISBN,
+ "isbn10": IsISBN10,
+ "isbn13": IsISBN13,
+ "uuid": IsUUID,
+ "uuid3": IsUUID3,
+ "uuid4": IsUUID4,
+ "uuid5": IsUUID5,
+ "ascii": IsASCII,
+ "printascii": IsPrintableASCII,
+ "multibyte": HasMultiByteCharacter,
+ "datauri": IsDataURI,
+ "latitude": IsLatitude,
+ "longitude": IsLongitude,
+ "ssn": IsSSN,
+ "ipv4": IsIPv4,
+ "ipv6": IsIPv6,
+ "ip": IsIP,
+ "cidrv4": IsCIDRv4,
+ "cidrv6": IsCIDRv6,
+ "cidr": IsCIDR,
+ "tcp4_addr": IsTCP4AddrResolvable,
+ "tcp6_addr": IsTCP6AddrResolvable,
+ "tcp_addr": IsTCPAddrResolvable,
+ "udp4_addr": IsUDP4AddrResolvable,
+ "udp6_addr": IsUDP6AddrResolvable,
+ "udp_addr": IsUDPAddrResolvable,
+ "ip4_addr": IsIP4AddrResolvable,
+ "ip6_addr": IsIP6AddrResolvable,
+ "ip_addr": IsIPAddrResolvable,
+ "unix_addr": IsUnixAddrResolvable,
+ "mac": IsMAC,
+}
+
+// IsMAC is the validation function for validating if the field's value is a valid MAC address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsMAC(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ _, err := net.ParseMAC(field.String())
+ return err == nil
+}
+
+// IsCIDRv4 is the validation function for validating if the field's value is a valid v4 CIDR address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsCIDRv4(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ ip, _, err := net.ParseCIDR(field.String())
+
+ return err == nil && ip.To4() != nil
+}
+
+// IsCIDRv6 is the validation function for validating if the field's value is a valid v6 CIDR address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsCIDRv6(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ ip, _, err := net.ParseCIDR(field.String())
+
+ return err == nil && ip.To4() == nil
+}
+
+// IsCIDR is the validation function for validating if the field's value is a valid v4 or v6 CIDR address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsCIDR(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ _, _, err := net.ParseCIDR(field.String())
+
+ return err == nil
+}
+
+// IsIPv4 is the validation function for validating if a value is a valid v4 IP address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsIPv4(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ ip := net.ParseIP(field.String())
+
+ return ip != nil && ip.To4() != nil
+}
+
+// IsIPv6 is the validation function for validating if the field's value is a valid v6 IP address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsIPv6(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ ip := net.ParseIP(field.String())
+
+ return ip != nil && ip.To4() == nil
+}
+
+// IsIP is the validation function for validating if the field's value is a valid v4 or v6 IP address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsIP(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ ip := net.ParseIP(field.String())
+
+ return ip != nil
+}
+
+// IsSSN is the validation function for validating if the field's value is a valid SSN.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsSSN(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ if field.Len() != 11 {
+ return false
+ }
+
+ return sSNRegex.MatchString(field.String())
+}
+
+// IsLongitude is the validation function for validating if the field's value is a valid longitude coordinate.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsLongitude(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return longitudeRegex.MatchString(field.String())
+}
+
+// IsLatitude is the validation function for validating if the field's value is a valid latitude coordinate.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsLatitude(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return latitudeRegex.MatchString(field.String())
+}
+
+// IsDataURI is the validation function for validating if the field's value is a valid data URI.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsDataURI(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ uri := strings.SplitN(field.String(), ",", 2)
+
+ if len(uri) != 2 {
+ return false
+ }
+
+ if !dataURIRegex.MatchString(uri[0]) {
+ return false
+ }
+
+ fld := reflect.ValueOf(uri[1])
+
+ return IsBase64(v, topStruct, currentStructOrField, fld, fld.Type(), fld.Kind(), param)
+}
+
+// HasMultiByteCharacter is the validation function for validating if the field's value has a multi byte character.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func HasMultiByteCharacter(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ if field.Len() == 0 {
+ return true
+ }
+
+ return multibyteRegex.MatchString(field.String())
+}
+
+// IsPrintableASCII is the validation function for validating if the field's value is a valid printable ASCII character.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsPrintableASCII(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return printableASCIIRegex.MatchString(field.String())
+}
+
+// IsASCII is the validation function for validating if the field's value is a valid ASCII character.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsASCII(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return aSCIIRegex.MatchString(field.String())
+}
+
+// IsUUID5 is the validation function for validating if the field's value is a valid v5 UUID.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsUUID5(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return uUID5Regex.MatchString(field.String())
+}
+
+// IsUUID4 is the validation function for validating if the field's value is a valid v4 UUID.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsUUID4(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return uUID4Regex.MatchString(field.String())
+}
+
+// IsUUID3 is the validation function for validating if the field's value is a valid v3 UUID.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsUUID3(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return uUID3Regex.MatchString(field.String())
+}
+
+// IsUUID is the validation function for validating if the field's value is a valid UUID of any version.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsUUID(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return uUIDRegex.MatchString(field.String())
+}
+
+// IsISBN is the validation function for validating if the field's value is a valid v10 or v13 ISBN.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsISBN(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return IsISBN10(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) || IsISBN13(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param)
+}
+
+// IsISBN13 is the validation function for validating if the field's value is a valid v13 ISBN.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsISBN13(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ s := strings.Replace(strings.Replace(field.String(), "-", "", 4), " ", "", 4)
+
+ if !iSBN13Regex.MatchString(s) {
+ return false
+ }
+
+ var checksum int32
+ var i int32
+
+ factor := []int32{1, 3}
+
+ for i = 0; i < 12; i++ {
+ checksum += factor[i%2] * int32(s[i]-'0')
+ }
+
+ return (int32(s[12]-'0'))-((10-(checksum%10))%10) == 0
+}
+
+// IsISBN10 is the validation function for validating if the field's value is a valid v10 ISBN.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsISBN10(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ s := strings.Replace(strings.Replace(field.String(), "-", "", 3), " ", "", 3)
+
+ if !iSBN10Regex.MatchString(s) {
+ return false
+ }
+
+ var checksum int32
+ var i int32
+
+ for i = 0; i < 9; i++ {
+ checksum += (i + 1) * int32(s[i]-'0')
+ }
+
+ if s[9] == 'X' {
+ checksum += 10 * 10
+ } else {
+ checksum += 10 * int32(s[9]-'0')
+ }
+
+ return checksum%11 == 0
+}
+
+// ExcludesRune is the validation function for validating that the field's value does not contain the rune specified within the param.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func ExcludesRune(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return !ContainsRune(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param)
+}
+
+// ExcludesAll is the validation function for validating that the field's value does not contain any of the characters specified within the param.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func ExcludesAll(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return !ContainsAny(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param)
+}
+
+// Excludes is the validation function for validating that the field's value does not contain the text specified within the param.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func Excludes(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return !Contains(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param)
+}
+
+// ContainsRune is the validation function for validating that the field's value contains the rune specified within the param.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func ContainsRune(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ r, _ := utf8.DecodeRuneInString(param)
+
+ return strings.ContainsRune(field.String(), r)
+}
+
+// ContainsAny is the validation function for validating that the field's value contains any of the characters specified within the param.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func ContainsAny(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return strings.ContainsAny(field.String(), param)
+}
+
+// Contains is the validation function for validating that the field's value contains the text specified within the param.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func Contains(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return strings.Contains(field.String(), param)
+}
+
+// IsNeField is the validation function for validating if the current field's value is not equal to the field specified by the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsNeField(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ currentField, currentKind, ok := v.GetStructFieldOK(currentStructOrField, param)
+
+ if !ok || currentKind != fieldKind {
+ return true
+ }
+
+ switch fieldKind {
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return field.Int() != currentField.Int()
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return field.Uint() != currentField.Uint()
+
+ case reflect.Float32, reflect.Float64:
+ return field.Float() != currentField.Float()
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ return int64(field.Len()) != int64(currentField.Len())
+
+ case reflect.Struct:
+
+ // Not Same underlying type i.e. struct and time
+ if fieldType != currentField.Type() {
+ return true
+ }
+
+ if fieldType == timeType {
+
+ t := currentField.Interface().(time.Time)
+ fieldTime := field.Interface().(time.Time)
+
+ return !fieldTime.Equal(t)
+ }
+
+ }
+
+ // default reflect.String:
+ return field.String() != currentField.String()
+}
+
+// IsNe is the validation function for validating that the field's value does not equal the provided param value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsNe(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return !IsEq(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param)
+}
+
+// IsLteCrossStructField is the validation function for validating if the current field's value is less than or equal to the field, within a separate struct, specified by the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsLteCrossStructField(v *Validate, topStruct reflect.Value, current reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ topField, topKind, ok := v.GetStructFieldOK(topStruct, param)
+ if !ok || topKind != fieldKind {
+ return false
+ }
+
+ switch fieldKind {
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return field.Int() <= topField.Int()
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return field.Uint() <= topField.Uint()
+
+ case reflect.Float32, reflect.Float64:
+ return field.Float() <= topField.Float()
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ return int64(field.Len()) <= int64(topField.Len())
+
+ case reflect.Struct:
+
+ // Not Same underlying type i.e. struct and time
+ if fieldType != topField.Type() {
+ return false
+ }
+
+ if fieldType == timeType {
+
+ fieldTime := field.Interface().(time.Time)
+ topTime := topField.Interface().(time.Time)
+
+ return fieldTime.Before(topTime) || fieldTime.Equal(topTime)
+ }
+ }
+
+ // default reflect.String:
+ return field.String() <= topField.String()
+}
+
+// IsLtCrossStructField is the validation function for validating if the current field's value is less than the field, within a separate struct, specified by the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsLtCrossStructField(v *Validate, topStruct reflect.Value, current reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ topField, topKind, ok := v.GetStructFieldOK(topStruct, param)
+ if !ok || topKind != fieldKind {
+ return false
+ }
+
+ switch fieldKind {
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return field.Int() < topField.Int()
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return field.Uint() < topField.Uint()
+
+ case reflect.Float32, reflect.Float64:
+ return field.Float() < topField.Float()
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ return int64(field.Len()) < int64(topField.Len())
+
+ case reflect.Struct:
+
+ // Not Same underlying type i.e. struct and time
+ if fieldType != topField.Type() {
+ return false
+ }
+
+ if fieldType == timeType {
+
+ fieldTime := field.Interface().(time.Time)
+ topTime := topField.Interface().(time.Time)
+
+ return fieldTime.Before(topTime)
+ }
+ }
+
+ // default reflect.String:
+ return field.String() < topField.String()
+}
+
+// IsGteCrossStructField is the validation function for validating if the current field's value is greater than or equal to the field, within a separate struct, specified by the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsGteCrossStructField(v *Validate, topStruct reflect.Value, current reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ topField, topKind, ok := v.GetStructFieldOK(topStruct, param)
+ if !ok || topKind != fieldKind {
+ return false
+ }
+
+ switch fieldKind {
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return field.Int() >= topField.Int()
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return field.Uint() >= topField.Uint()
+
+ case reflect.Float32, reflect.Float64:
+ return field.Float() >= topField.Float()
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ return int64(field.Len()) >= int64(topField.Len())
+
+ case reflect.Struct:
+
+ // Not Same underlying type i.e. struct and time
+ if fieldType != topField.Type() {
+ return false
+ }
+
+ if fieldType == timeType {
+
+ fieldTime := field.Interface().(time.Time)
+ topTime := topField.Interface().(time.Time)
+
+ return fieldTime.After(topTime) || fieldTime.Equal(topTime)
+ }
+ }
+
+ // default reflect.String:
+ return field.String() >= topField.String()
+}
+
+// IsGtCrossStructField is the validation function for validating if the current field's value is greater than the field, within a separate struct, specified by the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsGtCrossStructField(v *Validate, topStruct reflect.Value, current reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ topField, topKind, ok := v.GetStructFieldOK(topStruct, param)
+ if !ok || topKind != fieldKind {
+ return false
+ }
+
+ switch fieldKind {
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return field.Int() > topField.Int()
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return field.Uint() > topField.Uint()
+
+ case reflect.Float32, reflect.Float64:
+ return field.Float() > topField.Float()
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ return int64(field.Len()) > int64(topField.Len())
+
+ case reflect.Struct:
+
+ // Not Same underlying type i.e. struct and time
+ if fieldType != topField.Type() {
+ return false
+ }
+
+ if fieldType == timeType {
+
+ fieldTime := field.Interface().(time.Time)
+ topTime := topField.Interface().(time.Time)
+
+ return fieldTime.After(topTime)
+ }
+ }
+
+ // default reflect.String:
+ return field.String() > topField.String()
+}
+
+// IsNeCrossStructField is the validation function for validating that the current field's value is not equal to the field, within a separate struct, specified by the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsNeCrossStructField(v *Validate, topStruct reflect.Value, current reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ topField, currentKind, ok := v.GetStructFieldOK(topStruct, param)
+ if !ok || currentKind != fieldKind {
+ return true
+ }
+
+ switch fieldKind {
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return topField.Int() != field.Int()
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return topField.Uint() != field.Uint()
+
+ case reflect.Float32, reflect.Float64:
+ return topField.Float() != field.Float()
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ return int64(topField.Len()) != int64(field.Len())
+
+ case reflect.Struct:
+
+ // Not Same underlying type i.e. struct and time
+ if fieldType != topField.Type() {
+ return true
+ }
+
+ if fieldType == timeType {
+
+ t := field.Interface().(time.Time)
+ fieldTime := topField.Interface().(time.Time)
+
+ return !fieldTime.Equal(t)
+ }
+ }
+
+ // default reflect.String:
+ return topField.String() != field.String()
+}
+
+// IsEqCrossStructField is the validation function for validating that the current field's value is equal to the field, within a separate struct, specified by the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsEqCrossStructField(v *Validate, topStruct reflect.Value, current reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ topField, topKind, ok := v.GetStructFieldOK(topStruct, param)
+ if !ok || topKind != fieldKind {
+ return false
+ }
+
+ switch fieldKind {
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return topField.Int() == field.Int()
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return topField.Uint() == field.Uint()
+
+ case reflect.Float32, reflect.Float64:
+ return topField.Float() == field.Float()
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ return int64(topField.Len()) == int64(field.Len())
+
+ case reflect.Struct:
+
+ // Not Same underlying type i.e. struct and time
+ if fieldType != topField.Type() {
+ return false
+ }
+
+ if fieldType == timeType {
+
+ t := field.Interface().(time.Time)
+ fieldTime := topField.Interface().(time.Time)
+
+ return fieldTime.Equal(t)
+ }
+ }
+
+ // default reflect.String:
+ return topField.String() == field.String()
+}
+
+// IsEqField is the validation function for validating if the current field's value is equal to the field specified by the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsEqField(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ currentField, currentKind, ok := v.GetStructFieldOK(currentStructOrField, param)
+ if !ok || currentKind != fieldKind {
+ return false
+ }
+
+ switch fieldKind {
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return field.Int() == currentField.Int()
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return field.Uint() == currentField.Uint()
+
+ case reflect.Float32, reflect.Float64:
+ return field.Float() == currentField.Float()
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ return int64(field.Len()) == int64(currentField.Len())
+
+ case reflect.Struct:
+
+ // Not Same underlying type i.e. struct and time
+ if fieldType != currentField.Type() {
+ return false
+ }
+
+ if fieldType == timeType {
+
+ t := currentField.Interface().(time.Time)
+ fieldTime := field.Interface().(time.Time)
+
+ return fieldTime.Equal(t)
+ }
+
+ }
+
+ // default reflect.String:
+ return field.String() == currentField.String()
+}
+
+// IsEq is the validation function for validating if the current field's value is equal to the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsEq(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ switch fieldKind {
+
+ case reflect.String:
+ return field.String() == param
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ p := asInt(param)
+
+ return int64(field.Len()) == p
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ p := asInt(param)
+
+ return field.Int() == p
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ p := asUint(param)
+
+ return field.Uint() == p
+
+ case reflect.Float32, reflect.Float64:
+ p := asFloat(param)
+
+ return field.Float() == p
+ }
+
+ panic(fmt.Sprintf("Bad field type %T", field.Interface()))
+}
+
+// IsBase64 is the validation function for validating if the current field's value is a valid base 64.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsBase64(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return base64Regex.MatchString(field.String())
+}
+
+// IsURI is the validation function for validating if the current field's value is a valid URI.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsURI(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ switch fieldKind {
+
+ case reflect.String:
+
+ s := field.String()
+
+ // checks needed as of Go 1.6 because of change https://github.com/golang/go/commit/617c93ce740c3c3cc28cdd1a0d712be183d0b328#diff-6c2d018290e298803c0c9419d8739885L195
+ // emulate browser and strip the '#' suffix prior to validation. see issue-#237
+ if i := strings.Index(s, "#"); i > -1 {
+ s = s[:i]
+ }
+
+ if s == blank {
+ return false
+ }
+
+ _, err := url.ParseRequestURI(s)
+
+ return err == nil
+ }
+
+ panic(fmt.Sprintf("Bad field type %T", field.Interface()))
+}
+
+// IsURL is the validation function for validating if the current field's value is a valid URL.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsURL(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ switch fieldKind {
+
+ case reflect.String:
+
+ var i int
+ s := field.String()
+
+ // checks needed as of Go 1.6 because of change https://github.com/golang/go/commit/617c93ce740c3c3cc28cdd1a0d712be183d0b328#diff-6c2d018290e298803c0c9419d8739885L195
+ // emulate browser and strip the '#' suffix prior to validation. see issue-#237
+ if i = strings.Index(s, "#"); i > -1 {
+ s = s[:i]
+ }
+
+ if s == blank {
+ return false
+ }
+
+ url, err := url.ParseRequestURI(s)
+
+ if err != nil || url.Scheme == blank {
+ return false
+ }
+
+ return err == nil
+ }
+
+ panic(fmt.Sprintf("Bad field type %T", field.Interface()))
+}
+
+// IsEmail is the validation function for validating if the current field's value is a valid email address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsEmail(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return emailRegex.MatchString(field.String())
+}
+
+// IsHSLA is the validation function for validating if the current field's value is a valid HSLA color.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsHSLA(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return hslaRegex.MatchString(field.String())
+}
+
+// IsHSL is the validation function for validating if the current field's value is a valid HSL color.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsHSL(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return hslRegex.MatchString(field.String())
+}
+
+// IsRGBA is the validation function for validating if the current field's value is a valid RGBA color.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsRGBA(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return rgbaRegex.MatchString(field.String())
+}
+
+// IsRGB is the validation function for validating if the current field's value is a valid RGB color.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsRGB(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return rgbRegex.MatchString(field.String())
+}
+
+// IsHEXColor is the validation function for validating if the current field's value is a valid HEX color.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsHEXColor(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return hexcolorRegex.MatchString(field.String())
+}
+
+// IsHexadecimal is the validation function for validating if the current field's value is a valid hexadecimal.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsHexadecimal(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return hexadecimalRegex.MatchString(field.String())
+}
+
+// IsNumber is the validation function for validating if the current field's value is a valid number.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsNumber(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return numberRegex.MatchString(field.String())
+}
+
+// IsNumeric is the validation function for validating if the current field's value is a valid numeric value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsNumeric(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return numericRegex.MatchString(field.String())
+}
+
+// IsAlphanum is the validation function for validating if the current field's value is a valid alphanumeric value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsAlphanum(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return alphaNumericRegex.MatchString(field.String())
+}
+
+// IsAlpha is the validation function for validating if the current field's value is a valid alpha value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsAlpha(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return alphaRegex.MatchString(field.String())
+}
+
+// HasValue is the validation function for validating if the current field's value is not the default static value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func HasValue(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ switch fieldKind {
+ case reflect.Slice, reflect.Map, reflect.Ptr, reflect.Interface, reflect.Chan, reflect.Func:
+ return !field.IsNil()
+ default:
+ return field.IsValid() && field.Interface() != reflect.Zero(fieldType).Interface()
+ }
+}
+
+// IsGteField is the validation function for validating if the current field's value is greater than or equal to the field specified by the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsGteField(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ currentField, currentKind, ok := v.GetStructFieldOK(currentStructOrField, param)
+ if !ok || currentKind != fieldKind {
+ return false
+ }
+
+ switch fieldKind {
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+
+ return field.Int() >= currentField.Int()
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+
+ return field.Uint() >= currentField.Uint()
+
+ case reflect.Float32, reflect.Float64:
+
+ return field.Float() >= currentField.Float()
+
+ case reflect.Struct:
+
+ // Not Same underlying type i.e. struct and time
+ if fieldType != currentField.Type() {
+ return false
+ }
+
+ if fieldType == timeType {
+
+ t := currentField.Interface().(time.Time)
+ fieldTime := field.Interface().(time.Time)
+
+ return fieldTime.After(t) || fieldTime.Equal(t)
+ }
+ }
+
+ // default reflect.String
+ return len(field.String()) >= len(currentField.String())
+}
+
+// IsGtField is the validation function for validating if the current field's value is greater than the field specified by the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsGtField(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ currentField, currentKind, ok := v.GetStructFieldOK(currentStructOrField, param)
+ if !ok || currentKind != fieldKind {
+ return false
+ }
+
+ switch fieldKind {
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+
+ return field.Int() > currentField.Int()
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+
+ return field.Uint() > currentField.Uint()
+
+ case reflect.Float32, reflect.Float64:
+
+ return field.Float() > currentField.Float()
+
+ case reflect.Struct:
+
+ // Not Same underlying type i.e. struct and time
+ if fieldType != currentField.Type() {
+ return false
+ }
+
+ if fieldType == timeType {
+
+ t := currentField.Interface().(time.Time)
+ fieldTime := field.Interface().(time.Time)
+
+ return fieldTime.After(t)
+ }
+ }
+
+ // default reflect.String
+ return len(field.String()) > len(currentField.String())
+}
+
+// IsGte is the validation function for validating if the current field's value is greater than or equal to the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsGte(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ switch fieldKind {
+
+ case reflect.String:
+ p := asInt(param)
+
+ return int64(utf8.RuneCountInString(field.String())) >= p
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ p := asInt(param)
+
+ return int64(field.Len()) >= p
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ p := asInt(param)
+
+ return field.Int() >= p
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ p := asUint(param)
+
+ return field.Uint() >= p
+
+ case reflect.Float32, reflect.Float64:
+ p := asFloat(param)
+
+ return field.Float() >= p
+
+ case reflect.Struct:
+
+ if fieldType == timeType || fieldType == timePtrType {
+
+ now := time.Now().UTC()
+ t := field.Interface().(time.Time)
+
+ return t.After(now) || t.Equal(now)
+ }
+ }
+
+ panic(fmt.Sprintf("Bad field type %T", field.Interface()))
+}
+
+// IsGt is the validation function for validating if the current field's value is greater than the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsGt(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ switch fieldKind {
+
+ case reflect.String:
+ p := asInt(param)
+
+ return int64(utf8.RuneCountInString(field.String())) > p
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ p := asInt(param)
+
+ return int64(field.Len()) > p
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ p := asInt(param)
+
+ return field.Int() > p
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ p := asUint(param)
+
+ return field.Uint() > p
+
+ case reflect.Float32, reflect.Float64:
+ p := asFloat(param)
+
+ return field.Float() > p
+ case reflect.Struct:
+
+ if fieldType == timeType || fieldType == timePtrType {
+
+ return field.Interface().(time.Time).After(time.Now().UTC())
+ }
+ }
+
+ panic(fmt.Sprintf("Bad field type %T", field.Interface()))
+}
+
+// HasLengthOf is the validation function for validating if the current field's value is equal to the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func HasLengthOf(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ switch fieldKind {
+
+ case reflect.String:
+ p := asInt(param)
+
+ return int64(utf8.RuneCountInString(field.String())) == p
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ p := asInt(param)
+
+ return int64(field.Len()) == p
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ p := asInt(param)
+
+ return field.Int() == p
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ p := asUint(param)
+
+ return field.Uint() == p
+
+ case reflect.Float32, reflect.Float64:
+ p := asFloat(param)
+
+ return field.Float() == p
+ }
+
+ panic(fmt.Sprintf("Bad field type %T", field.Interface()))
+}
+
+// HasMinOf is the validation function for validating if the current field's value is greater than or equal to the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func HasMinOf(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ return IsGte(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param)
+}
+
+// IsLteField is the validation function for validating if the current field's value is less than or equal to the field specified by the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsLteField(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ currentField, currentKind, ok := v.GetStructFieldOK(currentStructOrField, param)
+ if !ok || currentKind != fieldKind {
+ return false
+ }
+
+ switch fieldKind {
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+
+ return field.Int() <= currentField.Int()
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+
+ return field.Uint() <= currentField.Uint()
+
+ case reflect.Float32, reflect.Float64:
+
+ return field.Float() <= currentField.Float()
+
+ case reflect.Struct:
+
+ // Not Same underlying type i.e. struct and time
+ if fieldType != currentField.Type() {
+ return false
+ }
+
+ if fieldType == timeType {
+
+ t := currentField.Interface().(time.Time)
+ fieldTime := field.Interface().(time.Time)
+
+ return fieldTime.Before(t) || fieldTime.Equal(t)
+ }
+ }
+
+ // default reflect.String
+ return len(field.String()) <= len(currentField.String())
+}
+
+// IsLtField is the validation function for validating if the current field's value is less than the field specified by the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsLtField(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ currentField, currentKind, ok := v.GetStructFieldOK(currentStructOrField, param)
+ if !ok || currentKind != fieldKind {
+ return false
+ }
+
+ switch fieldKind {
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+
+ return field.Int() < currentField.Int()
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+
+ return field.Uint() < currentField.Uint()
+
+ case reflect.Float32, reflect.Float64:
+
+ return field.Float() < currentField.Float()
+
+ case reflect.Struct:
+
+ // Not Same underlying type i.e. struct and time
+ if fieldType != currentField.Type() {
+ return false
+ }
+
+ if fieldType == timeType {
+
+ t := currentField.Interface().(time.Time)
+ fieldTime := field.Interface().(time.Time)
+
+ return fieldTime.Before(t)
+ }
+ }
+
+ // default reflect.String
+ return len(field.String()) < len(currentField.String())
+}
+
+// IsLte is the validation function for validating if the current field's value is less than or equal to the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsLte(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ switch fieldKind {
+
+ case reflect.String:
+ p := asInt(param)
+
+ return int64(utf8.RuneCountInString(field.String())) <= p
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ p := asInt(param)
+
+ return int64(field.Len()) <= p
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ p := asInt(param)
+
+ return field.Int() <= p
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ p := asUint(param)
+
+ return field.Uint() <= p
+
+ case reflect.Float32, reflect.Float64:
+ p := asFloat(param)
+
+ return field.Float() <= p
+
+ case reflect.Struct:
+
+ if fieldType == timeType || fieldType == timePtrType {
+
+ now := time.Now().UTC()
+ t := field.Interface().(time.Time)
+
+ return t.Before(now) || t.Equal(now)
+ }
+ }
+
+ panic(fmt.Sprintf("Bad field type %T", field.Interface()))
+}
+
+// IsLt is the validation function for validating if the current field's value is less than the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsLt(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ switch fieldKind {
+
+ case reflect.String:
+ p := asInt(param)
+
+ return int64(utf8.RuneCountInString(field.String())) < p
+
+ case reflect.Slice, reflect.Map, reflect.Array:
+ p := asInt(param)
+
+ return int64(field.Len()) < p
+
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ p := asInt(param)
+
+ return field.Int() < p
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ p := asUint(param)
+
+ return field.Uint() < p
+
+ case reflect.Float32, reflect.Float64:
+ p := asFloat(param)
+
+ return field.Float() < p
+
+ case reflect.Struct:
+
+ if fieldType == timeType || fieldType == timePtrType {
+
+ return field.Interface().(time.Time).Before(time.Now().UTC())
+ }
+ }
+
+ panic(fmt.Sprintf("Bad field type %T", field.Interface()))
+}
+
+// HasMaxOf is the validation function for validating if the current field's value is less than or equal to the param's value.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func HasMaxOf(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ return IsLte(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param)
+}
+
+// IsTCP4AddrResolvable is the validation function for validating if the field's value is a resolvable tcp4 address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsTCP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ if !isIP4Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) {
+ return false
+ }
+
+ _, err := net.ResolveTCPAddr("tcp4", field.String())
+ return err == nil
+}
+
+// IsTCP6AddrResolvable is the validation function for validating if the field's value is a resolvable tcp6 address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsTCP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ if !isIP6Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) {
+ return false
+ }
+
+ _, err := net.ResolveTCPAddr("tcp6", field.String())
+ return err == nil
+}
+
+// IsTCPAddrResolvable is the validation function for validating if the field's value is a resolvable tcp address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsTCPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ if !isIP4Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) &&
+ !isIP6Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) {
+ return false
+ }
+
+ _, err := net.ResolveTCPAddr("tcp", field.String())
+ return err == nil
+}
+
+// IsUDP4AddrResolvable is the validation function for validating if the field's value is a resolvable udp4 address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsUDP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ if !isIP4Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) {
+ return false
+ }
+
+ _, err := net.ResolveUDPAddr("udp4", field.String())
+ return err == nil
+}
+
+// IsUDP6AddrResolvable is the validation function for validating if the field's value is a resolvable udp6 address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsUDP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ if !isIP6Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) {
+ return false
+ }
+
+ _, err := net.ResolveUDPAddr("udp6", field.String())
+ return err == nil
+}
+
+// IsUDPAddrResolvable is the validation function for validating if the field's value is a resolvable udp address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsUDPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ if !isIP4Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) &&
+ !isIP6Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) {
+ return false
+ }
+
+ _, err := net.ResolveUDPAddr("udp", field.String())
+ return err == nil
+}
+
+// IsIP4AddrResolvable is the validation function for validating if the field's value is a resolvable ip4 address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsIP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ if !IsIPv4(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) {
+ return false
+ }
+
+ _, err := net.ResolveIPAddr("ip4", field.String())
+ return err == nil
+}
+
+// IsIP6AddrResolvable is the validation function for validating if the field's value is a resolvable ip6 address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsIP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ if !IsIPv6(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) {
+ return false
+ }
+
+ _, err := net.ResolveIPAddr("ip6", field.String())
+ return err == nil
+}
+
+// IsIPAddrResolvable is the validation function for validating if the field's value is a resolvable ip address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsIPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ if !IsIP(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) {
+ return false
+ }
+
+ _, err := net.ResolveIPAddr("ip", field.String())
+ return err == nil
+}
+
+// IsUnixAddrResolvable is the validation function for validating if the field's value is a resolvable unix address.
+// NOTE: This is exposed for use within your own custom functions and not intended to be called directly.
+func IsUnixAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ _, err := net.ResolveUnixAddr("unix", field.String())
+ return err == nil
+}
+
+func isIP4Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ val := field.String()
+
+ if idx := strings.LastIndex(val, ":"); idx != -1 {
+ val = val[0:idx]
+ }
+
+ if !IsIPv4(v, topStruct, currentStructOrField, reflect.ValueOf(val), fieldType, fieldKind, param) {
+ return false
+ }
+
+ return true
+}
+
+func isIP6Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+ val := field.String()
+
+ if idx := strings.LastIndex(val, ":"); idx != -1 {
+ if idx != 0 && val[idx-1:idx] == "]" {
+ val = val[1 : idx-1]
+ }
+ }
+
+ if !IsIPv6(v, topStruct, currentStructOrField, reflect.ValueOf(val), fieldType, fieldKind, param) {
+ return false
+ }
+
+ return true
+}
diff --git a/vendor/gopkg.in/go-playground/validator.v8/benchmarks_test.go b/vendor/gopkg.in/go-playground/validator.v8/benchmarks_test.go
new file mode 100644
index 000000000..84db7431f
--- /dev/null
+++ b/vendor/gopkg.in/go-playground/validator.v8/benchmarks_test.go
@@ -0,0 +1,524 @@
+package validator
+
+import (
+ sql "database/sql/driver"
+ "testing"
+ "time"
+)
+
+func BenchmarkFieldSuccess(b *testing.B) {
+
+ var s *string
+ tmp := "1"
+ s = &tmp
+
+ for n := 0; n < b.N; n++ {
+ validate.Field(s, "len=1")
+ }
+}
+
+func BenchmarkFieldFailure(b *testing.B) {
+
+ var s *string
+ tmp := "12"
+ s = &tmp
+
+ for n := 0; n < b.N; n++ {
+ validate.Field(s, "len=1")
+ }
+}
+
+func BenchmarkFieldDiveSuccess(b *testing.B) {
+
+ m := make([]*string, 3)
+ t1 := "val1"
+ t2 := "val2"
+ t3 := "val3"
+
+ m[0] = &t1
+ m[1] = &t2
+ m[2] = &t3
+
+ for n := 0; n < b.N; n++ {
+ validate.Field(m, "required,dive,required")
+ }
+}
+
+func BenchmarkFieldDiveFailure(b *testing.B) {
+
+ m := make([]*string, 3)
+ t1 := "val1"
+ t2 := ""
+ t3 := "val3"
+
+ m[0] = &t1
+ m[1] = &t2
+ m[2] = &t3
+
+ for n := 0; n < b.N; n++ {
+ validate.Field(m, "required,dive,required")
+ }
+}
+
+func BenchmarkFieldCustomTypeSuccess(b *testing.B) {
+
+ validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
+
+ val := valuer{
+ Name: "1",
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.Field(val, "len=1")
+ }
+}
+
+func BenchmarkFieldCustomTypeFailure(b *testing.B) {
+
+ validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
+
+ val := valuer{}
+
+ for n := 0; n < b.N; n++ {
+ validate.Field(val, "len=1")
+ }
+}
+
+func BenchmarkFieldOrTagSuccess(b *testing.B) {
+
+ var s *string
+ tmp := "rgba(0,0,0,1)"
+ s = &tmp
+
+ for n := 0; n < b.N; n++ {
+ validate.Field(s, "rgb|rgba")
+ }
+}
+
+func BenchmarkFieldOrTagFailure(b *testing.B) {
+
+ var s *string
+ tmp := "#000"
+ s = &tmp
+
+ for n := 0; n < b.N; n++ {
+ validate.Field(s, "rgb|rgba")
+ }
+}
+
+func BenchmarkStructLevelValidationSuccess(b *testing.B) {
+
+ validate.RegisterStructValidation(StructValidationTestStructSuccess, TestStruct{})
+
+ tst := &TestStruct{
+ String: "good value",
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.Struct(tst)
+ }
+}
+
+func BenchmarkStructLevelValidationFailure(b *testing.B) {
+
+ validate.RegisterStructValidation(StructValidationTestStruct, TestStruct{})
+
+ tst := &TestStruct{
+ String: "good value",
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.Struct(tst)
+ }
+}
+
+func BenchmarkStructSimpleCustomTypeSuccess(b *testing.B) {
+
+ validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
+
+ val := valuer{
+ Name: "1",
+ }
+
+ type Foo struct {
+ Valuer valuer `validate:"len=1"`
+ IntValue int `validate:"min=5,max=10"`
+ }
+
+ validFoo := &Foo{Valuer: val, IntValue: 7}
+
+ for n := 0; n < b.N; n++ {
+ validate.Struct(validFoo)
+ }
+}
+
+func BenchmarkStructSimpleCustomTypeFailure(b *testing.B) {
+
+ validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
+
+ val := valuer{}
+
+ type Foo struct {
+ Valuer valuer `validate:"len=1"`
+ IntValue int `validate:"min=5,max=10"`
+ }
+
+ validFoo := &Foo{Valuer: val, IntValue: 3}
+
+ for n := 0; n < b.N; n++ {
+ validate.Struct(validFoo)
+ }
+}
+
+func BenchmarkStructPartialSuccess(b *testing.B) {
+
+ type Test struct {
+ Name string `validate:"required"`
+ NickName string `validate:"required"`
+ }
+
+ test := &Test{
+ Name: "Joey Bloggs",
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.StructPartial(test, "Name")
+ }
+}
+
+func BenchmarkStructPartialFailure(b *testing.B) {
+
+ type Test struct {
+ Name string `validate:"required"`
+ NickName string `validate:"required"`
+ }
+
+ test := &Test{
+ Name: "Joey Bloggs",
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.StructPartial(test, "NickName")
+ }
+}
+
+func BenchmarkStructExceptSuccess(b *testing.B) {
+
+ type Test struct {
+ Name string `validate:"required"`
+ NickName string `validate:"required"`
+ }
+
+ test := &Test{
+ Name: "Joey Bloggs",
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.StructPartial(test, "Nickname")
+ }
+}
+
+func BenchmarkStructExceptFailure(b *testing.B) {
+
+ type Test struct {
+ Name string `validate:"required"`
+ NickName string `validate:"required"`
+ }
+
+ test := &Test{
+ Name: "Joey Bloggs",
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.StructPartial(test, "Name")
+ }
+}
+
+func BenchmarkStructSimpleCrossFieldSuccess(b *testing.B) {
+
+ type Test struct {
+ Start time.Time
+ End time.Time `validate:"gtfield=Start"`
+ }
+
+ now := time.Now().UTC()
+ then := now.Add(time.Hour * 5)
+
+ test := &Test{
+ Start: now,
+ End: then,
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.Struct(test)
+ }
+}
+
+func BenchmarkStructSimpleCrossFieldFailure(b *testing.B) {
+
+ type Test struct {
+ Start time.Time
+ End time.Time `validate:"gtfield=Start"`
+ }
+
+ now := time.Now().UTC()
+ then := now.Add(time.Hour * -5)
+
+ test := &Test{
+ Start: now,
+ End: then,
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.Struct(test)
+ }
+}
+
+func BenchmarkStructSimpleCrossStructCrossFieldSuccess(b *testing.B) {
+
+ type Inner struct {
+ Start time.Time
+ }
+
+ type Outer struct {
+ Inner *Inner
+ CreatedAt time.Time `validate:"eqcsfield=Inner.Start"`
+ }
+
+ now := time.Now().UTC()
+
+ inner := &Inner{
+ Start: now,
+ }
+
+ outer := &Outer{
+ Inner: inner,
+ CreatedAt: now,
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.Struct(outer)
+ }
+}
+
+func BenchmarkStructSimpleCrossStructCrossFieldFailure(b *testing.B) {
+
+ type Inner struct {
+ Start time.Time
+ }
+
+ type Outer struct {
+ Inner *Inner
+ CreatedAt time.Time `validate:"eqcsfield=Inner.Start"`
+ }
+
+ now := time.Now().UTC()
+ then := now.Add(time.Hour * 5)
+
+ inner := &Inner{
+ Start: then,
+ }
+
+ outer := &Outer{
+ Inner: inner,
+ CreatedAt: now,
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.Struct(outer)
+ }
+}
+
+func BenchmarkStructSimpleSuccess(b *testing.B) {
+
+ type Foo struct {
+ StringValue string `validate:"min=5,max=10"`
+ IntValue int `validate:"min=5,max=10"`
+ }
+
+ validFoo := &Foo{StringValue: "Foobar", IntValue: 7}
+
+ for n := 0; n < b.N; n++ {
+ validate.Struct(validFoo)
+ }
+}
+
+func BenchmarkStructSimpleFailure(b *testing.B) {
+
+ type Foo struct {
+ StringValue string `validate:"min=5,max=10"`
+ IntValue int `validate:"min=5,max=10"`
+ }
+
+ invalidFoo := &Foo{StringValue: "Fo", IntValue: 3}
+
+ for n := 0; n < b.N; n++ {
+ validate.Struct(invalidFoo)
+ }
+}
+
+func BenchmarkStructSimpleSuccessParallel(b *testing.B) {
+
+ type Foo struct {
+ StringValue string `validate:"min=5,max=10"`
+ IntValue int `validate:"min=5,max=10"`
+ }
+
+ validFoo := &Foo{StringValue: "Foobar", IntValue: 7}
+
+ b.RunParallel(func(pb *testing.PB) {
+ for pb.Next() {
+ validate.Struct(validFoo)
+ }
+ })
+}
+
+func BenchmarkStructSimpleFailureParallel(b *testing.B) {
+
+ type Foo struct {
+ StringValue string `validate:"min=5,max=10"`
+ IntValue int `validate:"min=5,max=10"`
+ }
+
+ invalidFoo := &Foo{StringValue: "Fo", IntValue: 3}
+
+ b.RunParallel(func(pb *testing.PB) {
+ for pb.Next() {
+ validate.Struct(invalidFoo)
+ }
+ })
+}
+
+func BenchmarkStructComplexSuccess(b *testing.B) {
+
+ tSuccess := &TestString{
+ Required: "Required",
+ Len: "length==10",
+ Min: "min=1",
+ Max: "1234567890",
+ MinMax: "12345",
+ Lt: "012345678",
+ Lte: "0123456789",
+ Gt: "01234567890",
+ Gte: "0123456789",
+ OmitEmpty: "",
+ Sub: &SubTest{
+ Test: "1",
+ },
+ SubIgnore: &SubTest{
+ Test: "",
+ },
+ Anonymous: struct {
+ A string `validate:"required"`
+ }{
+ A: "1",
+ },
+ Iface: &Impl{
+ F: "123",
+ },
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.Struct(tSuccess)
+ }
+}
+
+func BenchmarkStructComplexFailure(b *testing.B) {
+
+ tFail := &TestString{
+ Required: "",
+ Len: "",
+ Min: "",
+ Max: "12345678901",
+ MinMax: "",
+ Lt: "0123456789",
+ Lte: "01234567890",
+ Gt: "1",
+ Gte: "1",
+ OmitEmpty: "12345678901",
+ Sub: &SubTest{
+ Test: "",
+ },
+ Anonymous: struct {
+ A string `validate:"required"`
+ }{
+ A: "",
+ },
+ Iface: &Impl{
+ F: "12",
+ },
+ }
+
+ for n := 0; n < b.N; n++ {
+ validate.Struct(tFail)
+ }
+}
+
+func BenchmarkStructComplexSuccessParallel(b *testing.B) {
+
+ tSuccess := &TestString{
+ Required: "Required",
+ Len: "length==10",
+ Min: "min=1",
+ Max: "1234567890",
+ MinMax: "12345",
+ Lt: "012345678",
+ Lte: "0123456789",
+ Gt: "01234567890",
+ Gte: "0123456789",
+ OmitEmpty: "",
+ Sub: &SubTest{
+ Test: "1",
+ },
+ SubIgnore: &SubTest{
+ Test: "",
+ },
+ Anonymous: struct {
+ A string `validate:"required"`
+ }{
+ A: "1",
+ },
+ Iface: &Impl{
+ F: "123",
+ },
+ }
+
+ b.RunParallel(func(pb *testing.PB) {
+ for pb.Next() {
+ validate.Struct(tSuccess)
+ }
+ })
+}
+
+func BenchmarkStructComplexFailureParallel(b *testing.B) {
+
+ tFail := &TestString{
+ Required: "",
+ Len: "",
+ Min: "",
+ Max: "12345678901",
+ MinMax: "",
+ Lt: "0123456789",
+ Lte: "01234567890",
+ Gt: "1",
+ Gte: "1",
+ OmitEmpty: "12345678901",
+ Sub: &SubTest{
+ Test: "",
+ },
+ Anonymous: struct {
+ A string `validate:"required"`
+ }{
+ A: "",
+ },
+ Iface: &Impl{
+ F: "12",
+ },
+ }
+
+ b.RunParallel(func(pb *testing.PB) {
+ for pb.Next() {
+ validate.Struct(tFail)
+ }
+ })
+}
diff --git a/vendor/gopkg.in/go-playground/validator.v8/cache.go b/vendor/gopkg.in/go-playground/validator.v8/cache.go
new file mode 100644
index 000000000..76670c1dd
--- /dev/null
+++ b/vendor/gopkg.in/go-playground/validator.v8/cache.go
@@ -0,0 +1,263 @@
+package validator
+
+import (
+ "fmt"
+ "reflect"
+ "strings"
+ "sync"
+ "sync/atomic"
+)
+
+type tagType uint8
+
+const (
+ typeDefault tagType = iota
+ typeOmitEmpty
+ typeNoStructLevel
+ typeStructOnly
+ typeDive
+ typeOr
+ typeExists
+)
+
+type structCache struct {
+ lock sync.Mutex
+ m atomic.Value // map[reflect.Type]*cStruct
+}
+
+func (sc *structCache) Get(key reflect.Type) (c *cStruct, found bool) {
+ c, found = sc.m.Load().(map[reflect.Type]*cStruct)[key]
+ return
+}
+
+func (sc *structCache) Set(key reflect.Type, value *cStruct) {
+
+ m := sc.m.Load().(map[reflect.Type]*cStruct)
+
+ nm := make(map[reflect.Type]*cStruct, len(m)+1)
+ for k, v := range m {
+ nm[k] = v
+ }
+ nm[key] = value
+ sc.m.Store(nm)
+}
+
+type tagCache struct {
+ lock sync.Mutex
+ m atomic.Value // map[string]*cTag
+}
+
+func (tc *tagCache) Get(key string) (c *cTag, found bool) {
+ c, found = tc.m.Load().(map[string]*cTag)[key]
+ return
+}
+
+func (tc *tagCache) Set(key string, value *cTag) {
+
+ m := tc.m.Load().(map[string]*cTag)
+
+ nm := make(map[string]*cTag, len(m)+1)
+ for k, v := range m {
+ nm[k] = v
+ }
+ nm[key] = value
+ tc.m.Store(nm)
+}
+
+type cStruct struct {
+ Name string
+ fields map[int]*cField
+ fn StructLevelFunc
+}
+
+type cField struct {
+ Idx int
+ Name string
+ AltName string
+ cTags *cTag
+}
+
+type cTag struct {
+ tag string
+ aliasTag string
+ actualAliasTag string
+ param string
+ hasAlias bool
+ typeof tagType
+ hasTag bool
+ fn Func
+ next *cTag
+}
+
+func (v *Validate) extractStructCache(current reflect.Value, sName string) *cStruct {
+
+ v.structCache.lock.Lock()
+ defer v.structCache.lock.Unlock() // leave as defer! because if inner panics, it will never get unlocked otherwise!
+
+ typ := current.Type()
+
+ // could have been multiple trying to access, but once first is done this ensures struct
+ // isn't parsed again.
+ cs, ok := v.structCache.Get(typ)
+ if ok {
+ return cs
+ }
+
+ cs = &cStruct{Name: sName, fields: make(map[int]*cField), fn: v.structLevelFuncs[typ]}
+
+ numFields := current.NumField()
+
+ var ctag *cTag
+ var fld reflect.StructField
+ var tag string
+ var customName string
+
+ for i := 0; i < numFields; i++ {
+
+ fld = typ.Field(i)
+
+ if !fld.Anonymous && fld.PkgPath != blank {
+ continue
+ }
+
+ tag = fld.Tag.Get(v.tagName)
+
+ if tag == skipValidationTag {
+ continue
+ }
+
+ customName = fld.Name
+
+ if v.fieldNameTag != blank {
+
+ name := strings.SplitN(fld.Tag.Get(v.fieldNameTag), ",", 2)[0]
+
+ // dash check is for json "-" (aka skipValidationTag) means don't output in json
+ if name != "" && name != skipValidationTag {
+ customName = name
+ }
+ }
+
+ // NOTE: cannot use shared tag cache, because tags may be equal, but things like alias may be different
+ // and so only struct level caching can be used instead of combined with Field tag caching
+
+ if len(tag) > 0 {
+ ctag, _ = v.parseFieldTagsRecursive(tag, fld.Name, blank, false)
+ } else {
+ // even if field doesn't have validations need cTag for traversing to potential inner/nested
+ // elements of the field.
+ ctag = new(cTag)
+ }
+
+ cs.fields[i] = &cField{Idx: i, Name: fld.Name, AltName: customName, cTags: ctag}
+ }
+
+ v.structCache.Set(typ, cs)
+
+ return cs
+}
+
+func (v *Validate) parseFieldTagsRecursive(tag string, fieldName string, alias string, hasAlias bool) (firstCtag *cTag, current *cTag) {
+
+ var t string
+ var ok bool
+ noAlias := len(alias) == 0
+ tags := strings.Split(tag, tagSeparator)
+
+ for i := 0; i < len(tags); i++ {
+
+ t = tags[i]
+
+ if noAlias {
+ alias = t
+ }
+
+ if v.hasAliasValidators {
+ // check map for alias and process new tags, otherwise process as usual
+ if tagsVal, found := v.aliasValidators[t]; found {
+
+ if i == 0 {
+ firstCtag, current = v.parseFieldTagsRecursive(tagsVal, fieldName, t, true)
+ } else {
+ next, curr := v.parseFieldTagsRecursive(tagsVal, fieldName, t, true)
+ current.next, current = next, curr
+
+ }
+
+ continue
+ }
+ }
+
+ if i == 0 {
+ current = &cTag{aliasTag: alias, hasAlias: hasAlias, hasTag: true}
+ firstCtag = current
+ } else {
+ current.next = &cTag{aliasTag: alias, hasAlias: hasAlias, hasTag: true}
+ current = current.next
+ }
+
+ switch t {
+
+ case diveTag:
+ current.typeof = typeDive
+ continue
+
+ case omitempty:
+ current.typeof = typeOmitEmpty
+ continue
+
+ case structOnlyTag:
+ current.typeof = typeStructOnly
+ continue
+
+ case noStructLevelTag:
+ current.typeof = typeNoStructLevel
+ continue
+
+ case existsTag:
+ current.typeof = typeExists
+ continue
+
+ default:
+
+ // if a pipe character is needed within the param you must use the utf8Pipe representation "0x7C"
+ orVals := strings.Split(t, orSeparator)
+
+ for j := 0; j < len(orVals); j++ {
+
+ vals := strings.SplitN(orVals[j], tagKeySeparator, 2)
+
+ if noAlias {
+ alias = vals[0]
+ current.aliasTag = alias
+ } else {
+ current.actualAliasTag = t
+ }
+
+ if j > 0 {
+ current.next = &cTag{aliasTag: alias, actualAliasTag: current.actualAliasTag, hasAlias: hasAlias, hasTag: true}
+ current = current.next
+ }
+
+ current.tag = vals[0]
+ if len(current.tag) == 0 {
+ panic(strings.TrimSpace(fmt.Sprintf(invalidValidation, fieldName)))
+ }
+
+ if current.fn, ok = v.validationFuncs[current.tag]; !ok {
+ panic(strings.TrimSpace(fmt.Sprintf(undefinedValidation, fieldName)))
+ }
+
+ if len(orVals) > 1 {
+ current.typeof = typeOr
+ }
+
+ if len(vals) > 1 {
+ current.param = strings.Replace(strings.Replace(vals[1], utf8HexComma, ",", -1), utf8Pipe, "|", -1)
+ }
+ }
+ }
+ }
+
+ return
+}
diff --git a/vendor/gopkg.in/go-playground/validator.v8/doc.go b/vendor/gopkg.in/go-playground/validator.v8/doc.go
new file mode 100644
index 000000000..fdede2c4c
--- /dev/null
+++ b/vendor/gopkg.in/go-playground/validator.v8/doc.go
@@ -0,0 +1,852 @@
+/*
+Package validator implements value validations for structs and individual fields
+based on tags.
+
+It can also handle Cross-Field and Cross-Struct validation for nested structs
+and has the ability to dive into arrays and maps of any type.
+
+Why not a better error message?
+Because this library intends for you to handle your own error messages.
+
+Why should I handle my own errors?
+Many reasons. We built an internationalized application and needed to know the
+field, and what validation failed so we could provide a localized error.
+
+ if fieldErr.Field == "Name" {
+ switch fieldErr.ErrorTag
+ case "required":
+ return "Translated string based on field + error"
+ default:
+ return "Translated string based on field"
+ }
+
+
+Validation Functions Return Type error
+
+Doing things this way is actually the way the standard library does, see the
+file.Open method here:
+
+ https://golang.org/pkg/os/#Open.
+
+The authors return type "error" to avoid the issue discussed in the following,
+where err is always != nil:
+
+ http://stackoverflow.com/a/29138676/3158232
+ https://github.com/go-playground/validator/issues/134
+
+Validator only returns nil or ValidationErrors as type error; so, in your code
+all you need to do is check if the error returned is not nil, and if it's not
+type cast it to type ValidationErrors like so err.(validator.ValidationErrors).
+
+Custom Functions
+
+Custom functions can be added. Example:
+
+ // Structure
+ func customFunc(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ if whatever {
+ return false
+ }
+
+ return true
+ }
+
+ validate.RegisterValidation("custom tag name", customFunc)
+ // NOTES: using the same tag name as an existing function
+ // will overwrite the existing one
+
+Cross-Field Validation
+
+Cross-Field Validation can be done via the following tags:
+ - eqfield
+ - nefield
+ - gtfield
+ - gtefield
+ - ltfield
+ - ltefield
+ - eqcsfield
+ - necsfield
+ - gtcsfield
+ - ftecsfield
+ - ltcsfield
+ - ltecsfield
+
+If, however, some custom cross-field validation is required, it can be done
+using a custom validation.
+
+Why not just have cross-fields validation tags (i.e. only eqcsfield and not
+eqfield)?
+
+The reason is efficiency. If you want to check a field within the same struct
+"eqfield" only has to find the field on the same struct (1 level). But, if we
+used "eqcsfield" it could be multiple levels down. Example:
+
+ type Inner struct {
+ StartDate time.Time
+ }
+
+ type Outer struct {
+ InnerStructField *Inner
+ CreatedAt time.Time `validate:"ltecsfield=InnerStructField.StartDate"`
+ }
+
+ now := time.Now()
+
+ inner := &Inner{
+ StartDate: now,
+ }
+
+ outer := &Outer{
+ InnerStructField: inner,
+ CreatedAt: now,
+ }
+
+ errs := validate.Struct(outer)
+
+ // NOTE: when calling validate.Struct(val) topStruct will be the top level struct passed
+ // into the function
+ // when calling validate.FieldWithValue(val, field, tag) val will be
+ // whatever you pass, struct, field...
+ // when calling validate.Field(field, tag) val will be nil
+
+Multiple Validators
+
+Multiple validators on a field will process in the order defined. Example:
+
+ type Test struct {
+ Field `validate:"max=10,min=1"`
+ }
+
+ // max will be checked then min
+
+Bad Validator definitions are not handled by the library. Example:
+
+ type Test struct {
+ Field `validate:"min=10,max=0"`
+ }
+
+ // this definition of min max will never succeed
+
+Using Validator Tags
+
+Baked In Cross-Field validation only compares fields on the same struct.
+If Cross-Field + Cross-Struct validation is needed you should implement your
+own custom validator.
+
+Comma (",") is the default separator of validation tags. If you wish to
+have a comma included within the parameter (i.e. excludesall=,) you will need to
+use the UTF-8 hex representation 0x2C, which is replaced in the code as a comma,
+so the above will become excludesall=0x2C.
+
+ type Test struct {
+ Field `validate:"excludesall=,"` // BAD! Do not include a comma.
+ Field `validate:"excludesall=0x2C"` // GOOD! Use the UTF-8 hex representation.
+ }
+
+Pipe ("|") is the default separator of validation tags. If you wish to
+have a pipe included within the parameter i.e. excludesall=| you will need to
+use the UTF-8 hex representation 0x7C, which is replaced in the code as a pipe,
+so the above will become excludesall=0x7C
+
+ type Test struct {
+ Field `validate:"excludesall=|"` // BAD! Do not include a a pipe!
+ Field `validate:"excludesall=0x7C"` // GOOD! Use the UTF-8 hex representation.
+ }
+
+
+Baked In Validators and Tags
+
+Here is a list of the current built in validators:
+
+
+Skip Field
+
+Tells the validation to skip this struct field; this is particularly
+handy in ignoring embedded structs from being validated. (Usage: -)
+ Usage: -
+
+
+Or Operator
+
+This is the 'or' operator allowing multiple validators to be used and
+accepted. (Usage: rbg|rgba) <-- this would allow either rgb or rgba
+colors to be accepted. This can also be combined with 'and' for example
+( Usage: omitempty,rgb|rgba)
+
+ Usage: |
+
+StructOnly
+
+When a field that is a nested struct is encountered, and contains this flag
+any validation on the nested struct will be run, but none of the nested
+struct fields will be validated. This is usefull if inside of you program
+you know the struct will be valid, but need to verify it has been assigned.
+NOTE: only "required" and "omitempty" can be used on a struct itself.
+
+ Usage: structonly
+
+NoStructLevel
+
+Same as structonly tag except that any struct level validations will not run.
+
+ Usage: nostructlevel
+
+Exists
+
+Is a special tag without a validation function attached. It is used when a field
+is a Pointer, Interface or Invalid and you wish to validate that it exists.
+Example: want to ensure a bool exists if you define the bool as a pointer and
+use exists it will ensure there is a value; couldn't use required as it would
+fail when the bool was false. exists will fail is the value is a Pointer, Interface
+or Invalid and is nil.
+
+ Usage: exists
+
+Omit Empty
+
+Allows conditional validation, for example if a field is not set with
+a value (Determined by the "required" validator) then other validation
+such as min or max won't run, but if a value is set validation will run.
+
+ Usage: omitempty
+
+Dive
+
+This tells the validator to dive into a slice, array or map and validate that
+level of the slice, array or map with the validation tags that follow.
+Multidimensional nesting is also supported, each level you wish to dive will
+require another dive tag.
+
+ Usage: dive
+
+Example #1
+
+ [][]string with validation tag "gt=0,dive,len=1,dive,required"
+ // gt=0 will be applied to []
+ // len=1 will be applied to []string
+ // required will be applied to string
+
+Example #2
+
+ [][]string with validation tag "gt=0,dive,dive,required"
+ // gt=0 will be applied to []
+ // []string will be spared validation
+ // required will be applied to string
+
+Required
+
+This validates that the value is not the data types default zero value.
+For numbers ensures value is not zero. For strings ensures value is
+not "". For slices, maps, pointers, interfaces, channels and functions
+ensures the value is not nil.
+
+ Usage: required
+
+Length
+
+For numbers, max will ensure that the value is
+equal to the parameter given. For strings, it checks that
+the string length is exactly that number of characters. For slices,
+arrays, and maps, validates the number of items.
+
+ Usage: len=10
+
+Maximum
+
+For numbers, max will ensure that the value is
+less than or equal to the parameter given. For strings, it checks
+that the string length is at most that number of characters. For
+slices, arrays, and maps, validates the number of items.
+
+ Usage: max=10
+
+Mininum
+
+For numbers, min will ensure that the value is
+greater or equal to the parameter given. For strings, it checks that
+the string length is at least that number of characters. For slices,
+arrays, and maps, validates the number of items.
+
+ Usage: min=10
+
+Equals
+
+For strings & numbers, eq will ensure that the value is
+equal to the parameter given. For slices, arrays, and maps,
+validates the number of items.
+
+ Usage: eq=10
+
+Not Equal
+
+For strings & numbers, ne will ensure that the value is not
+equal to the parameter given. For slices, arrays, and maps,
+validates the number of items.
+
+ Usage: ne=10
+
+Greater Than
+
+For numbers, this will ensure that the value is greater than the
+parameter given. For strings, it checks that the string length
+is greater than that number of characters. For slices, arrays
+and maps it validates the number of items.
+
+Example #1
+
+ Usage: gt=10
+
+Example #2 (time.Time)
+
+For time.Time ensures the time value is greater than time.Now.UTC().
+
+ Usage: gt
+
+Greater Than or Equal
+
+Same as 'min' above. Kept both to make terminology with 'len' easier.
+
+
+Example #1
+
+ Usage: gte=10
+
+Example #2 (time.Time)
+
+For time.Time ensures the time value is greater than or equal to time.Now.UTC().
+
+ Usage: gte
+
+Less Than
+
+For numbers, this will ensure that the value is less than the parameter given.
+For strings, it checks that the string length is less than that number of
+characters. For slices, arrays, and maps it validates the number of items.
+
+Example #1
+
+ Usage: lt=10
+
+Example #2 (time.Time)
+For time.Time ensures the time value is less than time.Now.UTC().
+
+ Usage: lt
+
+Less Than or Equal
+
+Same as 'max' above. Kept both to make terminology with 'len' easier.
+
+Example #1
+
+ Usage: lte=10
+
+Example #2 (time.Time)
+
+For time.Time ensures the time value is less than or equal to time.Now.UTC().
+
+ Usage: lte
+
+Field Equals Another Field
+
+This will validate the field value against another fields value either within
+a struct or passed in field.
+
+Example #1:
+
+ // Validation on Password field using:
+ Usage: eqfield=ConfirmPassword
+
+Example #2:
+
+ // Validating by field:
+ validate.FieldWithValue(password, confirmpassword, "eqfield")
+
+Field Equals Another Field (relative)
+
+This does the same as eqfield except that it validates the field provided relative
+to the top level struct.
+
+ Usage: eqcsfield=InnerStructField.Field)
+
+Field Does Not Equal Another Field
+
+This will validate the field value against another fields value either within
+a struct or passed in field.
+
+Examples:
+
+ // Confirm two colors are not the same:
+ //
+ // Validation on Color field:
+ Usage: nefield=Color2
+
+ // Validating by field:
+ validate.FieldWithValue(color1, color2, "nefield")
+
+Field Does Not Equal Another Field (relative)
+
+This does the same as nefield except that it validates the field provided
+relative to the top level struct.
+
+ Usage: necsfield=InnerStructField.Field
+
+Field Greater Than Another Field
+
+Only valid for Numbers and time.Time types, this will validate the field value
+against another fields value either within a struct or passed in field.
+usage examples are for validation of a Start and End date:
+
+Example #1:
+
+ // Validation on End field using:
+ validate.Struct Usage(gtfield=Start)
+
+Example #2:
+
+ // Validating by field:
+ validate.FieldWithValue(start, end, "gtfield")
+
+
+Field Greater Than Another Relative Field
+
+This does the same as gtfield except that it validates the field provided
+relative to the top level struct.
+
+ Usage: gtcsfield=InnerStructField.Field
+
+Field Greater Than or Equal To Another Field
+
+Only valid for Numbers and time.Time types, this will validate the field value
+against another fields value either within a struct or passed in field.
+usage examples are for validation of a Start and End date:
+
+Example #1:
+
+ // Validation on End field using:
+ validate.Struct Usage(gtefield=Start)
+
+Example #2:
+
+ // Validating by field:
+ validate.FieldWithValue(start, end, "gtefield")
+
+Field Greater Than or Equal To Another Relative Field
+
+This does the same as gtefield except that it validates the field provided relative
+to the top level struct.
+
+ Usage: gtecsfield=InnerStructField.Field
+
+Less Than Another Field
+
+Only valid for Numbers and time.Time types, this will validate the field value
+against another fields value either within a struct or passed in field.
+usage examples are for validation of a Start and End date:
+
+Example #1:
+
+ // Validation on End field using:
+ validate.Struct Usage(ltfield=Start)
+
+Example #2:
+
+ // Validating by field:
+ validate.FieldWithValue(start, end, "ltfield")
+
+Less Than Another Relative Field
+
+This does the same as ltfield except that it validates the field provided relative
+to the top level struct.
+
+ Usage: ltcsfield=InnerStructField.Field
+
+Less Than or Equal To Another Field
+
+Only valid for Numbers and time.Time types, this will validate the field value
+against another fields value either within a struct or passed in field.
+usage examples are for validation of a Start and End date:
+
+Example #1:
+
+ // Validation on End field using:
+ validate.Struct Usage(ltefield=Start)
+
+Example #2:
+
+ // Validating by field:
+ validate.FieldWithValue(start, end, "ltefield")
+
+Less Than or Equal To Another Relative Field
+
+This does the same as ltefield except that it validates the field provided relative
+to the top level struct.
+
+ Usage: ltecsfield=InnerStructField.Field
+
+Alpha Only
+
+This validates that a string value contains alpha characters only
+
+ Usage: alpha
+
+Alphanumeric
+
+This validates that a string value contains alphanumeric characters only
+
+ Usage: alphanum
+
+Numeric
+
+This validates that a string value contains a basic numeric value.
+basic excludes exponents etc...
+
+ Usage: numeric
+
+Hexadecimal String
+
+This validates that a string value contains a valid hexadecimal.
+
+ Usage: hexadecimal
+
+Hexcolor String
+
+This validates that a string value contains a valid hex color including
+hashtag (#)
+
+ Usage: hexcolor
+
+RGB String
+
+This validates that a string value contains a valid rgb color
+
+ Usage: rgb
+
+RGBA String
+
+This validates that a string value contains a valid rgba color
+
+ Usage: rgba
+
+HSL String
+
+This validates that a string value contains a valid hsl color
+
+ Usage: hsl
+
+HSLA String
+
+This validates that a string value contains a valid hsla color
+
+ Usage: hsla
+
+E-mail String
+
+This validates that a string value contains a valid email
+This may not conform to all possibilities of any rfc standard, but neither
+does any email provider accept all posibilities.
+
+ Usage: email
+
+URL String
+
+This validates that a string value contains a valid url
+This will accept any url the golang request uri accepts but must contain
+a schema for example http:// or rtmp://
+
+ Usage: url
+
+URI String
+
+This validates that a string value contains a valid uri
+This will accept any uri the golang request uri accepts
+
+ Usage: uri
+
+Base64 String
+
+This validates that a string value contains a valid base64 value.
+Although an empty string is valid base64 this will report an empty string
+as an error, if you wish to accept an empty string as valid you can use
+this with the omitempty tag.
+
+ Usage: base64
+
+Contains
+
+This validates that a string value contains the substring value.
+
+ Usage: contains=@
+
+Contains Any
+
+This validates that a string value contains any Unicode code points
+in the substring value.
+
+ Usage: containsany=!@#?
+
+Contains Rune
+
+This validates that a string value contains the supplied rune value.
+
+ Usage: containsrune=@
+
+Excludes
+
+This validates that a string value does not contain the substring value.
+
+ Usage: excludes=@
+
+Excludes All
+
+This validates that a string value does not contain any Unicode code
+points in the substring value.
+
+ Usage: excludesall=!@#?
+
+Excludes Rune
+
+This validates that a string value does not contain the supplied rune value.
+
+ Usage: excludesrune=@
+
+International Standard Book Number
+
+This validates that a string value contains a valid isbn10 or isbn13 value.
+
+ Usage: isbn
+
+International Standard Book Number 10
+
+This validates that a string value contains a valid isbn10 value.
+
+ Usage: isbn10
+
+International Standard Book Number 13
+
+This validates that a string value contains a valid isbn13 value.
+
+ Usage: isbn13
+
+
+Universally Unique Identifier UUID
+
+This validates that a string value contains a valid UUID.
+
+ Usage: uuid
+
+Universally Unique Identifier UUID v3
+
+This validates that a string value contains a valid version 3 UUID.
+
+ Usage: uuid3
+
+Universally Unique Identifier UUID v4
+
+This validates that a string value contains a valid version 4 UUID.
+
+ Usage: uuid4
+
+Universally Unique Identifier UUID v5
+
+This validates that a string value contains a valid version 5 UUID.
+
+ Usage: uuid5
+
+ASCII
+
+This validates that a string value contains only ASCII characters.
+NOTE: if the string is blank, this validates as true.
+
+ Usage: ascii
+
+Printable ASCII
+
+This validates that a string value contains only printable ASCII characters.
+NOTE: if the string is blank, this validates as true.
+
+ Usage: asciiprint
+
+Multi-Byte Characters
+
+This validates that a string value contains one or more multibyte characters.
+NOTE: if the string is blank, this validates as true.
+
+ Usage: multibyte
+
+Data URL
+
+This validates that a string value contains a valid DataURI.
+NOTE: this will also validate that the data portion is valid base64
+
+ Usage: datauri
+
+Latitude
+
+This validates that a string value contains a valid latitude.
+
+ Usage: latitude
+
+Longitude
+
+This validates that a string value contains a valid longitude.
+
+ Usage: longitude
+
+Social Security Number SSN
+
+This validates that a string value contains a valid U.S. Social Security Number.
+
+ Usage: ssn
+
+Internet Protocol Address IP
+
+This validates that a string value contains a valid IP Adress.
+
+ Usage: ip
+
+Internet Protocol Address IPv4
+
+This validates that a string value contains a valid v4 IP Adress.
+
+ Usage: ipv4
+
+Internet Protocol Address IPv6
+
+This validates that a string value contains a valid v6 IP Adress.
+
+ Usage: ipv6
+
+Classless Inter-Domain Routing CIDR
+
+This validates that a string value contains a valid CIDR Adress.
+
+ Usage: cidr
+
+Classless Inter-Domain Routing CIDRv4
+
+This validates that a string value contains a valid v4 CIDR Adress.
+
+ Usage: cidrv4
+
+Classless Inter-Domain Routing CIDRv6
+
+This validates that a string value contains a valid v6 CIDR Adress.
+
+ Usage: cidrv6
+
+Transmission Control Protocol Address TCP
+
+This validates that a string value contains a valid resolvable TCP Adress.
+
+ Usage: tcp_addr
+
+Transmission Control Protocol Address TCPv4
+
+This validates that a string value contains a valid resolvable v4 TCP Adress.
+
+ Usage: tcp4_addr
+
+Transmission Control Protocol Address TCPv6
+
+This validates that a string value contains a valid resolvable v6 TCP Adress.
+
+ Usage: tcp6_addr
+
+User Datagram Protocol Address UDP
+
+This validates that a string value contains a valid resolvable UDP Adress.
+
+ Usage: udp_addr
+
+User Datagram Protocol Address UDPv4
+
+This validates that a string value contains a valid resolvable v4 UDP Adress.
+
+ Usage: udp4_addr
+
+User Datagram Protocol Address UDPv6
+
+This validates that a string value contains a valid resolvable v6 UDP Adress.
+
+ Usage: udp6_addr
+
+Internet Protocol Address IP
+
+This validates that a string value contains a valid resolvable IP Adress.
+
+ Usage: ip_addr
+
+Internet Protocol Address IPv4
+
+This validates that a string value contains a valid resolvable v4 IP Adress.
+
+ Usage: ip4_addr
+
+Internet Protocol Address IPv6
+
+This validates that a string value contains a valid resolvable v6 IP Adress.
+
+ Usage: ip6_addr
+
+Unix domain socket end point Address
+
+This validates that a string value contains a valid Unix Adress.
+
+ Usage: unix_addr
+
+Media Access Control Address MAC
+
+This validates that a string value contains a valid MAC Adress.
+
+ Usage: mac
+
+Note: See Go's ParseMAC for accepted formats and types:
+
+ http://golang.org/src/net/mac.go?s=866:918#L29
+
+Alias Validators and Tags
+
+NOTE: When returning an error, the tag returned in "FieldError" will be
+the alias tag unless the dive tag is part of the alias. Everything after the
+dive tag is not reported as the alias tag. Also, the "ActualTag" in the before
+case will be the actual tag within the alias that failed.
+
+Here is a list of the current built in alias tags:
+
+ "iscolor"
+ alias is "hexcolor|rgb|rgba|hsl|hsla" (Usage: iscolor)
+
+Validator notes:
+
+ regex
+ a regex validator won't be added because commas and = signs can be part
+ of a regex which conflict with the validation definitions. Although
+ workarounds can be made, they take away from using pure regex's.
+ Furthermore it's quick and dirty but the regex's become harder to
+ maintain and are not reusable, so it's as much a programming philosiphy
+ as anything.
+
+ In place of this new validator functions should be created; a regex can
+ be used within the validator function and even be precompiled for better
+ efficiency within regexes.go.
+
+ And the best reason, you can submit a pull request and we can keep on
+ adding to the validation library of this package!
+
+Panics
+
+This package panics when bad input is provided, this is by design, bad code like
+that should not make it to production.
+
+ type Test struct {
+ TestField string `validate:"nonexistantfunction=1"`
+ }
+
+ t := &Test{
+ TestField: "Test"
+ }
+
+ validate.Struct(t) // this will panic
+*/
+package validator
diff --git a/vendor/gopkg.in/go-playground/validator.v8/examples/custom/custom.go b/vendor/gopkg.in/go-playground/validator.v8/examples/custom/custom.go
new file mode 100644
index 000000000..ee14bd2f8
--- /dev/null
+++ b/vendor/gopkg.in/go-playground/validator.v8/examples/custom/custom.go
@@ -0,0 +1,45 @@
+package main
+
+import (
+ "database/sql"
+ "database/sql/driver"
+ "fmt"
+ "reflect"
+
+ "gopkg.in/go-playground/validator.v8"
+)
+
+// DbBackedUser User struct
+type DbBackedUser struct {
+ Name sql.NullString `validate:"required"`
+ Age sql.NullInt64 `validate:"required"`
+}
+
+func main() {
+
+ config := &validator.Config{TagName: "validate"}
+
+ validate := validator.New(config)
+
+ // register all sql.Null* types to use the ValidateValuer CustomTypeFunc
+ validate.RegisterCustomTypeFunc(ValidateValuer, sql.NullString{}, sql.NullInt64{}, sql.NullBool{}, sql.NullFloat64{})
+
+ x := DbBackedUser{Name: sql.NullString{String: "", Valid: true}, Age: sql.NullInt64{Int64: 0, Valid: false}}
+ errs := validate.Struct(x)
+
+ if errs != nil {
+ fmt.Printf("Errs:\n%+v\n", errs)
+ }
+}
+
+// ValidateValuer implements validator.CustomTypeFunc
+func ValidateValuer(field reflect.Value) interface{} {
+ if valuer, ok := field.Interface().(driver.Valuer); ok {
+ val, err := valuer.Value()
+ if err == nil {
+ return val
+ }
+ // handle the error how you want
+ }
+ return nil
+}
diff --git a/vendor/gopkg.in/go-playground/validator.v8/examples/simple/simple.go b/vendor/gopkg.in/go-playground/validator.v8/examples/simple/simple.go
new file mode 100644
index 000000000..d16cc830a
--- /dev/null
+++ b/vendor/gopkg.in/go-playground/validator.v8/examples/simple/simple.go
@@ -0,0 +1,155 @@
+package main
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+
+ sql "database/sql/driver"
+
+ "gopkg.in/go-playground/validator.v8"
+)
+
+// User contains user information
+type User struct {
+ FirstName string `validate:"required"`
+ LastName string `validate:"required"`
+ Age uint8 `validate:"gte=0,lte=130"`
+ Email string `validate:"required,email"`
+ FavouriteColor string `validate:"hexcolor|rgb|rgba"`
+ Addresses []*Address `validate:"required,dive,required"` // a person can have a home and cottage...
+}
+
+// Address houses a users address information
+type Address struct {
+ Street string `validate:"required"`
+ City string `validate:"required"`
+ Planet string `validate:"required"`
+ Phone string `validate:"required"`
+}
+
+var validate *validator.Validate
+
+func main() {
+
+ config := &validator.Config{TagName: "validate"}
+
+ validate = validator.New(config)
+
+ validateStruct()
+ validateField()
+}
+
+func validateStruct() {
+
+ address := &Address{
+ Street: "Eavesdown Docks",
+ Planet: "Persphone",
+ Phone: "none",
+ }
+
+ user := &User{
+ FirstName: "Badger",
+ LastName: "Smith",
+ Age: 135,
+ Email: "Badger.Smith@gmail.com",
+ FavouriteColor: "#000",
+ Addresses: []*Address{address},
+ }
+
+ // returns nil or ValidationErrors ( map[string]*FieldError )
+ errs := validate.Struct(user)
+
+ if errs != nil {
+
+ fmt.Println(errs) // output: Key: "User.Age" Error:Field validation for "Age" failed on the "lte" tag
+ // Key: "User.Addresses[0].City" Error:Field validation for "City" failed on the "required" tag
+ err := errs.(validator.ValidationErrors)["User.Addresses[0].City"]
+ fmt.Println(err.Field) // output: City
+ fmt.Println(err.Tag) // output: required
+ fmt.Println(err.Kind) // output: string
+ fmt.Println(err.Type) // output: string
+ fmt.Println(err.Param) // output:
+ fmt.Println(err.Value) // output:
+
+ // from here you can create your own error messages in whatever language you wish
+ return
+ }
+
+ // save user to database
+}
+
+func validateField() {
+ myEmail := "joeybloggs.gmail.com"
+
+ errs := validate.Field(myEmail, "required,email")
+
+ if errs != nil {
+ fmt.Println(errs) // output: Key: "" Error:Field validation for "" failed on the "email" tag
+ return
+ }
+
+ // email ok, move on
+}
+
+var validate2 *validator.Validate
+
+type valuer struct {
+ Name string
+}
+
+func (v valuer) Value() (sql.Value, error) {
+
+ if v.Name == "errorme" {
+ return nil, errors.New("some kind of error")
+ }
+
+ if v.Name == "blankme" {
+ return "", nil
+ }
+
+ if len(v.Name) == 0 {
+ return nil, nil
+ }
+
+ return v.Name, nil
+}
+
+// ValidateValuerType implements validator.CustomTypeFunc
+func ValidateValuerType(field reflect.Value) interface{} {
+ if valuer, ok := field.Interface().(sql.Valuer); ok {
+ val, err := valuer.Value()
+ if err != nil {
+ // handle the error how you want
+ return nil
+ }
+
+ return val
+ }
+
+ return nil
+}
+
+func main2() {
+
+ config := &validator.Config{TagName: "validate"}
+
+ validate2 = validator.New(config)
+ validate2.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
+
+ validateCustomFieldType()
+}
+
+func validateCustomFieldType() {
+ val := valuer{
+ Name: "blankme",
+ }
+
+ errs := validate2.Field(val, "required")
+ if errs != nil {
+ fmt.Println(errs) // output: Key: "" Error:Field validation for "" failed on the "required" tag
+ return
+ }
+
+ // all ok
+}
diff --git a/vendor/gopkg.in/go-playground/validator.v8/examples/struct-level/struct_level.go b/vendor/gopkg.in/go-playground/validator.v8/examples/struct-level/struct_level.go
new file mode 100644
index 000000000..92526c95b
--- /dev/null
+++ b/vendor/gopkg.in/go-playground/validator.v8/examples/struct-level/struct_level.go
@@ -0,0 +1,99 @@
+package main
+
+import (
+ "fmt"
+ "reflect"
+
+ "gopkg.in/go-playground/validator.v8"
+)
+
+// User contains user information
+type User struct {
+ FirstName string `json:"fname"`
+ LastName string `json:"lname"`
+ Age uint8 `validate:"gte=0,lte=130"`
+ Email string `validate:"required,email"`
+ FavouriteColor string `validate:"hexcolor|rgb|rgba"`
+ Addresses []*Address `validate:"required,dive,required"` // a person can have a home and cottage...
+}
+
+// Address houses a users address information
+type Address struct {
+ Street string `validate:"required"`
+ City string `validate:"required"`
+ Planet string `validate:"required"`
+ Phone string `validate:"required"`
+}
+
+var validate *validator.Validate
+
+func main() {
+
+ config := &validator.Config{TagName: "validate"}
+
+ validate = validator.New(config)
+ validate.RegisterStructValidation(UserStructLevelValidation, User{})
+
+ validateStruct()
+}
+
+// UserStructLevelValidation contains custom struct level validations that don't always
+// make sense at the field validation level. For Example this function validates that either
+// FirstName or LastName exist; could have done that with a custom field validation but then
+// would have had to add it to both fields duplicating the logic + overhead, this way it's
+// only validated once.
+//
+// NOTE: you may ask why wouldn't I just do this outside of validator, because doing this way
+// hooks right into validator and you can combine with validation tags and still have a
+// common error output format.
+func UserStructLevelValidation(v *validator.Validate, structLevel *validator.StructLevel) {
+
+ user := structLevel.CurrentStruct.Interface().(User)
+
+ if len(user.FirstName) == 0 && len(user.LastName) == 0 {
+ structLevel.ReportError(reflect.ValueOf(user.FirstName), "FirstName", "fname", "fnameorlname")
+ structLevel.ReportError(reflect.ValueOf(user.LastName), "LastName", "lname", "fnameorlname")
+ }
+
+ // plus can to more, even with different tag than "fnameorlname"
+}
+
+func validateStruct() {
+
+ address := &Address{
+ Street: "Eavesdown Docks",
+ Planet: "Persphone",
+ Phone: "none",
+ City: "Unknown",
+ }
+
+ user := &User{
+ FirstName: "",
+ LastName: "",
+ Age: 45,
+ Email: "Badger.Smith@gmail.com",
+ FavouriteColor: "#000",
+ Addresses: []*Address{address},
+ }
+
+ // returns nil or ValidationErrors ( map[string]*FieldError )
+ errs := validate.Struct(user)
+
+ if errs != nil {
+
+ fmt.Println(errs) // output: Key: 'User.LastName' Error:Field validation for 'LastName' failed on the 'fnameorlname' tag
+ // Key: 'User.FirstName' Error:Field validation for 'FirstName' failed on the 'fnameorlname' tag
+ err := errs.(validator.ValidationErrors)["User.FirstName"]
+ fmt.Println(err.Field) // output: FirstName
+ fmt.Println(err.Tag) // output: fnameorlname
+ fmt.Println(err.Kind) // output: string
+ fmt.Println(err.Type) // output: string
+ fmt.Println(err.Param) // output:
+ fmt.Println(err.Value) // output:
+
+ // from here you can create your own error messages in whatever language you wish
+ return
+ }
+
+ // save user to database
+}
diff --git a/vendor/gopkg.in/go-playground/validator.v8/examples_test.go b/vendor/gopkg.in/go-playground/validator.v8/examples_test.go
new file mode 100644
index 000000000..fde22461a
--- /dev/null
+++ b/vendor/gopkg.in/go-playground/validator.v8/examples_test.go
@@ -0,0 +1,83 @@
+package validator_test
+
+import (
+ "fmt"
+
+ "gopkg.in/go-playground/validator.v8"
+)
+
+func ExampleValidate_new() {
+ config := &validator.Config{TagName: "validate"}
+
+ validator.New(config)
+}
+
+func ExampleValidate_field() {
+ // This should be stored somewhere globally
+ var validate *validator.Validate
+
+ config := &validator.Config{TagName: "validate"}
+
+ validate = validator.New(config)
+
+ i := 0
+ errs := validate.Field(i, "gt=1,lte=10")
+ err := errs.(validator.ValidationErrors)[""]
+ fmt.Println(err.Field)
+ fmt.Println(err.Tag)
+ fmt.Println(err.Kind) // NOTE: Kind and Type can be different i.e. time Kind=struct and Type=time.Time
+ fmt.Println(err.Type)
+ fmt.Println(err.Param)
+ fmt.Println(err.Value)
+ //Output:
+ //
+ //gt
+ //int
+ //int
+ //1
+ //0
+}
+
+func ExampleValidate_struct() {
+ // This should be stored somewhere globally
+ var validate *validator.Validate
+
+ config := &validator.Config{TagName: "validate"}
+
+ validate = validator.New(config)
+
+ type ContactInformation struct {
+ Phone string `validate:"required"`
+ Street string `validate:"required"`
+ City string `validate:"required"`
+ }
+
+ type User struct {
+ Name string `validate:"required,excludesall=!@#$%^&*()_+-=:;?/0x2C"` // 0x2C = comma (,)
+ Age int8 `validate:"required,gt=0,lt=150"`
+ Email string `validate:"email"`
+ ContactInformation []*ContactInformation
+ }
+
+ contactInfo := &ContactInformation{
+ Street: "26 Here Blvd.",
+ City: "Paradeso",
+ }
+
+ user := &User{
+ Name: "Joey Bloggs",
+ Age: 31,
+ Email: "joeybloggs@gmail.com",
+ ContactInformation: []*ContactInformation{contactInfo},
+ }
+
+ errs := validate.Struct(user)
+ for _, v := range errs.(validator.ValidationErrors) {
+ fmt.Println(v.Field) // Phone
+ fmt.Println(v.Tag) // required
+ //... and so forth
+ //Output:
+ //Phone
+ //required
+ }
+}
diff --git a/vendor/gopkg.in/go-playground/validator.v8/logo.png b/vendor/gopkg.in/go-playground/validator.v8/logo.png
new file mode 100644
index 000000000..355000f52
Binary files /dev/null and b/vendor/gopkg.in/go-playground/validator.v8/logo.png differ
diff --git a/vendor/gopkg.in/go-playground/validator.v8/regexes.go b/vendor/gopkg.in/go-playground/validator.v8/regexes.go
new file mode 100644
index 000000000..83ae1982a
--- /dev/null
+++ b/vendor/gopkg.in/go-playground/validator.v8/regexes.go
@@ -0,0 +1,59 @@
+package validator
+
+import "regexp"
+
+const (
+ alphaRegexString = "^[a-zA-Z]+$"
+ alphaNumericRegexString = "^[a-zA-Z0-9]+$"
+ numericRegexString = "^[-+]?[0-9]+(?:\\.[0-9]+)?$"
+ numberRegexString = "^[0-9]+$"
+ hexadecimalRegexString = "^[0-9a-fA-F]+$"
+ hexcolorRegexString = "^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$"
+ rgbRegexString = "^rgb\\(\\s*(?:(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])|(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])%\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])%\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])%)\\s*\\)$"
+ rgbaRegexString = "^rgba\\(\\s*(?:(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])|(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])%\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])%\\s*,\\s*(?:0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])%)\\s*,\\s*(?:(?:0.[1-9]*)|[01])\\s*\\)$"
+ hslRegexString = "^hsl\\(\\s*(?:0|[1-9]\\d?|[12]\\d\\d|3[0-5]\\d|360)\\s*,\\s*(?:(?:0|[1-9]\\d?|100)%)\\s*,\\s*(?:(?:0|[1-9]\\d?|100)%)\\s*\\)$"
+ hslaRegexString = "^hsla\\(\\s*(?:0|[1-9]\\d?|[12]\\d\\d|3[0-5]\\d|360)\\s*,\\s*(?:(?:0|[1-9]\\d?|100)%)\\s*,\\s*(?:(?:0|[1-9]\\d?|100)%)\\s*,\\s*(?:(?:0.[1-9]*)|[01])\\s*\\)$"
+ emailRegexString = "^(?:(?:(?:(?:[a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])+(?:\\.([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])+)*)|(?:(?:\\x22)(?:(?:(?:(?:\\x20|\\x09)*(?:\\x0d\\x0a))?(?:\\x20|\\x09)+)?(?:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]|\\x21|[\\x23-\\x5b]|[\\x5d-\\x7e]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(?:\\(?:[\\x01-\\x09\\x0b\\x0c\\x0d-\\x7f]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}]))))*(?:(?:(?:\\x20|\\x09)*(?:\\x0d\\x0a))?(\\x20|\\x09)+)?(?:\\x22)))@(?:(?:(?:[a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(?:(?:[a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])(?:[a-zA-Z]|\\d|-|\\.|_|~|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])*(?:[a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])))\\.)+(?:(?:[a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(?:(?:[a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])(?:[a-zA-Z]|\\d|-|\\.|_|~|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])*(?:[a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])))\\.?$"
+ base64RegexString = "^(?:[A-Za-z0-9+\\/]{4})*(?:[A-Za-z0-9+\\/]{2}==|[A-Za-z0-9+\\/]{3}=|[A-Za-z0-9+\\/]{4})$"
+ iSBN10RegexString = "^(?:[0-9]{9}X|[0-9]{10})$"
+ iSBN13RegexString = "^(?:(?:97(?:8|9))[0-9]{10})$"
+ uUID3RegexString = "^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$"
+ uUID4RegexString = "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
+ uUID5RegexString = "^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
+ uUIDRegexString = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
+ aSCIIRegexString = "^[\x00-\x7F]*$"
+ printableASCIIRegexString = "^[\x20-\x7E]*$"
+ multibyteRegexString = "[^\x00-\x7F]"
+ dataURIRegexString = "^data:.+\\/(.+);base64$"
+ latitudeRegexString = "^[-+]?([1-8]?\\d(\\.\\d+)?|90(\\.0+)?)$"
+ longitudeRegexString = "^[-+]?(180(\\.0+)?|((1[0-7]\\d)|([1-9]?\\d))(\\.\\d+)?)$"
+ sSNRegexString = `^\d{3}[- ]?\d{2}[- ]?\d{4}$`
+)
+
+var (
+ alphaRegex = regexp.MustCompile(alphaRegexString)
+ alphaNumericRegex = regexp.MustCompile(alphaNumericRegexString)
+ numericRegex = regexp.MustCompile(numericRegexString)
+ numberRegex = regexp.MustCompile(numberRegexString)
+ hexadecimalRegex = regexp.MustCompile(hexadecimalRegexString)
+ hexcolorRegex = regexp.MustCompile(hexcolorRegexString)
+ rgbRegex = regexp.MustCompile(rgbRegexString)
+ rgbaRegex = regexp.MustCompile(rgbaRegexString)
+ hslRegex = regexp.MustCompile(hslRegexString)
+ hslaRegex = regexp.MustCompile(hslaRegexString)
+ emailRegex = regexp.MustCompile(emailRegexString)
+ base64Regex = regexp.MustCompile(base64RegexString)
+ iSBN10Regex = regexp.MustCompile(iSBN10RegexString)
+ iSBN13Regex = regexp.MustCompile(iSBN13RegexString)
+ uUID3Regex = regexp.MustCompile(uUID3RegexString)
+ uUID4Regex = regexp.MustCompile(uUID4RegexString)
+ uUID5Regex = regexp.MustCompile(uUID5RegexString)
+ uUIDRegex = regexp.MustCompile(uUIDRegexString)
+ aSCIIRegex = regexp.MustCompile(aSCIIRegexString)
+ printableASCIIRegex = regexp.MustCompile(printableASCIIRegexString)
+ multibyteRegex = regexp.MustCompile(multibyteRegexString)
+ dataURIRegex = regexp.MustCompile(dataURIRegexString)
+ latitudeRegex = regexp.MustCompile(latitudeRegexString)
+ longitudeRegex = regexp.MustCompile(longitudeRegexString)
+ sSNRegex = regexp.MustCompile(sSNRegexString)
+)
diff --git a/vendor/gopkg.in/go-playground/validator.v8/util.go b/vendor/gopkg.in/go-playground/validator.v8/util.go
new file mode 100644
index 000000000..e81157909
--- /dev/null
+++ b/vendor/gopkg.in/go-playground/validator.v8/util.go
@@ -0,0 +1,252 @@
+package validator
+
+import (
+ "reflect"
+ "strconv"
+ "strings"
+)
+
+const (
+ blank = ""
+ namespaceSeparator = "."
+ leftBracket = "["
+ rightBracket = "]"
+ restrictedTagChars = ".[],|=+()`~!@#$%^&*\\\"/?<>{}"
+ restrictedAliasErr = "Alias '%s' either contains restricted characters or is the same as a restricted tag needed for normal operation"
+ restrictedTagErr = "Tag '%s' either contains restricted characters or is the same as a restricted tag needed for normal operation"
+)
+
+var (
+ restrictedTags = map[string]struct{}{
+ diveTag: {},
+ existsTag: {},
+ structOnlyTag: {},
+ omitempty: {},
+ skipValidationTag: {},
+ utf8HexComma: {},
+ utf8Pipe: {},
+ noStructLevelTag: {},
+ }
+)
+
+// ExtractType gets the actual underlying type of field value.
+// It will dive into pointers, customTypes and return you the
+// underlying value and it's kind.
+// it is exposed for use within you Custom Functions
+func (v *Validate) ExtractType(current reflect.Value) (reflect.Value, reflect.Kind) {
+
+ val, k, _ := v.extractTypeInternal(current, false)
+ return val, k
+}
+
+// only exists to not break backward compatibility, needed to return the third param for a bug fix internally
+func (v *Validate) extractTypeInternal(current reflect.Value, nullable bool) (reflect.Value, reflect.Kind, bool) {
+
+ switch current.Kind() {
+ case reflect.Ptr:
+
+ nullable = true
+
+ if current.IsNil() {
+ return current, reflect.Ptr, nullable
+ }
+
+ return v.extractTypeInternal(current.Elem(), nullable)
+
+ case reflect.Interface:
+
+ nullable = true
+
+ if current.IsNil() {
+ return current, reflect.Interface, nullable
+ }
+
+ return v.extractTypeInternal(current.Elem(), nullable)
+
+ case reflect.Invalid:
+ return current, reflect.Invalid, nullable
+
+ default:
+
+ if v.hasCustomFuncs {
+
+ if fn, ok := v.customTypeFuncs[current.Type()]; ok {
+ return v.extractTypeInternal(reflect.ValueOf(fn(current)), nullable)
+ }
+ }
+
+ return current, current.Kind(), nullable
+ }
+}
+
+// GetStructFieldOK traverses a struct to retrieve a specific field denoted by the provided namespace and
+// returns the field, field kind and whether is was successful in retrieving the field at all.
+// NOTE: when not successful ok will be false, this can happen when a nested struct is nil and so the field
+// could not be retrieved because it didn't exist.
+func (v *Validate) GetStructFieldOK(current reflect.Value, namespace string) (reflect.Value, reflect.Kind, bool) {
+
+ current, kind := v.ExtractType(current)
+
+ if kind == reflect.Invalid {
+ return current, kind, false
+ }
+
+ if namespace == blank {
+ return current, kind, true
+ }
+
+ switch kind {
+
+ case reflect.Ptr, reflect.Interface:
+
+ return current, kind, false
+
+ case reflect.Struct:
+
+ typ := current.Type()
+ fld := namespace
+ ns := namespace
+
+ if typ != timeType && typ != timePtrType {
+
+ idx := strings.Index(namespace, namespaceSeparator)
+
+ if idx != -1 {
+ fld = namespace[:idx]
+ ns = namespace[idx+1:]
+ } else {
+ ns = blank
+ }
+
+ bracketIdx := strings.Index(fld, leftBracket)
+ if bracketIdx != -1 {
+ fld = fld[:bracketIdx]
+
+ ns = namespace[bracketIdx:]
+ }
+
+ current = current.FieldByName(fld)
+
+ return v.GetStructFieldOK(current, ns)
+ }
+
+ case reflect.Array, reflect.Slice:
+ idx := strings.Index(namespace, leftBracket)
+ idx2 := strings.Index(namespace, rightBracket)
+
+ arrIdx, _ := strconv.Atoi(namespace[idx+1 : idx2])
+
+ if arrIdx >= current.Len() {
+ return current, kind, false
+ }
+
+ startIdx := idx2 + 1
+
+ if startIdx < len(namespace) {
+ if namespace[startIdx:startIdx+1] == namespaceSeparator {
+ startIdx++
+ }
+ }
+
+ return v.GetStructFieldOK(current.Index(arrIdx), namespace[startIdx:])
+
+ case reflect.Map:
+ idx := strings.Index(namespace, leftBracket) + 1
+ idx2 := strings.Index(namespace, rightBracket)
+
+ endIdx := idx2
+
+ if endIdx+1 < len(namespace) {
+ if namespace[endIdx+1:endIdx+2] == namespaceSeparator {
+ endIdx++
+ }
+ }
+
+ key := namespace[idx:idx2]
+
+ switch current.Type().Key().Kind() {
+ case reflect.Int:
+ i, _ := strconv.Atoi(key)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(i)), namespace[endIdx+1:])
+ case reflect.Int8:
+ i, _ := strconv.ParseInt(key, 10, 8)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(int8(i))), namespace[endIdx+1:])
+ case reflect.Int16:
+ i, _ := strconv.ParseInt(key, 10, 16)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(int16(i))), namespace[endIdx+1:])
+ case reflect.Int32:
+ i, _ := strconv.ParseInt(key, 10, 32)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(int32(i))), namespace[endIdx+1:])
+ case reflect.Int64:
+ i, _ := strconv.ParseInt(key, 10, 64)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(i)), namespace[endIdx+1:])
+ case reflect.Uint:
+ i, _ := strconv.ParseUint(key, 10, 0)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(uint(i))), namespace[endIdx+1:])
+ case reflect.Uint8:
+ i, _ := strconv.ParseUint(key, 10, 8)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(uint8(i))), namespace[endIdx+1:])
+ case reflect.Uint16:
+ i, _ := strconv.ParseUint(key, 10, 16)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(uint16(i))), namespace[endIdx+1:])
+ case reflect.Uint32:
+ i, _ := strconv.ParseUint(key, 10, 32)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(uint32(i))), namespace[endIdx+1:])
+ case reflect.Uint64:
+ i, _ := strconv.ParseUint(key, 10, 64)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(i)), namespace[endIdx+1:])
+ case reflect.Float32:
+ f, _ := strconv.ParseFloat(key, 32)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(float32(f))), namespace[endIdx+1:])
+ case reflect.Float64:
+ f, _ := strconv.ParseFloat(key, 64)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(f)), namespace[endIdx+1:])
+ case reflect.Bool:
+ b, _ := strconv.ParseBool(key)
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(b)), namespace[endIdx+1:])
+
+ // reflect.Type = string
+ default:
+ return v.GetStructFieldOK(current.MapIndex(reflect.ValueOf(key)), namespace[endIdx+1:])
+ }
+ }
+
+ // if got here there was more namespace, cannot go any deeper
+ panic("Invalid field namespace")
+}
+
+// asInt returns the parameter as a int64
+// or panics if it can't convert
+func asInt(param string) int64 {
+
+ i, err := strconv.ParseInt(param, 0, 64)
+ panicIf(err)
+
+ return i
+}
+
+// asUint returns the parameter as a uint64
+// or panics if it can't convert
+func asUint(param string) uint64 {
+
+ i, err := strconv.ParseUint(param, 0, 64)
+ panicIf(err)
+
+ return i
+}
+
+// asFloat returns the parameter as a float64
+// or panics if it can't convert
+func asFloat(param string) float64 {
+
+ i, err := strconv.ParseFloat(param, 64)
+ panicIf(err)
+
+ return i
+}
+
+func panicIf(err error) {
+ if err != nil {
+ panic(err.Error())
+ }
+}
diff --git a/vendor/gopkg.in/go-playground/validator.v8/validator.go b/vendor/gopkg.in/go-playground/validator.v8/validator.go
new file mode 100644
index 000000000..2b1d7164d
--- /dev/null
+++ b/vendor/gopkg.in/go-playground/validator.v8/validator.go
@@ -0,0 +1,782 @@
+/**
+ * Package validator
+ *
+ * MISC:
+ * - anonymous structs - they don't have names so expect the Struct name within StructErrors to be blank
+ *
+ */
+
+package validator
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "reflect"
+ "strings"
+ "sync"
+ "time"
+)
+
+const (
+ utf8HexComma = "0x2C"
+ utf8Pipe = "0x7C"
+ tagSeparator = ","
+ orSeparator = "|"
+ tagKeySeparator = "="
+ structOnlyTag = "structonly"
+ noStructLevelTag = "nostructlevel"
+ omitempty = "omitempty"
+ skipValidationTag = "-"
+ diveTag = "dive"
+ existsTag = "exists"
+ fieldErrMsg = "Key: '%s' Error:Field validation for '%s' failed on the '%s' tag"
+ arrayIndexFieldName = "%s" + leftBracket + "%d" + rightBracket
+ mapIndexFieldName = "%s" + leftBracket + "%v" + rightBracket
+ invalidValidation = "Invalid validation tag on field %s"
+ undefinedValidation = "Undefined validation function on field %s"
+ validatorNotInitialized = "Validator instance not initialized"
+ fieldNameRequired = "Field Name Required"
+ tagRequired = "Tag Required"
+)
+
+var (
+ timeType = reflect.TypeOf(time.Time{})
+ timePtrType = reflect.TypeOf(&time.Time{})
+ defaultCField = new(cField)
+)
+
+// StructLevel contains all of the information and helper methods
+// for reporting errors during struct level validation
+type StructLevel struct {
+ TopStruct reflect.Value
+ CurrentStruct reflect.Value
+ errPrefix string
+ nsPrefix string
+ errs ValidationErrors
+ v *Validate
+}
+
+// ReportValidationErrors accepts the key relative to the top level struct and validatin errors.
+// Example: had a triple nested struct User, ContactInfo, Country and ran errs := validate.Struct(country)
+// from within a User struct level validation would call this method like so:
+// ReportValidationErrors("ContactInfo.", errs)
+// NOTE: relativeKey can contain both the Field Relative and Custom name relative paths
+// i.e. ReportValidationErrors("ContactInfo.|cInfo", errs) where cInfo represents say the JSON name of
+// the relative path; this will be split into 2 variables in the next valiator version.
+func (sl *StructLevel) ReportValidationErrors(relativeKey string, errs ValidationErrors) {
+ for _, e := range errs {
+
+ idx := strings.Index(relativeKey, "|")
+ var rel string
+ var cRel string
+
+ if idx != -1 {
+ rel = relativeKey[:idx]
+ cRel = relativeKey[idx+1:]
+ } else {
+ rel = relativeKey
+ }
+
+ key := sl.errPrefix + rel + e.Field
+
+ e.FieldNamespace = key
+ e.NameNamespace = sl.nsPrefix + cRel + e.Name
+
+ sl.errs[key] = e
+ }
+}
+
+// ReportError reports an error just by passing the field and tag information
+// NOTE: tag can be an existing validation tag or just something you make up
+// and precess on the flip side it's up to you.
+func (sl *StructLevel) ReportError(field reflect.Value, fieldName string, customName string, tag string) {
+
+ field, kind := sl.v.ExtractType(field)
+
+ if fieldName == blank {
+ panic(fieldNameRequired)
+ }
+
+ if customName == blank {
+ customName = fieldName
+ }
+
+ if tag == blank {
+ panic(tagRequired)
+ }
+
+ ns := sl.errPrefix + fieldName
+
+ switch kind {
+ case reflect.Invalid:
+ sl.errs[ns] = &FieldError{
+ FieldNamespace: ns,
+ NameNamespace: sl.nsPrefix + customName,
+ Name: customName,
+ Field: fieldName,
+ Tag: tag,
+ ActualTag: tag,
+ Param: blank,
+ Kind: kind,
+ }
+ default:
+ sl.errs[ns] = &FieldError{
+ FieldNamespace: ns,
+ NameNamespace: sl.nsPrefix + customName,
+ Name: customName,
+ Field: fieldName,
+ Tag: tag,
+ ActualTag: tag,
+ Param: blank,
+ Value: field.Interface(),
+ Kind: kind,
+ Type: field.Type(),
+ }
+ }
+}
+
+// Validate contains the validator settings passed in using the Config struct
+type Validate struct {
+ tagName string
+ fieldNameTag string
+ validationFuncs map[string]Func
+ structLevelFuncs map[reflect.Type]StructLevelFunc
+ customTypeFuncs map[reflect.Type]CustomTypeFunc
+ aliasValidators map[string]string
+ hasCustomFuncs bool
+ hasAliasValidators bool
+ hasStructLevelFuncs bool
+ tagCache *tagCache
+ structCache *structCache
+ errsPool *sync.Pool
+}
+
+func (v *Validate) initCheck() {
+ if v == nil {
+ panic(validatorNotInitialized)
+ }
+}
+
+// Config contains the options that a Validator instance will use.
+// It is passed to the New() function
+type Config struct {
+ TagName string
+ FieldNameTag string
+}
+
+// CustomTypeFunc allows for overriding or adding custom field type handler functions
+// field = field value of the type to return a value to be validated
+// example Valuer from sql drive see https://golang.org/src/database/sql/driver/types.go?s=1210:1293#L29
+type CustomTypeFunc func(field reflect.Value) interface{}
+
+// Func accepts all values needed for file and cross field validation
+// v = validator instance, needed but some built in functions for it's custom types
+// topStruct = top level struct when validating by struct otherwise nil
+// currentStruct = current level struct when validating by struct otherwise optional comparison value
+// field = field value for validation
+// param = parameter used in validation i.e. gt=0 param would be 0
+type Func func(v *Validate, topStruct reflect.Value, currentStruct reflect.Value, field reflect.Value, fieldtype reflect.Type, fieldKind reflect.Kind, param string) bool
+
+// StructLevelFunc accepts all values needed for struct level validation
+type StructLevelFunc func(v *Validate, structLevel *StructLevel)
+
+// ValidationErrors is a type of map[string]*FieldError
+// it exists to allow for multiple errors to be passed from this library
+// and yet still subscribe to the error interface
+type ValidationErrors map[string]*FieldError
+
+// Error is intended for use in development + debugging and not intended to be a production error message.
+// It allows ValidationErrors to subscribe to the Error interface.
+// All information to create an error message specific to your application is contained within
+// the FieldError found within the ValidationErrors map
+func (ve ValidationErrors) Error() string {
+
+ buff := bytes.NewBufferString(blank)
+
+ for key, err := range ve {
+ buff.WriteString(fmt.Sprintf(fieldErrMsg, key, err.Field, err.Tag))
+ buff.WriteString("\n")
+ }
+
+ return strings.TrimSpace(buff.String())
+}
+
+// FieldError contains a single field's validation error along
+// with other properties that may be needed for error message creation
+type FieldError struct {
+ FieldNamespace string
+ NameNamespace string
+ Field string
+ Name string
+ Tag string
+ ActualTag string
+ Kind reflect.Kind
+ Type reflect.Type
+ Param string
+ Value interface{}
+}
+
+// New creates a new Validate instance for use.
+func New(config *Config) *Validate {
+
+ tc := new(tagCache)
+ tc.m.Store(make(map[string]*cTag))
+
+ sc := new(structCache)
+ sc.m.Store(make(map[reflect.Type]*cStruct))
+
+ v := &Validate{
+ tagName: config.TagName,
+ fieldNameTag: config.FieldNameTag,
+ tagCache: tc,
+ structCache: sc,
+ errsPool: &sync.Pool{New: func() interface{} {
+ return ValidationErrors{}
+ }}}
+
+ if len(v.aliasValidators) == 0 {
+ // must copy alias validators for separate validations to be used in each validator instance
+ v.aliasValidators = map[string]string{}
+ for k, val := range bakedInAliasValidators {
+ v.RegisterAliasValidation(k, val)
+ }
+ }
+
+ if len(v.validationFuncs) == 0 {
+ // must copy validators for separate validations to be used in each instance
+ v.validationFuncs = map[string]Func{}
+ for k, val := range bakedInValidators {
+ v.RegisterValidation(k, val)
+ }
+ }
+
+ return v
+}
+
+// RegisterStructValidation registers a StructLevelFunc against a number of types
+// NOTE: this method is not thread-safe it is intended that these all be registered prior to any validation
+func (v *Validate) RegisterStructValidation(fn StructLevelFunc, types ...interface{}) {
+ v.initCheck()
+
+ if v.structLevelFuncs == nil {
+ v.structLevelFuncs = map[reflect.Type]StructLevelFunc{}
+ }
+
+ for _, t := range types {
+ v.structLevelFuncs[reflect.TypeOf(t)] = fn
+ }
+
+ v.hasStructLevelFuncs = true
+}
+
+// RegisterValidation adds a validation Func to a Validate's map of validators denoted by the key
+// NOTE: if the key already exists, the previous validation function will be replaced.
+// NOTE: this method is not thread-safe it is intended that these all be registered prior to any validation
+func (v *Validate) RegisterValidation(key string, fn Func) error {
+ v.initCheck()
+
+ if key == blank {
+ return errors.New("Function Key cannot be empty")
+ }
+
+ if fn == nil {
+ return errors.New("Function cannot be empty")
+ }
+
+ _, ok := restrictedTags[key]
+
+ if ok || strings.ContainsAny(key, restrictedTagChars) {
+ panic(fmt.Sprintf(restrictedTagErr, key))
+ }
+
+ v.validationFuncs[key] = fn
+
+ return nil
+}
+
+// RegisterCustomTypeFunc registers a CustomTypeFunc against a number of types
+// NOTE: this method is not thread-safe it is intended that these all be registered prior to any validation
+func (v *Validate) RegisterCustomTypeFunc(fn CustomTypeFunc, types ...interface{}) {
+ v.initCheck()
+
+ if v.customTypeFuncs == nil {
+ v.customTypeFuncs = map[reflect.Type]CustomTypeFunc{}
+ }
+
+ for _, t := range types {
+ v.customTypeFuncs[reflect.TypeOf(t)] = fn
+ }
+
+ v.hasCustomFuncs = true
+}
+
+// RegisterAliasValidation registers a mapping of a single validationstag that
+// defines a common or complex set of validation(s) to simplify adding validation
+// to structs. NOTE: when returning an error the tag returned in FieldError will be
+// the alias tag unless the dive tag is part of the alias; everything after the
+// dive tag is not reported as the alias tag. Also the ActualTag in the before case
+// will be the actual tag within the alias that failed.
+// NOTE: this method is not thread-safe it is intended that these all be registered prior to any validation
+func (v *Validate) RegisterAliasValidation(alias, tags string) {
+ v.initCheck()
+
+ _, ok := restrictedTags[alias]
+
+ if ok || strings.ContainsAny(alias, restrictedTagChars) {
+ panic(fmt.Sprintf(restrictedAliasErr, alias))
+ }
+
+ v.aliasValidators[alias] = tags
+ v.hasAliasValidators = true
+}
+
+// Field validates a single field using tag style validation and returns nil or ValidationErrors as type error.
+// You will need to assert the error if it's not nil i.e. err.(validator.ValidationErrors) to access the map of errors.
+// NOTE: it returns ValidationErrors instead of a single FieldError because this can also
+// validate Array, Slice and maps fields which may contain more than one error
+func (v *Validate) Field(field interface{}, tag string) error {
+ v.initCheck()
+
+ if len(tag) == 0 || tag == skipValidationTag {
+ return nil
+ }
+
+ errs := v.errsPool.Get().(ValidationErrors)
+ fieldVal := reflect.ValueOf(field)
+
+ ctag, ok := v.tagCache.Get(tag)
+ if !ok {
+ v.tagCache.lock.Lock()
+ defer v.tagCache.lock.Unlock()
+
+ // could have been multiple trying to access, but once first is done this ensures tag
+ // isn't parsed again.
+ ctag, ok = v.tagCache.Get(tag)
+ if !ok {
+ ctag, _ = v.parseFieldTagsRecursive(tag, blank, blank, false)
+ v.tagCache.Set(tag, ctag)
+ }
+ }
+
+ v.traverseField(fieldVal, fieldVal, fieldVal, blank, blank, errs, false, false, nil, nil, defaultCField, ctag)
+
+ if len(errs) == 0 {
+ v.errsPool.Put(errs)
+ return nil
+ }
+
+ return errs
+}
+
+// FieldWithValue validates a single field, against another fields value using tag style validation and returns nil or ValidationErrors.
+// You will need to assert the error if it's not nil i.e. err.(validator.ValidationErrors) to access the map of errors.
+// NOTE: it returns ValidationErrors instead of a single FieldError because this can also
+// validate Array, Slice and maps fields which may contain more than one error
+func (v *Validate) FieldWithValue(val interface{}, field interface{}, tag string) error {
+ v.initCheck()
+
+ if len(tag) == 0 || tag == skipValidationTag {
+ return nil
+ }
+
+ errs := v.errsPool.Get().(ValidationErrors)
+ topVal := reflect.ValueOf(val)
+
+ ctag, ok := v.tagCache.Get(tag)
+ if !ok {
+ v.tagCache.lock.Lock()
+ defer v.tagCache.lock.Unlock()
+
+ // could have been multiple trying to access, but once first is done this ensures tag
+ // isn't parsed again.
+ ctag, ok = v.tagCache.Get(tag)
+ if !ok {
+ ctag, _ = v.parseFieldTagsRecursive(tag, blank, blank, false)
+ v.tagCache.Set(tag, ctag)
+ }
+ }
+
+ v.traverseField(topVal, topVal, reflect.ValueOf(field), blank, blank, errs, false, false, nil, nil, defaultCField, ctag)
+
+ if len(errs) == 0 {
+ v.errsPool.Put(errs)
+ return nil
+ }
+
+ return errs
+}
+
+// StructPartial validates the fields passed in only, ignoring all others.
+// Fields may be provided in a namespaced fashion relative to the struct provided
+// i.e. NestedStruct.Field or NestedArrayField[0].Struct.Name and returns nil or ValidationErrors as error
+// You will need to assert the error if it's not nil i.e. err.(validator.ValidationErrors) to access the map of errors.
+func (v *Validate) StructPartial(current interface{}, fields ...string) error {
+ v.initCheck()
+
+ sv, _ := v.ExtractType(reflect.ValueOf(current))
+ name := sv.Type().Name()
+ m := map[string]struct{}{}
+
+ if fields != nil {
+ for _, k := range fields {
+
+ flds := strings.Split(k, namespaceSeparator)
+ if len(flds) > 0 {
+
+ key := name + namespaceSeparator
+ for _, s := range flds {
+
+ idx := strings.Index(s, leftBracket)
+
+ if idx != -1 {
+ for idx != -1 {
+ key += s[:idx]
+ m[key] = struct{}{}
+
+ idx2 := strings.Index(s, rightBracket)
+ idx2++
+ key += s[idx:idx2]
+ m[key] = struct{}{}
+ s = s[idx2:]
+ idx = strings.Index(s, leftBracket)
+ }
+ } else {
+
+ key += s
+ m[key] = struct{}{}
+ }
+
+ key += namespaceSeparator
+ }
+ }
+ }
+ }
+
+ errs := v.errsPool.Get().(ValidationErrors)
+
+ v.ensureValidStruct(sv, sv, sv, blank, blank, errs, true, len(m) != 0, false, m, false)
+
+ if len(errs) == 0 {
+ v.errsPool.Put(errs)
+ return nil
+ }
+
+ return errs
+}
+
+// StructExcept validates all fields except the ones passed in.
+// Fields may be provided in a namespaced fashion relative to the struct provided
+// i.e. NestedStruct.Field or NestedArrayField[0].Struct.Name and returns nil or ValidationErrors as error
+// You will need to assert the error if it's not nil i.e. err.(validator.ValidationErrors) to access the map of errors.
+func (v *Validate) StructExcept(current interface{}, fields ...string) error {
+ v.initCheck()
+
+ sv, _ := v.ExtractType(reflect.ValueOf(current))
+ name := sv.Type().Name()
+ m := map[string]struct{}{}
+
+ for _, key := range fields {
+ m[name+namespaceSeparator+key] = struct{}{}
+ }
+
+ errs := v.errsPool.Get().(ValidationErrors)
+
+ v.ensureValidStruct(sv, sv, sv, blank, blank, errs, true, len(m) != 0, true, m, false)
+
+ if len(errs) == 0 {
+ v.errsPool.Put(errs)
+ return nil
+ }
+
+ return errs
+}
+
+// Struct validates a structs exposed fields, and automatically validates nested structs, unless otherwise specified.
+// it returns nil or ValidationErrors as error.
+// You will need to assert the error if it's not nil i.e. err.(validator.ValidationErrors) to access the map of errors.
+func (v *Validate) Struct(current interface{}) error {
+ v.initCheck()
+
+ errs := v.errsPool.Get().(ValidationErrors)
+ sv := reflect.ValueOf(current)
+
+ v.ensureValidStruct(sv, sv, sv, blank, blank, errs, true, false, false, nil, false)
+
+ if len(errs) == 0 {
+ v.errsPool.Put(errs)
+ return nil
+ }
+
+ return errs
+}
+
+func (v *Validate) ensureValidStruct(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, nsPrefix string, errs ValidationErrors, useStructName bool, partial bool, exclude bool, includeExclude map[string]struct{}, isStructOnly bool) {
+
+ if current.Kind() == reflect.Ptr && !current.IsNil() {
+ current = current.Elem()
+ }
+
+ if current.Kind() != reflect.Struct && current.Kind() != reflect.Interface {
+ panic("value passed for validation is not a struct")
+ }
+
+ v.tranverseStruct(topStruct, currentStruct, current, errPrefix, nsPrefix, errs, useStructName, partial, exclude, includeExclude, nil, nil)
+}
+
+// tranverseStruct traverses a structs fields and then passes them to be validated by traverseField
+func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, nsPrefix string, errs ValidationErrors, useStructName bool, partial bool, exclude bool, includeExclude map[string]struct{}, cs *cStruct, ct *cTag) {
+
+ var ok bool
+ first := len(nsPrefix) == 0
+ typ := current.Type()
+
+ cs, ok = v.structCache.Get(typ)
+ if !ok {
+ cs = v.extractStructCache(current, typ.Name())
+ }
+
+ if useStructName {
+ errPrefix += cs.Name + namespaceSeparator
+
+ if len(v.fieldNameTag) != 0 {
+ nsPrefix += cs.Name + namespaceSeparator
+ }
+ }
+
+ // structonly tag present don't tranverseFields
+ // but must still check and run below struct level validation
+ // if present
+ if first || ct == nil || ct.typeof != typeStructOnly {
+
+ for _, f := range cs.fields {
+
+ if partial {
+
+ _, ok = includeExclude[errPrefix+f.Name]
+
+ if (ok && exclude) || (!ok && !exclude) {
+ continue
+ }
+ }
+
+ v.traverseField(topStruct, currentStruct, current.Field(f.Idx), errPrefix, nsPrefix, errs, partial, exclude, includeExclude, cs, f, f.cTags)
+ }
+ }
+
+ // check if any struct level validations, after all field validations already checked.
+ if cs.fn != nil {
+ cs.fn(v, &StructLevel{v: v, TopStruct: topStruct, CurrentStruct: current, errPrefix: errPrefix, nsPrefix: nsPrefix, errs: errs})
+ }
+}
+
+// traverseField validates any field, be it a struct or single field, ensures it's validity and passes it along to be validated via it's tag options
+func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, nsPrefix string, errs ValidationErrors, partial bool, exclude bool, includeExclude map[string]struct{}, cs *cStruct, cf *cField, ct *cTag) {
+
+ current, kind, nullable := v.extractTypeInternal(current, false)
+ var typ reflect.Type
+
+ switch kind {
+ case reflect.Ptr, reflect.Interface, reflect.Invalid:
+
+ if ct == nil {
+ return
+ }
+
+ if ct.typeof == typeOmitEmpty {
+ return
+ }
+
+ if ct.hasTag {
+
+ ns := errPrefix + cf.Name
+
+ if kind == reflect.Invalid {
+ errs[ns] = &FieldError{
+ FieldNamespace: ns,
+ NameNamespace: nsPrefix + cf.AltName,
+ Name: cf.AltName,
+ Field: cf.Name,
+ Tag: ct.aliasTag,
+ ActualTag: ct.tag,
+ Param: ct.param,
+ Kind: kind,
+ }
+ return
+ }
+
+ errs[ns] = &FieldError{
+ FieldNamespace: ns,
+ NameNamespace: nsPrefix + cf.AltName,
+ Name: cf.AltName,
+ Field: cf.Name,
+ Tag: ct.aliasTag,
+ ActualTag: ct.tag,
+ Param: ct.param,
+ Value: current.Interface(),
+ Kind: kind,
+ Type: current.Type(),
+ }
+
+ return
+ }
+
+ case reflect.Struct:
+ typ = current.Type()
+
+ if typ != timeType {
+
+ if ct != nil {
+ ct = ct.next
+ }
+
+ if ct != nil && ct.typeof == typeNoStructLevel {
+ return
+ }
+
+ v.tranverseStruct(topStruct, current, current, errPrefix+cf.Name+namespaceSeparator, nsPrefix+cf.AltName+namespaceSeparator, errs, false, partial, exclude, includeExclude, cs, ct)
+ return
+ }
+ }
+
+ if !ct.hasTag {
+ return
+ }
+
+ typ = current.Type()
+
+OUTER:
+ for {
+ if ct == nil {
+ return
+ }
+
+ switch ct.typeof {
+
+ case typeExists:
+ ct = ct.next
+ continue
+
+ case typeOmitEmpty:
+
+ if !nullable && !HasValue(v, topStruct, currentStruct, current, typ, kind, blank) {
+ return
+ }
+
+ ct = ct.next
+ continue
+
+ case typeDive:
+
+ ct = ct.next
+
+ // traverse slice or map here
+ // or panic ;)
+ switch kind {
+ case reflect.Slice, reflect.Array:
+
+ for i := 0; i < current.Len(); i++ {
+ v.traverseField(topStruct, currentStruct, current.Index(i), errPrefix, nsPrefix, errs, partial, exclude, includeExclude, cs, &cField{Name: fmt.Sprintf(arrayIndexFieldName, cf.Name, i), AltName: fmt.Sprintf(arrayIndexFieldName, cf.AltName, i)}, ct)
+ }
+
+ case reflect.Map:
+ for _, key := range current.MapKeys() {
+ v.traverseField(topStruct, currentStruct, current.MapIndex(key), errPrefix, nsPrefix, errs, partial, exclude, includeExclude, cs, &cField{Name: fmt.Sprintf(mapIndexFieldName, cf.Name, key.Interface()), AltName: fmt.Sprintf(mapIndexFieldName, cf.AltName, key.Interface())}, ct)
+ }
+
+ default:
+ // throw error, if not a slice or map then should not have gotten here
+ // bad dive tag
+ panic("dive error! can't dive on a non slice or map")
+ }
+
+ return
+
+ case typeOr:
+
+ errTag := blank
+
+ for {
+
+ if ct.fn(v, topStruct, currentStruct, current, typ, kind, ct.param) {
+
+ // drain rest of the 'or' values, then continue or leave
+ for {
+
+ ct = ct.next
+
+ if ct == nil {
+ return
+ }
+
+ if ct.typeof != typeOr {
+ continue OUTER
+ }
+ }
+ }
+
+ errTag += orSeparator + ct.tag
+
+ if ct.next == nil {
+ // if we get here, no valid 'or' value and no more tags
+
+ ns := errPrefix + cf.Name
+
+ if ct.hasAlias {
+ errs[ns] = &FieldError{
+ FieldNamespace: ns,
+ NameNamespace: nsPrefix + cf.AltName,
+ Name: cf.AltName,
+ Field: cf.Name,
+ Tag: ct.aliasTag,
+ ActualTag: ct.actualAliasTag,
+ Value: current.Interface(),
+ Type: typ,
+ Kind: kind,
+ }
+ } else {
+ errs[errPrefix+cf.Name] = &FieldError{
+ FieldNamespace: ns,
+ NameNamespace: nsPrefix + cf.AltName,
+ Name: cf.AltName,
+ Field: cf.Name,
+ Tag: errTag[1:],
+ ActualTag: errTag[1:],
+ Value: current.Interface(),
+ Type: typ,
+ Kind: kind,
+ }
+ }
+
+ return
+ }
+
+ ct = ct.next
+ }
+
+ default:
+ if !ct.fn(v, topStruct, currentStruct, current, typ, kind, ct.param) {
+
+ ns := errPrefix + cf.Name
+
+ errs[ns] = &FieldError{
+ FieldNamespace: ns,
+ NameNamespace: nsPrefix + cf.AltName,
+ Name: cf.AltName,
+ Field: cf.Name,
+ Tag: ct.aliasTag,
+ ActualTag: ct.tag,
+ Value: current.Interface(),
+ Param: ct.param,
+ Type: typ,
+ Kind: kind,
+ }
+
+ return
+
+ }
+
+ ct = ct.next
+ }
+ }
+}
diff --git a/vendor/gopkg.in/go-playground/validator.v8/validator_test.go b/vendor/gopkg.in/go-playground/validator.v8/validator_test.go
new file mode 100644
index 000000000..3629acc2b
--- /dev/null
+++ b/vendor/gopkg.in/go-playground/validator.v8/validator_test.go
@@ -0,0 +1,5900 @@
+package validator
+
+import (
+ "database/sql"
+ "database/sql/driver"
+ "encoding/json"
+ "fmt"
+ "reflect"
+ "testing"
+ "time"
+
+ . "gopkg.in/go-playground/assert.v1"
+)
+
+// NOTES:
+// - Run "go test" to run tests
+// - Run "gocov test | gocov report" to report on test converage by file
+// - Run "gocov test | gocov annotate -" to report on all code and functions, those ,marked with "MISS" were never called
+//
+// or
+//
+// -- may be a good idea to change to output path to somewherelike /tmp
+// go test -coverprofile cover.out && go tool cover -html=cover.out -o cover.html
+//
+//
+// go test -cpuprofile cpu.out
+// ./validator.test -test.bench=. -test.cpuprofile=cpu.prof
+// go tool pprof validator.test cpu.prof
+//
+//
+// go test -memprofile mem.out
+
+type I interface {
+ Foo() string
+}
+
+type Impl struct {
+ F string `validate:"len=3"`
+}
+
+func (i *Impl) Foo() string {
+ return i.F
+}
+
+type SubTest struct {
+ Test string `validate:"required"`
+}
+
+type TestInterface struct {
+ Iface I
+}
+
+type TestString struct {
+ BlankTag string `validate:""`
+ Required string `validate:"required"`
+ Len string `validate:"len=10"`
+ Min string `validate:"min=1"`
+ Max string `validate:"max=10"`
+ MinMax string `validate:"min=1,max=10"`
+ Lt string `validate:"lt=10"`
+ Lte string `validate:"lte=10"`
+ Gt string `validate:"gt=10"`
+ Gte string `validate:"gte=10"`
+ OmitEmpty string `validate:"omitempty,min=1,max=10"`
+ Sub *SubTest
+ SubIgnore *SubTest `validate:"-"`
+ Anonymous struct {
+ A string `validate:"required"`
+ }
+ Iface I
+}
+
+type TestInt32 struct {
+ Required int `validate:"required"`
+ Len int `validate:"len=10"`
+ Min int `validate:"min=1"`
+ Max int `validate:"max=10"`
+ MinMax int `validate:"min=1,max=10"`
+ Lt int `validate:"lt=10"`
+ Lte int `validate:"lte=10"`
+ Gt int `validate:"gt=10"`
+ Gte int `validate:"gte=10"`
+ OmitEmpty int `validate:"omitempty,min=1,max=10"`
+}
+
+type TestUint64 struct {
+ Required uint64 `validate:"required"`
+ Len uint64 `validate:"len=10"`
+ Min uint64 `validate:"min=1"`
+ Max uint64 `validate:"max=10"`
+ MinMax uint64 `validate:"min=1,max=10"`
+ OmitEmpty uint64 `validate:"omitempty,min=1,max=10"`
+}
+
+type TestFloat64 struct {
+ Required float64 `validate:"required"`
+ Len float64 `validate:"len=10"`
+ Min float64 `validate:"min=1"`
+ Max float64 `validate:"max=10"`
+ MinMax float64 `validate:"min=1,max=10"`
+ Lte float64 `validate:"lte=10"`
+ OmitEmpty float64 `validate:"omitempty,min=1,max=10"`
+}
+
+type TestSlice struct {
+ Required []int `validate:"required"`
+ Len []int `validate:"len=10"`
+ Min []int `validate:"min=1"`
+ Max []int `validate:"max=10"`
+ MinMax []int `validate:"min=1,max=10"`
+ OmitEmpty []int `validate:"omitempty,min=1,max=10"`
+}
+
+var validate = New(&Config{TagName: "validate"})
+
+func AssertError(t *testing.T, err error, key, field, expectedTag string) {
+
+ errs := err.(ValidationErrors)
+
+ val, ok := errs[key]
+ EqualSkip(t, 2, ok, true)
+ NotEqualSkip(t, 2, val, nil)
+ EqualSkip(t, 2, val.Field, field)
+ EqualSkip(t, 2, val.Tag, expectedTag)
+}
+
+type valuer struct {
+ Name string
+}
+
+func (v valuer) Value() (driver.Value, error) {
+
+ if v.Name == "errorme" {
+ panic("SQL Driver Valuer error: some kind of error")
+ // return nil, errors.New("some kind of error")
+ }
+
+ if len(v.Name) == 0 {
+ return nil, nil
+ }
+
+ return v.Name, nil
+}
+
+type MadeUpCustomType struct {
+ FirstName string
+ LastName string
+}
+
+func ValidateCustomType(field reflect.Value) interface{} {
+ if cust, ok := field.Interface().(MadeUpCustomType); ok {
+
+ if len(cust.FirstName) == 0 || len(cust.LastName) == 0 {
+ return ""
+ }
+
+ return cust.FirstName + " " + cust.LastName
+ }
+
+ return ""
+}
+
+func OverrideIntTypeForSomeReason(field reflect.Value) interface{} {
+
+ if i, ok := field.Interface().(int); ok {
+ if i == 1 {
+ return "1"
+ }
+
+ if i == 2 {
+ return "12"
+ }
+ }
+
+ return ""
+}
+
+type CustomMadeUpStruct struct {
+ MadeUp MadeUpCustomType `validate:"required"`
+ OverriddenInt int `validate:"gt=1"`
+}
+
+func ValidateValuerType(field reflect.Value) interface{} {
+
+ if valuer, ok := field.Interface().(driver.Valuer); ok {
+
+ val, err := valuer.Value()
+ if err != nil {
+ // handle the error how you want
+ return nil
+ }
+
+ return val
+ }
+
+ return nil
+}
+
+type TestPartial struct {
+ NoTag string
+ BlankTag string `validate:""`
+ Required string `validate:"required"`
+ SubSlice []*SubTest `validate:"required,dive"`
+ Sub *SubTest
+ SubIgnore *SubTest `validate:"-"`
+ Anonymous struct {
+ A string `validate:"required"`
+ ASubSlice []*SubTest `validate:"required,dive"`
+
+ SubAnonStruct []struct {
+ Test string `validate:"required"`
+ OtherTest string `validate:"required"`
+ } `validate:"required,dive"`
+ }
+}
+
+type TestStruct struct {
+ String string `validate:"required" json:"StringVal"`
+}
+
+func StructValidationTestStructSuccess(v *Validate, structLevel *StructLevel) {
+
+ st := structLevel.CurrentStruct.Interface().(TestStruct)
+
+ if st.String != "good value" {
+ structLevel.ReportError(reflect.ValueOf(st.String), "String", "StringVal", "badvalueteststruct")
+ }
+}
+
+func StructValidationTestStruct(v *Validate, structLevel *StructLevel) {
+
+ st := structLevel.CurrentStruct.Interface().(TestStruct)
+
+ if st.String != "bad value" {
+ structLevel.ReportError(reflect.ValueOf(st.String), "String", "StringVal", "badvalueteststruct")
+ }
+}
+
+func StructValidationBadTestStructFieldName(v *Validate, structLevel *StructLevel) {
+
+ st := structLevel.CurrentStruct.Interface().(TestStruct)
+
+ if st.String != "bad value" {
+ structLevel.ReportError(reflect.ValueOf(st.String), "", "StringVal", "badvalueteststruct")
+ }
+}
+
+func StructValidationBadTestStructTag(v *Validate, structLevel *StructLevel) {
+
+ st := structLevel.CurrentStruct.Interface().(TestStruct)
+
+ if st.String != "bad value" {
+ structLevel.ReportError(reflect.ValueOf(st.String), "String", "StringVal", "")
+ }
+}
+
+func StructValidationNoTestStructCustomName(v *Validate, structLevel *StructLevel) {
+
+ st := structLevel.CurrentStruct.Interface().(TestStruct)
+
+ if st.String != "bad value" {
+ structLevel.ReportError(reflect.ValueOf(st.String), "String", "", "badvalueteststruct")
+ }
+}
+
+func StructValidationTestStructInvalid(v *Validate, structLevel *StructLevel) {
+
+ st := structLevel.CurrentStruct.Interface().(TestStruct)
+
+ if st.String != "bad value" {
+ structLevel.ReportError(reflect.ValueOf(nil), "String", "StringVal", "badvalueteststruct")
+ }
+}
+
+func StructValidationTestStructReturnValidationErrors(v *Validate, structLevel *StructLevel) {
+
+ s := structLevel.CurrentStruct.Interface().(TestStructReturnValidationErrors)
+
+ errs := v.Struct(s.Inner1.Inner2)
+ if errs == nil {
+ return
+ }
+
+ structLevel.ReportValidationErrors("Inner1.", errs.(ValidationErrors))
+}
+
+func StructValidationTestStructReturnValidationErrors2(v *Validate, structLevel *StructLevel) {
+
+ s := structLevel.CurrentStruct.Interface().(TestStructReturnValidationErrors)
+
+ errs := v.Struct(s.Inner1.Inner2)
+ if errs == nil {
+ return
+ }
+
+ structLevel.ReportValidationErrors("Inner1.|Inner1JSON.", errs.(ValidationErrors))
+}
+
+type TestStructReturnValidationErrorsInner2 struct {
+ String string `validate:"required" json:"JSONString"`
+}
+
+type TestStructReturnValidationErrorsInner1 struct {
+ Inner2 *TestStructReturnValidationErrorsInner2
+}
+
+type TestStructReturnValidationErrors struct {
+ Inner1 *TestStructReturnValidationErrorsInner1 `json:"Inner1JSON"`
+}
+
+type Inner2Namespace struct {
+ String []string `validate:"dive,required" json:"JSONString"`
+}
+
+type Inner1Namespace struct {
+ Inner2 *Inner2Namespace `json:"Inner2JSON"`
+}
+
+type Namespace struct {
+ Inner1 *Inner1Namespace `json:"Inner1JSON"`
+}
+
+func TestNameNamespace(t *testing.T) {
+
+ config := &Config{
+ TagName: "validate",
+ FieldNameTag: "json",
+ }
+
+ v1 := New(config)
+ i2 := &Inner2Namespace{String: []string{"ok", "ok", "ok"}}
+ i1 := &Inner1Namespace{Inner2: i2}
+ ns := &Namespace{Inner1: i1}
+
+ errs := v1.Struct(ns)
+ Equal(t, errs, nil)
+
+ i2.String[1] = ""
+
+ errs = v1.Struct(ns)
+ NotEqual(t, errs, nil)
+
+ ve := errs.(ValidationErrors)
+ Equal(t, len(ve), 1)
+ AssertError(t, errs, "Namespace.Inner1.Inner2.String[1]", "String[1]", "required")
+
+ fe, ok := ve["Namespace.Inner1.Inner2.String[1]"]
+ Equal(t, ok, true)
+
+ Equal(t, fe.Field, "String[1]")
+ Equal(t, fe.FieldNamespace, "Namespace.Inner1.Inner2.String[1]")
+ Equal(t, fe.Name, "JSONString[1]")
+ Equal(t, fe.NameNamespace, "Namespace.Inner1JSON.Inner2JSON.JSONString[1]")
+}
+
+func TestAnonymous(t *testing.T) {
+
+ v2 := New(&Config{TagName: "validate", FieldNameTag: "json"})
+
+ type Test struct {
+ Anonymous struct {
+ A string `validate:"required" json:"EH"`
+ }
+ AnonymousB struct {
+ B string `validate:"required" json:"BEE"`
+ }
+ anonymousC struct {
+ c string `validate:"required"`
+ }
+ }
+
+ tst := &Test{
+ Anonymous: struct {
+ A string `validate:"required" json:"EH"`
+ }{
+ A: "1",
+ },
+ AnonymousB: struct {
+ B string `validate:"required" json:"BEE"`
+ }{
+ B: "",
+ },
+ anonymousC: struct {
+ c string `validate:"required"`
+ }{
+ c: "",
+ },
+ }
+
+ err := v2.Struct(tst)
+ NotEqual(t, err, nil)
+
+ errs := err.(ValidationErrors)
+
+ Equal(t, len(errs), 1)
+ AssertError(t, errs, "Test.AnonymousB.B", "B", "required")
+ Equal(t, errs["Test.AnonymousB.B"].Field, "B")
+ Equal(t, errs["Test.AnonymousB.B"].Name, "BEE")
+
+ s := struct {
+ c string `validate:"required"`
+ }{
+ c: "",
+ }
+
+ err = v2.Struct(s)
+ Equal(t, err, nil)
+}
+
+func TestAnonymousSameStructDifferentTags(t *testing.T) {
+
+ v2 := New(&Config{TagName: "validate", FieldNameTag: "json"})
+
+ type Test struct {
+ A interface{}
+ }
+
+ tst := &Test{
+ A: struct {
+ A string `validate:"required"`
+ }{
+ A: "",
+ },
+ }
+
+ err := v2.Struct(tst)
+ NotEqual(t, err, nil)
+
+ errs := err.(ValidationErrors)
+
+ Equal(t, len(errs), 1)
+ AssertError(t, errs, "Test.A.A", "A", "required")
+
+ tst = &Test{
+ A: struct {
+ A string `validate:"omitempty,required"`
+ }{
+ A: "",
+ },
+ }
+
+ err = v2.Struct(tst)
+ Equal(t, err, nil)
+}
+
+func TestStructLevelReturnValidationErrors(t *testing.T) {
+ config := &Config{
+ TagName: "validate",
+ }
+
+ v1 := New(config)
+ v1.RegisterStructValidation(StructValidationTestStructReturnValidationErrors, TestStructReturnValidationErrors{})
+
+ inner2 := &TestStructReturnValidationErrorsInner2{
+ String: "I'm HERE",
+ }
+
+ inner1 := &TestStructReturnValidationErrorsInner1{
+ Inner2: inner2,
+ }
+
+ val := &TestStructReturnValidationErrors{
+ Inner1: inner1,
+ }
+
+ errs := v1.Struct(val)
+ Equal(t, errs, nil)
+
+ inner2.String = ""
+
+ errs = v1.Struct(val)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 2)
+ AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.Inner2.String", "String", "required")
+ // this is an extra error reported from struct validation
+ AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.String", "String", "required")
+}
+
+func TestStructLevelReturnValidationErrorsWithJSON(t *testing.T) {
+ config := &Config{
+ TagName: "validate",
+ FieldNameTag: "json",
+ }
+
+ v1 := New(config)
+ v1.RegisterStructValidation(StructValidationTestStructReturnValidationErrors2, TestStructReturnValidationErrors{})
+
+ inner2 := &TestStructReturnValidationErrorsInner2{
+ String: "I'm HERE",
+ }
+
+ inner1 := &TestStructReturnValidationErrorsInner1{
+ Inner2: inner2,
+ }
+
+ val := &TestStructReturnValidationErrors{
+ Inner1: inner1,
+ }
+
+ errs := v1.Struct(val)
+ Equal(t, errs, nil)
+
+ inner2.String = ""
+
+ errs = v1.Struct(val)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 2)
+ AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.Inner2.String", "String", "required")
+ // this is an extra error reported from struct validation, it's a badly formatted one, but on purpose
+ AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.String", "String", "required")
+
+ fe, ok := errs.(ValidationErrors)["TestStructReturnValidationErrors.Inner1.Inner2.String"]
+ Equal(t, ok, true)
+
+ // check for proper JSON namespace
+ Equal(t, fe.Field, "String")
+ Equal(t, fe.Name, "JSONString")
+ Equal(t, fe.FieldNamespace, "TestStructReturnValidationErrors.Inner1.Inner2.String")
+ Equal(t, fe.NameNamespace, "TestStructReturnValidationErrors.Inner1JSON.Inner2.JSONString")
+
+ fe, ok = errs.(ValidationErrors)["TestStructReturnValidationErrors.Inner1.String"]
+ Equal(t, ok, true)
+
+ // check for proper JSON namespace
+ Equal(t, fe.Field, "String")
+ Equal(t, fe.Name, "JSONString")
+ Equal(t, fe.FieldNamespace, "TestStructReturnValidationErrors.Inner1.String")
+ Equal(t, fe.NameNamespace, "TestStructReturnValidationErrors.Inner1JSON.JSONString")
+}
+
+func TestStructLevelValidations(t *testing.T) {
+
+ config := &Config{
+ TagName: "validate",
+ }
+
+ v1 := New(config)
+ v1.RegisterStructValidation(StructValidationTestStruct, TestStruct{})
+
+ tst := &TestStruct{
+ String: "good value",
+ }
+
+ errs := v1.Struct(tst)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestStruct.String", "String", "badvalueteststruct")
+
+ v2 := New(config)
+ v2.RegisterStructValidation(StructValidationBadTestStructFieldName, TestStruct{})
+
+ PanicMatches(t, func() { v2.Struct(tst) }, fieldNameRequired)
+
+ v3 := New(config)
+ v3.RegisterStructValidation(StructValidationBadTestStructTag, TestStruct{})
+
+ PanicMatches(t, func() { v3.Struct(tst) }, tagRequired)
+
+ v4 := New(config)
+ v4.RegisterStructValidation(StructValidationNoTestStructCustomName, TestStruct{})
+
+ errs = v4.Struct(tst)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestStruct.String", "String", "badvalueteststruct")
+
+ v5 := New(config)
+ v5.RegisterStructValidation(StructValidationTestStructInvalid, TestStruct{})
+
+ errs = v5.Struct(tst)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestStruct.String", "String", "badvalueteststruct")
+
+ v6 := New(config)
+ v6.RegisterStructValidation(StructValidationTestStructSuccess, TestStruct{})
+
+ errs = v6.Struct(tst)
+ Equal(t, errs, nil)
+}
+
+func TestAliasTags(t *testing.T) {
+
+ validate.RegisterAliasValidation("iscolor", "hexcolor|rgb|rgba|hsl|hsla")
+
+ s := "rgb(255,255,255)"
+ errs := validate.Field(s, "iscolor")
+ Equal(t, errs, nil)
+
+ s = ""
+ errs = validate.Field(s, "omitempty,iscolor")
+ Equal(t, errs, nil)
+
+ s = "rgb(255,255,0)"
+ errs = validate.Field(s, "iscolor,len=5")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "len")
+
+ type Test struct {
+ Color string `validate:"iscolor"`
+ }
+
+ tst := &Test{
+ Color: "#000",
+ }
+
+ errs = validate.Struct(tst)
+ Equal(t, errs, nil)
+
+ tst.Color = "cfvre"
+ errs = validate.Struct(tst)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.Color", "Color", "iscolor")
+ Equal(t, errs.(ValidationErrors)["Test.Color"].ActualTag, "hexcolor|rgb|rgba|hsl|hsla")
+
+ validate.RegisterAliasValidation("req", "required,dive,iscolor")
+ arr := []string{"val1", "#fff", "#000"}
+
+ errs = validate.Field(arr, "req")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "[0]", "[0]", "iscolor")
+
+ PanicMatches(t, func() { validate.RegisterAliasValidation("exists", "gt=5,lt=10") }, "Alias 'exists' either contains restricted characters or is the same as a restricted tag needed for normal operation")
+}
+
+func TestNilValidator(t *testing.T) {
+
+ type TestStruct struct {
+ Test string `validate:"required"`
+ }
+
+ ts := TestStruct{}
+
+ var val *Validate
+
+ fn := func(v *Validate, topStruct reflect.Value, current reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ return current.String() == field.String()
+ }
+
+ PanicMatches(t, func() { val.RegisterCustomTypeFunc(ValidateCustomType, MadeUpCustomType{}) }, validatorNotInitialized)
+ PanicMatches(t, func() { val.RegisterValidation("something", fn) }, validatorNotInitialized)
+ PanicMatches(t, func() { val.Field(ts.Test, "required") }, validatorNotInitialized)
+ PanicMatches(t, func() { val.FieldWithValue("test", ts.Test, "required") }, validatorNotInitialized)
+ PanicMatches(t, func() { val.Struct(ts) }, validatorNotInitialized)
+ PanicMatches(t, func() { val.StructExcept(ts, "Test") }, validatorNotInitialized)
+ PanicMatches(t, func() { val.StructPartial(ts, "Test") }, validatorNotInitialized)
+}
+
+func TestStructPartial(t *testing.T) {
+
+ p1 := []string{
+ "NoTag",
+ "Required",
+ }
+
+ p2 := []string{
+ "SubSlice[0].Test",
+ "Sub",
+ "SubIgnore",
+ "Anonymous.A",
+ }
+
+ p3 := []string{
+ "SubTest.Test",
+ }
+
+ p4 := []string{
+ "A",
+ }
+
+ tPartial := &TestPartial{
+ NoTag: "NoTag",
+ Required: "Required",
+
+ SubSlice: []*SubTest{
+ {
+
+ Test: "Required",
+ },
+ {
+
+ Test: "Required",
+ },
+ },
+
+ Sub: &SubTest{
+ Test: "1",
+ },
+ SubIgnore: &SubTest{
+ Test: "",
+ },
+ Anonymous: struct {
+ A string `validate:"required"`
+ ASubSlice []*SubTest `validate:"required,dive"`
+ SubAnonStruct []struct {
+ Test string `validate:"required"`
+ OtherTest string `validate:"required"`
+ } `validate:"required,dive"`
+ }{
+ A: "1",
+ ASubSlice: []*SubTest{
+ {
+ Test: "Required",
+ },
+ {
+ Test: "Required",
+ },
+ },
+
+ SubAnonStruct: []struct {
+ Test string `validate:"required"`
+ OtherTest string `validate:"required"`
+ }{
+ {"Required", "RequiredOther"},
+ {"Required", "RequiredOther"},
+ },
+ },
+ }
+
+ // the following should all return no errors as everything is valid in
+ // the default state
+ errs := validate.StructPartial(tPartial, p1...)
+ Equal(t, errs, nil)
+
+ errs = validate.StructPartial(tPartial, p2...)
+ Equal(t, errs, nil)
+
+ // this isn't really a robust test, but is ment to illustrate the ANON CASE below
+ errs = validate.StructPartial(tPartial.SubSlice[0], p3...)
+ Equal(t, errs, nil)
+
+ errs = validate.StructExcept(tPartial, p1...)
+ Equal(t, errs, nil)
+
+ errs = validate.StructExcept(tPartial, p2...)
+ Equal(t, errs, nil)
+
+ // mod tParial for required feild and re-test making sure invalid fields are NOT required:
+ tPartial.Required = ""
+
+ errs = validate.StructExcept(tPartial, p1...)
+ Equal(t, errs, nil)
+
+ errs = validate.StructPartial(tPartial, p2...)
+ Equal(t, errs, nil)
+
+ // inversion and retesting Partial to generate failures:
+ errs = validate.StructPartial(tPartial, p1...)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestPartial.Required", "Required", "required")
+
+ errs = validate.StructExcept(tPartial, p2...)
+ AssertError(t, errs, "TestPartial.Required", "Required", "required")
+
+ // reset Required field, and set nested struct
+ tPartial.Required = "Required"
+ tPartial.Anonymous.A = ""
+
+ // will pass as unset feilds is not going to be tested
+ errs = validate.StructPartial(tPartial, p1...)
+ Equal(t, errs, nil)
+
+ errs = validate.StructExcept(tPartial, p2...)
+ Equal(t, errs, nil)
+
+ // ANON CASE the response here is strange, it clearly does what it is being told to
+ errs = validate.StructExcept(tPartial.Anonymous, p4...)
+ Equal(t, errs, nil)
+
+ // will fail as unset feild is tested
+ errs = validate.StructPartial(tPartial, p2...)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestPartial.Anonymous.A", "A", "required")
+
+ errs = validate.StructExcept(tPartial, p1...)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestPartial.Anonymous.A", "A", "required")
+
+ // reset nested struct and unset struct in slice
+ tPartial.Anonymous.A = "Required"
+ tPartial.SubSlice[0].Test = ""
+
+ // these will pass as unset item is NOT tested
+ errs = validate.StructPartial(tPartial, p1...)
+ Equal(t, errs, nil)
+
+ errs = validate.StructExcept(tPartial, p2...)
+ Equal(t, errs, nil)
+
+ // these will fail as unset item IS tested
+ errs = validate.StructExcept(tPartial, p1...)
+ AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required")
+ Equal(t, len(errs.(ValidationErrors)), 1)
+
+ errs = validate.StructPartial(tPartial, p2...)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required")
+ Equal(t, len(errs.(ValidationErrors)), 1)
+
+ // Unset second slice member concurrently to test dive behavior:
+ tPartial.SubSlice[1].Test = ""
+
+ errs = validate.StructPartial(tPartial, p1...)
+ Equal(t, errs, nil)
+
+ // NOTE: When specifying nested items, it is still the users responsibility
+ // to specify the dive tag, the library does not override this.
+ errs = validate.StructExcept(tPartial, p2...)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required")
+
+ errs = validate.StructExcept(tPartial, p1...)
+ Equal(t, len(errs.(ValidationErrors)), 2)
+ AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required")
+ AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required")
+
+ errs = validate.StructPartial(tPartial, p2...)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required")
+
+ // reset struct in slice, and unset struct in slice in unset posistion
+ tPartial.SubSlice[0].Test = "Required"
+
+ // these will pass as the unset item is NOT tested
+ errs = validate.StructPartial(tPartial, p1...)
+ Equal(t, errs, nil)
+
+ errs = validate.StructPartial(tPartial, p2...)
+ Equal(t, errs, nil)
+
+ // testing for missing item by exception, yes it dives and fails
+ errs = validate.StructExcept(tPartial, p1...)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required")
+
+ errs = validate.StructExcept(tPartial, p2...)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required")
+
+ tPartial.SubSlice[1].Test = "Required"
+
+ tPartial.Anonymous.SubAnonStruct[0].Test = ""
+ // these will pass as the unset item is NOT tested
+ errs = validate.StructPartial(tPartial, p1...)
+ Equal(t, errs, nil)
+
+ errs = validate.StructPartial(tPartial, p2...)
+ Equal(t, errs, nil)
+
+ errs = validate.StructExcept(tPartial, p1...)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestPartial.Anonymous.SubAnonStruct[0].Test", "Test", "required")
+
+ errs = validate.StructExcept(tPartial, p2...)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestPartial.Anonymous.SubAnonStruct[0].Test", "Test", "required")
+
+}
+
+func TestCrossStructLteFieldValidation(t *testing.T) {
+
+ type Inner struct {
+ CreatedAt *time.Time
+ String string
+ Int int
+ Uint uint
+ Float float64
+ Array []string
+ }
+
+ type Test struct {
+ Inner *Inner
+ CreatedAt *time.Time `validate:"ltecsfield=Inner.CreatedAt"`
+ String string `validate:"ltecsfield=Inner.String"`
+ Int int `validate:"ltecsfield=Inner.Int"`
+ Uint uint `validate:"ltecsfield=Inner.Uint"`
+ Float float64 `validate:"ltecsfield=Inner.Float"`
+ Array []string `validate:"ltecsfield=Inner.Array"`
+ }
+
+ now := time.Now().UTC()
+ then := now.Add(time.Hour * 5)
+
+ inner := &Inner{
+ CreatedAt: &then,
+ String: "abcd",
+ Int: 13,
+ Uint: 13,
+ Float: 1.13,
+ Array: []string{"val1", "val2"},
+ }
+
+ test := &Test{
+ Inner: inner,
+ CreatedAt: &now,
+ String: "abc",
+ Int: 12,
+ Uint: 12,
+ Float: 1.12,
+ Array: []string{"val1"},
+ }
+
+ errs := validate.Struct(test)
+ Equal(t, errs, nil)
+
+ test.CreatedAt = &then
+ test.String = "abcd"
+ test.Int = 13
+ test.Uint = 13
+ test.Float = 1.13
+ test.Array = []string{"val1", "val2"}
+
+ errs = validate.Struct(test)
+ Equal(t, errs, nil)
+
+ after := now.Add(time.Hour * 10)
+
+ test.CreatedAt = &after
+ test.String = "abce"
+ test.Int = 14
+ test.Uint = 14
+ test.Float = 1.14
+ test.Array = []string{"val1", "val2", "val3"}
+
+ errs = validate.Struct(test)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.CreatedAt", "CreatedAt", "ltecsfield")
+ AssertError(t, errs, "Test.String", "String", "ltecsfield")
+ AssertError(t, errs, "Test.Int", "Int", "ltecsfield")
+ AssertError(t, errs, "Test.Uint", "Uint", "ltecsfield")
+ AssertError(t, errs, "Test.Float", "Float", "ltecsfield")
+ AssertError(t, errs, "Test.Array", "Array", "ltecsfield")
+
+ errs = validate.FieldWithValue(1, "", "ltecsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltecsfield")
+
+ errs = validate.FieldWithValue(test, now, "ltecsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltecsfield")
+}
+
+func TestCrossStructLtFieldValidation(t *testing.T) {
+
+ type Inner struct {
+ CreatedAt *time.Time
+ String string
+ Int int
+ Uint uint
+ Float float64
+ Array []string
+ }
+
+ type Test struct {
+ Inner *Inner
+ CreatedAt *time.Time `validate:"ltcsfield=Inner.CreatedAt"`
+ String string `validate:"ltcsfield=Inner.String"`
+ Int int `validate:"ltcsfield=Inner.Int"`
+ Uint uint `validate:"ltcsfield=Inner.Uint"`
+ Float float64 `validate:"ltcsfield=Inner.Float"`
+ Array []string `validate:"ltcsfield=Inner.Array"`
+ }
+
+ now := time.Now().UTC()
+ then := now.Add(time.Hour * 5)
+
+ inner := &Inner{
+ CreatedAt: &then,
+ String: "abcd",
+ Int: 13,
+ Uint: 13,
+ Float: 1.13,
+ Array: []string{"val1", "val2"},
+ }
+
+ test := &Test{
+ Inner: inner,
+ CreatedAt: &now,
+ String: "abc",
+ Int: 12,
+ Uint: 12,
+ Float: 1.12,
+ Array: []string{"val1"},
+ }
+
+ errs := validate.Struct(test)
+ Equal(t, errs, nil)
+
+ test.CreatedAt = &then
+ test.String = "abcd"
+ test.Int = 13
+ test.Uint = 13
+ test.Float = 1.13
+ test.Array = []string{"val1", "val2"}
+
+ errs = validate.Struct(test)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.CreatedAt", "CreatedAt", "ltcsfield")
+ AssertError(t, errs, "Test.String", "String", "ltcsfield")
+ AssertError(t, errs, "Test.Int", "Int", "ltcsfield")
+ AssertError(t, errs, "Test.Uint", "Uint", "ltcsfield")
+ AssertError(t, errs, "Test.Float", "Float", "ltcsfield")
+ AssertError(t, errs, "Test.Array", "Array", "ltcsfield")
+
+ errs = validate.FieldWithValue(1, "", "ltcsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltcsfield")
+
+ errs = validate.FieldWithValue(test, now, "ltcsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltcsfield")
+}
+
+func TestCrossStructGteFieldValidation(t *testing.T) {
+
+ type Inner struct {
+ CreatedAt *time.Time
+ String string
+ Int int
+ Uint uint
+ Float float64
+ Array []string
+ }
+
+ type Test struct {
+ Inner *Inner
+ CreatedAt *time.Time `validate:"gtecsfield=Inner.CreatedAt"`
+ String string `validate:"gtecsfield=Inner.String"`
+ Int int `validate:"gtecsfield=Inner.Int"`
+ Uint uint `validate:"gtecsfield=Inner.Uint"`
+ Float float64 `validate:"gtecsfield=Inner.Float"`
+ Array []string `validate:"gtecsfield=Inner.Array"`
+ }
+
+ now := time.Now().UTC()
+ then := now.Add(time.Hour * -5)
+
+ inner := &Inner{
+ CreatedAt: &then,
+ String: "abcd",
+ Int: 13,
+ Uint: 13,
+ Float: 1.13,
+ Array: []string{"val1", "val2"},
+ }
+
+ test := &Test{
+ Inner: inner,
+ CreatedAt: &now,
+ String: "abcde",
+ Int: 14,
+ Uint: 14,
+ Float: 1.14,
+ Array: []string{"val1", "val2", "val3"},
+ }
+
+ errs := validate.Struct(test)
+ Equal(t, errs, nil)
+
+ test.CreatedAt = &then
+ test.String = "abcd"
+ test.Int = 13
+ test.Uint = 13
+ test.Float = 1.13
+ test.Array = []string{"val1", "val2"}
+
+ errs = validate.Struct(test)
+ Equal(t, errs, nil)
+
+ before := now.Add(time.Hour * -10)
+
+ test.CreatedAt = &before
+ test.String = "abc"
+ test.Int = 12
+ test.Uint = 12
+ test.Float = 1.12
+ test.Array = []string{"val1"}
+
+ errs = validate.Struct(test)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.CreatedAt", "CreatedAt", "gtecsfield")
+ AssertError(t, errs, "Test.String", "String", "gtecsfield")
+ AssertError(t, errs, "Test.Int", "Int", "gtecsfield")
+ AssertError(t, errs, "Test.Uint", "Uint", "gtecsfield")
+ AssertError(t, errs, "Test.Float", "Float", "gtecsfield")
+ AssertError(t, errs, "Test.Array", "Array", "gtecsfield")
+
+ errs = validate.FieldWithValue(1, "", "gtecsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtecsfield")
+
+ errs = validate.FieldWithValue(test, now, "gtecsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtecsfield")
+}
+
+func TestCrossStructGtFieldValidation(t *testing.T) {
+
+ type Inner struct {
+ CreatedAt *time.Time
+ String string
+ Int int
+ Uint uint
+ Float float64
+ Array []string
+ }
+
+ type Test struct {
+ Inner *Inner
+ CreatedAt *time.Time `validate:"gtcsfield=Inner.CreatedAt"`
+ String string `validate:"gtcsfield=Inner.String"`
+ Int int `validate:"gtcsfield=Inner.Int"`
+ Uint uint `validate:"gtcsfield=Inner.Uint"`
+ Float float64 `validate:"gtcsfield=Inner.Float"`
+ Array []string `validate:"gtcsfield=Inner.Array"`
+ }
+
+ now := time.Now().UTC()
+ then := now.Add(time.Hour * -5)
+
+ inner := &Inner{
+ CreatedAt: &then,
+ String: "abcd",
+ Int: 13,
+ Uint: 13,
+ Float: 1.13,
+ Array: []string{"val1", "val2"},
+ }
+
+ test := &Test{
+ Inner: inner,
+ CreatedAt: &now,
+ String: "abcde",
+ Int: 14,
+ Uint: 14,
+ Float: 1.14,
+ Array: []string{"val1", "val2", "val3"},
+ }
+
+ errs := validate.Struct(test)
+ Equal(t, errs, nil)
+
+ test.CreatedAt = &then
+ test.String = "abcd"
+ test.Int = 13
+ test.Uint = 13
+ test.Float = 1.13
+ test.Array = []string{"val1", "val2"}
+
+ errs = validate.Struct(test)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.CreatedAt", "CreatedAt", "gtcsfield")
+ AssertError(t, errs, "Test.String", "String", "gtcsfield")
+ AssertError(t, errs, "Test.Int", "Int", "gtcsfield")
+ AssertError(t, errs, "Test.Uint", "Uint", "gtcsfield")
+ AssertError(t, errs, "Test.Float", "Float", "gtcsfield")
+ AssertError(t, errs, "Test.Array", "Array", "gtcsfield")
+
+ errs = validate.FieldWithValue(1, "", "gtcsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtcsfield")
+
+ errs = validate.FieldWithValue(test, now, "gtcsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtcsfield")
+}
+
+func TestCrossStructNeFieldValidation(t *testing.T) {
+
+ type Inner struct {
+ CreatedAt *time.Time
+ }
+
+ type Test struct {
+ Inner *Inner
+ CreatedAt *time.Time `validate:"necsfield=Inner.CreatedAt"`
+ }
+
+ now := time.Now().UTC()
+ then := now.Add(time.Hour * 5)
+
+ inner := &Inner{
+ CreatedAt: &then,
+ }
+
+ test := &Test{
+ Inner: inner,
+ CreatedAt: &now,
+ }
+
+ errs := validate.Struct(test)
+ Equal(t, errs, nil)
+
+ test.CreatedAt = &then
+
+ errs = validate.Struct(test)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.CreatedAt", "CreatedAt", "necsfield")
+
+ var j uint64
+ var k float64
+ var j2 uint64
+ var k2 float64
+ s := "abcd"
+ i := 1
+ j = 1
+ k = 1.543
+ arr := []string{"test"}
+
+ s2 := "abcd"
+ i2 := 1
+ j2 = 1
+ k2 = 1.543
+ arr2 := []string{"test"}
+ arr3 := []string{"test", "test2"}
+ now2 := now
+
+ errs = validate.FieldWithValue(s, s2, "necsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "necsfield")
+
+ errs = validate.FieldWithValue(i2, i, "necsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "necsfield")
+
+ errs = validate.FieldWithValue(j2, j, "necsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "necsfield")
+
+ errs = validate.FieldWithValue(k2, k, "necsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "necsfield")
+
+ errs = validate.FieldWithValue(arr2, arr, "necsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "necsfield")
+
+ errs = validate.FieldWithValue(now2, now, "necsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "necsfield")
+
+ errs = validate.FieldWithValue(arr3, arr, "necsfield")
+ Equal(t, errs, nil)
+
+ type SInner struct {
+ Name string
+ }
+
+ type TStruct struct {
+ Inner *SInner
+ CreatedAt *time.Time `validate:"necsfield=Inner"`
+ }
+
+ sinner := &SInner{
+ Name: "NAME",
+ }
+
+ test2 := &TStruct{
+ Inner: sinner,
+ CreatedAt: &now,
+ }
+
+ errs = validate.Struct(test2)
+ Equal(t, errs, nil)
+
+ test2.Inner = nil
+ errs = validate.Struct(test2)
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(nil, 1, "necsfield")
+ Equal(t, errs, nil)
+}
+
+func TestCrossStructEqFieldValidation(t *testing.T) {
+
+ type Inner struct {
+ CreatedAt *time.Time
+ }
+
+ type Test struct {
+ Inner *Inner
+ CreatedAt *time.Time `validate:"eqcsfield=Inner.CreatedAt"`
+ }
+
+ now := time.Now().UTC()
+
+ inner := &Inner{
+ CreatedAt: &now,
+ }
+
+ test := &Test{
+ Inner: inner,
+ CreatedAt: &now,
+ }
+
+ errs := validate.Struct(test)
+ Equal(t, errs, nil)
+
+ newTime := time.Now().UTC()
+ test.CreatedAt = &newTime
+
+ errs = validate.Struct(test)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.CreatedAt", "CreatedAt", "eqcsfield")
+
+ var j uint64
+ var k float64
+ s := "abcd"
+ i := 1
+ j = 1
+ k = 1.543
+ arr := []string{"test"}
+
+ var j2 uint64
+ var k2 float64
+ s2 := "abcd"
+ i2 := 1
+ j2 = 1
+ k2 = 1.543
+ arr2 := []string{"test"}
+ arr3 := []string{"test", "test2"}
+ now2 := now
+
+ errs = validate.FieldWithValue(s, s2, "eqcsfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(i2, i, "eqcsfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(j2, j, "eqcsfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(k2, k, "eqcsfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(arr2, arr, "eqcsfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(now2, now, "eqcsfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(arr3, arr, "eqcsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "eqcsfield")
+
+ type SInner struct {
+ Name string
+ }
+
+ type TStruct struct {
+ Inner *SInner
+ CreatedAt *time.Time `validate:"eqcsfield=Inner"`
+ }
+
+ sinner := &SInner{
+ Name: "NAME",
+ }
+
+ test2 := &TStruct{
+ Inner: sinner,
+ CreatedAt: &now,
+ }
+
+ errs = validate.Struct(test2)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TStruct.CreatedAt", "CreatedAt", "eqcsfield")
+
+ test2.Inner = nil
+ errs = validate.Struct(test2)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TStruct.CreatedAt", "CreatedAt", "eqcsfield")
+
+ errs = validate.FieldWithValue(nil, 1, "eqcsfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "eqcsfield")
+}
+
+func TestCrossNamespaceFieldValidation(t *testing.T) {
+
+ type SliceStruct struct {
+ Name string
+ }
+
+ type MapStruct struct {
+ Name string
+ }
+
+ type Inner struct {
+ CreatedAt *time.Time
+ Slice []string
+ SliceStructs []*SliceStruct
+ SliceSlice [][]string
+ SliceSliceStruct [][]*SliceStruct
+ SliceMap []map[string]string
+ Map map[string]string
+ MapMap map[string]map[string]string
+ MapStructs map[string]*SliceStruct
+ MapMapStruct map[string]map[string]*SliceStruct
+ MapSlice map[string][]string
+ MapInt map[int]string
+ MapInt8 map[int8]string
+ MapInt16 map[int16]string
+ MapInt32 map[int32]string
+ MapInt64 map[int64]string
+ MapUint map[uint]string
+ MapUint8 map[uint8]string
+ MapUint16 map[uint16]string
+ MapUint32 map[uint32]string
+ MapUint64 map[uint64]string
+ MapFloat32 map[float32]string
+ MapFloat64 map[float64]string
+ MapBool map[bool]string
+ }
+
+ type Test struct {
+ Inner *Inner
+ CreatedAt *time.Time
+ }
+
+ now := time.Now()
+
+ inner := &Inner{
+ CreatedAt: &now,
+ Slice: []string{"val1", "val2", "val3"},
+ SliceStructs: []*SliceStruct{{Name: "name1"}, {Name: "name2"}, {Name: "name3"}},
+ SliceSlice: [][]string{{"1", "2", "3"}, {"4", "5", "6"}, {"7", "8", "9"}},
+ SliceSliceStruct: [][]*SliceStruct{{{Name: "name1"}, {Name: "name2"}, {Name: "name3"}}, {{Name: "name4"}, {Name: "name5"}, {Name: "name6"}}, {{Name: "name7"}, {Name: "name8"}, {Name: "name9"}}},
+ SliceMap: []map[string]string{{"key1": "val1", "key2": "val2", "key3": "val3"}, {"key4": "val4", "key5": "val5", "key6": "val6"}},
+ Map: map[string]string{"key1": "val1", "key2": "val2", "key3": "val3"},
+ MapStructs: map[string]*SliceStruct{"key1": {Name: "name1"}, "key2": {Name: "name2"}, "key3": {Name: "name3"}},
+ MapMap: map[string]map[string]string{"key1": {"key1-1": "val1"}, "key2": {"key2-1": "val2"}, "key3": {"key3-1": "val3"}},
+ MapMapStruct: map[string]map[string]*SliceStruct{"key1": {"key1-1": {Name: "name1"}}, "key2": {"key2-1": {Name: "name2"}}, "key3": {"key3-1": {Name: "name3"}}},
+ MapSlice: map[string][]string{"key1": {"1", "2", "3"}, "key2": {"4", "5", "6"}, "key3": {"7", "8", "9"}},
+ MapInt: map[int]string{1: "val1", 2: "val2", 3: "val3"},
+ MapInt8: map[int8]string{1: "val1", 2: "val2", 3: "val3"},
+ MapInt16: map[int16]string{1: "val1", 2: "val2", 3: "val3"},
+ MapInt32: map[int32]string{1: "val1", 2: "val2", 3: "val3"},
+ MapInt64: map[int64]string{1: "val1", 2: "val2", 3: "val3"},
+ MapUint: map[uint]string{1: "val1", 2: "val2", 3: "val3"},
+ MapUint8: map[uint8]string{1: "val1", 2: "val2", 3: "val3"},
+ MapUint16: map[uint16]string{1: "val1", 2: "val2", 3: "val3"},
+ MapUint32: map[uint32]string{1: "val1", 2: "val2", 3: "val3"},
+ MapUint64: map[uint64]string{1: "val1", 2: "val2", 3: "val3"},
+ MapFloat32: map[float32]string{1.01: "val1", 2.02: "val2", 3.03: "val3"},
+ MapFloat64: map[float64]string{1.01: "val1", 2.02: "val2", 3.03: "val3"},
+ MapBool: map[bool]string{true: "val1", false: "val2"},
+ }
+
+ test := &Test{
+ Inner: inner,
+ CreatedAt: &now,
+ }
+
+ val := reflect.ValueOf(test)
+
+ current, kind, ok := validate.GetStructFieldOK(val, "Inner.CreatedAt")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.Struct)
+ tm, ok := current.Interface().(time.Time)
+ Equal(t, ok, true)
+ Equal(t, tm, now)
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.Slice[1]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.CrazyNonExistantField")
+ Equal(t, ok, false)
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.Slice[101]")
+ Equal(t, ok, false)
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.Map[key3]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val3")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapMap[key2][key2-1]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapStructs[key2].Name")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "name2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapMapStruct[key3][key3-1].Name")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "name3")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.SliceSlice[2][0]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "7")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.SliceSliceStruct[2][1].Name")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "name8")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.SliceMap[1][key5]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val5")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapSlice[key3][2]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "9")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapInt[2]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapInt8[2]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapInt16[2]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapInt32[2]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapInt64[2]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapUint[2]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapUint8[2]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapUint16[2]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapUint32[2]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapUint64[2]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapFloat32[3.03]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val3")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapFloat64[2.02]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val2")
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapBool[true]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.String)
+ Equal(t, current.String(), "val1")
+
+ inner = &Inner{
+ CreatedAt: &now,
+ Slice: []string{"val1", "val2", "val3"},
+ SliceStructs: []*SliceStruct{{Name: "name1"}, {Name: "name2"}, nil},
+ SliceSlice: [][]string{{"1", "2", "3"}, {"4", "5", "6"}, {"7", "8", "9"}},
+ SliceSliceStruct: [][]*SliceStruct{{{Name: "name1"}, {Name: "name2"}, {Name: "name3"}}, {{Name: "name4"}, {Name: "name5"}, {Name: "name6"}}, {{Name: "name7"}, {Name: "name8"}, {Name: "name9"}}},
+ SliceMap: []map[string]string{{"key1": "val1", "key2": "val2", "key3": "val3"}, {"key4": "val4", "key5": "val5", "key6": "val6"}},
+ Map: map[string]string{"key1": "val1", "key2": "val2", "key3": "val3"},
+ MapStructs: map[string]*SliceStruct{"key1": {Name: "name1"}, "key2": {Name: "name2"}, "key3": {Name: "name3"}},
+ MapMap: map[string]map[string]string{"key1": {"key1-1": "val1"}, "key2": {"key2-1": "val2"}, "key3": {"key3-1": "val3"}},
+ MapMapStruct: map[string]map[string]*SliceStruct{"key1": {"key1-1": {Name: "name1"}}, "key2": {"key2-1": {Name: "name2"}}, "key3": {"key3-1": {Name: "name3"}}},
+ MapSlice: map[string][]string{"key1": {"1", "2", "3"}, "key2": {"4", "5", "6"}, "key3": {"7", "8", "9"}},
+ }
+
+ test = &Test{
+ Inner: inner,
+ CreatedAt: nil,
+ }
+
+ val = reflect.ValueOf(test)
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.SliceStructs[2]")
+ Equal(t, ok, true)
+ Equal(t, kind, reflect.Ptr)
+ Equal(t, current.String(), "<*validator.SliceStruct Value>")
+ Equal(t, current.IsNil(), true)
+
+ current, kind, ok = validate.GetStructFieldOK(val, "Inner.SliceStructs[2].Name")
+ Equal(t, ok, false)
+ Equal(t, kind, reflect.Ptr)
+ Equal(t, current.String(), "<*validator.SliceStruct Value>")
+ Equal(t, current.IsNil(), true)
+
+ PanicMatches(t, func() { validate.GetStructFieldOK(reflect.ValueOf(1), "crazyinput") }, "Invalid field namespace")
+}
+
+func TestExistsValidation(t *testing.T) {
+
+ jsonText := "{ \"truthiness2\": true }"
+
+ type Thing struct {
+ Truthiness *bool `json:"truthiness" validate:"exists,required"`
+ }
+
+ var ting Thing
+
+ err := json.Unmarshal([]byte(jsonText), &ting)
+ Equal(t, err, nil)
+ NotEqual(t, ting, nil)
+ Equal(t, ting.Truthiness, nil)
+
+ errs := validate.Struct(ting)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Thing.Truthiness", "Truthiness", "exists")
+
+ jsonText = "{ \"truthiness\": true }"
+
+ err = json.Unmarshal([]byte(jsonText), &ting)
+ Equal(t, err, nil)
+ NotEqual(t, ting, nil)
+ Equal(t, ting.Truthiness, true)
+
+ errs = validate.Struct(ting)
+ Equal(t, errs, nil)
+}
+
+func TestSQLValue2Validation(t *testing.T) {
+
+ config := &Config{
+ TagName: "validate",
+ }
+
+ validate := New(config)
+ validate.RegisterCustomTypeFunc(ValidateValuerType, valuer{}, (*driver.Valuer)(nil), sql.NullString{}, sql.NullInt64{}, sql.NullBool{}, sql.NullFloat64{})
+ validate.RegisterCustomTypeFunc(ValidateCustomType, MadeUpCustomType{})
+ validate.RegisterCustomTypeFunc(OverrideIntTypeForSomeReason, 1)
+
+ val := valuer{
+ Name: "",
+ }
+
+ errs := validate.Field(val, "required")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "required")
+
+ val.Name = "Valid Name"
+ errs = validate.Field(val, "required")
+ Equal(t, errs, nil)
+
+ val.Name = "errorme"
+
+ PanicMatches(t, func() { validate.Field(val, "required") }, "SQL Driver Valuer error: some kind of error")
+
+ type myValuer valuer
+
+ myVal := valuer{
+ Name: "",
+ }
+
+ errs = validate.Field(myVal, "required")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "required")
+
+ cust := MadeUpCustomType{
+ FirstName: "Joey",
+ LastName: "Bloggs",
+ }
+
+ c := CustomMadeUpStruct{MadeUp: cust, OverriddenInt: 2}
+
+ errs = validate.Struct(c)
+ Equal(t, errs, nil)
+
+ c.MadeUp.FirstName = ""
+ c.OverriddenInt = 1
+
+ errs = validate.Struct(c)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 2)
+ AssertError(t, errs, "CustomMadeUpStruct.MadeUp", "MadeUp", "required")
+ AssertError(t, errs, "CustomMadeUpStruct.OverriddenInt", "OverriddenInt", "gt")
+}
+
+func TestSQLValueValidation(t *testing.T) {
+
+ validate := New(&Config{TagName: "validate"})
+ validate.RegisterCustomTypeFunc(ValidateValuerType, (*driver.Valuer)(nil), valuer{})
+ validate.RegisterCustomTypeFunc(ValidateCustomType, MadeUpCustomType{})
+ validate.RegisterCustomTypeFunc(OverrideIntTypeForSomeReason, 1)
+
+ val := valuer{
+ Name: "",
+ }
+
+ errs := validate.Field(val, "required")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "required")
+
+ val.Name = "Valid Name"
+ errs = validate.Field(val, "required")
+ Equal(t, errs, nil)
+
+ val.Name = "errorme"
+
+ PanicMatches(t, func() { errs = validate.Field(val, "required") }, "SQL Driver Valuer error: some kind of error")
+
+ type myValuer valuer
+
+ myVal := valuer{
+ Name: "",
+ }
+
+ errs = validate.Field(myVal, "required")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "required")
+
+ cust := MadeUpCustomType{
+ FirstName: "Joey",
+ LastName: "Bloggs",
+ }
+
+ c := CustomMadeUpStruct{MadeUp: cust, OverriddenInt: 2}
+
+ errs = validate.Struct(c)
+ Equal(t, errs, nil)
+
+ c.MadeUp.FirstName = ""
+ c.OverriddenInt = 1
+
+ errs = validate.Struct(c)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 2)
+ AssertError(t, errs, "CustomMadeUpStruct.MadeUp", "MadeUp", "required")
+ AssertError(t, errs, "CustomMadeUpStruct.OverriddenInt", "OverriddenInt", "gt")
+}
+
+func TestMACValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"3D:F2:C9:A6:B3:4F", true},
+ {"3D-F2-C9-A6-B3:4F", false},
+ {"123", false},
+ {"", false},
+ {"abacaba", false},
+ {"00:25:96:FF:FE:12:34:56", true},
+ {"0025:96FF:FE12:3456", false},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "mac")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d mac failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d mac failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "mac" {
+ t.Fatalf("Index: %d mac failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestIPValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"10.0.0.1", true},
+ {"172.16.0.1", true},
+ {"192.168.0.1", true},
+ {"192.168.255.254", true},
+ {"192.168.255.256", false},
+ {"172.16.255.254", true},
+ {"172.16.256.255", false},
+ {"2001:cdba:0000:0000:0000:0000:3257:9652", true},
+ {"2001:cdba:0:0:0:0:3257:9652", true},
+ {"2001:cdba::3257:9652", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "ip")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ip failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ip failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "ip" {
+ t.Fatalf("Index: %d ip failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestIPv6Validation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"10.0.0.1", false},
+ {"172.16.0.1", false},
+ {"192.168.0.1", false},
+ {"192.168.255.254", false},
+ {"192.168.255.256", false},
+ {"172.16.255.254", false},
+ {"172.16.256.255", false},
+ {"2001:cdba:0000:0000:0000:0000:3257:9652", true},
+ {"2001:cdba:0:0:0:0:3257:9652", true},
+ {"2001:cdba::3257:9652", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "ipv6")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ipv6 failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ipv6 failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "ipv6" {
+ t.Fatalf("Index: %d ipv6 failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestIPv4Validation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"10.0.0.1", true},
+ {"172.16.0.1", true},
+ {"192.168.0.1", true},
+ {"192.168.255.254", true},
+ {"192.168.255.256", false},
+ {"172.16.255.254", true},
+ {"172.16.256.255", false},
+ {"2001:cdba:0000:0000:0000:0000:3257:9652", false},
+ {"2001:cdba:0:0:0:0:3257:9652", false},
+ {"2001:cdba::3257:9652", false},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "ipv4")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ipv4 failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ipv4 failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "ipv4" {
+ t.Fatalf("Index: %d ipv4 failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestCIDRValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"10.0.0.0/0", true},
+ {"10.0.0.1/8", true},
+ {"172.16.0.1/16", true},
+ {"192.168.0.1/24", true},
+ {"192.168.255.254/24", true},
+ {"192.168.255.254/48", false},
+ {"192.168.255.256/24", false},
+ {"172.16.255.254/16", true},
+ {"172.16.256.255/16", false},
+ {"2001:cdba:0000:0000:0000:0000:3257:9652/64", true},
+ {"2001:cdba:0000:0000:0000:0000:3257:9652/256", false},
+ {"2001:cdba:0:0:0:0:3257:9652/32", true},
+ {"2001:cdba::3257:9652/16", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "cidr")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d cidr failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d cidr failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "cidr" {
+ t.Fatalf("Index: %d cidr failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestCIDRv6Validation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"10.0.0.0/0", false},
+ {"10.0.0.1/8", false},
+ {"172.16.0.1/16", false},
+ {"192.168.0.1/24", false},
+ {"192.168.255.254/24", false},
+ {"192.168.255.254/48", false},
+ {"192.168.255.256/24", false},
+ {"172.16.255.254/16", false},
+ {"172.16.256.255/16", false},
+ {"2001:cdba:0000:0000:0000:0000:3257:9652/64", true},
+ {"2001:cdba:0000:0000:0000:0000:3257:9652/256", false},
+ {"2001:cdba:0:0:0:0:3257:9652/32", true},
+ {"2001:cdba::3257:9652/16", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "cidrv6")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d cidrv6 failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d cidrv6 failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "cidrv6" {
+ t.Fatalf("Index: %d cidrv6 failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestCIDRv4Validation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"10.0.0.0/0", true},
+ {"10.0.0.1/8", true},
+ {"172.16.0.1/16", true},
+ {"192.168.0.1/24", true},
+ {"192.168.255.254/24", true},
+ {"192.168.255.254/48", false},
+ {"192.168.255.256/24", false},
+ {"172.16.255.254/16", true},
+ {"172.16.256.255/16", false},
+ {"2001:cdba:0000:0000:0000:0000:3257:9652/64", false},
+ {"2001:cdba:0000:0000:0000:0000:3257:9652/256", false},
+ {"2001:cdba:0:0:0:0:3257:9652/32", false},
+ {"2001:cdba::3257:9652/16", false},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "cidrv4")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d cidrv4 failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d cidrv4 failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "cidrv4" {
+ t.Fatalf("Index: %d cidrv4 failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestTCPAddrValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {":80", false},
+ {"127.0.0.1:80", true},
+ {"[::1]:80", true},
+ {"256.0.0.0:1", false},
+ {"[::1]", false},
+ }
+
+ for i, test := range tests {
+ errs := validate.Field(test.param, "tcp_addr")
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d tcp_addr failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d tcp_addr failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "tcp_addr" {
+ t.Fatalf("Index: %d tcp_addr failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestTCP6AddrValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {":80", false},
+ {"127.0.0.1:80", false},
+ {"[::1]:80", true},
+ {"256.0.0.0:1", false},
+ {"[::1]", false},
+ }
+
+ for i, test := range tests {
+ errs := validate.Field(test.param, "tcp6_addr")
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d tcp6_addr failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d tcp6_addr failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "tcp6_addr" {
+ t.Fatalf("Index: %d tcp6_addr failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestTCP4AddrValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {":80", false},
+ {"127.0.0.1:80", true},
+ {"[::1]:80", false}, // https://github.com/golang/go/issues/14037
+ {"256.0.0.0:1", false},
+ {"[::1]", false},
+ }
+
+ for i, test := range tests {
+ errs := validate.Field(test.param, "tcp4_addr")
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d tcp4_addr failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Log(test.param, IsEqual(errs, nil))
+ t.Fatalf("Index: %d tcp4_addr failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "tcp4_addr" {
+ t.Fatalf("Index: %d tcp4_addr failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestUDPAddrValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {":80", false},
+ {"127.0.0.1:80", true},
+ {"[::1]:80", true},
+ {"256.0.0.0:1", false},
+ {"[::1]", false},
+ }
+
+ for i, test := range tests {
+ errs := validate.Field(test.param, "udp_addr")
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d udp_addr failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d udp_addr failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "udp_addr" {
+ t.Fatalf("Index: %d udp_addr failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestUDP6AddrValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {":80", false},
+ {"127.0.0.1:80", false},
+ {"[::1]:80", true},
+ {"256.0.0.0:1", false},
+ {"[::1]", false},
+ }
+
+ for i, test := range tests {
+ errs := validate.Field(test.param, "udp6_addr")
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d udp6_addr failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d udp6_addr failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "udp6_addr" {
+ t.Fatalf("Index: %d udp6_addr failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestUDP4AddrValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {":80", false},
+ {"127.0.0.1:80", true},
+ {"[::1]:80", false}, // https://github.com/golang/go/issues/14037
+ {"256.0.0.0:1", false},
+ {"[::1]", false},
+ }
+
+ for i, test := range tests {
+ errs := validate.Field(test.param, "udp4_addr")
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d udp4_addr failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Log(test.param, IsEqual(errs, nil))
+ t.Fatalf("Index: %d udp4_addr failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "udp4_addr" {
+ t.Fatalf("Index: %d udp4_addr failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestIPAddrValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"127.0.0.1", true},
+ {"127.0.0.1:80", false},
+ {"::1", true},
+ {"256.0.0.0", false},
+ {"localhost", false},
+ }
+
+ for i, test := range tests {
+ errs := validate.Field(test.param, "ip_addr")
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ip_addr failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ip_addr failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "ip_addr" {
+ t.Fatalf("Index: %d ip_addr failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestIP6AddrValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"127.0.0.1", false}, // https://github.com/golang/go/issues/14037
+ {"127.0.0.1:80", false},
+ {"::1", true},
+ {"0:0:0:0:0:0:0:1", true},
+ {"256.0.0.0", false},
+ }
+
+ for i, test := range tests {
+ errs := validate.Field(test.param, "ip6_addr")
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ip6_addr failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ip6_addr failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "ip6_addr" {
+ t.Fatalf("Index: %d ip6_addr failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestIP4AddrValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"127.0.0.1", true},
+ {"127.0.0.1:80", false},
+ {"::1", false}, // https://github.com/golang/go/issues/14037
+ {"256.0.0.0", false},
+ {"localhost", false},
+ }
+
+ for i, test := range tests {
+ errs := validate.Field(test.param, "ip4_addr")
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ip4_addr failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Log(test.param, IsEqual(errs, nil))
+ t.Fatalf("Index: %d ip4_addr failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "ip4_addr" {
+ t.Fatalf("Index: %d ip4_addr failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestUnixAddrValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", true},
+ {"v.sock", true},
+ }
+
+ for i, test := range tests {
+ errs := validate.Field(test.param, "unix_addr")
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d unix_addr failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Log(test.param, IsEqual(errs, nil))
+ t.Fatalf("Index: %d unix_addr failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "unix_addr" {
+ t.Fatalf("Index: %d unix_addr failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestSliceMapArrayChanFuncPtrInterfaceRequiredValidation(t *testing.T) {
+
+ var m map[string]string
+
+ errs := validate.Field(m, "required")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "required")
+
+ m = map[string]string{}
+ errs = validate.Field(m, "required")
+ Equal(t, errs, nil)
+
+ var arr [5]string
+ errs = validate.Field(arr, "required")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "required")
+
+ arr[0] = "ok"
+ errs = validate.Field(arr, "required")
+ Equal(t, errs, nil)
+
+ var s []string
+ errs = validate.Field(s, "required")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "required")
+
+ s = []string{}
+ errs = validate.Field(s, "required")
+ Equal(t, errs, nil)
+
+ var c chan string
+ errs = validate.Field(c, "required")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "required")
+
+ c = make(chan string)
+ errs = validate.Field(c, "required")
+ Equal(t, errs, nil)
+
+ var tst *int
+ errs = validate.Field(tst, "required")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "required")
+
+ one := 1
+ tst = &one
+ errs = validate.Field(tst, "required")
+ Equal(t, errs, nil)
+
+ var iface interface{}
+
+ errs = validate.Field(iface, "required")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "required")
+
+ errs = validate.Field(iface, "omitempty,required")
+ Equal(t, errs, nil)
+
+ errs = validate.Field(iface, "")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(nil, iface, "")
+ Equal(t, errs, nil)
+
+ var f func(string)
+
+ errs = validate.Field(f, "required")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "required")
+
+ f = func(name string) {}
+
+ errs = validate.Field(f, "required")
+ Equal(t, errs, nil)
+}
+
+func TestDatePtrValidationIssueValidation(t *testing.T) {
+
+ type Test struct {
+ LastViewed *time.Time
+ Reminder *time.Time
+ }
+
+ test := &Test{}
+
+ errs := validate.Struct(test)
+ Equal(t, errs, nil)
+}
+
+func TestCommaAndPipeObfuscationValidation(t *testing.T) {
+ s := "My Name Is, |joeybloggs|"
+
+ errs := validate.Field(s, "excludesall=0x2C")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "excludesall")
+
+ errs = validate.Field(s, "excludesall=0x7C")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "excludesall")
+}
+
+func TestBadKeyValidation(t *testing.T) {
+ type Test struct {
+ Name string `validate:"required, "`
+ }
+
+ tst := &Test{
+ Name: "test",
+ }
+
+ PanicMatches(t, func() { validate.Struct(tst) }, "Undefined validation function on field Name")
+
+ type Test2 struct {
+ Name string `validate:"required,,len=2"`
+ }
+
+ tst2 := &Test2{
+ Name: "test",
+ }
+
+ PanicMatches(t, func() { validate.Struct(tst2) }, "Invalid validation tag on field Name")
+}
+
+func TestInterfaceErrValidation(t *testing.T) {
+
+ var v1 interface{}
+ var v2 interface{}
+
+ v2 = 1
+ v1 = v2
+
+ errs := validate.Field(v1, "len=1")
+ Equal(t, errs, nil)
+
+ errs = validate.Field(v2, "len=1")
+ Equal(t, errs, nil)
+
+ type ExternalCMD struct {
+ Userid string `json:"userid"`
+ Action uint32 `json:"action"`
+ Data interface{} `json:"data,omitempty" validate:"required"`
+ }
+
+ s := &ExternalCMD{
+ Userid: "123456",
+ Action: 10000,
+ // Data: 1,
+ }
+
+ errs = validate.Struct(s)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "ExternalCMD.Data", "Data", "required")
+
+ type ExternalCMD2 struct {
+ Userid string `json:"userid"`
+ Action uint32 `json:"action"`
+ Data interface{} `json:"data,omitempty" validate:"len=1"`
+ }
+
+ s2 := &ExternalCMD2{
+ Userid: "123456",
+ Action: 10000,
+ // Data: 1,
+ }
+
+ errs = validate.Struct(s2)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "ExternalCMD2.Data", "Data", "len")
+
+ s3 := &ExternalCMD2{
+ Userid: "123456",
+ Action: 10000,
+ Data: 2,
+ }
+
+ errs = validate.Struct(s3)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "ExternalCMD2.Data", "Data", "len")
+
+ type Inner struct {
+ Name string `validate:"required"`
+ }
+
+ inner := &Inner{
+ Name: "",
+ }
+
+ s4 := &ExternalCMD{
+ Userid: "123456",
+ Action: 10000,
+ Data: inner,
+ }
+
+ errs = validate.Struct(s4)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "ExternalCMD.Data.Name", "Name", "required")
+
+ type TestMapStructPtr struct {
+ Errs map[int]interface{} `validate:"gt=0,dive,len=2"`
+ }
+
+ mip := map[int]interface{}{0: &Inner{"ok"}, 3: nil, 4: &Inner{"ok"}}
+
+ msp := &TestMapStructPtr{
+ Errs: mip,
+ }
+
+ errs = validate.Struct(msp)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "TestMapStructPtr.Errs[3]", "Errs[3]", "len")
+
+ type TestMultiDimensionalStructs struct {
+ Errs [][]interface{} `validate:"gt=0,dive,dive"`
+ }
+
+ var errStructArray [][]interface{}
+
+ errStructArray = append(errStructArray, []interface{}{&Inner{"ok"}, &Inner{""}, &Inner{""}})
+ errStructArray = append(errStructArray, []interface{}{&Inner{"ok"}, &Inner{""}, &Inner{""}})
+
+ tms := &TestMultiDimensionalStructs{
+ Errs: errStructArray,
+ }
+
+ errs = validate.Struct(tms)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 4)
+ AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][2].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructs.Errs[1][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructs.Errs[1][2].Name", "Name", "required")
+
+ type TestMultiDimensionalStructsPtr2 struct {
+ Errs [][]*Inner `validate:"gt=0,dive,dive,required"`
+ }
+
+ var errStructPtr2Array [][]*Inner
+
+ errStructPtr2Array = append(errStructPtr2Array, []*Inner{{"ok"}, {""}, {""}})
+ errStructPtr2Array = append(errStructPtr2Array, []*Inner{{"ok"}, {""}, {""}})
+ errStructPtr2Array = append(errStructPtr2Array, []*Inner{{"ok"}, {""}, nil})
+
+ tmsp2 := &TestMultiDimensionalStructsPtr2{
+ Errs: errStructPtr2Array,
+ }
+
+ errs = validate.Struct(tmsp2)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 6)
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][2].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[1][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[1][2].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[2][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[2][2]", "Errs[2][2]", "required")
+
+ m := map[int]interface{}{0: "ok", 3: "", 4: "ok"}
+
+ errs = validate.Field(m, "len=3,dive,len=2")
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "[3]", "[3]", "len")
+
+ errs = validate.Field(m, "len=2,dive,required")
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "", "", "len")
+
+ arr := []interface{}{"ok", "", "ok"}
+
+ errs = validate.Field(arr, "len=3,dive,len=2")
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "[1]", "[1]", "len")
+
+ errs = validate.Field(arr, "len=2,dive,required")
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "", "", "len")
+
+ type MyStruct struct {
+ A, B string
+ C interface{}
+ }
+
+ var a MyStruct
+
+ a.A = "value"
+ a.C = "nu"
+
+ errs = validate.Struct(a)
+ Equal(t, errs, nil)
+}
+
+func TestMapDiveValidation(t *testing.T) {
+
+ n := map[int]interface{}{0: nil}
+ errs := validate.Field(n, "omitempty,required")
+ Equal(t, errs, nil)
+
+ m := map[int]string{0: "ok", 3: "", 4: "ok"}
+
+ errs = validate.Field(m, "len=3,dive,required")
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "[3]", "[3]", "required")
+
+ errs = validate.Field(m, "len=2,dive,required")
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "", "", "len")
+
+ type Inner struct {
+ Name string `validate:"required"`
+ }
+
+ type TestMapStruct struct {
+ Errs map[int]Inner `validate:"gt=0,dive"`
+ }
+
+ mi := map[int]Inner{0: {"ok"}, 3: {""}, 4: {"ok"}}
+
+ ms := &TestMapStruct{
+ Errs: mi,
+ }
+
+ errs = validate.Struct(ms)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "TestMapStruct.Errs[3].Name", "Name", "required")
+
+ // for full test coverage
+ s := fmt.Sprint(errs.Error())
+ NotEqual(t, s, "")
+
+ type TestMapTimeStruct struct {
+ Errs map[int]*time.Time `validate:"gt=0,dive,required"`
+ }
+
+ t1 := time.Now().UTC()
+
+ mta := map[int]*time.Time{0: &t1, 3: nil, 4: nil}
+
+ mt := &TestMapTimeStruct{
+ Errs: mta,
+ }
+
+ errs = validate.Struct(mt)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 2)
+ AssertError(t, errs, "TestMapTimeStruct.Errs[3]", "Errs[3]", "required")
+ AssertError(t, errs, "TestMapTimeStruct.Errs[4]", "Errs[4]", "required")
+
+ type TestMapStructPtr struct {
+ Errs map[int]*Inner `validate:"gt=0,dive,required"`
+ }
+
+ mip := map[int]*Inner{0: {"ok"}, 3: nil, 4: {"ok"}}
+
+ msp := &TestMapStructPtr{
+ Errs: mip,
+ }
+
+ errs = validate.Struct(msp)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "TestMapStructPtr.Errs[3]", "Errs[3]", "required")
+
+ type TestMapStructPtr2 struct {
+ Errs map[int]*Inner `validate:"gt=0,dive,omitempty,required"`
+ }
+
+ mip2 := map[int]*Inner{0: {"ok"}, 3: nil, 4: {"ok"}}
+
+ msp2 := &TestMapStructPtr2{
+ Errs: mip2,
+ }
+
+ errs = validate.Struct(msp2)
+ Equal(t, errs, nil)
+}
+
+func TestArrayDiveValidation(t *testing.T) {
+
+ arr := []string{"ok", "", "ok"}
+
+ errs := validate.Field(arr, "len=3,dive,required")
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "[1]", "[1]", "required")
+
+ errs = validate.Field(arr, "len=2,dive,required")
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "", "", "len")
+
+ type BadDive struct {
+ Name string `validate:"dive"`
+ }
+
+ bd := &BadDive{
+ Name: "TEST",
+ }
+
+ PanicMatches(t, func() { validate.Struct(bd) }, "dive error! can't dive on a non slice or map")
+
+ type Test struct {
+ Errs []string `validate:"gt=0,dive,required"`
+ }
+
+ test := &Test{
+ Errs: []string{"ok", "", "ok"},
+ }
+
+ errs = validate.Struct(test)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "Test.Errs[1]", "Errs[1]", "required")
+
+ test = &Test{
+ Errs: []string{"ok", "ok", ""},
+ }
+
+ errs = validate.Struct(test)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 1)
+ AssertError(t, errs, "Test.Errs[2]", "Errs[2]", "required")
+
+ type TestMultiDimensional struct {
+ Errs [][]string `validate:"gt=0,dive,dive,required"`
+ }
+
+ var errArray [][]string
+
+ errArray = append(errArray, []string{"ok", "", ""})
+ errArray = append(errArray, []string{"ok", "", ""})
+
+ tm := &TestMultiDimensional{
+ Errs: errArray,
+ }
+
+ errs = validate.Struct(tm)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 4)
+ AssertError(t, errs, "TestMultiDimensional.Errs[0][1]", "Errs[0][1]", "required")
+ AssertError(t, errs, "TestMultiDimensional.Errs[0][2]", "Errs[0][2]", "required")
+ AssertError(t, errs, "TestMultiDimensional.Errs[1][1]", "Errs[1][1]", "required")
+ AssertError(t, errs, "TestMultiDimensional.Errs[1][2]", "Errs[1][2]", "required")
+
+ type Inner struct {
+ Name string `validate:"required"`
+ }
+
+ type TestMultiDimensionalStructs struct {
+ Errs [][]Inner `validate:"gt=0,dive,dive"`
+ }
+
+ var errStructArray [][]Inner
+
+ errStructArray = append(errStructArray, []Inner{{"ok"}, {""}, {""}})
+ errStructArray = append(errStructArray, []Inner{{"ok"}, {""}, {""}})
+
+ tms := &TestMultiDimensionalStructs{
+ Errs: errStructArray,
+ }
+
+ errs = validate.Struct(tms)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 4)
+ AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][2].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructs.Errs[1][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructs.Errs[1][2].Name", "Name", "required")
+
+ type TestMultiDimensionalStructsPtr struct {
+ Errs [][]*Inner `validate:"gt=0,dive,dive"`
+ }
+
+ var errStructPtrArray [][]*Inner
+
+ errStructPtrArray = append(errStructPtrArray, []*Inner{{"ok"}, {""}, {""}})
+ errStructPtrArray = append(errStructPtrArray, []*Inner{{"ok"}, {""}, {""}})
+ errStructPtrArray = append(errStructPtrArray, []*Inner{{"ok"}, {""}, nil})
+
+ tmsp := &TestMultiDimensionalStructsPtr{
+ Errs: errStructPtrArray,
+ }
+
+ errs = validate.Struct(tmsp)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 5)
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[0][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[0][2].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[1][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[1][2].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[2][1].Name", "Name", "required")
+
+ // for full test coverage
+ s := fmt.Sprint(errs.Error())
+ NotEqual(t, s, "")
+
+ type TestMultiDimensionalStructsPtr2 struct {
+ Errs [][]*Inner `validate:"gt=0,dive,dive,required"`
+ }
+
+ var errStructPtr2Array [][]*Inner
+
+ errStructPtr2Array = append(errStructPtr2Array, []*Inner{{"ok"}, {""}, {""}})
+ errStructPtr2Array = append(errStructPtr2Array, []*Inner{{"ok"}, {""}, {""}})
+ errStructPtr2Array = append(errStructPtr2Array, []*Inner{{"ok"}, {""}, nil})
+
+ tmsp2 := &TestMultiDimensionalStructsPtr2{
+ Errs: errStructPtr2Array,
+ }
+
+ errs = validate.Struct(tmsp2)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 6)
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][2].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[1][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[1][2].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[2][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[2][2]", "Errs[2][2]", "required")
+
+ type TestMultiDimensionalStructsPtr3 struct {
+ Errs [][]*Inner `validate:"gt=0,dive,dive,omitempty"`
+ }
+
+ var errStructPtr3Array [][]*Inner
+
+ errStructPtr3Array = append(errStructPtr3Array, []*Inner{{"ok"}, {""}, {""}})
+ errStructPtr3Array = append(errStructPtr3Array, []*Inner{{"ok"}, {""}, {""}})
+ errStructPtr3Array = append(errStructPtr3Array, []*Inner{{"ok"}, {""}, nil})
+
+ tmsp3 := &TestMultiDimensionalStructsPtr3{
+ Errs: errStructPtr3Array,
+ }
+
+ errs = validate.Struct(tmsp3)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 5)
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[0][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[0][2].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[1][1].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[1][2].Name", "Name", "required")
+ AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[2][1].Name", "Name", "required")
+
+ type TestMultiDimensionalTimeTime struct {
+ Errs [][]*time.Time `validate:"gt=0,dive,dive,required"`
+ }
+
+ var errTimePtr3Array [][]*time.Time
+
+ t1 := time.Now().UTC()
+ t2 := time.Now().UTC()
+ t3 := time.Now().UTC().Add(time.Hour * 24)
+
+ errTimePtr3Array = append(errTimePtr3Array, []*time.Time{&t1, &t2, &t3})
+ errTimePtr3Array = append(errTimePtr3Array, []*time.Time{&t1, &t2, nil})
+ errTimePtr3Array = append(errTimePtr3Array, []*time.Time{&t1, nil, nil})
+
+ tmtp3 := &TestMultiDimensionalTimeTime{
+ Errs: errTimePtr3Array,
+ }
+
+ errs = validate.Struct(tmtp3)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 3)
+ AssertError(t, errs, "TestMultiDimensionalTimeTime.Errs[1][2]", "Errs[1][2]", "required")
+ AssertError(t, errs, "TestMultiDimensionalTimeTime.Errs[2][1]", "Errs[2][1]", "required")
+ AssertError(t, errs, "TestMultiDimensionalTimeTime.Errs[2][2]", "Errs[2][2]", "required")
+
+ type TestMultiDimensionalTimeTime2 struct {
+ Errs [][]*time.Time `validate:"gt=0,dive,dive,required"`
+ }
+
+ var errTimeArray [][]*time.Time
+
+ t1 = time.Now().UTC()
+ t2 = time.Now().UTC()
+ t3 = time.Now().UTC().Add(time.Hour * 24)
+
+ errTimeArray = append(errTimeArray, []*time.Time{&t1, &t2, &t3})
+ errTimeArray = append(errTimeArray, []*time.Time{&t1, &t2, nil})
+ errTimeArray = append(errTimeArray, []*time.Time{&t1, nil, nil})
+
+ tmtp := &TestMultiDimensionalTimeTime2{
+ Errs: errTimeArray,
+ }
+
+ errs = validate.Struct(tmtp)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 3)
+ AssertError(t, errs, "TestMultiDimensionalTimeTime2.Errs[1][2]", "Errs[1][2]", "required")
+ AssertError(t, errs, "TestMultiDimensionalTimeTime2.Errs[2][1]", "Errs[2][1]", "required")
+ AssertError(t, errs, "TestMultiDimensionalTimeTime2.Errs[2][2]", "Errs[2][2]", "required")
+}
+
+func TestNilStructPointerValidation(t *testing.T) {
+ type Inner struct {
+ Data string
+ }
+
+ type Outer struct {
+ Inner *Inner `validate:"omitempty"`
+ }
+
+ inner := &Inner{
+ Data: "test",
+ }
+
+ outer := &Outer{
+ Inner: inner,
+ }
+
+ errs := validate.Struct(outer)
+ Equal(t, errs, nil)
+
+ outer = &Outer{
+ Inner: nil,
+ }
+
+ errs = validate.Struct(outer)
+ Equal(t, errs, nil)
+
+ type Inner2 struct {
+ Data string
+ }
+
+ type Outer2 struct {
+ Inner2 *Inner2 `validate:"required"`
+ }
+
+ inner2 := &Inner2{
+ Data: "test",
+ }
+
+ outer2 := &Outer2{
+ Inner2: inner2,
+ }
+
+ errs = validate.Struct(outer2)
+ Equal(t, errs, nil)
+
+ outer2 = &Outer2{
+ Inner2: nil,
+ }
+
+ errs = validate.Struct(outer2)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Outer2.Inner2", "Inner2", "required")
+
+ type Inner3 struct {
+ Data string
+ }
+
+ type Outer3 struct {
+ Inner3 *Inner3
+ }
+
+ inner3 := &Inner3{
+ Data: "test",
+ }
+
+ outer3 := &Outer3{
+ Inner3: inner3,
+ }
+
+ errs = validate.Struct(outer3)
+ Equal(t, errs, nil)
+
+ type Inner4 struct {
+ Data string
+ }
+
+ type Outer4 struct {
+ Inner4 *Inner4 `validate:"-"`
+ }
+
+ inner4 := &Inner4{
+ Data: "test",
+ }
+
+ outer4 := &Outer4{
+ Inner4: inner4,
+ }
+
+ errs = validate.Struct(outer4)
+ Equal(t, errs, nil)
+}
+
+func TestSSNValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"00-90-8787", false},
+ {"66690-76", false},
+ {"191 60 2869", true},
+ {"191-60-2869", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "ssn")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d SSN failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d SSN failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "ssn" {
+ t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestLongitudeValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"-180.000", true},
+ {"180.1", false},
+ {"+73.234", true},
+ {"+382.3811", false},
+ {"23.11111111", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "longitude")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d Longitude failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d Longitude failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "longitude" {
+ t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestLatitudeValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"-90.000", true},
+ {"+90", true},
+ {"47.1231231", true},
+ {"+99.9", false},
+ {"108", false},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "latitude")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "latitude" {
+ t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestDataURIValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"data:image/png;base64,TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdC4=", true},
+ {"data:text/plain;base64,Vml2YW11cyBmZXJtZW50dW0gc2VtcGVyIHBvcnRhLg==", true},
+ {"image/gif;base64,U3VzcGVuZGlzc2UgbGVjdHVzIGxlbw==", false},
+ {"data:image/gif;base64,MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuMPNS1Ufof9EW/M98FNw" +
+ "UAKrwflsqVxaxQjBQnHQmiI7Vac40t8x7pIb8gLGV6wL7sBTJiPovJ0V7y7oc0Ye" +
+ "rhKh0Rm4skP2z/jHwwZICgGzBvA0rH8xlhUiTvcwDCJ0kc+fh35hNt8srZQM4619" +
+ "FTgB66Xmp4EtVyhpQV+t02g6NzK72oZI0vnAvqhpkxLeLiMCyrI416wHm5Tkukhx" +
+ "QmcL2a6hNOyu0ixX/x2kSFXApEnVrJ+/IxGyfyw8kf4N2IZpW5nEP847lpfj0SZZ" +
+ "Fwrd1mnfnDbYohX2zRptLy2ZUn06Qo9pkG5ntvFEPo9bfZeULtjYzIl6K8gJ2uGZ" + "HQIDAQAB", true},
+ {"data:image/png;base64,12345", false},
+ {"", false},
+ {"data:text,:;base85,U3VzcGVuZGlzc2UgbGVjdHVzIGxlbw==", false},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "datauri")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d DataURI failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d DataURI failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "datauri" {
+ t.Fatalf("Index: %d DataURI failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestMultibyteValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", true},
+ {"abc", false},
+ {"123", false},
+ {"<>@;.-=", false},
+ {"ひらがな・カタカナ、．漢字", true},
+ {"あいうえお foobar", true},
+ {"test＠example.com", true},
+ {"test＠example.com", true},
+ {"1234abcDEｘｙｚ", true},
+ {"ｶﾀｶﾅ", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "multibyte")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d Multibyte failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d Multibyte failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "multibyte" {
+ t.Fatalf("Index: %d Multibyte failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestPrintableASCIIValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", true},
+ {"ｆｏｏbar", false},
+ {"ｘｙｚ０９８", false},
+ {"１２３456", false},
+ {"ｶﾀｶﾅ", false},
+ {"foobar", true},
+ {"0987654321", true},
+ {"test@example.com", true},
+ {"1234abcDEF", true},
+ {"newline\n", false},
+ {"\x19test\x7F", false},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "printascii")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d Printable ASCII failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d Printable ASCII failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "printascii" {
+ t.Fatalf("Index: %d Printable ASCII failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestASCIIValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", true},
+ {"ｆｏｏbar", false},
+ {"ｘｙｚ０９８", false},
+ {"１２３456", false},
+ {"ｶﾀｶﾅ", false},
+ {"foobar", true},
+ {"0987654321", true},
+ {"test@example.com", true},
+ {"1234abcDEF", true},
+ {"", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "ascii")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ASCII failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ASCII failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "ascii" {
+ t.Fatalf("Index: %d ASCII failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestUUID5Validation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+
+ {"", false},
+ {"xxxa987fbc9-4bed-3078-cf07-9141ba07c9f3", false},
+ {"9c858901-8a57-4791-81fe-4c455b099bc9", false},
+ {"a987fbc9-4bed-3078-cf07-9141ba07c9f3", false},
+ {"987fbc97-4bed-5078-af07-9141ba07c9f3", true},
+ {"987fbc97-4bed-5078-9f07-9141ba07c9f3", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "uuid5")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d UUID5 failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d UUID5 failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "uuid5" {
+ t.Fatalf("Index: %d UUID5 failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestUUID4Validation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"xxxa987fbc9-4bed-3078-cf07-9141ba07c9f3", false},
+ {"a987fbc9-4bed-5078-af07-9141ba07c9f3", false},
+ {"934859", false},
+ {"57b73598-8764-4ad0-a76a-679bb6640eb1", true},
+ {"625e63f3-58f5-40b7-83a1-a72ad31acffb", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "uuid4")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d UUID4 failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d UUID4 failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "uuid4" {
+ t.Fatalf("Index: %d UUID4 failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestUUID3Validation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"412452646", false},
+ {"xxxa987fbc9-4bed-3078-cf07-9141ba07c9f3", false},
+ {"a987fbc9-4bed-4078-8f07-9141ba07c9f3", false},
+ {"a987fbc9-4bed-3078-cf07-9141ba07c9f3", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "uuid3")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d UUID3 failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d UUID3 failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "uuid3" {
+ t.Fatalf("Index: %d UUID3 failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestUUIDValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"xxxa987fbc9-4bed-3078-cf07-9141ba07c9f3", false},
+ {"a987fbc9-4bed-3078-cf07-9141ba07c9f3xxx", false},
+ {"a987fbc94bed3078cf079141ba07c9f3", false},
+ {"934859", false},
+ {"987fbc9-4bed-3078-cf07a-9141ba07c9f3", false},
+ {"aaaaaaaa-1111-1111-aaag-111111111111", false},
+ {"a987fbc9-4bed-3078-cf07-9141ba07c9f3", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "uuid")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d UUID failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d UUID failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "uuid" {
+ t.Fatalf("Index: %d UUID failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestISBNValidation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"foo", false},
+ {"3836221195", true},
+ {"1-61729-085-8", true},
+ {"3 423 21412 0", true},
+ {"3 401 01319 X", true},
+ {"9784873113685", true},
+ {"978-4-87311-368-5", true},
+ {"978 3401013190", true},
+ {"978-3-8362-2119-1", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "isbn")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ISBN failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ISBN failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "isbn" {
+ t.Fatalf("Index: %d ISBN failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestISBN13Validation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"foo", false},
+ {"3-8362-2119-5", false},
+ {"01234567890ab", false},
+ {"978 3 8362 2119 0", false},
+ {"9784873113685", true},
+ {"978-4-87311-368-5", true},
+ {"978 3401013190", true},
+ {"978-3-8362-2119-1", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "isbn13")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ISBN13 failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ISBN13 failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "isbn13" {
+ t.Fatalf("Index: %d ISBN13 failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestISBN10Validation(t *testing.T) {
+ tests := []struct {
+ param string
+ expected bool
+ }{
+ {"", false},
+ {"foo", false},
+ {"3423214121", false},
+ {"978-3836221191", false},
+ {"3-423-21412-1", false},
+ {"3 423 21412 1", false},
+ {"3836221195", true},
+ {"1-61729-085-8", true},
+ {"3 423 21412 0", true},
+ {"3 401 01319 X", true},
+ }
+
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "isbn10")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ISBN10 failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d ISBN10 failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "isbn10" {
+ t.Fatalf("Index: %d ISBN10 failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+}
+
+func TestExcludesRuneValidation(t *testing.T) {
+
+ tests := []struct {
+ Value string `validate:"excludesrune=☻"`
+ Tag string
+ ExpectedNil bool
+ }{
+ {Value: "a☺b☻c☹d", Tag: "excludesrune=☻", ExpectedNil: false},
+ {Value: "abcd", Tag: "excludesrune=☻", ExpectedNil: true},
+ }
+
+ for i, s := range tests {
+ errs := validate.Field(s.Value, s.Tag)
+
+ if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
+ t.Fatalf("Index: %d failed Error: %s", i, errs)
+ }
+
+ errs = validate.Struct(s)
+
+ if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
+ t.Fatalf("Index: %d failed Error: %s", i, errs)
+ }
+ }
+}
+
+func TestExcludesAllValidation(t *testing.T) {
+
+ tests := []struct {
+ Value string `validate:"excludesall=@!{}[]"`
+ Tag string
+ ExpectedNil bool
+ }{
+ {Value: "abcd@!jfk", Tag: "excludesall=@!{}[]", ExpectedNil: false},
+ {Value: "abcdefg", Tag: "excludesall=@!{}[]", ExpectedNil: true},
+ }
+
+ for i, s := range tests {
+ errs := validate.Field(s.Value, s.Tag)
+
+ if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
+ t.Fatalf("Index: %d failed Error: %s", i, errs)
+ }
+
+ errs = validate.Struct(s)
+
+ if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
+ t.Fatalf("Index: %d failed Error: %s", i, errs)
+ }
+ }
+
+ username := "joeybloggs "
+
+ errs := validate.Field(username, "excludesall=@ ")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "excludesall")
+
+ excluded := ","
+
+ errs = validate.Field(excluded, "excludesall=!@#$%^&*()_+.0x2C?")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "excludesall")
+
+ excluded = "="
+
+ errs = validate.Field(excluded, "excludesall=!@#$%^&*()_+.0x2C=?")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "excludesall")
+}
+
+func TestExcludesValidation(t *testing.T) {
+
+ tests := []struct {
+ Value string `validate:"excludes=@"`
+ Tag string
+ ExpectedNil bool
+ }{
+ {Value: "abcd@!jfk", Tag: "excludes=@", ExpectedNil: false},
+ {Value: "abcdq!jfk", Tag: "excludes=@", ExpectedNil: true},
+ }
+
+ for i, s := range tests {
+ errs := validate.Field(s.Value, s.Tag)
+
+ if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
+ t.Fatalf("Index: %d failed Error: %s", i, errs)
+ }
+
+ errs = validate.Struct(s)
+
+ if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
+ t.Fatalf("Index: %d failed Error: %s", i, errs)
+ }
+ }
+}
+
+func TestContainsRuneValidation(t *testing.T) {
+
+ tests := []struct {
+ Value string `validate:"containsrune=☻"`
+ Tag string
+ ExpectedNil bool
+ }{
+ {Value: "a☺b☻c☹d", Tag: "containsrune=☻", ExpectedNil: true},
+ {Value: "abcd", Tag: "containsrune=☻", ExpectedNil: false},
+ }
+
+ for i, s := range tests {
+ errs := validate.Field(s.Value, s.Tag)
+
+ if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
+ t.Fatalf("Index: %d failed Error: %s", i, errs)
+ }
+
+ errs = validate.Struct(s)
+
+ if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
+ t.Fatalf("Index: %d failed Error: %s", i, errs)
+ }
+ }
+}
+
+func TestContainsAnyValidation(t *testing.T) {
+
+ tests := []struct {
+ Value string `validate:"containsany=@!{}[]"`
+ Tag string
+ ExpectedNil bool
+ }{
+ {Value: "abcd@!jfk", Tag: "containsany=@!{}[]", ExpectedNil: true},
+ {Value: "abcdefg", Tag: "containsany=@!{}[]", ExpectedNil: false},
+ }
+
+ for i, s := range tests {
+ errs := validate.Field(s.Value, s.Tag)
+
+ if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
+ t.Fatalf("Index: %d failed Error: %s", i, errs)
+ }
+
+ errs = validate.Struct(s)
+
+ if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
+ t.Fatalf("Index: %d failed Error: %s", i, errs)
+ }
+ }
+}
+
+func TestContainsValidation(t *testing.T) {
+
+ tests := []struct {
+ Value string `validate:"contains=@"`
+ Tag string
+ ExpectedNil bool
+ }{
+ {Value: "abcd@!jfk", Tag: "contains=@", ExpectedNil: true},
+ {Value: "abcdq!jfk", Tag: "contains=@", ExpectedNil: false},
+ }
+
+ for i, s := range tests {
+ errs := validate.Field(s.Value, s.Tag)
+
+ if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
+ t.Fatalf("Index: %d failed Error: %s", i, errs)
+ }
+
+ errs = validate.Struct(s)
+
+ if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
+ t.Fatalf("Index: %d failed Error: %s", i, errs)
+ }
+ }
+}
+
+func TestIsNeFieldValidation(t *testing.T) {
+
+ var j uint64
+ var k float64
+ s := "abcd"
+ i := 1
+ j = 1
+ k = 1.543
+ arr := []string{"test"}
+ now := time.Now().UTC()
+
+ var j2 uint64
+ var k2 float64
+ s2 := "abcdef"
+ i2 := 3
+ j2 = 2
+ k2 = 1.5434456
+ arr2 := []string{"test", "test2"}
+ arr3 := []string{"test"}
+ now2 := now
+
+ errs := validate.FieldWithValue(s, s2, "nefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(i2, i, "nefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(j2, j, "nefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(k2, k, "nefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(arr2, arr, "nefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(now2, now, "nefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "nefield")
+
+ errs = validate.FieldWithValue(arr3, arr, "nefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "nefield")
+
+ type Test struct {
+ Start *time.Time `validate:"nefield=End"`
+ End *time.Time
+ }
+
+ sv := &Test{
+ Start: &now,
+ End: &now,
+ }
+
+ errs = validate.Struct(sv)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.Start", "Start", "nefield")
+
+ now3 := time.Now().UTC()
+
+ sv = &Test{
+ Start: &now,
+ End: &now3,
+ }
+
+ errs = validate.Struct(sv)
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(nil, 1, "nefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(sv, now, "nefield")
+ Equal(t, errs, nil)
+
+ type Test2 struct {
+ Start *time.Time `validate:"nefield=NonExistantField"`
+ End *time.Time
+ }
+
+ sv2 := &Test2{
+ Start: &now,
+ End: &now,
+ }
+
+ errs = validate.Struct(sv2)
+ Equal(t, errs, nil)
+}
+
+func TestIsNeValidation(t *testing.T) {
+
+ var j uint64
+ var k float64
+ s := "abcdef"
+ i := 3
+ j = 2
+ k = 1.5434
+ arr := []string{"test"}
+ now := time.Now().UTC()
+
+ errs := validate.Field(s, "ne=abcd")
+ Equal(t, errs, nil)
+
+ errs = validate.Field(i, "ne=1")
+ Equal(t, errs, nil)
+
+ errs = validate.Field(j, "ne=1")
+ Equal(t, errs, nil)
+
+ errs = validate.Field(k, "ne=1.543")
+ Equal(t, errs, nil)
+
+ errs = validate.Field(arr, "ne=2")
+ Equal(t, errs, nil)
+
+ errs = validate.Field(arr, "ne=1")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ne")
+
+ PanicMatches(t, func() { validate.Field(now, "ne=now") }, "Bad field type time.Time")
+}
+
+func TestIsEqFieldValidation(t *testing.T) {
+
+ var j uint64
+ var k float64
+ s := "abcd"
+ i := 1
+ j = 1
+ k = 1.543
+ arr := []string{"test"}
+ now := time.Now().UTC()
+
+ var j2 uint64
+ var k2 float64
+ s2 := "abcd"
+ i2 := 1
+ j2 = 1
+ k2 = 1.543
+ arr2 := []string{"test"}
+ arr3 := []string{"test", "test2"}
+ now2 := now
+
+ errs := validate.FieldWithValue(s, s2, "eqfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(i2, i, "eqfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(j2, j, "eqfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(k2, k, "eqfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(arr2, arr, "eqfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(now2, now, "eqfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(arr3, arr, "eqfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "eqfield")
+
+ type Test struct {
+ Start *time.Time `validate:"eqfield=End"`
+ End *time.Time
+ }
+
+ sv := &Test{
+ Start: &now,
+ End: &now,
+ }
+
+ errs = validate.Struct(sv)
+ Equal(t, errs, nil)
+
+ now3 := time.Now().UTC()
+
+ sv = &Test{
+ Start: &now,
+ End: &now3,
+ }
+
+ errs = validate.Struct(sv)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.Start", "Start", "eqfield")
+
+ errs = validate.FieldWithValue(nil, 1, "eqfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "eqfield")
+
+ channel := make(chan string)
+ errs = validate.FieldWithValue(5, channel, "eqfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "eqfield")
+
+ errs = validate.FieldWithValue(5, now, "eqfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "eqfield")
+
+ type Test2 struct {
+ Start *time.Time `validate:"eqfield=NonExistantField"`
+ End *time.Time
+ }
+
+ sv2 := &Test2{
+ Start: &now,
+ End: &now,
+ }
+
+ errs = validate.Struct(sv2)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test2.Start", "Start", "eqfield")
+
+ type Inner struct {
+ Name string
+ }
+
+ type TStruct struct {
+ Inner *Inner
+ CreatedAt *time.Time `validate:"eqfield=Inner"`
+ }
+
+ inner := &Inner{
+ Name: "NAME",
+ }
+
+ test := &TStruct{
+ Inner: inner,
+ CreatedAt: &now,
+ }
+
+ errs = validate.Struct(test)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TStruct.CreatedAt", "CreatedAt", "eqfield")
+}
+
+func TestIsEqValidation(t *testing.T) {
+
+ var j uint64
+ var k float64
+ s := "abcd"
+ i := 1
+ j = 1
+ k = 1.543
+ arr := []string{"test"}
+ now := time.Now().UTC()
+
+ errs := validate.Field(s, "eq=abcd")
+ Equal(t, errs, nil)
+
+ errs = validate.Field(i, "eq=1")
+ Equal(t, errs, nil)
+
+ errs = validate.Field(j, "eq=1")
+ Equal(t, errs, nil)
+
+ errs = validate.Field(k, "eq=1.543")
+ Equal(t, errs, nil)
+
+ errs = validate.Field(arr, "eq=1")
+ Equal(t, errs, nil)
+
+ errs = validate.Field(arr, "eq=2")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "eq")
+
+ PanicMatches(t, func() { validate.Field(now, "eq=now") }, "Bad field type time.Time")
+}
+
+func TestBase64Validation(t *testing.T) {
+
+ s := "dW5pY29ybg=="
+
+ errs := validate.Field(s, "base64")
+ Equal(t, errs, nil)
+
+ s = "dGhpIGlzIGEgdGVzdCBiYXNlNjQ="
+ errs = validate.Field(s, "base64")
+ Equal(t, errs, nil)
+
+ s = ""
+ errs = validate.Field(s, "base64")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "base64")
+
+ s = "dW5pY29ybg== foo bar"
+ errs = validate.Field(s, "base64")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "base64")
+}
+
+func TestNoStructLevelValidation(t *testing.T) {
+
+ type Inner struct {
+ Test string `validate:"len=5"`
+ }
+
+ type Outer struct {
+ InnerStruct *Inner `validate:"required,nostructlevel"`
+ }
+
+ outer := &Outer{
+ InnerStruct: nil,
+ }
+
+ errs := validate.Struct(outer)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Outer.InnerStruct", "InnerStruct", "required")
+
+ inner := &Inner{
+ Test: "1234",
+ }
+
+ outer = &Outer{
+ InnerStruct: inner,
+ }
+
+ errs = validate.Struct(outer)
+ Equal(t, errs, nil)
+}
+
+func TestStructOnlyValidation(t *testing.T) {
+
+ type Inner struct {
+ Test string `validate:"len=5"`
+ }
+
+ type Outer struct {
+ InnerStruct *Inner `validate:"required,structonly"`
+ }
+
+ outer := &Outer{
+ InnerStruct: nil,
+ }
+
+ errs := validate.Struct(outer)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Outer.InnerStruct", "InnerStruct", "required")
+
+ inner := &Inner{
+ Test: "1234",
+ }
+
+ outer = &Outer{
+ InnerStruct: inner,
+ }
+
+ errs = validate.Struct(outer)
+ Equal(t, errs, nil)
+}
+
+func TestGtField(t *testing.T) {
+
+ type TimeTest struct {
+ Start *time.Time `validate:"required,gt"`
+ End *time.Time `validate:"required,gt,gtfield=Start"`
+ }
+
+ now := time.Now()
+ start := now.Add(time.Hour * 24)
+ end := start.Add(time.Hour * 24)
+
+ timeTest := &TimeTest{
+ Start: &start,
+ End: &end,
+ }
+
+ errs := validate.Struct(timeTest)
+ Equal(t, errs, nil)
+
+ timeTest = &TimeTest{
+ Start: &end,
+ End: &start,
+ }
+
+ errs = validate.Struct(timeTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TimeTest.End", "End", "gtfield")
+
+ errs = validate.FieldWithValue(&start, &end, "gtfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(&end, &start, "gtfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtfield")
+
+ errs = validate.FieldWithValue(&timeTest, &end, "gtfield")
+ NotEqual(t, errs, nil)
+
+ errs = validate.FieldWithValue("test", "test bigger", "gtfield")
+ Equal(t, errs, nil)
+
+ type IntTest struct {
+ Val1 int `validate:"required"`
+ Val2 int `validate:"required,gtfield=Val1"`
+ }
+
+ intTest := &IntTest{
+ Val1: 1,
+ Val2: 5,
+ }
+
+ errs = validate.Struct(intTest)
+ Equal(t, errs, nil)
+
+ intTest = &IntTest{
+ Val1: 5,
+ Val2: 1,
+ }
+
+ errs = validate.Struct(intTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "IntTest.Val2", "Val2", "gtfield")
+
+ errs = validate.FieldWithValue(int(1), int(5), "gtfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(int(5), int(1), "gtfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtfield")
+
+ type UIntTest struct {
+ Val1 uint `validate:"required"`
+ Val2 uint `validate:"required,gtfield=Val1"`
+ }
+
+ uIntTest := &UIntTest{
+ Val1: 1,
+ Val2: 5,
+ }
+
+ errs = validate.Struct(uIntTest)
+ Equal(t, errs, nil)
+
+ uIntTest = &UIntTest{
+ Val1: 5,
+ Val2: 1,
+ }
+
+ errs = validate.Struct(uIntTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "UIntTest.Val2", "Val2", "gtfield")
+
+ errs = validate.FieldWithValue(uint(1), uint(5), "gtfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(uint(5), uint(1), "gtfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtfield")
+
+ type FloatTest struct {
+ Val1 float64 `validate:"required"`
+ Val2 float64 `validate:"required,gtfield=Val1"`
+ }
+
+ floatTest := &FloatTest{
+ Val1: 1,
+ Val2: 5,
+ }
+
+ errs = validate.Struct(floatTest)
+ Equal(t, errs, nil)
+
+ floatTest = &FloatTest{
+ Val1: 5,
+ Val2: 1,
+ }
+
+ errs = validate.Struct(floatTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "FloatTest.Val2", "Val2", "gtfield")
+
+ errs = validate.FieldWithValue(float32(1), float32(5), "gtfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(float32(5), float32(1), "gtfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtfield")
+
+ errs = validate.FieldWithValue(nil, 1, "gtfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtfield")
+
+ errs = validate.FieldWithValue(5, "T", "gtfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtfield")
+
+ errs = validate.FieldWithValue(5, start, "gtfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtfield")
+
+ type TimeTest2 struct {
+ Start *time.Time `validate:"required"`
+ End *time.Time `validate:"required,gtfield=NonExistantField"`
+ }
+
+ timeTest2 := &TimeTest2{
+ Start: &start,
+ End: &end,
+ }
+
+ errs = validate.Struct(timeTest2)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TimeTest2.End", "End", "gtfield")
+}
+
+func TestLtField(t *testing.T) {
+
+ type TimeTest struct {
+ Start *time.Time `validate:"required,lt,ltfield=End"`
+ End *time.Time `validate:"required,lt"`
+ }
+
+ now := time.Now()
+ start := now.Add(time.Hour * 24 * -1 * 2)
+ end := start.Add(time.Hour * 24)
+
+ timeTest := &TimeTest{
+ Start: &start,
+ End: &end,
+ }
+
+ errs := validate.Struct(timeTest)
+ Equal(t, errs, nil)
+
+ timeTest = &TimeTest{
+ Start: &end,
+ End: &start,
+ }
+
+ errs = validate.Struct(timeTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TimeTest.Start", "Start", "ltfield")
+
+ errs = validate.FieldWithValue(&end, &start, "ltfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(&start, &end, "ltfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltfield")
+
+ errs = validate.FieldWithValue(timeTest, &end, "ltfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltfield")
+
+ errs = validate.FieldWithValue("test", "tes", "ltfield")
+ Equal(t, errs, nil)
+
+ type IntTest struct {
+ Val1 int `validate:"required"`
+ Val2 int `validate:"required,ltfield=Val1"`
+ }
+
+ intTest := &IntTest{
+ Val1: 5,
+ Val2: 1,
+ }
+
+ errs = validate.Struct(intTest)
+ Equal(t, errs, nil)
+
+ intTest = &IntTest{
+ Val1: 1,
+ Val2: 5,
+ }
+
+ errs = validate.Struct(intTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "IntTest.Val2", "Val2", "ltfield")
+
+ errs = validate.FieldWithValue(int(5), int(1), "ltfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(int(1), int(5), "ltfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltfield")
+
+ type UIntTest struct {
+ Val1 uint `validate:"required"`
+ Val2 uint `validate:"required,ltfield=Val1"`
+ }
+
+ uIntTest := &UIntTest{
+ Val1: 5,
+ Val2: 1,
+ }
+
+ errs = validate.Struct(uIntTest)
+ Equal(t, errs, nil)
+
+ uIntTest = &UIntTest{
+ Val1: 1,
+ Val2: 5,
+ }
+
+ errs = validate.Struct(uIntTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "UIntTest.Val2", "Val2", "ltfield")
+
+ errs = validate.FieldWithValue(uint(5), uint(1), "ltfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(uint(1), uint(5), "ltfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltfield")
+
+ type FloatTest struct {
+ Val1 float64 `validate:"required"`
+ Val2 float64 `validate:"required,ltfield=Val1"`
+ }
+
+ floatTest := &FloatTest{
+ Val1: 5,
+ Val2: 1,
+ }
+
+ errs = validate.Struct(floatTest)
+ Equal(t, errs, nil)
+
+ floatTest = &FloatTest{
+ Val1: 1,
+ Val2: 5,
+ }
+
+ errs = validate.Struct(floatTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "FloatTest.Val2", "Val2", "ltfield")
+
+ errs = validate.FieldWithValue(float32(5), float32(1), "ltfield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(float32(1), float32(5), "ltfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltfield")
+
+ errs = validate.FieldWithValue(nil, 5, "ltfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltfield")
+
+ errs = validate.FieldWithValue(1, "T", "ltfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltfield")
+
+ errs = validate.FieldWithValue(1, end, "ltfield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltfield")
+
+ type TimeTest2 struct {
+ Start *time.Time `validate:"required"`
+ End *time.Time `validate:"required,ltfield=NonExistantField"`
+ }
+
+ timeTest2 := &TimeTest2{
+ Start: &end,
+ End: &start,
+ }
+
+ errs = validate.Struct(timeTest2)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TimeTest2.End", "End", "ltfield")
+}
+
+func TestLteField(t *testing.T) {
+
+ type TimeTest struct {
+ Start *time.Time `validate:"required,lte,ltefield=End"`
+ End *time.Time `validate:"required,lte"`
+ }
+
+ now := time.Now()
+ start := now.Add(time.Hour * 24 * -1 * 2)
+ end := start.Add(time.Hour * 24)
+
+ timeTest := &TimeTest{
+ Start: &start,
+ End: &end,
+ }
+
+ errs := validate.Struct(timeTest)
+ Equal(t, errs, nil)
+
+ timeTest = &TimeTest{
+ Start: &end,
+ End: &start,
+ }
+
+ errs = validate.Struct(timeTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TimeTest.Start", "Start", "ltefield")
+
+ errs = validate.FieldWithValue(&end, &start, "ltefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(&start, &end, "ltefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltefield")
+
+ errs = validate.FieldWithValue(timeTest, &end, "ltefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltefield")
+
+ errs = validate.FieldWithValue("test", "tes", "ltefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue("test", "test", "ltefield")
+ Equal(t, errs, nil)
+
+ type IntTest struct {
+ Val1 int `validate:"required"`
+ Val2 int `validate:"required,ltefield=Val1"`
+ }
+
+ intTest := &IntTest{
+ Val1: 5,
+ Val2: 1,
+ }
+
+ errs = validate.Struct(intTest)
+ Equal(t, errs, nil)
+
+ intTest = &IntTest{
+ Val1: 1,
+ Val2: 5,
+ }
+
+ errs = validate.Struct(intTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "IntTest.Val2", "Val2", "ltefield")
+
+ errs = validate.FieldWithValue(int(5), int(1), "ltefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(int(1), int(5), "ltefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltefield")
+
+ type UIntTest struct {
+ Val1 uint `validate:"required"`
+ Val2 uint `validate:"required,ltefield=Val1"`
+ }
+
+ uIntTest := &UIntTest{
+ Val1: 5,
+ Val2: 1,
+ }
+
+ errs = validate.Struct(uIntTest)
+ Equal(t, errs, nil)
+
+ uIntTest = &UIntTest{
+ Val1: 1,
+ Val2: 5,
+ }
+
+ errs = validate.Struct(uIntTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "UIntTest.Val2", "Val2", "ltefield")
+
+ errs = validate.FieldWithValue(uint(5), uint(1), "ltefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(uint(1), uint(5), "ltefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltefield")
+
+ type FloatTest struct {
+ Val1 float64 `validate:"required"`
+ Val2 float64 `validate:"required,ltefield=Val1"`
+ }
+
+ floatTest := &FloatTest{
+ Val1: 5,
+ Val2: 1,
+ }
+
+ errs = validate.Struct(floatTest)
+ Equal(t, errs, nil)
+
+ floatTest = &FloatTest{
+ Val1: 1,
+ Val2: 5,
+ }
+
+ errs = validate.Struct(floatTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "FloatTest.Val2", "Val2", "ltefield")
+
+ errs = validate.FieldWithValue(float32(5), float32(1), "ltefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(float32(1), float32(5), "ltefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltefield")
+
+ errs = validate.FieldWithValue(nil, 5, "ltefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltefield")
+
+ errs = validate.FieldWithValue(1, "T", "ltefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltefield")
+
+ errs = validate.FieldWithValue(1, end, "ltefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "ltefield")
+
+ type TimeTest2 struct {
+ Start *time.Time `validate:"required"`
+ End *time.Time `validate:"required,ltefield=NonExistantField"`
+ }
+
+ timeTest2 := &TimeTest2{
+ Start: &end,
+ End: &start,
+ }
+
+ errs = validate.Struct(timeTest2)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TimeTest2.End", "End", "ltefield")
+}
+
+func TestGteField(t *testing.T) {
+
+ type TimeTest struct {
+ Start *time.Time `validate:"required,gte"`
+ End *time.Time `validate:"required,gte,gtefield=Start"`
+ }
+
+ now := time.Now()
+ start := now.Add(time.Hour * 24)
+ end := start.Add(time.Hour * 24)
+
+ timeTest := &TimeTest{
+ Start: &start,
+ End: &end,
+ }
+
+ errs := validate.Struct(timeTest)
+ Equal(t, errs, nil)
+
+ timeTest = &TimeTest{
+ Start: &end,
+ End: &start,
+ }
+
+ errs = validate.Struct(timeTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TimeTest.End", "End", "gtefield")
+
+ errs = validate.FieldWithValue(&start, &end, "gtefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(&end, &start, "gtefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtefield")
+
+ errs = validate.FieldWithValue(timeTest, &start, "gtefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtefield")
+
+ errs = validate.FieldWithValue("test", "test", "gtefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue("test", "test bigger", "gtefield")
+ Equal(t, errs, nil)
+
+ type IntTest struct {
+ Val1 int `validate:"required"`
+ Val2 int `validate:"required,gtefield=Val1"`
+ }
+
+ intTest := &IntTest{
+ Val1: 1,
+ Val2: 5,
+ }
+
+ errs = validate.Struct(intTest)
+ Equal(t, errs, nil)
+
+ intTest = &IntTest{
+ Val1: 5,
+ Val2: 1,
+ }
+
+ errs = validate.Struct(intTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "IntTest.Val2", "Val2", "gtefield")
+
+ errs = validate.FieldWithValue(int(1), int(5), "gtefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(int(5), int(1), "gtefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtefield")
+
+ type UIntTest struct {
+ Val1 uint `validate:"required"`
+ Val2 uint `validate:"required,gtefield=Val1"`
+ }
+
+ uIntTest := &UIntTest{
+ Val1: 1,
+ Val2: 5,
+ }
+
+ errs = validate.Struct(uIntTest)
+ Equal(t, errs, nil)
+
+ uIntTest = &UIntTest{
+ Val1: 5,
+ Val2: 1,
+ }
+
+ errs = validate.Struct(uIntTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "UIntTest.Val2", "Val2", "gtefield")
+
+ errs = validate.FieldWithValue(uint(1), uint(5), "gtefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(uint(5), uint(1), "gtefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtefield")
+
+ type FloatTest struct {
+ Val1 float64 `validate:"required"`
+ Val2 float64 `validate:"required,gtefield=Val1"`
+ }
+
+ floatTest := &FloatTest{
+ Val1: 1,
+ Val2: 5,
+ }
+
+ errs = validate.Struct(floatTest)
+ Equal(t, errs, nil)
+
+ floatTest = &FloatTest{
+ Val1: 5,
+ Val2: 1,
+ }
+
+ errs = validate.Struct(floatTest)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "FloatTest.Val2", "Val2", "gtefield")
+
+ errs = validate.FieldWithValue(float32(1), float32(5), "gtefield")
+ Equal(t, errs, nil)
+
+ errs = validate.FieldWithValue(float32(5), float32(1), "gtefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtefield")
+
+ errs = validate.FieldWithValue(nil, 1, "gtefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtefield")
+
+ errs = validate.FieldWithValue(5, "T", "gtefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtefield")
+
+ errs = validate.FieldWithValue(5, start, "gtefield")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gtefield")
+
+ type TimeTest2 struct {
+ Start *time.Time `validate:"required"`
+ End *time.Time `validate:"required,gtefield=NonExistantField"`
+ }
+
+ timeTest2 := &TimeTest2{
+ Start: &start,
+ End: &end,
+ }
+
+ errs = validate.Struct(timeTest2)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TimeTest2.End", "End", "gtefield")
+}
+
+func TestValidateByTagAndValue(t *testing.T) {
+
+ val := "test"
+ field := "test"
+ errs := validate.FieldWithValue(val, field, "required")
+ Equal(t, errs, nil)
+
+ fn := func(v *Validate, topStruct reflect.Value, current reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ return current.String() == field.String()
+ }
+
+ validate.RegisterValidation("isequaltestfunc", fn)
+
+ errs = validate.FieldWithValue(val, field, "isequaltestfunc")
+ Equal(t, errs, nil)
+
+ val = "unequal"
+
+ errs = validate.FieldWithValue(val, field, "isequaltestfunc")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "isequaltestfunc")
+}
+
+func TestAddFunctions(t *testing.T) {
+
+ fn := func(v *Validate, topStruct reflect.Value, currentStruct reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
+
+ return true
+ }
+
+ config := &Config{
+ TagName: "validateme",
+ }
+
+ validate := New(config)
+
+ errs := validate.RegisterValidation("new", fn)
+ Equal(t, errs, nil)
+
+ errs = validate.RegisterValidation("", fn)
+ NotEqual(t, errs, nil)
+
+ validate.RegisterValidation("new", nil)
+ NotEqual(t, errs, nil)
+
+ errs = validate.RegisterValidation("new", fn)
+ Equal(t, errs, nil)
+
+ PanicMatches(t, func() { validate.RegisterValidation("dive", fn) }, "Tag 'dive' either contains restricted characters or is the same as a restricted tag needed for normal operation")
+}
+
+func TestChangeTag(t *testing.T) {
+
+ config := &Config{
+ TagName: "val",
+ }
+ validate := New(config)
+
+ type Test struct {
+ Name string `val:"len=4"`
+ }
+ s := &Test{
+ Name: "TEST",
+ }
+
+ errs := validate.Struct(s)
+ Equal(t, errs, nil)
+}
+
+func TestUnexposedStruct(t *testing.T) {
+
+ type Test struct {
+ Name string
+ unexposed struct {
+ A string `validate:"required"`
+ }
+ }
+
+ s := &Test{
+ Name: "TEST",
+ }
+
+ errs := validate.Struct(s)
+ Equal(t, errs, nil)
+}
+
+func TestBadParams(t *testing.T) {
+
+ i := 1
+ errs := validate.Field(i, "-")
+ Equal(t, errs, nil)
+
+ PanicMatches(t, func() { validate.Field(i, "len=a") }, "strconv.ParseInt: parsing \"a\": invalid syntax")
+ PanicMatches(t, func() { validate.Field(i, "len=a") }, "strconv.ParseInt: parsing \"a\": invalid syntax")
+
+ var ui uint = 1
+ PanicMatches(t, func() { validate.Field(ui, "len=a") }, "strconv.ParseUint: parsing \"a\": invalid syntax")
+
+ f := 1.23
+ PanicMatches(t, func() { validate.Field(f, "len=a") }, "strconv.ParseFloat: parsing \"a\": invalid syntax")
+}
+
+func TestLength(t *testing.T) {
+
+ i := true
+ PanicMatches(t, func() { validate.Field(i, "len") }, "Bad field type bool")
+}
+
+func TestIsGt(t *testing.T) {
+
+ myMap := map[string]string{}
+ errs := validate.Field(myMap, "gt=0")
+ NotEqual(t, errs, nil)
+
+ f := 1.23
+ errs = validate.Field(f, "gt=5")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gt")
+
+ var ui uint = 5
+ errs = validate.Field(ui, "gt=10")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gt")
+
+ i := true
+ PanicMatches(t, func() { validate.Field(i, "gt") }, "Bad field type bool")
+
+ tm := time.Now().UTC()
+ tm = tm.Add(time.Hour * 24)
+
+ errs = validate.Field(tm, "gt")
+ Equal(t, errs, nil)
+
+ t2 := time.Now().UTC().Add(-time.Hour)
+
+ errs = validate.Field(t2, "gt")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gt")
+
+ type Test struct {
+ Now *time.Time `validate:"gt"`
+ }
+ s := &Test{
+ Now: &tm,
+ }
+
+ errs = validate.Struct(s)
+ Equal(t, errs, nil)
+
+ s = &Test{
+ Now: &t2,
+ }
+
+ errs = validate.Struct(s)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.Now", "Now", "gt")
+}
+
+func TestIsGte(t *testing.T) {
+
+ i := true
+ PanicMatches(t, func() { validate.Field(i, "gte") }, "Bad field type bool")
+
+ t1 := time.Now().UTC()
+ t1 = t1.Add(time.Hour * 24)
+
+ errs := validate.Field(t1, "gte")
+ Equal(t, errs, nil)
+
+ t2 := time.Now().UTC().Add(-time.Hour)
+
+ errs = validate.Field(t2, "gte")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "gte")
+
+ type Test struct {
+ Now *time.Time `validate:"gte"`
+ }
+ s := &Test{
+ Now: &t1,
+ }
+
+ errs = validate.Struct(s)
+ Equal(t, errs, nil)
+
+ s = &Test{
+ Now: &t2,
+ }
+
+ errs = validate.Struct(s)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.Now", "Now", "gte")
+}
+
+func TestIsLt(t *testing.T) {
+
+ myMap := map[string]string{}
+ errs := validate.Field(myMap, "lt=0")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "lt")
+
+ f := 1.23
+ errs = validate.Field(f, "lt=0")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "lt")
+
+ var ui uint = 5
+ errs = validate.Field(ui, "lt=0")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "lt")
+
+ i := true
+ PanicMatches(t, func() { validate.Field(i, "lt") }, "Bad field type bool")
+
+ t1 := time.Now().UTC().Add(-time.Hour)
+
+ errs = validate.Field(t1, "lt")
+ Equal(t, errs, nil)
+
+ t2 := time.Now().UTC()
+ t2 = t2.Add(time.Hour * 24)
+
+ errs = validate.Field(t2, "lt")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "lt")
+
+ type Test struct {
+ Now *time.Time `validate:"lt"`
+ }
+
+ s := &Test{
+ Now: &t1,
+ }
+
+ errs = validate.Struct(s)
+ Equal(t, errs, nil)
+
+ s = &Test{
+ Now: &t2,
+ }
+
+ errs = validate.Struct(s)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.Now", "Now", "lt")
+}
+
+func TestIsLte(t *testing.T) {
+
+ i := true
+ PanicMatches(t, func() { validate.Field(i, "lte") }, "Bad field type bool")
+
+ t1 := time.Now().UTC().Add(-time.Hour)
+
+ errs := validate.Field(t1, "lte")
+ Equal(t, errs, nil)
+
+ t2 := time.Now().UTC()
+ t2 = t2.Add(time.Hour * 24)
+
+ errs = validate.Field(t2, "lte")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "lte")
+
+ type Test struct {
+ Now *time.Time `validate:"lte"`
+ }
+
+ s := &Test{
+ Now: &t1,
+ }
+
+ errs = validate.Struct(s)
+ Equal(t, errs, nil)
+
+ s = &Test{
+ Now: &t2,
+ }
+
+ errs = validate.Struct(s)
+ NotEqual(t, errs, nil)
+}
+
+func TestUrl(t *testing.T) {
+
+ var tests = []struct {
+ param string
+ expected bool
+ }{
+ {"http://foo.bar#com", true},
+ {"http://foobar.com", true},
+ {"https://foobar.com", true},
+ {"foobar.com", false},
+ {"http://foobar.coffee/", true},
+ {"http://foobar.中文网/", true},
+ {"http://foobar.org/", true},
+ {"http://foobar.org:8080/", true},
+ {"ftp://foobar.ru/", true},
+ {"http://user:pass@www.foobar.com/", true},
+ {"http://127.0.0.1/", true},
+ {"http://duckduckgo.com/?q=%2F", true},
+ {"http://localhost:3000/", true},
+ {"http://foobar.com/?foo=bar#baz=qux", true},
+ {"http://foobar.com?foo=bar", true},
+ {"http://www.xn--froschgrn-x9a.net/", true},
+ {"", false},
+ {"xyz://foobar.com", true},
+ {"invalid.", false},
+ {".com", false},
+ {"rtmp://foobar.com", true},
+ {"http://www.foo_bar.com/", true},
+ {"http://localhost:3000/", true},
+ {"http://foobar.com/#baz", true},
+ {"http://foobar.com#baz=qux", true},
+ {"http://foobar.com/t$-_.+!*\\'(),", true},
+ {"http://www.foobar.com/~foobar", true},
+ {"http://www.-foobar.com/", true},
+ {"http://www.foo---bar.com/", true},
+ {"mailto:someone@example.com", true},
+ {"irc://irc.server.org/channel", true},
+ {"irc://#channel@network", true},
+ {"/abs/test/dir", false},
+ {"./rel/test/dir", false},
+ }
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "url")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d URL failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d URL failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "url" {
+ t.Fatalf("Index: %d URL failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+
+ i := 1
+ PanicMatches(t, func() { validate.Field(i, "url") }, "Bad field type int")
+}
+
+func TestUri(t *testing.T) {
+
+ var tests = []struct {
+ param string
+ expected bool
+ }{
+ {"http://foo.bar#com", true},
+ {"http://foobar.com", true},
+ {"https://foobar.com", true},
+ {"foobar.com", false},
+ {"http://foobar.coffee/", true},
+ {"http://foobar.中文网/", true},
+ {"http://foobar.org/", true},
+ {"http://foobar.org:8080/", true},
+ {"ftp://foobar.ru/", true},
+ {"http://user:pass@www.foobar.com/", true},
+ {"http://127.0.0.1/", true},
+ {"http://duckduckgo.com/?q=%2F", true},
+ {"http://localhost:3000/", true},
+ {"http://foobar.com/?foo=bar#baz=qux", true},
+ {"http://foobar.com?foo=bar", true},
+ {"http://www.xn--froschgrn-x9a.net/", true},
+ {"", false},
+ {"xyz://foobar.com", true},
+ {"invalid.", false},
+ {".com", false},
+ {"rtmp://foobar.com", true},
+ {"http://www.foo_bar.com/", true},
+ {"http://localhost:3000/", true},
+ {"http://foobar.com#baz=qux", true},
+ {"http://foobar.com/t$-_.+!*\\'(),", true},
+ {"http://www.foobar.com/~foobar", true},
+ {"http://www.-foobar.com/", true},
+ {"http://www.foo---bar.com/", true},
+ {"mailto:someone@example.com", true},
+ {"irc://irc.server.org/channel", true},
+ {"irc://#channel@network", true},
+ {"/abs/test/dir", true},
+ {"./rel/test/dir", false},
+ }
+ for i, test := range tests {
+
+ errs := validate.Field(test.param, "uri")
+
+ if test.expected {
+ if !IsEqual(errs, nil) {
+ t.Fatalf("Index: %d URI failed Error: %s", i, errs)
+ }
+ } else {
+ if IsEqual(errs, nil) {
+ t.Fatalf("Index: %d URI failed Error: %s", i, errs)
+ } else {
+ val := errs.(ValidationErrors)[""]
+ if val.Tag != "uri" {
+ t.Fatalf("Index: %d URI failed Error: %s", i, errs)
+ }
+ }
+ }
+ }
+
+ i := 1
+ PanicMatches(t, func() { validate.Field(i, "uri") }, "Bad field type int")
+}
+
+func TestOrTag(t *testing.T) {
+ s := "rgba(0,31,255,0.5)"
+ errs := validate.Field(s, "rgb|rgba")
+ Equal(t, errs, nil)
+
+ s = "rgba(0,31,255,0.5)"
+ errs = validate.Field(s, "rgb|rgba|len=18")
+ Equal(t, errs, nil)
+
+ s = "this ain't right"
+ errs = validate.Field(s, "rgb|rgba")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "rgb|rgba")
+
+ s = "this ain't right"
+ errs = validate.Field(s, "rgb|rgba|len=10")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "rgb|rgba|len")
+
+ s = "this is right"
+ errs = validate.Field(s, "rgb|rgba|len=13")
+ Equal(t, errs, nil)
+
+ s = ""
+ errs = validate.Field(s, "omitempty,rgb|rgba")
+ Equal(t, errs, nil)
+
+ s = "this is right, but a blank or isn't"
+
+ PanicMatches(t, func() { validate.Field(s, "rgb||len=13") }, "Invalid validation tag on field")
+ PanicMatches(t, func() { validate.Field(s, "rgb|rgbaa|len=13") }, "Undefined validation function on field")
+}
+
+func TestHsla(t *testing.T) {
+
+ s := "hsla(360,100%,100%,1)"
+ errs := validate.Field(s, "hsla")
+ Equal(t, errs, nil)
+
+ s = "hsla(360,100%,100%,0.5)"
+ errs = validate.Field(s, "hsla")
+ Equal(t, errs, nil)
+
+ s = "hsla(0,0%,0%, 0)"
+ errs = validate.Field(s, "hsla")
+ Equal(t, errs, nil)
+
+ s = "hsl(361,100%,50%,1)"
+ errs = validate.Field(s, "hsla")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hsla")
+
+ s = "hsl(361,100%,50%)"
+ errs = validate.Field(s, "hsla")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hsla")
+
+ s = "hsla(361,100%,50%)"
+ errs = validate.Field(s, "hsla")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hsla")
+
+ s = "hsla(360,101%,50%)"
+ errs = validate.Field(s, "hsla")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hsla")
+
+ s = "hsla(360,100%,101%)"
+ errs = validate.Field(s, "hsla")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hsla")
+
+ i := 1
+ validate.Field(i, "hsla")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hsla")
+}
+
+func TestHsl(t *testing.T) {
+
+ s := "hsl(360,100%,50%)"
+ errs := validate.Field(s, "hsl")
+ Equal(t, errs, nil)
+
+ s = "hsl(0,0%,0%)"
+ errs = validate.Field(s, "hsl")
+ Equal(t, errs, nil)
+
+ s = "hsl(361,100%,50%)"
+ errs = validate.Field(s, "hsl")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hsl")
+
+ s = "hsl(361,101%,50%)"
+ errs = validate.Field(s, "hsl")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hsl")
+
+ s = "hsl(361,100%,101%)"
+ errs = validate.Field(s, "hsl")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hsl")
+
+ s = "hsl(-10,100%,100%)"
+ errs = validate.Field(s, "hsl")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hsl")
+
+ i := 1
+ errs = validate.Field(i, "hsl")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hsl")
+}
+
+func TestRgba(t *testing.T) {
+
+ s := "rgba(0,31,255,0.5)"
+ errs := validate.Field(s, "rgba")
+ Equal(t, errs, nil)
+
+ s = "rgba(0,31,255,0.12)"
+ errs = validate.Field(s, "rgba")
+ Equal(t, errs, nil)
+
+ s = "rgba(12%,55%,100%,0.12)"
+ errs = validate.Field(s, "rgba")
+ Equal(t, errs, nil)
+
+ s = "rgba( 0, 31, 255, 0.5)"
+ errs = validate.Field(s, "rgba")
+ Equal(t, errs, nil)
+
+ s = "rgba(12%,55,100%,0.12)"
+ errs = validate.Field(s, "rgba")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "rgba")
+
+ s = "rgb(0, 31, 255)"
+ errs = validate.Field(s, "rgba")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "rgba")
+
+ s = "rgb(1,349,275,0.5)"
+ errs = validate.Field(s, "rgba")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "rgba")
+
+ s = "rgb(01,31,255,0.5)"
+ errs = validate.Field(s, "rgba")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "rgba")
+
+ i := 1
+ errs = validate.Field(i, "rgba")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "rgba")
+}
+
+func TestRgb(t *testing.T) {
+
+ s := "rgb(0,31,255)"
+ errs := validate.Field(s, "rgb")
+ Equal(t, errs, nil)
+
+ s = "rgb(0, 31, 255)"
+ errs = validate.Field(s, "rgb")
+ Equal(t, errs, nil)
+
+ s = "rgb(10%, 50%, 100%)"
+ errs = validate.Field(s, "rgb")
+ Equal(t, errs, nil)
+
+ s = "rgb(10%, 50%, 55)"
+ errs = validate.Field(s, "rgb")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "rgb")
+
+ s = "rgb(1,349,275)"
+ errs = validate.Field(s, "rgb")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "rgb")
+
+ s = "rgb(01,31,255)"
+ errs = validate.Field(s, "rgb")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "rgb")
+
+ s = "rgba(0,31,255)"
+ errs = validate.Field(s, "rgb")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "rgb")
+
+ i := 1
+ errs = validate.Field(i, "rgb")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "rgb")
+}
+
+func TestEmail(t *testing.T) {
+
+ s := "test@mail.com"
+ errs := validate.Field(s, "email")
+ Equal(t, errs, nil)
+
+ s = "Dörte@Sörensen.example.com"
+ errs = validate.Field(s, "email")
+ Equal(t, errs, nil)
+
+ s = "θσερ@εχαμπλε.ψομ"
+ errs = validate.Field(s, "email")
+ Equal(t, errs, nil)
+
+ s = "юзер@екзампл.ком"
+ errs = validate.Field(s, "email")
+ Equal(t, errs, nil)
+
+ s = "उपयोगकर्ता@उदाहरण.कॉम"
+ errs = validate.Field(s, "email")
+ Equal(t, errs, nil)
+
+ s = "用户@例子.广告"
+ errs = validate.Field(s, "email")
+ Equal(t, errs, nil)
+
+ s = ""
+ errs = validate.Field(s, "email")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "email")
+
+ s = "test@email"
+ errs = validate.Field(s, "email")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "email")
+
+ s = "test@email."
+ errs = validate.Field(s, "email")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "email")
+
+ s = "@email.com"
+ errs = validate.Field(s, "email")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "email")
+
+ i := true
+ errs = validate.Field(i, "email")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "email")
+}
+
+func TestHexColor(t *testing.T) {
+
+ s := "#fff"
+ errs := validate.Field(s, "hexcolor")
+ Equal(t, errs, nil)
+
+ s = "#c2c2c2"
+ errs = validate.Field(s, "hexcolor")
+ Equal(t, errs, nil)
+
+ s = "fff"
+ errs = validate.Field(s, "hexcolor")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hexcolor")
+
+ s = "fffFF"
+ errs = validate.Field(s, "hexcolor")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hexcolor")
+
+ i := true
+ errs = validate.Field(i, "hexcolor")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hexcolor")
+}
+
+func TestHexadecimal(t *testing.T) {
+
+ s := "ff0044"
+ errs := validate.Field(s, "hexadecimal")
+ Equal(t, errs, nil)
+
+ s = "abcdefg"
+ errs = validate.Field(s, "hexadecimal")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hexadecimal")
+
+ i := true
+ errs = validate.Field(i, "hexadecimal")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "hexadecimal")
+}
+
+func TestNumber(t *testing.T) {
+
+ s := "1"
+ errs := validate.Field(s, "number")
+ Equal(t, errs, nil)
+
+ s = "+1"
+ errs = validate.Field(s, "number")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "number")
+
+ s = "-1"
+ errs = validate.Field(s, "number")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "number")
+
+ s = "1.12"
+ errs = validate.Field(s, "number")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "number")
+
+ s = "+1.12"
+ errs = validate.Field(s, "number")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "number")
+
+ s = "-1.12"
+ errs = validate.Field(s, "number")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "number")
+
+ s = "1."
+ errs = validate.Field(s, "number")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "number")
+
+ s = "1.o"
+ errs = validate.Field(s, "number")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "number")
+
+ i := 1
+ errs = validate.Field(i, "number")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "number")
+}
+
+func TestNumeric(t *testing.T) {
+
+ s := "1"
+ errs := validate.Field(s, "numeric")
+ Equal(t, errs, nil)
+
+ s = "+1"
+ errs = validate.Field(s, "numeric")
+ Equal(t, errs, nil)
+
+ s = "-1"
+ errs = validate.Field(s, "numeric")
+ Equal(t, errs, nil)
+
+ s = "1.12"
+ errs = validate.Field(s, "numeric")
+ Equal(t, errs, nil)
+
+ s = "+1.12"
+ errs = validate.Field(s, "numeric")
+ Equal(t, errs, nil)
+
+ s = "-1.12"
+ errs = validate.Field(s, "numeric")
+ Equal(t, errs, nil)
+
+ s = "1."
+ errs = validate.Field(s, "numeric")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "numeric")
+
+ s = "1.o"
+ errs = validate.Field(s, "numeric")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "numeric")
+
+ i := 1
+ errs = validate.Field(i, "numeric")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "numeric")
+}
+
+func TestAlphaNumeric(t *testing.T) {
+
+ s := "abcd123"
+ errs := validate.Field(s, "alphanum")
+ Equal(t, errs, nil)
+
+ s = "abc!23"
+ errs = validate.Field(s, "alphanum")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "alphanum")
+
+ errs = validate.Field(1, "alphanum")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "alphanum")
+}
+
+func TestAlpha(t *testing.T) {
+
+ s := "abcd"
+ errs := validate.Field(s, "alpha")
+ Equal(t, errs, nil)
+
+ s = "abc®"
+ errs = validate.Field(s, "alpha")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "alpha")
+
+ s = "abc÷"
+ errs = validate.Field(s, "alpha")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "alpha")
+
+ s = "abc1"
+ errs = validate.Field(s, "alpha")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "alpha")
+
+ errs = validate.Field(1, "alpha")
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "", "", "alpha")
+
+}
+
+func TestStructStringValidation(t *testing.T) {
+
+ tSuccess := &TestString{
+ Required: "Required",
+ Len: "length==10",
+ Min: "min=1",
+ Max: "1234567890",
+ MinMax: "12345",
+ Lt: "012345678",
+ Lte: "0123456789",
+ Gt: "01234567890",
+ Gte: "0123456789",
+ OmitEmpty: "",
+ Sub: &SubTest{
+ Test: "1",
+ },
+ SubIgnore: &SubTest{
+ Test: "",
+ },
+ Anonymous: struct {
+ A string `validate:"required"`
+ }{
+ A: "1",
+ },
+ Iface: &Impl{
+ F: "123",
+ },
+ }
+
+ errs := validate.Struct(tSuccess)
+ Equal(t, errs, nil)
+
+ tFail := &TestString{
+ Required: "",
+ Len: "",
+ Min: "",
+ Max: "12345678901",
+ MinMax: "",
+ Lt: "0123456789",
+ Lte: "01234567890",
+ Gt: "1",
+ Gte: "1",
+ OmitEmpty: "12345678901",
+ Sub: &SubTest{
+ Test: "",
+ },
+ Anonymous: struct {
+ A string `validate:"required"`
+ }{
+ A: "",
+ },
+ Iface: &Impl{
+ F: "12",
+ },
+ }
+
+ errs = validate.Struct(tFail)
+
+ // Assert Top Level
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 13)
+
+ // Assert Fields
+ AssertError(t, errs, "TestString.Required", "Required", "required")
+ AssertError(t, errs, "TestString.Len", "Len", "len")
+ AssertError(t, errs, "TestString.Min", "Min", "min")
+ AssertError(t, errs, "TestString.Max", "Max", "max")
+ AssertError(t, errs, "TestString.MinMax", "MinMax", "min")
+ AssertError(t, errs, "TestString.Lt", "Lt", "lt")
+ AssertError(t, errs, "TestString.Lte", "Lte", "lte")
+ AssertError(t, errs, "TestString.Gt", "Gt", "gt")
+ AssertError(t, errs, "TestString.Gte", "Gte", "gte")
+ AssertError(t, errs, "TestString.OmitEmpty", "OmitEmpty", "max")
+
+ // Nested Struct Field Errs
+ AssertError(t, errs, "TestString.Anonymous.A", "A", "required")
+ AssertError(t, errs, "TestString.Sub.Test", "Test", "required")
+ AssertError(t, errs, "TestString.Iface.F", "F", "len")
+}
+
+func TestStructInt32Validation(t *testing.T) {
+
+ tSuccess := &TestInt32{
+ Required: 1,
+ Len: 10,
+ Min: 1,
+ Max: 10,
+ MinMax: 5,
+ Lt: 9,
+ Lte: 10,
+ Gt: 11,
+ Gte: 10,
+ OmitEmpty: 0,
+ }
+
+ errs := validate.Struct(tSuccess)
+ Equal(t, errs, nil)
+
+ tFail := &TestInt32{
+ Required: 0,
+ Len: 11,
+ Min: -1,
+ Max: 11,
+ MinMax: -1,
+ Lt: 10,
+ Lte: 11,
+ Gt: 10,
+ Gte: 9,
+ OmitEmpty: 11,
+ }
+
+ errs = validate.Struct(tFail)
+
+ // Assert Top Level
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 10)
+
+ // Assert Fields
+ AssertError(t, errs, "TestInt32.Required", "Required", "required")
+ AssertError(t, errs, "TestInt32.Len", "Len", "len")
+ AssertError(t, errs, "TestInt32.Min", "Min", "min")
+ AssertError(t, errs, "TestInt32.Max", "Max", "max")
+ AssertError(t, errs, "TestInt32.MinMax", "MinMax", "min")
+ AssertError(t, errs, "TestInt32.Lt", "Lt", "lt")
+ AssertError(t, errs, "TestInt32.Lte", "Lte", "lte")
+ AssertError(t, errs, "TestInt32.Gt", "Gt", "gt")
+ AssertError(t, errs, "TestInt32.Gte", "Gte", "gte")
+ AssertError(t, errs, "TestInt32.OmitEmpty", "OmitEmpty", "max")
+}
+
+func TestStructUint64Validation(t *testing.T) {
+
+ tSuccess := &TestUint64{
+ Required: 1,
+ Len: 10,
+ Min: 1,
+ Max: 10,
+ MinMax: 5,
+ OmitEmpty: 0,
+ }
+
+ errs := validate.Struct(tSuccess)
+ Equal(t, errs, nil)
+
+ tFail := &TestUint64{
+ Required: 0,
+ Len: 11,
+ Min: 0,
+ Max: 11,
+ MinMax: 0,
+ OmitEmpty: 11,
+ }
+
+ errs = validate.Struct(tFail)
+
+ // Assert Top Level
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 6)
+
+ // Assert Fields
+ AssertError(t, errs, "TestUint64.Required", "Required", "required")
+ AssertError(t, errs, "TestUint64.Len", "Len", "len")
+ AssertError(t, errs, "TestUint64.Min", "Min", "min")
+ AssertError(t, errs, "TestUint64.Max", "Max", "max")
+ AssertError(t, errs, "TestUint64.MinMax", "MinMax", "min")
+ AssertError(t, errs, "TestUint64.OmitEmpty", "OmitEmpty", "max")
+}
+
+func TestStructFloat64Validation(t *testing.T) {
+
+ tSuccess := &TestFloat64{
+ Required: 1,
+ Len: 10,
+ Min: 1,
+ Max: 10,
+ MinMax: 5,
+ OmitEmpty: 0,
+ }
+
+ errs := validate.Struct(tSuccess)
+ Equal(t, errs, nil)
+
+ tFail := &TestFloat64{
+ Required: 0,
+ Len: 11,
+ Min: 0,
+ Max: 11,
+ MinMax: 0,
+ OmitEmpty: 11,
+ }
+
+ errs = validate.Struct(tFail)
+
+ // Assert Top Level
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 6)
+
+ // Assert Fields
+ AssertError(t, errs, "TestFloat64.Required", "Required", "required")
+ AssertError(t, errs, "TestFloat64.Len", "Len", "len")
+ AssertError(t, errs, "TestFloat64.Min", "Min", "min")
+ AssertError(t, errs, "TestFloat64.Max", "Max", "max")
+ AssertError(t, errs, "TestFloat64.MinMax", "MinMax", "min")
+ AssertError(t, errs, "TestFloat64.OmitEmpty", "OmitEmpty", "max")
+}
+
+func TestStructSliceValidation(t *testing.T) {
+
+ tSuccess := &TestSlice{
+ Required: []int{1},
+ Len: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
+ Min: []int{1, 2},
+ Max: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
+ MinMax: []int{1, 2, 3, 4, 5},
+ OmitEmpty: nil,
+ }
+
+ errs := validate.Struct(tSuccess)
+ Equal(t, errs, nil)
+
+ tFail := &TestSlice{
+ Required: nil,
+ Len: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
+ Min: []int{},
+ Max: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
+ MinMax: []int{},
+ OmitEmpty: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
+ }
+
+ errs = validate.Struct(tFail)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs.(ValidationErrors)), 6)
+
+ // Assert Field Errors
+ AssertError(t, errs, "TestSlice.Required", "Required", "required")
+ AssertError(t, errs, "TestSlice.Len", "Len", "len")
+ AssertError(t, errs, "TestSlice.Min", "Min", "min")
+ AssertError(t, errs, "TestSlice.Max", "Max", "max")
+ AssertError(t, errs, "TestSlice.MinMax", "MinMax", "min")
+ AssertError(t, errs, "TestSlice.OmitEmpty", "OmitEmpty", "max")
+}
+
+func TestInvalidStruct(t *testing.T) {
+ s := &SubTest{
+ Test: "1",
+ }
+
+ PanicMatches(t, func() { validate.Struct(s.Test) }, "value passed for validation is not a struct")
+}
+
+func TestInvalidValidatorFunction(t *testing.T) {
+ s := &SubTest{
+ Test: "1",
+ }
+
+ PanicMatches(t, func() { validate.Field(s.Test, "zzxxBadFunction") }, "Undefined validation function on field")
+}
+
+func TestCustomFieldName(t *testing.T) {
+ type A struct {
+ B string `schema:"b" validate:"required"`
+ C string `schema:"c" validate:"required"`
+ D []bool `schema:"d" validate:"required"`
+ E string `schema:"-" validate:"required"`
+ }
+
+ a := &A{}
+
+ errs := New(&Config{TagName: "validate", FieldNameTag: "schema"}).Struct(a).(ValidationErrors)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs), 4)
+ Equal(t, errs["A.B"].Name, "b")
+ Equal(t, errs["A.C"].Name, "c")
+ Equal(t, errs["A.D"].Name, "d")
+ Equal(t, errs["A.E"].Name, "E")
+
+ errs = New(&Config{TagName: "validate"}).Struct(a).(ValidationErrors)
+ NotEqual(t, errs, nil)
+ Equal(t, len(errs), 4)
+ Equal(t, errs["A.B"].Name, "B")
+ Equal(t, errs["A.C"].Name, "C")
+ Equal(t, errs["A.D"].Name, "D")
+ Equal(t, errs["A.E"].Name, "E")
+}
+
+func TestMutipleRecursiveExtractStructCache(t *testing.T) {
+
+ type Recursive struct {
+ Field *string `validate:"exists,required,len=5,ne=string"`
+ }
+
+ var test Recursive
+
+ current := reflect.ValueOf(test)
+ name := "Recursive"
+ proceed := make(chan struct{})
+
+ sc := validate.extractStructCache(current, name)
+ ptr := fmt.Sprintf("%p", sc)
+
+ for i := 0; i < 100; i++ {
+
+ go func() {
+ <-proceed
+ sc := validate.extractStructCache(current, name)
+ Equal(t, ptr, fmt.Sprintf("%p", sc))
+ }()
+ }
+
+ close(proceed)
+}
+
+// Thanks @robbrockbank, see https://github.com/go-playground/validator/issues/249
+func TestPointerAndOmitEmpty(t *testing.T) {
+
+ type Test struct {
+ MyInt *int `validate:"omitempty,gte=2,lte=255"`
+ }
+
+ val1 := 0
+ val2 := 256
+
+ t1 := Test{MyInt: &val1} // This should fail validation on gte because value is 0
+ t2 := Test{MyInt: &val2} // This should fail validate on lte because value is 256
+ t3 := Test{MyInt: nil} // This should succeed validation because pointer is nil
+
+ errs := validate.Struct(t1)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.MyInt", "MyInt", "gte")
+
+ errs = validate.Struct(t2)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "Test.MyInt", "MyInt", "lte")
+
+ errs = validate.Struct(t3)
+ Equal(t, errs, nil)
+
+ type TestIface struct {
+ MyInt interface{} `validate:"omitempty,gte=2,lte=255"`
+ }
+
+ ti1 := TestIface{MyInt: &val1} // This should fail validation on gte because value is 0
+ ti2 := TestIface{MyInt: &val2} // This should fail validate on lte because value is 256
+ ti3 := TestIface{MyInt: nil} // This should succeed validation because pointer is nil
+
+ errs = validate.Struct(ti1)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestIface.MyInt", "MyInt", "gte")
+
+ errs = validate.Struct(ti2)
+ NotEqual(t, errs, nil)
+ AssertError(t, errs, "TestIface.MyInt", "MyInt", "lte")
+
+ errs = validate.Struct(ti3)
+ Equal(t, errs, nil)
+}
diff --git a/vendor/gopkg.in/yaml.v2/.travis.yml b/vendor/gopkg.in/yaml.v2/.travis.yml
new file mode 100644
index 000000000..004172a2e
--- /dev/null
+++ b/vendor/gopkg.in/yaml.v2/.travis.yml
@@ -0,0 +1,9 @@
+language: go
+
+go:
+ - 1.4
+ - 1.5
+ - 1.6
+ - tip
+
+go_import_path: gopkg.in/yaml.v2
diff --git a/vendor/gopkg.in/yaml.v2/LICENSE b/vendor/gopkg.in/yaml.v2/LICENSE
new file mode 100644
index 000000000..8dada3eda
--- /dev/null
+++ b/vendor/gopkg.in/yaml.v2/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "{}"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright {yyyy} {name of copyright owner}
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/vendor/gopkg.in/yaml.v2/LICENSE.libyaml b/vendor/gopkg.in/yaml.v2/LICENSE.libyaml
new file mode 100644
index 000000000..8da58fbf6
--- /dev/null
+++ b/vendor/gopkg.in/yaml.v2/LICENSE.libyaml
@@ -0,0 +1,31 @@
+The following files were ported to Go from C files of libyaml, and thus
+are still covered by their original copyright and license:
+
+ apic.go
+ emitterc.go
+ parserc.go
+ readerc.go
+ scannerc.go
+ writerc.go
+ yamlh.go
+ yamlprivateh.go
+
+Copyright (c) 2006 Kirill Simonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/gopkg.in/yaml.v2/README.md b/vendor/gopkg.in/yaml.v2/README.md
new file mode 100644
index 000000000..7a512d67c
--- /dev/null
+++ b/vendor/gopkg.in/yaml.v2/README.md
@@ -0,0 +1,133 @@
+# YAML support for the Go language
+
+Introduction
+------------
+
+The yaml package enables Go programs to comfortably encode and decode YAML
+values. It was developed within [Canonical](https://www.canonical.com) as
+part of the [juju](https://juju.ubuntu.com) project, and is based on a
+pure Go port of the well-known [libyaml](http://pyyaml.org/wiki/LibYAML)
+C library to parse and generate YAML data quickly and reliably.
+
+Compatibility
+-------------
+
+The yaml package supports most of YAML 1.1 and 1.2, including support for
+anchors, tags, map merging, etc. Multi-document unmarshalling is not yet
+implemented, and base-60 floats from YAML 1.1 are purposefully not
+supported since they're a poor design and are gone in YAML 1.2.
+
+Installation and usage
+----------------------
+
+The import path for the package is *gopkg.in/yaml.v2*.
+
+To install it, run:
+
+ go get gopkg.in/yaml.v2
+
+API documentation
+-----------------
+
+If opened in a browser, the import path itself leads to the API documentation:
+
+ * [https://gopkg.in/yaml.v2](https://gopkg.in/yaml.v2)
+
+API stability
+-------------
+
+The package API for yaml v2 will remain stable as described in [gopkg.in](https://gopkg.in).
+
+
+License
+-------
+
+The yaml package is licensed under the Apache License 2.0. Please see the LICENSE file for details.
+
+
+Example
+-------
+
+Some more examples can be found in the "examples" folder.
+
+```Go
+package main
+
+import (
+ "fmt"
+ "log"
+
+ "gopkg.in/yaml.v2"
+)
+
+var data = `
+a: Easy!
+b:
+ c: 2
+ d: [3, 4]
+`
+
+type T struct {
+ A string
+ B struct {
+ RenamedC int `yaml:"c"`
+ D []int `yaml:",flow"`
+ }
+}
+
+func main() {
+ t := T{}
+
+ err := yaml.Unmarshal([]byte(data), &t)
+ if err != nil {
+ log.Fatalf("error: %v", err)
+ }
+ fmt.Printf("--- t:\n%v\n\n", t)
+
+ d, err := yaml.Marshal(&t)
+ if err != nil {
+ log.Fatalf("error: %v", err)
+ }
+ fmt.Printf("--- t dump:\n%s\n\n", string(d))
+
+ m := make(map[interface{}]interface{})
+
+ err = yaml.Unmarshal([]byte(data), &m)
+ if err != nil {
+ log.Fatalf("error: %v", err)
+ }
+ fmt.Printf("--- m:\n%v\n\n", m)
+
+ d, err = yaml.Marshal(&m)
+ if err != nil {
+ log.Fatalf("error: %v", err)
+ }
+ fmt.Printf("--- m dump:\n%s\n\n", string(d))
+}
+```
+
+This example will generate the following output:
+
+```
+--- t:
+{Easy! {2 [3 4]}}
+
+--- t dump:
+a: Easy!
+b:
+ c: 2
+ d: [3, 4]
+
+
+--- m:
+map[a:Easy! b:map[c:2 d:[3 4]]]
+
+--- m dump:
+a: Easy!
+b:
+ c: 2
+ d:
+ - 3
+ - 4
+```
+
diff --git a/vendor/gopkg.in/yaml.v2/apic.go b/vendor/gopkg.in/yaml.v2/apic.go
new file mode 100644
index 000000000..95ec014e8
--- /dev/null
+++ b/vendor/gopkg.in/yaml.v2/apic.go
@@ -0,0 +1,742 @@
+package yaml
+
+import (
+ "io"
+ "os"
+)
+
+func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) {
+ //fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens))
+
+ // Check if we can move the queue at the beginning of the buffer.
+ if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) {
+ if parser.tokens_head != len(parser.tokens) {
+ copy(parser.tokens, parser.tokens[parser.tokens_head:])
+ }
+ parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head]
+ parser.tokens_head = 0
+ }
+ parser.tokens = append(parser.tokens, *token)
+ if pos < 0 {
+ return
+ }
+ copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:])
+ parser.tokens[parser.tokens_head+pos] = *token
+}
+
+// Create a new parser object.
+func yaml_parser_initialize(parser *yaml_parser_t) bool {
+ *parser = yaml_parser_t{
+ raw_buffer: make([]byte, 0, input_raw_buffer_size),
+ buffer: make([]byte, 0, input_buffer_size),
+ }
+ return true
+}
+
+// Destroy a parser object.
+func yaml_parser_delete(parser *yaml_parser_t) {
+ *parser = yaml_parser_t{}
+}
+
+// String read handler.
+func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
+ if parser.input_pos == len(parser.input) {
+ return 0, io.EOF
+ }
+ n = copy(buffer, parser.input[parser.input_pos:])
+ parser.input_pos += n
+ return n, nil
+}
+
+// File read handler.
+func yaml_file_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
+ return parser.input_file.Read(buffer)
+}
+
+// Set a string input.
+func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) {
+ if parser.read_handler != nil {
+ panic("must set the input source only once")
+ }
+ parser.read_handler = yaml_string_read_handler
+ parser.input = input
+ parser.input_pos = 0
+}
+
+// Set a file input.
+func yaml_parser_set_input_file(parser *yaml_parser_t, file *os.File) {
+ if parser.read_handler != nil {
+ panic("must set the input source only once")
+ }
+ parser.read_handler = yaml_file_read_handler
+ parser.input_file = file
+}
+
+// Set the source encoding.
+func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) {
+ if parser.encoding != yaml_ANY_ENCODING {
+ panic("must set the encoding only once")
+ }
+ parser.encoding = encoding
+}
+
+// Create a new emitter object.
+func yaml_emitter_initialize(emitter *yaml_emitter_t) bool {
+ *emitter = yaml_emitter_t{
+ buffer: make([]byte, output_buffer_size),
+ raw_buffer: make([]byte, 0, output_raw_buffer_size),
+ states: make([]yaml_emitter_state_t, 0, initial_stack_size),
+ events: make([]yaml_event_t, 0, initial_queue_size),
+ }
+ return true
+}
+
+// Destroy an emitter object.
+func yaml_emitter_delete(emitter *yaml_emitter_t) {
+ *emitter = yaml_emitter_t{}
+}
+
+// String write handler.
+func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
+ *emitter.output_buffer = append(*emitter.output_buffer, buffer...)
+ return nil
+}
+
+// File write handler.
+func yaml_file_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
+ _, err := emitter.output_file.Write(buffer)
+ return err
+}
+
+// Set a string output.
+func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) {
+ if emitter.write_handler != nil {
+ panic("must set the output target only once")
+ }
+ emitter.write_handler = yaml_string_write_handler
+ emitter.output_buffer = output_buffer
+}
+
+// Set a file output.
+func yaml_emitter_set_output_file(emitter *yaml_emitter_t, file io.Writer) {
+ if emitter.write_handler != nil {
+ panic("must set the output target only once")
+ }
+ emitter.write_handler = yaml_file_write_handler
+ emitter.output_file = file
+}
+
+// Set the output encoding.
+func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) {
+ if emitter.encoding != yaml_ANY_ENCODING {
+ panic("must set the output encoding only once")
+ }
+ emitter.encoding = encoding
+}
+
+// Set the canonical output style.
+func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) {
+ emitter.canonical = canonical
+}
+
+//// Set the indentation increment.
+func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {
+ if indent < 2 || indent > 9 {
+ indent = 2
+ }
+ emitter.best_indent = indent
+}
+
+// Set the preferred line width.
+func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) {
+ if width < 0 {
+ width = -1
+ }
+ emitter.best_width = width
+}
+
+// Set if unescaped non-ASCII characters are allowed.
+func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) {
+ emitter.unicode = unicode
+}
+
+// Set the preferred line break character.
+func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) {
+ emitter.line_break = line_break
+}
+
+///*
+// * Destroy a token object.
+// */
+//
+//YAML_DECLARE(void)
+//yaml_token_delete(yaml_token_t *token)
+//{
+// assert(token); // Non-NULL token object expected.
+//
+// switch (token.type)
+// {
+// case YAML_TAG_DIRECTIVE_TOKEN:
+// yaml_free(token.data.tag_directive.handle);
+// yaml_free(token.data.tag_directive.prefix);
+// break;
+//
+// case YAML_ALIAS_TOKEN:
+// yaml_free(token.data.alias.value);
+// break;
+//
+// case YAML_ANCHOR_TOKEN:
+// yaml_free(token.data.anchor.value);
+// break;
+//
+// case YAML_TAG_TOKEN:
+// yaml_free(token.data.tag.handle);
+// yaml_free(token.data.tag.suffix);
+// break;
+//
+// case YAML_SCALAR_TOKEN:
+// yaml_free(token.data.scalar.value);
+// break;
+//
+// default:
+// break;
+// }
+//
+// memset(token, 0, sizeof(yaml_token_t));
+//}
+//
+///*
+// * Check if a string is a valid UTF-8 sequence.
+// *
+// * Check 'reader.c' for more details on UTF-8 encoding.
+// */
+//
+//static int
+//yaml_check_utf8(yaml_char_t *start, size_t length)
+//{
+// yaml_char_t *end = start+length;
+// yaml_char_t *pointer = start;
+//
+// while (pointer < end) {
+// unsigned char octet;
+// unsigned int width;
+// unsigned int value;
+// size_t k;
+//
+// octet = pointer[0];
+// width = (octet & 0x80) == 0x00 ? 1 :
+// (octet & 0xE0) == 0xC0 ? 2 :
+// (octet & 0xF0) == 0xE0 ? 3 :
+// (octet & 0xF8) == 0xF0 ? 4 : 0;
+// value = (octet & 0x80) == 0x00 ? octet & 0x7F :
+// (octet & 0xE0) == 0xC0 ? octet & 0x1F :
+// (octet & 0xF0) == 0xE0 ? octet & 0x0F :
+// (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
+// if (!width) return 0;
+// if (pointer+width > end) return 0;
+// for (k = 1; k < width; k ++) {
+// octet = pointer[k];
+// if ((octet & 0xC0) != 0x80) return 0;
+// value = (value << 6) + (octet & 0x3F);
+// }
+// if (!((width == 1) ||
+// (width == 2 && value >= 0x80) ||
+// (width == 3 && value >= 0x800) ||
+// (width == 4 && value >= 0x10000))) return 0;
+//
+// pointer += width;
+// }
+//
+// return 1;
+//}
+//
+
+// Create STREAM-START.
+func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_STREAM_START_EVENT,
+ encoding: encoding,
+ }
+ return true
+}
+
+// Create STREAM-END.
+func yaml_stream_end_event_initialize(event *yaml_event_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_STREAM_END_EVENT,
+ }
+ return true
+}
+
+// Create DOCUMENT-START.
+func yaml_document_start_event_initialize(event *yaml_event_t, version_directive *yaml_version_directive_t,
+ tag_directives []yaml_tag_directive_t, implicit bool) bool {
+ *event = yaml_event_t{
+ typ: yaml_DOCUMENT_START_EVENT,
+ version_directive: version_directive,
+ tag_directives: tag_directives,
+ implicit: implicit,
+ }
+ return true
+}
+
+// Create DOCUMENT-END.
+func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) bool {
+ *event = yaml_event_t{
+ typ: yaml_DOCUMENT_END_EVENT,
+ implicit: implicit,
+ }
+ return true
+}
+
+///*
+// * Create ALIAS.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_alias_event_initialize(event *yaml_event_t, anchor *yaml_char_t)
+//{
+// mark yaml_mark_t = { 0, 0, 0 }
+// anchor_copy *yaml_char_t = NULL
+//
+// assert(event) // Non-NULL event object is expected.
+// assert(anchor) // Non-NULL anchor is expected.
+//
+// if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0
+//
+// anchor_copy = yaml_strdup(anchor)
+// if (!anchor_copy)
+// return 0
+//
+// ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark)
+//
+// return 1
+//}
+
+// Create SCALAR.
+func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_SCALAR_EVENT,
+ anchor: anchor,
+ tag: tag,
+ value: value,
+ implicit: plain_implicit,
+ quoted_implicit: quoted_implicit,
+ style: yaml_style_t(style),
+ }
+ return true
+}
+
+// Create SEQUENCE-START.
+func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_START_EVENT,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(style),
+ }
+ return true
+}
+
+// Create SEQUENCE-END.
+func yaml_sequence_end_event_initialize(event *yaml_event_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_END_EVENT,
+ }
+ return true
+}
+
+// Create MAPPING-START.
+func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_START_EVENT,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(style),
+ }
+ return true
+}
+
+// Create MAPPING-END.
+func yaml_mapping_end_event_initialize(event *yaml_event_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_END_EVENT,
+ }
+ return true
+}
+
+// Destroy an event object.
+func yaml_event_delete(event *yaml_event_t) {
+ *event = yaml_event_t{}
+}
+
+///*
+// * Create a document object.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_initialize(document *yaml_document_t,
+// version_directive *yaml_version_directive_t,
+// tag_directives_start *yaml_tag_directive_t,
+// tag_directives_end *yaml_tag_directive_t,
+// start_implicit int, end_implicit int)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// struct {
+// start *yaml_node_t
+// end *yaml_node_t
+// top *yaml_node_t
+// } nodes = { NULL, NULL, NULL }
+// version_directive_copy *yaml_version_directive_t = NULL
+// struct {
+// start *yaml_tag_directive_t
+// end *yaml_tag_directive_t
+// top *yaml_tag_directive_t
+// } tag_directives_copy = { NULL, NULL, NULL }
+// value yaml_tag_directive_t = { NULL, NULL }
+// mark yaml_mark_t = { 0, 0, 0 }
+//
+// assert(document) // Non-NULL document object is expected.
+// assert((tag_directives_start && tag_directives_end) ||
+// (tag_directives_start == tag_directives_end))
+// // Valid tag directives are expected.
+//
+// if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error
+//
+// if (version_directive) {
+// version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t))
+// if (!version_directive_copy) goto error
+// version_directive_copy.major = version_directive.major
+// version_directive_copy.minor = version_directive.minor
+// }
+//
+// if (tag_directives_start != tag_directives_end) {
+// tag_directive *yaml_tag_directive_t
+// if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
+// goto error
+// for (tag_directive = tag_directives_start
+// tag_directive != tag_directives_end; tag_directive ++) {
+// assert(tag_directive.handle)
+// assert(tag_directive.prefix)
+// if (!yaml_check_utf8(tag_directive.handle,
+// strlen((char *)tag_directive.handle)))
+// goto error
+// if (!yaml_check_utf8(tag_directive.prefix,
+// strlen((char *)tag_directive.prefix)))
+// goto error
+// value.handle = yaml_strdup(tag_directive.handle)
+// value.prefix = yaml_strdup(tag_directive.prefix)
+// if (!value.handle || !value.prefix) goto error
+// if (!PUSH(&context, tag_directives_copy, value))
+// goto error
+// value.handle = NULL
+// value.prefix = NULL
+// }
+// }
+//
+// DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
+// tag_directives_copy.start, tag_directives_copy.top,
+// start_implicit, end_implicit, mark, mark)
+//
+// return 1
+//
+//error:
+// STACK_DEL(&context, nodes)
+// yaml_free(version_directive_copy)
+// while (!STACK_EMPTY(&context, tag_directives_copy)) {
+// value yaml_tag_directive_t = POP(&context, tag_directives_copy)
+// yaml_free(value.handle)
+// yaml_free(value.prefix)
+// }
+// STACK_DEL(&context, tag_directives_copy)
+// yaml_free(value.handle)
+// yaml_free(value.prefix)
+//
+// return 0
+//}
+//
+///*
+// * Destroy a document object.
+// */
+//
+//YAML_DECLARE(void)
+//yaml_document_delete(document *yaml_document_t)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// tag_directive *yaml_tag_directive_t
+//
+// context.error = YAML_NO_ERROR // Eliminate a compliler warning.
+//
+// assert(document) // Non-NULL document object is expected.
+//
+// while (!STACK_EMPTY(&context, document.nodes)) {
+// node yaml_node_t = POP(&context, document.nodes)
+// yaml_free(node.tag)
+// switch (node.type) {
+// case YAML_SCALAR_NODE:
+// yaml_free(node.data.scalar.value)
+// break
+// case YAML_SEQUENCE_NODE:
+// STACK_DEL(&context, node.data.sequence.items)
+// break
+// case YAML_MAPPING_NODE:
+// STACK_DEL(&context, node.data.mapping.pairs)
+// break
+// default:
+// assert(0) // Should not happen.
+// }
+// }
+// STACK_DEL(&context, document.nodes)
+//
+// yaml_free(document.version_directive)
+// for (tag_directive = document.tag_directives.start
+// tag_directive != document.tag_directives.end
+// tag_directive++) {
+// yaml_free(tag_directive.handle)
+// yaml_free(tag_directive.prefix)
+// }
+// yaml_free(document.tag_directives.start)
+//
+// memset(document, 0, sizeof(yaml_document_t))
+//}
+//
+///**
+// * Get a document node.
+// */
+//
+//YAML_DECLARE(yaml_node_t *)
+//yaml_document_get_node(document *yaml_document_t, index int)
+//{
+// assert(document) // Non-NULL document object is expected.
+//
+// if (index > 0 && document.nodes.start + index <= document.nodes.top) {
+// return document.nodes.start + index - 1
+// }
+// return NULL
+//}
+//
+///**
+// * Get the root object.
+// */
+//
+//YAML_DECLARE(yaml_node_t *)
+//yaml_document_get_root_node(document *yaml_document_t)
+//{
+// assert(document) // Non-NULL document object is expected.
+//
+// if (document.nodes.top != document.nodes.start) {
+// return document.nodes.start
+// }
+// return NULL
+//}
+//
+///*
+// * Add a scalar node to a document.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_add_scalar(document *yaml_document_t,
+// tag *yaml_char_t, value *yaml_char_t, length int,
+// style yaml_scalar_style_t)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// mark yaml_mark_t = { 0, 0, 0 }
+// tag_copy *yaml_char_t = NULL
+// value_copy *yaml_char_t = NULL
+// node yaml_node_t
+//
+// assert(document) // Non-NULL document object is expected.
+// assert(value) // Non-NULL value is expected.
+//
+// if (!tag) {
+// tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG
+// }
+//
+// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
+// tag_copy = yaml_strdup(tag)
+// if (!tag_copy) goto error
+//
+// if (length < 0) {
+// length = strlen((char *)value)
+// }
+//
+// if (!yaml_check_utf8(value, length)) goto error
+// value_copy = yaml_malloc(length+1)
+// if (!value_copy) goto error
+// memcpy(value_copy, value, length)
+// value_copy[length] = '\0'
+//
+// SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark)
+// if (!PUSH(&context, document.nodes, node)) goto error
+//
+// return document.nodes.top - document.nodes.start
+//
+//error:
+// yaml_free(tag_copy)
+// yaml_free(value_copy)
+//
+// return 0
+//}
+//
+///*
+// * Add a sequence node to a document.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_add_sequence(document *yaml_document_t,
+// tag *yaml_char_t, style yaml_sequence_style_t)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// mark yaml_mark_t = { 0, 0, 0 }
+// tag_copy *yaml_char_t = NULL
+// struct {
+// start *yaml_node_item_t
+// end *yaml_node_item_t
+// top *yaml_node_item_t
+// } items = { NULL, NULL, NULL }
+// node yaml_node_t
+//
+// assert(document) // Non-NULL document object is expected.
+//
+// if (!tag) {
+// tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG
+// }
+//
+// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
+// tag_copy = yaml_strdup(tag)
+// if (!tag_copy) goto error
+//
+// if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error
+//
+// SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
+// style, mark, mark)
+// if (!PUSH(&context, document.nodes, node)) goto error
+//
+// return document.nodes.top - document.nodes.start
+//
+//error:
+// STACK_DEL(&context, items)
+// yaml_free(tag_copy)
+//
+// return 0
+//}
+//
+///*
+// * Add a mapping node to a document.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_add_mapping(document *yaml_document_t,
+// tag *yaml_char_t, style yaml_mapping_style_t)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// mark yaml_mark_t = { 0, 0, 0 }
+// tag_copy *yaml_char_t = NULL
+// struct {
+// start *yaml_node_pair_t
+// end *yaml_node_pair_t
+// top *yaml_node_pair_t
+// } pairs = { NULL, NULL, NULL }
+// node yaml_node_t
+//
+// assert(document) // Non-NULL document object is expected.
+//
+// if (!tag) {
+// tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG
+// }
+//
+// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
+// tag_copy = yaml_strdup(tag)
+// if (!tag_copy) goto error
+//
+// if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error
+//
+// MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
+// style, mark, mark)
+// if (!PUSH(&context, document.nodes, node)) goto error
+//
+// return document.nodes.top - document.nodes.start
+//
+//error:
+// STACK_DEL(&context, pairs)
+// yaml_free(tag_copy)
+//
+// return 0
+//}
+//
+///*
+// * Append an item to a sequence node.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_append_sequence_item(document *yaml_document_t,
+// sequence int, item int)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+//
+// assert(document) // Non-NULL document is required.
+// assert(sequence > 0
+// && document.nodes.start + sequence <= document.nodes.top)
+// // Valid sequence id is required.
+// assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE)
+// // A sequence node is required.
+// assert(item > 0 && document.nodes.start + item <= document.nodes.top)
+// // Valid item id is required.
+//
+// if (!PUSH(&context,
+// document.nodes.start[sequence-1].data.sequence.items, item))
+// return 0
+//
+// return 1
+//}
+//
+///*
+// * Append a pair of a key and a value to a mapping node.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_append_mapping_pair(document *yaml_document_t,
+// mapping int, key int, value int)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+//
+// pair yaml_node_pair_t
+//
+// assert(document) // Non-NULL document is required.
+// assert(mapping > 0
+// && document.nodes.start + mapping <= document.nodes.top)
+// // Valid mapping id is required.
+// assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE)
+// // A mapping node is required.
+// assert(key > 0 && document.nodes.start + key <= document.nodes.top)
+// // Valid key id is required.
+// assert(value > 0 && document.nodes.start + value <= document.nodes.top)
+// // Valid value id is required.
+//
+// pair.key = key
+// pair.value = value
+//
+// if (!PUSH(&context,
+// document.nodes.start[mapping-1].data.mapping.pairs, pair))
+// return 0
+//
+// return 1
+//}
+//
+//
diff --git a/vendor/gopkg.in/yaml.v2/decode.go b/vendor/gopkg.in/yaml.v2/decode.go
new file mode 100644
index 000000000..db1f5f206
--- /dev/null
+++ b/vendor/gopkg.in/yaml.v2/decode.go
@@ -0,0 +1,685 @@
+package yaml
+
+import (
+ "encoding"
+ "encoding/base64"
+ "fmt"
+ "math"
+ "reflect"
+ "strconv"
+ "time"
+)
+
+const (
+ documentNode = 1 << iota
+ mappingNode
+ sequenceNode
+ scalarNode
+ aliasNode
+)
+
+type node struct {
+ kind int
+ line, column int
+ tag string
+ value string
+ implicit bool
+ children []*node
+ anchors map[string]*node
+}
+
+// ----------------------------------------------------------------------------
+// Parser, produces a node tree out of a libyaml event stream.
+
+type parser struct {
+ parser yaml_parser_t
+ event yaml_event_t
+ doc *node
+}
+
+func newParser(b []byte) *parser {
+ p := parser{}
+ if !yaml_parser_initialize(&p.parser) {
+ panic("failed to initialize YAML emitter")
+ }
+
+ if len(b) == 0 {
+ b = []byte{'\n'}
+ }
+
+ yaml_parser_set_input_string(&p.parser, b)
+
+ p.skip()
+ if p.event.typ != yaml_STREAM_START_EVENT {
+ panic("expected stream start event, got " + strconv.Itoa(int(p.event.typ)))
+ }
+ p.skip()
+ return &p
+}
+
+func (p *parser) destroy() {
+ if p.event.typ != yaml_NO_EVENT {
+ yaml_event_delete(&p.event)
+ }
+ yaml_parser_delete(&p.parser)
+}
+
+func (p *parser) skip() {
+ if p.event.typ != yaml_NO_EVENT {
+ if p.event.typ == yaml_STREAM_END_EVENT {
+ failf("attempted to go past the end of stream; corrupted value?")
+ }
+ yaml_event_delete(&p.event)
+ }
+ if !yaml_parser_parse(&p.parser, &p.event) {
+ p.fail()
+ }
+}
+
+func (p *parser) fail() {
+ var where string
+ var line int
+ if p.parser.problem_mark.line != 0 {
+ line = p.parser.problem_mark.line
+ } else if p.parser.context_mark.line != 0 {
+ line = p.parser.context_mark.line
+ }
+ if line != 0 {
+ where = "line " + strconv.Itoa(line) + ": "
+ }
+ var msg string
+ if len(p.parser.problem) > 0 {
+ msg = p.parser.problem
+ } else {
+ msg = "unknown problem parsing YAML content"
+ }
+ failf("%s%s", where, msg)
+}
+
+func (p *parser) anchor(n *node, anchor []byte) {
+ if anchor != nil {
+ p.doc.anchors[string(anchor)] = n
+ }
+}
+
+func (p *parser) parse() *node {
+ switch p.event.typ {
+ case yaml_SCALAR_EVENT:
+ return p.scalar()
+ case yaml_ALIAS_EVENT:
+ return p.alias()
+ case yaml_MAPPING_START_EVENT:
+ return p.mapping()
+ case yaml_SEQUENCE_START_EVENT:
+ return p.sequence()
+ case yaml_DOCUMENT_START_EVENT:
+ return p.document()
+ case yaml_STREAM_END_EVENT:
+ // Happens when attempting to decode an empty buffer.
+ return nil
+ default:
+ panic("attempted to parse unknown event: " + strconv.Itoa(int(p.event.typ)))
+ }
+}
+
+func (p *parser) node(kind int) *node {
+ return &node{
+ kind: kind,
+ line: p.event.start_mark.line,
+ column: p.event.start_mark.column,
+ }
+}
+
+func (p *parser) document() *node {
+ n := p.node(documentNode)
+ n.anchors = make(map[string]*node)
+ p.doc = n
+ p.skip()
+ n.children = append(n.children, p.parse())
+ if p.event.typ != yaml_DOCUMENT_END_EVENT {
+ panic("expected end of document event but got " + strconv.Itoa(int(p.event.typ)))
+ }
+ p.skip()
+ return n
+}
+
+func (p *parser) alias() *node {
+ n := p.node(aliasNode)
+ n.value = string(p.event.anchor)
+ p.skip()
+ return n
+}
+
+func (p *parser) scalar() *node {
+ n := p.node(scalarNode)
+ n.value = string(p.event.value)
+ n.tag = string(p.event.tag)
+ n.implicit = p.event.implicit
+ p.anchor(n, p.event.anchor)
+ p.skip()
+ return n
+}
+
+func (p *parser) sequence() *node {
+ n := p.node(sequenceNode)
+ p.anchor(n, p.event.anchor)
+ p.skip()
+ for p.event.typ != yaml_SEQUENCE_END_EVENT {
+ n.children = append(n.children, p.parse())
+ }
+ p.skip()
+ return n
+}
+
+func (p *parser) mapping() *node {
+ n := p.node(mappingNode)
+ p.anchor(n, p.event.anchor)
+ p.skip()
+ for p.event.typ != yaml_MAPPING_END_EVENT {
+ n.children = append(n.children, p.parse(), p.parse())
+ }
+ p.skip()
+ return n
+}
+
+// ----------------------------------------------------------------------------
+// Decoder, unmarshals a node into a provided value.
+
+type decoder struct {
+ doc *node
+ aliases map[string]bool
+ mapType reflect.Type
+ terrors []string
+ strict bool
+}
+
+var (
+ mapItemType = reflect.TypeOf(MapItem{})
+ durationType = reflect.TypeOf(time.Duration(0))
+ defaultMapType = reflect.TypeOf(map[interface{}]interface{}{})
+ ifaceType = defaultMapType.Elem()
+)
+
+func newDecoder(strict bool) *decoder {
+ d := &decoder{mapType: defaultMapType, strict: strict}
+ d.aliases = make(map[string]bool)
+ return d
+}
+
+func (d *decoder) terror(n *node, tag string, out reflect.Value) {
+ if n.tag != "" {
+ tag = n.tag
+ }
+ value := n.value
+ if tag != yaml_SEQ_TAG && tag != yaml_MAP_TAG {
+ if len(value) > 10 {
+ value = " `" + value[:7] + "...`"
+ } else {
+ value = " `" + value + "`"
+ }
+ }
+ d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.line+1, shortTag(tag), value, out.Type()))
+}
+
+func (d *decoder) callUnmarshaler(n *node, u Unmarshaler) (good bool) {
+ terrlen := len(d.terrors)
+ err := u.UnmarshalYAML(func(v interface{}) (err error) {
+ defer handleErr(&err)
+ d.unmarshal(n, reflect.ValueOf(v))
+ if len(d.terrors) > terrlen {
+ issues := d.terrors[terrlen:]
+ d.terrors = d.terrors[:terrlen]
+ return &TypeError{issues}
+ }
+ return nil
+ })
+ if e, ok := err.(*TypeError); ok {
+ d.terrors = append(d.terrors, e.Errors...)
+ return false
+ }
+ if err != nil {
+ fail(err)
+ }
+ return true
+}
+
+// d.prepare initializes and dereferences pointers and calls UnmarshalYAML
+// if a value is found to implement it.
+// It returns the initialized and dereferenced out value, whether
+// unmarshalling was already done by UnmarshalYAML, and if so whether
+// its types unmarshalled appropriately.
+//
+// If n holds a null value, prepare returns before doing anything.
+func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) {
+ if n.tag == yaml_NULL_TAG || n.kind == scalarNode && n.tag == "" && (n.value == "null" || n.value == "" && n.implicit) {
+ return out, false, false
+ }
+ again := true
+ for again {
+ again = false
+ if out.Kind() == reflect.Ptr {
+ if out.IsNil() {
+ out.Set(reflect.New(out.Type().Elem()))
+ }
+ out = out.Elem()
+ again = true
+ }
+ if out.CanAddr() {
+ if u, ok := out.Addr().Interface().(Unmarshaler); ok {
+ good = d.callUnmarshaler(n, u)
+ return out, true, good
+ }
+ }
+ }
+ return out, false, false
+}
+
+func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) {
+ switch n.kind {
+ case documentNode:
+ return d.document(n, out)
+ case aliasNode:
+ return d.alias(n, out)
+ }
+ out, unmarshaled, good := d.prepare(n, out)
+ if unmarshaled {
+ return good
+ }
+ switch n.kind {
+ case scalarNode:
+ good = d.scalar(n, out)
+ case mappingNode:
+ good = d.mapping(n, out)
+ case sequenceNode:
+ good = d.sequence(n, out)
+ default:
+ panic("internal error: unknown node kind: " + strconv.Itoa(n.kind))
+ }
+ return good
+}
+
+func (d *decoder) document(n *node, out reflect.Value) (good bool) {
+ if len(n.children) == 1 {
+ d.doc = n
+ d.unmarshal(n.children[0], out)
+ return true
+ }
+ return false
+}
+
+func (d *decoder) alias(n *node, out reflect.Value) (good bool) {
+ an, ok := d.doc.anchors[n.value]
+ if !ok {
+ failf("unknown anchor '%s' referenced", n.value)
+ }
+ if d.aliases[n.value] {
+ failf("anchor '%s' value contains itself", n.value)
+ }
+ d.aliases[n.value] = true
+ good = d.unmarshal(an, out)
+ delete(d.aliases, n.value)
+ return good
+}
+
+var zeroValue reflect.Value
+
+func resetMap(out reflect.Value) {
+ for _, k := range out.MapKeys() {
+ out.SetMapIndex(k, zeroValue)
+ }
+}
+
+func (d *decoder) scalar(n *node, out reflect.Value) (good bool) {
+ var tag string
+ var resolved interface{}
+ if n.tag == "" && !n.implicit {
+ tag = yaml_STR_TAG
+ resolved = n.value
+ } else {
+ tag, resolved = resolve(n.tag, n.value)
+ if tag == yaml_BINARY_TAG {
+ data, err := base64.StdEncoding.DecodeString(resolved.(string))
+ if err != nil {
+ failf("!!binary value contains invalid base64 data")
+ }
+ resolved = string(data)
+ }
+ }
+ if resolved == nil {
+ if out.Kind() == reflect.Map && !out.CanAddr() {
+ resetMap(out)
+ } else {
+ out.Set(reflect.Zero(out.Type()))
+ }
+ return true
+ }
+ if s, ok := resolved.(string); ok && out.CanAddr() {
+ if u, ok := out.Addr().Interface().(encoding.TextUnmarshaler); ok {
+ err := u.UnmarshalText([]byte(s))
+ if err != nil {
+ fail(err)
+ }
+ return true
+ }
+ }
+ switch out.Kind() {
+ case reflect.String:
+ if tag == yaml_BINARY_TAG {
+ out.SetString(resolved.(string))
+ good = true
+ } else if resolved != nil {
+ out.SetString(n.value)
+ good = true
+ }
+ case reflect.Interface:
+ if resolved == nil {
+ out.Set(reflect.Zero(out.Type()))
+ } else {
+ out.Set(reflect.ValueOf(resolved))
+ }
+ good = true
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ switch resolved := resolved.(type) {
+ case int:
+ if !out.OverflowInt(int64(resolved)) {
+ out.SetInt(int64(resolved))
+ good = true
+ }
+ case int64:
+ if !out.OverflowInt(resolved) {
+ out.SetInt(resolved)
+ good = true
+ }
+ case uint64:
+ if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
+ out.SetInt(int64(resolved))
+ good = true
+ }
+ case float64:
+ if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
+ out.SetInt(int64(resolved))
+ good = true
+ }
+ case string:
+ if out.Type() == durationType {
+ d, err := time.ParseDuration(resolved)
+ if err == nil {
+ out.SetInt(int64(d))
+ good = true
+ }
+ }
+ }
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ switch resolved := resolved.(type) {
+ case int:
+ if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
+ out.SetUint(uint64(resolved))
+ good = true
+ }
+ case int64:
+ if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
+ out.SetUint(uint64(resolved))
+ good = true
+ }
+ case uint64:
+ if !out.OverflowUint(uint64(resolved)) {
+ out.SetUint(uint64(resolved))
+ good = true
+ }
+ case float64:
+ if resolved <= math.MaxUint64 && !out.OverflowUint(uint64(resolved)) {
+ out.SetUint(uint64(resolved))
+ good = true
+ }
+ }
+ case reflect.Bool:
+ switch resolved := resolved.(type) {
+ case bool:
+ out.SetBool(resolved)
+ good = true
+ }
+ case reflect.Float32, reflect.Float64:
+ switch resolved := resolved.(type) {
+ case int:
+ out.SetFloat(float64(resolved))
+ good = true
+ case int64:
+ out.SetFloat(float64(resolved))
+ good = true
+ case uint64:
+ out.SetFloat(float64(resolved))
+ good = true
+ case float64:
+ out.SetFloat(resolved)
+ good = true
+ }
+ case reflect.Ptr:
+ if out.Type().Elem() == reflect.TypeOf(resolved) {
+ // TODO DOes this make sense? When is out a Ptr except when decoding a nil value?
+ elem := reflect.New(out.Type().Elem())
+ elem.Elem().Set(reflect.ValueOf(resolved))
+ out.Set(elem)
+ good = true
+ }
+ }
+ if !good {
+ d.terror(n, tag, out)
+ }
+ return good
+}
+
+func settableValueOf(i interface{}) reflect.Value {
+ v := reflect.ValueOf(i)
+ sv := reflect.New(v.Type()).Elem()
+ sv.Set(v)
+ return sv
+}
+
+func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
+ l := len(n.children)
+
+ var iface reflect.Value
+ switch out.Kind() {
+ case reflect.Slice:
+ out.Set(reflect.MakeSlice(out.Type(), l, l))
+ case reflect.Interface:
+ // No type hints. Will have to use a generic sequence.
+ iface = out
+ out = settableValueOf(make([]interface{}, l))
+ default:
+ d.terror(n, yaml_SEQ_TAG, out)
+ return false
+ }
+ et := out.Type().Elem()
+
+ j := 0
+ for i := 0; i < l; i++ {
+ e := reflect.New(et).Elem()
+ if ok := d.unmarshal(n.children[i], e); ok {
+ out.Index(j).Set(e)
+ j++
+ }
+ }
+ out.Set(out.Slice(0, j))
+ if iface.IsValid() {
+ iface.Set(out)
+ }
+ return true
+}
+
+func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
+ switch out.Kind() {
+ case reflect.Struct:
+ return d.mappingStruct(n, out)
+ case reflect.Slice:
+ return d.mappingSlice(n, out)
+ case reflect.Map:
+ // okay
+ case reflect.Interface:
+ if d.mapType.Kind() == reflect.Map {
+ iface := out
+ out = reflect.MakeMap(d.mapType)
+ iface.Set(out)
+ } else {
+ slicev := reflect.New(d.mapType).Elem()
+ if !d.mappingSlice(n, slicev) {
+ return false
+ }
+ out.Set(slicev)
+ return true
+ }
+ default:
+ d.terror(n, yaml_MAP_TAG, out)
+ return false
+ }
+ outt := out.Type()
+ kt := outt.Key()
+ et := outt.Elem()
+
+ mapType := d.mapType
+ if outt.Key() == ifaceType && outt.Elem() == ifaceType {
+ d.mapType = outt
+ }
+
+ if out.IsNil() {
+ out.Set(reflect.MakeMap(outt))
+ }
+ l := len(n.children)
+ for i := 0; i < l; i += 2 {
+ if isMerge(n.children[i]) {
+ d.merge(n.children[i+1], out)
+ continue
+ }
+ k := reflect.New(kt).Elem()
+ if d.unmarshal(n.children[i], k) {
+ kkind := k.Kind()
+ if kkind == reflect.Interface {
+ kkind = k.Elem().Kind()
+ }
+ if kkind == reflect.Map || kkind == reflect.Slice {
+ failf("invalid map key: %#v", k.Interface())
+ }
+ e := reflect.New(et).Elem()
+ if d.unmarshal(n.children[i+1], e) {
+ out.SetMapIndex(k, e)
+ }
+ }
+ }
+ d.mapType = mapType
+ return true
+}
+
+func (d *decoder) mappingSlice(n *node, out reflect.Value) (good bool) {
+ outt := out.Type()
+ if outt.Elem() != mapItemType {
+ d.terror(n, yaml_MAP_TAG, out)
+ return false
+ }
+
+ mapType := d.mapType
+ d.mapType = outt
+
+ var slice []MapItem
+ var l = len(n.children)
+ for i := 0; i < l; i += 2 {
+ if isMerge(n.children[i]) {
+ d.merge(n.children[i+1], out)
+ continue
+ }
+ item := MapItem{}
+ k := reflect.ValueOf(&item.Key).Elem()
+ if d.unmarshal(n.children[i], k) {
+ v := reflect.ValueOf(&item.Value).Elem()
+ if d.unmarshal(n.children[i+1], v) {
+ slice = append(slice, item)
+ }
+ }
+ }
+ out.Set(reflect.ValueOf(slice))
+ d.mapType = mapType
+ return true
+}
+
+func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) {
+ sinfo, err := getStructInfo(out.Type())
+ if err != nil {
+ panic(err)
+ }
+ name := settableValueOf("")
+ l := len(n.children)
+
+ var inlineMap reflect.Value
+ var elemType reflect.Type
+ if sinfo.InlineMap != -1 {
+ inlineMap = out.Field(sinfo.InlineMap)
+ inlineMap.Set(reflect.New(inlineMap.Type()).Elem())
+ elemType = inlineMap.Type().Elem()
+ }
+
+ for i := 0; i < l; i += 2 {
+ ni := n.children[i]
+ if isMerge(ni) {
+ d.merge(n.children[i+1], out)
+ continue
+ }
+ if !d.unmarshal(ni, name) {
+ continue
+ }
+ if info, ok := sinfo.FieldsMap[name.String()]; ok {
+ var field reflect.Value
+ if info.Inline == nil {
+ field = out.Field(info.Num)
+ } else {
+ field = out.FieldByIndex(info.Inline)
+ }
+ d.unmarshal(n.children[i+1], field)
+ } else if sinfo.InlineMap != -1 {
+ if inlineMap.IsNil() {
+ inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
+ }
+ value := reflect.New(elemType).Elem()
+ d.unmarshal(n.children[i+1], value)
+ inlineMap.SetMapIndex(name, value)
+ } else if d.strict {
+ d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s not found in struct %s", n.line+1, name.String(), out.Type()))
+ }
+ }
+ return true
+}
+
+func failWantMap() {
+ failf("map merge requires map or sequence of maps as the value")
+}
+
+func (d *decoder) merge(n *node, out reflect.Value) {
+ switch n.kind {
+ case mappingNode:
+ d.unmarshal(n, out)
+ case aliasNode:
+ an, ok := d.doc.anchors[n.value]
+ if ok && an.kind != mappingNode {
+ failWantMap()
+ }
+ d.unmarshal(n, out)
+ case sequenceNode:
+ // Step backwards as earlier nodes take precedence.
+ for i := len(n.children) - 1; i >= 0; i-- {
+ ni := n.children[i]
+ if ni.kind == aliasNode {
+ an, ok := d.doc.anchors[ni.value]
+ if ok && an.kind != mappingNode {
+ failWantMap()
+ }
+ } else if ni.kind != mappingNode {
+ failWantMap()
+ }
+ d.unmarshal(ni, out)
+ }
+ default:
+ failWantMap()
+ }
+}
+
+func isMerge(n *node) bool {
+ return n.kind == scalarNode && n.value == "<<" && (n.implicit == true || n.tag == yaml_MERGE_TAG)
+}
diff --git a/vendor/gopkg.in/yaml.v2/decode_test.go b/vendor/gopkg.in/yaml.v2/decode_test.go
new file mode 100644
index 000000000..713b1ee9c
--- /dev/null
+++ b/vendor/gopkg.in/yaml.v2/decode_test.go
@@ -0,0 +1,1017 @@
+package yaml_test
+
+import (
+ "errors"
+ . "gopkg.in/check.v1"
+ "gopkg.in/yaml.v2"
+ "math"
+ "net"
+ "reflect"
+ "strings"
+ "time"
+)
+
+var unmarshalIntTest = 123
+
+var unmarshalTests = []struct {
+ data string
+ value interface{}
+}{
+ {
+ "",
+ &struct{}{},
+ }, {
+ "{}", &struct{}{},
+ }, {
+ "v: hi",
+ map[string]string{"v": "hi"},
+ }, {
+ "v: hi", map[string]interface{}{"v": "hi"},
+ }, {
+ "v: true",
+ map[string]string{"v": "true"},
+ }, {
+ "v: true",
+ map[string]interface{}{"v": true},
+ }, {
+ "v: 10",
+ map[string]interface{}{"v": 10},
+ }, {
+ "v: 0b10",
+ map[string]interface{}{"v": 2},
+ }, {
+ "v: 0xA",
+ map[string]interface{}{"v": 10},
+ }, {
+ "v: 4294967296",
+ map[string]int64{"v": 4294967296},
+ }, {
+ "v: 0.1",
+ map[string]interface{}{"v": 0.1},
+ }, {
+ "v: .1",
+ map[string]interface{}{"v": 0.1},
+ }, {
+ "v: .Inf",
+ map[string]interface{}{"v": math.Inf(+1)},
+ }, {
+ "v: -.Inf",
+ map[string]interface{}{"v": math.Inf(-1)},
+ }, {
+ "v: -10",
+ map[string]interface{}{"v": -10},
+ }, {
+ "v: -.1",
+ map[string]interface{}{"v": -0.1},
+ },
+
+ // Simple values.
+ {
+ "123",
+ &unmarshalIntTest,
+ },
+
+ // Floats from spec
+ {
+ "canonical: 6.8523e+5",
+ map[string]interface{}{"canonical": 6.8523e+5},
+ }, {
+ "expo: 685.230_15e+03",
+ map[string]interface{}{"expo": 685.23015e+03},
+ }, {
+ "fixed: 685_230.15",
+ map[string]interface{}{"fixed": 685230.15},
+ }, {
+ "neginf: -.inf",
+ map[string]interface{}{"neginf": math.Inf(-1)},
+ }, {
+ "fixed: 685_230.15",
+ map[string]float64{"fixed": 685230.15},
+ },
+ //{"sexa: 190:20:30.15", map[string]interface{}{"sexa": 0}}, // Unsupported
+ //{"notanum: .NaN", map[string]interface{}{"notanum": math.NaN()}}, // Equality of NaN fails.
+
+ // Bools from spec
+ {
+ "canonical: y",
+ map[string]interface{}{"canonical": true},
+ }, {
+ "answer: NO",
+ map[string]interface{}{"answer": false},
+ }, {
+ "logical: True",
+ map[string]interface{}{"logical": true},
+ }, {
+ "option: on",
+ map[string]interface{}{"option": true},
+ }, {
+ "option: on",
+ map[string]bool{"option": true},
+ },
+ // Ints from spec
+ {
+ "canonical: 685230",
+ map[string]interface{}{"canonical": 685230},
+ }, {
+ "decimal: +685_230",
+ map[string]interface{}{"decimal": 685230},
+ }, {
+ "octal: 02472256",
+ map[string]interface{}{"octal": 685230},
+ }, {
+ "hexa: 0x_0A_74_AE",
+ map[string]interface{}{"hexa": 685230},
+ }, {
+ "bin: 0b1010_0111_0100_1010_1110",
+ map[string]interface{}{"bin": 685230},
+ }, {
+ "bin: -0b101010",
+ map[string]interface{}{"bin": -42},
+ }, {
+ "decimal: +685_230",
+ map[string]int{"decimal": 685230},
+ },
+
+ //{"sexa: 190:20:30", map[string]interface{}{"sexa": 0}}, // Unsupported
+
+ // Nulls from spec
+ {
+ "empty:",
+ map[string]interface{}{"empty": nil},
+ }, {
+ "canonical: ~",
+ map[string]interface{}{"canonical": nil},
+ }, {
+ "english: null",
+ map[string]interface{}{"english": nil},
+ }, {
+ "~: null key",
+ map[interface{}]string{nil: "null key"},
+ }, {
+ "empty:",
+ map[string]*bool{"empty": nil},
+ },
+
+ // Flow sequence
+ {
+ "seq: [A,B]",
+ map[string]interface{}{"seq": []interface{}{"A", "B"}},
+ }, {
+ "seq: [A,B,C,]",
+ map[string][]string{"seq": []string{"A", "B", "C"}},
+ }, {
+ "seq: [A,1,C]",
+ map[string][]string{"seq": []string{"A", "1", "C"}},
+ }, {
+ "seq: [A,1,C]",
+ map[string][]int{"seq": []int{1}},
+ }, {
+ "seq: [A,1,C]",
+ map[string]interface{}{"seq": []interface{}{"A", 1, "C"}},
+ },
+ // Block sequence
+ {
+ "seq:\n - A\n - B",
+ map[string]interface{}{"seq": []interface{}{"A", "B"}},
+ }, {
+ "seq:\n - A\n - B\n - C",
+ map[string][]string{"seq": []string{"A", "B", "C"}},
+ }, {
+ "seq:\n - A\n - 1\n - C",
+ map[string][]string{"seq": []string{"A", "1", "C"}},
+ }, {
+ "seq:\n - A\n - 1\n - C",
+ map[string][]int{"seq": []int{1}},
+ }, {
+ "seq:\n - A\n - 1\n - C",
+ map[string]interface{}{"seq": []interface{}{"A", 1, "C"}},
+ },
+
+ // Literal block scalar
+ {
+ "scalar: | # Comment\n\n literal\n\n \ttext\n\n",
+ map[string]string{"scalar": "\nliteral\n\n\ttext\n"},
+ },
+
+ // Folded block scalar
+ {
+ "scalar: > # Comment\n\n folded\n line\n \n next\n line\n * one\n * two\n\n last\n line\n\n",
+ map[string]string{"scalar": "\nfolded line\nnext line\n * one\n * two\n\nlast line\n"},
+ },
+
+ // Map inside interface with no type hints.
+ {
+ "a: {b: c}",
+ map[interface{}]interface{}{"a": map[interface{}]interface{}{"b": "c"}},
+ },
+
+ // Structs and type conversions.
+ {
+ "hello: world",
+ &struct{ Hello string }{"world"},
+ }, {
+ "a: {b: c}",
+ &struct{ A struct{ B string } }{struct{ B string }{"c"}},
+ }, {
+ "a: {b: c}",
+ &struct{ A *struct{ B string } }{&struct{ B string }{"c"}},
+ }, {
+ "a: {b: c}",
+ &struct{ A map[string]string }{map[string]string{"b": "c"}},
+ }, {
+ "a: {b: c}",
+ &struct{ A *map[string]string }{&map[string]string{"b": "c"}},
+ }, {
+ "a:",
+ &struct{ A map[string]string }{},
+ }, {
+ "a: 1",
+ &struct{ A int }{1},
+ }, {
+ "a: 1",
+ &struct{ A float64 }{1},
+ }, {
+ "a: 1.0",
+ &struct{ A int }{1},
+ }, {
+ "a: 1.0",
+ &struct{ A uint }{1},
+ }, {
+ "a: [1, 2]",
+ &struct{ A []int }{[]int{1, 2}},
+ }, {
+ "a: 1",
+ &struct{ B int }{0},
+ }, {
+ "a: 1",
+ &struct {
+ B int "a"
+ }{1},
+ }, {
+ "a: y",
+ &struct{ A bool }{true},
+ },
+
+ // Some cross type conversions
+ {
+ "v: 42",
+ map[string]uint{"v": 42},
+ }, {
+ "v: -42",
+ map[string]uint{},
+ }, {
+ "v: 4294967296",
+ map[string]uint64{"v": 4294967296},
+ }, {
+ "v: -4294967296",
+ map[string]uint64{},
+ },
+
+ // int
+ {
+ "int_max: 2147483647",
+ map[string]int{"int_max": math.MaxInt32},
+ },
+ {
+ "int_min: -2147483648",
+ map[string]int{"int_min": math.MinInt32},
+ },
+ {
+ "int_overflow: 9223372036854775808", // math.MaxInt64 + 1
+ map[string]int{},
+ },
+
+ // int64
+ {
+ "int64_max: 9223372036854775807",
+ map[string]int64{"int64_max": math.MaxInt64},
+ },
+ {
+ "int64_max_base2: 0b111111111111111111111111111111111111111111111111111111111111111",
+ map[string]int64{"int64_max_base2": math.MaxInt64},
+ },
+ {
+ "int64_min: -9223372036854775808",
+ map[string]int64{"int64_min": math.MinInt64},
+ },
+ {
+ "int64_neg_base2: -0b111111111111111111111111111111111111111111111111111111111111111",
+ map[string]int64{"int64_neg_base2": -math.MaxInt64},
+ },
+ {
+ "int64_overflow: 9223372036854775808", // math.MaxInt64 + 1
+ map[string]int64{},
+ },
+
+ // uint
+ {
+ "uint_min: 0",
+ map[string]uint{"uint_min": 0},
+ },
+ {
+ "uint_max: 4294967295",
+ map[string]uint{"uint_max": math.MaxUint32},
+ },
+ {
+ "uint_underflow: -1",
+ map[string]uint{},
+ },
+
+ // uint64
+ {
+ "uint64_min: 0",
+ map[string]uint{"uint64_min": 0},
+ },
+ {
+ "uint64_max: 18446744073709551615",
+ map[string]uint64{"uint64_max": math.MaxUint64},
+ },
+ {
+ "uint64_max_base2: 0b1111111111111111111111111111111111111111111111111111111111111111",
+ map[string]uint64{"uint64_max_base2": math.MaxUint64},
+ },
+ {
+ "uint64_maxint64: 9223372036854775807",
+ map[string]uint64{"uint64_maxint64": math.MaxInt64},
+ },
+ {
+ "uint64_underflow: -1",
+ map[string]uint64{},
+ },
+
+ // float32
+ {
+ "float32_max: 3.40282346638528859811704183484516925440e+38",
+ map[string]float32{"float32_max": math.MaxFloat32},
+ },
+ {
+ "float32_nonzero: 1.401298464324817070923729583289916131280e-45",
+ map[string]float32{"float32_nonzero": math.SmallestNonzeroFloat32},
+ },
+ {
+ "float32_maxuint64: 18446744073709551615",
+ map[string]float32{"float32_maxuint64": float32(math.MaxUint64)},
+ },
+ {
+ "float32_maxuint64+1: 18446744073709551616",
+ map[string]float32{"float32_maxuint64+1": float32(math.MaxUint64 + 1)},
+ },
+
+ // float64
+ {
+ "float64_max: 1.797693134862315708145274237317043567981e+308",
+ map[string]float64{"float64_max": math.MaxFloat64},
+ },
+ {
+ "float64_nonzero: 4.940656458412465441765687928682213723651e-324",
+ map[string]float64{"float64_nonzero": math.SmallestNonzeroFloat64},
+ },
+ {
+ "float64_maxuint64: 18446744073709551615",
+ map[string]float64{"float64_maxuint64": float64(math.MaxUint64)},
+ },
+ {
+ "float64_maxuint64+1: 18446744073709551616",
+ map[string]float64{"float64_maxuint64+1": float64(math.MaxUint64 + 1)},
+ },
+
+ // Overflow cases.
+ {
+ "v: 4294967297",
+ map[string]int32{},
+ }, {
+ "v: 128",
+ map[string]int8{},
+ },
+
+ // Quoted values.
+ {
+ "'1': '\"2\"'",
+ map[interface{}]interface{}{"1": "\"2\""},
+ }, {
+ "v:\n- A\n- 'B\n\n C'\n",
+ map[string][]string{"v": []string{"A", "B\nC"}},
+ },
+
+ // Explicit tags.
+ {
+ "v: !!float '1.1'",
+ map[string]interface{}{"v": 1.1},
+ }, {
+ "v: !!null ''",
+ map[string]interface{}{"v": nil},
+ }, {
+ "%TAG !y! tag:yaml.org,2002:\n---\nv: !y!int '1'",
+ map[string]interface{}{"v": 1},
+ },
+
+ // Non-specific tag (Issue #75)
+ {
+ "v: ! test",
+ map[string]interface{}{"v": "test"},
+ },
+
+ // Anchors and aliases.
+ {
+ "a: &x 1\nb: &y 2\nc: *x\nd: *y\n",
+ &struct{ A, B, C, D int }{1, 2, 1, 2},
+ }, {
+ "a: &a {c: 1}\nb: *a",
+ &struct {
+ A, B struct {
+ C int
+ }
+ }{struct{ C int }{1}, struct{ C int }{1}},
+ }, {
+ "a: &a [1, 2]\nb: *a",
+ &struct{ B []int }{[]int{1, 2}},
+ }, {
+ "b: *a\na: &a {c: 1}",
+ &struct {
+ A, B struct {
+ C int
+ }
+ }{struct{ C int }{1}, struct{ C int }{1}},
+ },
+
+ // Bug #1133337
+ {
+ "foo: ''",
+ map[string]*string{"foo": new(string)},
+ }, {
+ "foo: null",
+ map[string]string{"foo": ""},
+ }, {
+ "foo: null",
+ map[string]interface{}{"foo": nil},
+ },
+
+ // Ignored field
+ {
+ "a: 1\nb: 2\n",
+ &struct {
+ A int
+ B int "-"
+ }{1, 0},
+ },
+
+ // Bug #1191981
+ {
+ "" +
+ "%YAML 1.1\n" +
+ "--- !!str\n" +
+ `"Generic line break (no glyph)\n\` + "\n" +
+ ` Generic line break (glyphed)\n\` + "\n" +
+ ` Line separator\u2028\` + "\n" +
+ ` Paragraph separator\u2029"` + "\n",
+ "" +
+ "Generic line break (no glyph)\n" +
+ "Generic line break (glyphed)\n" +
+ "Line separator\u2028Paragraph separator\u2029",
+ },
+
+ // Struct inlining
+ {
+ "a: 1\nb: 2\nc: 3\n",
+ &struct {
+ A int
+ C inlineB `yaml:",inline"`
+ }{1, inlineB{2, inlineC{3}}},
+ },
+
+ // Map inlining
+ {
+ "a: 1\nb: 2\nc: 3\n",
+ &struct {
+ A int
+ C map[string]int `yaml:",inline"`
+ }{1, map[string]int{"b": 2, "c": 3}},
+ },
+
+ // bug 1243827
+ {
+ "a: -b_c",
+ map[string]interface{}{"a": "-b_c"},
+ },
+ {
+ "a: +b_c",
+ map[string]interface{}{"a": "+b_c"},
+ },
+ {
+ "a: 50cent_of_dollar",
+ map[string]interface{}{"a": "50cent_of_dollar"},
+ },
+
+ // Duration
+ {
+ "a: 3s",
+ map[string]time.Duration{"a": 3 * time.Second},
+ },
+
+ // Issue #24.
+ {
+ "a: