pharnexbase
/
validator
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
💯Go Struct and Field validation, including Cross Field, Cross Struct, Map, Slice and Array diving
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
256 Commits
10 Branches
157 Tags
3.2 MiB
 
Tag: Branch: Tree: 88cc19b9e1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '88cc19b9e1'
${ noResults }
validator/validator_test.go

3844 lines
96 KiB
Raw Blame History

package validator
import (
"fmt"
"path"
"reflect"
"runtime"
"testing"
)
// 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", ValidationFuncs: BakedInValidators})
func IsEqual(t *testing.T, val1, val2 interface{}) bool {
v1 := reflect.ValueOf(val1)
v2 := reflect.ValueOf(val2)
if v1.Kind() == reflect.Ptr {
v1 = v1.Elem()
}
if v2.Kind() == reflect.Ptr {
v2 = v2.Elem()
}
if !v1.IsValid() && !v2.IsValid() {
return true
}
v1Underlying := reflect.Zero(reflect.TypeOf(v1)).Interface()
v2Underlying := reflect.Zero(reflect.TypeOf(v2)).Interface()
if v1 == v1Underlying {
if v2 == v2Underlying {
goto CASE4
} else {
goto CASE3
}
} else {
if v2 == v2Underlying {
goto CASE2
} else {
goto CASE1
}
}
CASE1:
return reflect.DeepEqual(v1.Interface(), v2.Interface())
CASE2:
return reflect.DeepEqual(v1.Interface(), v2)
CASE3:
return reflect.DeepEqual(v1, v2.Interface())
CASE4:
return reflect.DeepEqual(v1, v2)
}
func Equal(t *testing.T, val1, val2 interface{}) {
EqualSkip(t, 2, val1, val2)
}
func EqualSkip(t *testing.T, skip int, val1, val2 interface{}) {
if !IsEqual(t, val1, val2) {
_, file, line, _ := runtime.Caller(skip)
fmt.Printf("%s:%d %v does not equal %v\n", path.Base(file), line, val1, val2)
t.FailNow()
}
}
func NotEqual(t *testing.T, val1, val2 interface{}) {
NotEqualSkip(t, 2, val1, val2)
}
func NotEqualSkip(t *testing.T, skip int, val1, val2 interface{}) {
if IsEqual(t, val1, val2) {
_, file, line, _ := runtime.Caller(skip)
fmt.Printf("%s:%d %v should not be equal %v\n", path.Base(file), line, val1, val2)
t.FailNow()
}
}
func PanicMatches(t *testing.T, fn func(), matches string) {
PanicMatchesSkip(t, 2, fn, matches)
}
func PanicMatchesSkip(t *testing.T, skip int, fn func(), matches string) {
_, file, line, _ := runtime.Caller(skip)
defer func() {
if r := recover(); r != nil {
err := fmt.Sprintf("%s", r)
if err != matches {
fmt.Printf("%s:%d Panic... expected [%s] received [%s]", path.Base(file), line, matches, err)
t.FailNow()
}
}
}()
fn()
}
func TestValidation(t *testing.T) {
type Inner struct {
Name string
}
type Test struct {
Name string `validate:"required"`
Arr []string `validate:"required"`
// Inner *Inner `validate:"required"`
}
// inner := &Inner{
// Name: "",
// }
tst := &Test{Name: "Dean"}
// tst := &Test{Inner: inner}
errs := validate.Struct(tst)
fmt.Println(errs)
fmt.Println(errs == nil)
}
// func AssertStruct(t *testing.T, s *StructErrors, structFieldName string, expectedStructName string) *StructErrors {
// val, ok := s.StructErrors[structFieldName]
// EqualSkip(t, 2, ok, true)
// NotEqualSkip(t, 2, val, nil)
// EqualSkip(t, 2, val.Struct, expectedStructName)
// return val
// }
// func AssertFieldError(t *testing.T, s *StructErrors, field string, expectedTag string) {
// val, ok := s.Errors[field]
// EqualSkip(t, 2, ok, true)
// NotEqualSkip(t, 2, val, nil)
// EqualSkip(t, 2, val.Field, field)
// EqualSkip(t, 2, val.Tag, expectedTag)
// }
// func AssertMapFieldError(t *testing.T, s map[string]*FieldError, field string, expectedTag string) {
// val, ok := s[field]
// EqualSkip(t, 2, ok, true)
// NotEqualSkip(t, 2, val, nil)
// EqualSkip(t, 2, val.Field, field)
// EqualSkip(t, 2, val.Tag, expectedTag)
// }
// func TestBadKeyValidation(t *testing.T) {
// type Test struct {
// Name string `validate:"required, "`
// }
// tst := &Test{
// Name: "test",
// }
// PanicMatches(t, func() { validate.Struct(tst) }, "Invalid validation tag on field Name")
// }
// func TestFlattenValidation(t *testing.T) {
// type Inner struct {
// Name string `validate:"required"`
// }
// type TestMultiDimensionalStructsPtr struct {
// Errs [][]*Inner `validate:"gt=0,dive,dive,required"`
// }
// var errStructPtrArray [][]*Inner
// errStructPtrArray = append(errStructPtrArray, []*Inner{&Inner{"ok"}, &Inner{""}, &Inner{"ok"}})
// tmsp := &TestMultiDimensionalStructsPtr{
// Errs: errStructPtrArray,
// }
// errs := validate.Struct(tmsp)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// // for full test coverage
// fmt.Sprint(errs.Error())
// fieldErr := errs.Errors["Errs"]
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, fieldErr.Field, "Errs")
// Equal(t, len(fieldErr.SliceOrArrayErrs), 1)
// innerSlice1, ok := fieldErr.SliceOrArrayErrs[0].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerSlice1.IsPlaceholderErr, true)
// Equal(t, innerSlice1.Field, "Errs[0]")
// flatFieldErr, ok := fieldErr.Flatten()["[0][1].Inner.Name"]
// Equal(t, ok, true)
// Equal(t, flatFieldErr.Field, "Name")
// Equal(t, flatFieldErr.Tag, "required")
// structErrFlatten, ok := errs.Flatten()["Errs[0][1].Inner.Name"]
// Equal(t, ok, true)
// Equal(t, structErrFlatten.Field, "Name")
// Equal(t, structErrFlatten.Tag, "required")
// errStructPtrArray = [][]*Inner{}
// errStructPtrArray = append(errStructPtrArray, []*Inner{&Inner{"ok"}, nil, &Inner{"ok"}})
// tmsp = &TestMultiDimensionalStructsPtr{
// Errs: errStructPtrArray,
// }
// errs = validate.Struct(tmsp)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// // for full test coverage
// fmt.Sprint(errs.Error())
// fieldErr = errs.Errors["Errs"]
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, fieldErr.Field, "Errs")
// Equal(t, len(fieldErr.SliceOrArrayErrs), 1)
// innerSlice1, ok = fieldErr.SliceOrArrayErrs[0].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerSlice1.IsPlaceholderErr, true)
// Equal(t, innerSlice1.Field, "Errs[0]")
// flatFieldErr, ok = fieldErr.Flatten()["[0][1]"]
// Equal(t, ok, true)
// Equal(t, flatFieldErr.Field, "Errs[0][1]")
// Equal(t, flatFieldErr.Tag, "required")
// type TestMapStructPtr struct {
// Errs map[int]*Inner `validate:"gt=0,dive,required"`
// }
// mip := map[int]*Inner{0: &Inner{"ok"}, 3: &Inner{""}, 4: &Inner{"ok"}}
// msp := &TestMapStructPtr{
// Errs: mip,
// }
// errs = validate.Struct(msp)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// fieldError := errs.Errors["Errs"]
// Equal(t, fieldError.IsPlaceholderErr, true)
// Equal(t, fieldError.IsMap, true)
// Equal(t, len(fieldError.MapErrs), 1)
// innerStructError, ok := fieldError.MapErrs[3].(*StructErrors)
// Equal(t, ok, true)
// Equal(t, innerStructError.Struct, "Inner")
// Equal(t, len(innerStructError.Errors), 1)
// innerInnerFieldError, ok := innerStructError.Errors["Name"]
// Equal(t, ok, true)
// Equal(t, innerInnerFieldError.IsPlaceholderErr, false)
// Equal(t, innerInnerFieldError.IsSliceOrArray, false)
// Equal(t, innerInnerFieldError.Field, "Name")
// Equal(t, innerInnerFieldError.Tag, "required")
// flatErrs, ok := errs.Flatten()["Errs[3].Inner.Name"]
// Equal(t, ok, true)
// Equal(t, flatErrs.Field, "Name")
// Equal(t, flatErrs.Tag, "required")
// mip2 := map[int]*Inner{0: &Inner{"ok"}, 3: nil, 4: &Inner{"ok"}}
// msp2 := &TestMapStructPtr{
// Errs: mip2,
// }
// errs = validate.Struct(msp2)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// fieldError = errs.Errors["Errs"]
// Equal(t, fieldError.IsPlaceholderErr, true)
// Equal(t, fieldError.IsMap, true)
// Equal(t, len(fieldError.MapErrs), 1)
// innerFieldError, ok := fieldError.MapErrs[3].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerFieldError.IsPlaceholderErr, false)
// Equal(t, innerFieldError.IsSliceOrArray, false)
// Equal(t, innerFieldError.Field, "Errs[3]")
// Equal(t, innerFieldError.Tag, "required")
// flatErrs, ok = errs.Flatten()["Errs[3]"]
// Equal(t, ok, true)
// Equal(t, flatErrs.Field, "Errs[3]")
// Equal(t, flatErrs.Tag, "required")
// type TestMapInnerArrayStruct struct {
// Errs map[int][]string `validate:"gt=0,dive,dive,required"`
// }
// mias := map[int][]string{0: []string{"ok"}, 3: []string{"ok", ""}, 4: []string{"ok"}}
// mia := &TestMapInnerArrayStruct{
// Errs: mias,
// }
// errs = validate.Struct(mia)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// flatErrs, ok = errs.Flatten()["Errs[3][1]"]
// Equal(t, ok, true)
// Equal(t, flatErrs.Field, "Errs[3][1]")
// Equal(t, flatErrs.Tag, "required")
// }
// func TestInterfaceErrValidation(t *testing.T) {
// var v1 interface{}
// var v2 interface{}
// v2 = 1
// v1 = v2
// err := validate.Field(v1, "len=1")
// Equal(t, err, nil)
// err = validate.Field(v2, "len=1")
// Equal(t, err, 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, errs.Errors["Data"].Field, "Data")
// Equal(t, errs.Errors["Data"].Tag, "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, errs.Errors["Data"].Field, "Data")
// Equal(t, errs.Errors["Data"].Tag, "len")
// Equal(t, errs.Errors["Data"].Param, "1")
// s3 := &ExternalCMD2{
// Userid: "123456",
// Action: 10000,
// Data: 2,
// }
// errs = validate.Struct(s3)
// NotEqual(t, errs, nil)
// Equal(t, errs.Errors["Data"].Field, "Data")
// Equal(t, errs.Errors["Data"].Tag, "len")
// Equal(t, errs.Errors["Data"].Param, "1")
// 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, errs.StructErrors["Data"].Struct, "Inner")
// Equal(t, errs.StructErrors["Data"].Errors["Name"].Field, "Name")
// Equal(t, errs.StructErrors["Data"].Errors["Name"].Tag, "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.Errors), 1)
// fieldError := errs.Errors["Errs"]
// Equal(t, fieldError.IsPlaceholderErr, true)
// Equal(t, fieldError.IsMap, true)
// Equal(t, len(fieldError.MapErrs), 1)
// innerFieldError, ok := fieldError.MapErrs[3].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerFieldError.IsPlaceholderErr, false)
// Equal(t, innerFieldError.IsMap, false)
// Equal(t, len(innerFieldError.MapErrs), 0)
// Equal(t, innerFieldError.Field, "Errs[3]")
// Equal(t, innerFieldError.Tag, "len")
// type TestMultiDimensionalStructs struct {
// Errs [][]interface{} `validate:"gt=0,dive,dive,len=2"`
// }
// 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.Errors), 1)
// fieldErr, ok := errs.Errors["Errs"]
// Equal(t, ok, true)
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, len(fieldErr.SliceOrArrayErrs), 2)
// sliceError1, ok := fieldErr.SliceOrArrayErrs[0].(*FieldError)
// Equal(t, ok, true)
// Equal(t, sliceError1.IsPlaceholderErr, true)
// Equal(t, sliceError1.IsSliceOrArray, true)
// Equal(t, len(sliceError1.SliceOrArrayErrs), 2)
// innerSliceStructError1, ok := sliceError1.SliceOrArrayErrs[1].(*StructErrors)
// Equal(t, ok, true)
// Equal(t, len(innerSliceStructError1.Errors), 1)
// innerInnersliceError1 := innerSliceStructError1.Errors["Name"]
// Equal(t, innerInnersliceError1.IsPlaceholderErr, false)
// Equal(t, innerInnersliceError1.IsSliceOrArray, false)
// Equal(t, len(innerInnersliceError1.SliceOrArrayErrs), 0)
// type TestMultiDimensionalStructsPtr2 struct {
// Errs [][]*Inner `validate:"gt=0,dive,dive,len=2"`
// }
// var errStructPtr2Array [][]*Inner
// errStructPtr2Array = append(errStructPtr2Array, []*Inner{&Inner{"ok"}, &Inner{""}, &Inner{""}})
// errStructPtr2Array = append(errStructPtr2Array, []*Inner{&Inner{"ok"}, &Inner{""}, &Inner{""}})
// errStructPtr2Array = append(errStructPtr2Array, []*Inner{&Inner{"ok"}, &Inner{""}, nil})
// tmsp2 := &TestMultiDimensionalStructsPtr2{
// Errs: errStructPtr2Array,
// }
// errs = validate.Struct(tmsp2)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// fieldErr, ok = errs.Errors["Errs"]
// Equal(t, ok, true)
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, len(fieldErr.SliceOrArrayErrs), 3)
// sliceError1, ok = fieldErr.SliceOrArrayErrs[2].(*FieldError)
// Equal(t, ok, true)
// Equal(t, sliceError1.IsPlaceholderErr, true)
// Equal(t, sliceError1.IsSliceOrArray, true)
// Equal(t, len(sliceError1.SliceOrArrayErrs), 2)
// innerSliceStructError1, ok = sliceError1.SliceOrArrayErrs[1].(*StructErrors)
// Equal(t, ok, true)
// Equal(t, len(innerSliceStructError1.Errors), 1)
// innerSliceStructError2, ok := sliceError1.SliceOrArrayErrs[2].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerSliceStructError2.IsPlaceholderErr, false)
// Equal(t, innerSliceStructError2.IsSliceOrArray, false)
// Equal(t, len(innerSliceStructError2.SliceOrArrayErrs), 0)
// Equal(t, innerSliceStructError2.Field, "Errs[2][2]")
// innerInnersliceError1 = innerSliceStructError1.Errors["Name"]
// Equal(t, innerInnersliceError1.IsPlaceholderErr, false)
// Equal(t, innerInnersliceError1.IsSliceOrArray, false)
// Equal(t, len(innerInnersliceError1.SliceOrArrayErrs), 0)
// m := map[int]interface{}{0: "ok", 3: "", 4: "ok"}
// err = validate.Field(m, "len=3,dive,len=2")
// NotEqual(t, err, nil)
// Equal(t, err.IsPlaceholderErr, true)
// Equal(t, err.IsMap, true)
// Equal(t, len(err.MapErrs), 1)
// err = validate.Field(m, "len=2,dive,required")
// NotEqual(t, err, nil)
// Equal(t, err.IsPlaceholderErr, false)
// Equal(t, err.IsMap, false)
// Equal(t, len(err.MapErrs), 0)
// arr := []interface{}{"ok", "", "ok"}
// err = validate.Field(arr, "len=3,dive,len=2")
// NotEqual(t, err, nil)
// Equal(t, err.IsPlaceholderErr, true)
// Equal(t, err.IsSliceOrArray, true)
// Equal(t, len(err.SliceOrArrayErrs), 1)
// err = validate.Field(arr, "len=2,dive,required")
// NotEqual(t, err, nil)
// Equal(t, err.IsPlaceholderErr, false)
// Equal(t, err.IsSliceOrArray, false)
// Equal(t, len(err.SliceOrArrayErrs), 0)
// 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}
// err := validate.Field(n, "omitempty,required")
// m := map[int]string{0: "ok", 3: "", 4: "ok"}
// err = validate.Field(m, "len=3,dive,required")
// NotEqual(t, err, nil)
// Equal(t, err.IsPlaceholderErr, true)
// Equal(t, err.IsMap, true)
// Equal(t, len(err.MapErrs), 1)
// err = validate.Field(m, "len=2,dive,required")
// NotEqual(t, err, nil)
// Equal(t, err.IsPlaceholderErr, false)
// Equal(t, err.IsMap, false)
// Equal(t, len(err.MapErrs), 0)
// type Inner struct {
// Name string `validate:"required"`
// }
// type TestMapStruct struct {
// Errs map[int]Inner `validate:"gt=0,dive"`
// }
// mi := map[int]Inner{0: Inner{"ok"}, 3: Inner{""}, 4: Inner{"ok"}}
// ms := &TestMapStruct{
// Errs: mi,
// }
// errs := validate.Struct(ms)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// // for full test coverage
// fmt.Sprint(errs.Error())
// fieldError := errs.Errors["Errs"]
// Equal(t, fieldError.IsPlaceholderErr, true)
// Equal(t, fieldError.IsMap, true)
// Equal(t, len(fieldError.MapErrs), 1)
// structErr, ok := fieldError.MapErrs[3].(*StructErrors)
// Equal(t, ok, true)
// Equal(t, len(structErr.Errors), 1)
// innerErr := structErr.Errors["Name"]
// Equal(t, innerErr.IsPlaceholderErr, false)
// Equal(t, innerErr.IsMap, false)
// Equal(t, len(innerErr.MapErrs), 0)
// Equal(t, innerErr.Field, "Name")
// Equal(t, innerErr.Tag, "required")
// 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.Errors), 1)
// fieldError = errs.Errors["Errs"]
// Equal(t, fieldError.IsPlaceholderErr, true)
// Equal(t, fieldError.IsMap, true)
// Equal(t, len(fieldError.MapErrs), 2)
// innerErr, ok = fieldError.MapErrs[3].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerErr.IsPlaceholderErr, false)
// Equal(t, innerErr.IsMap, false)
// Equal(t, len(innerErr.MapErrs), 0)
// Equal(t, innerErr.Field, "Errs[3]")
// Equal(t, innerErr.Tag, "required")
// type TestMapStructPtr struct {
// Errs map[int]*Inner `validate:"gt=0,dive,required"`
// }
// mip := map[int]*Inner{0: &Inner{"ok"}, 3: nil, 4: &Inner{"ok"}}
// msp := &TestMapStructPtr{
// Errs: mip,
// }
// errs = validate.Struct(msp)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// fieldError = errs.Errors["Errs"]
// Equal(t, fieldError.IsPlaceholderErr, true)
// Equal(t, fieldError.IsMap, true)
// Equal(t, len(fieldError.MapErrs), 1)
// innerFieldError, ok := fieldError.MapErrs[3].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerFieldError.IsPlaceholderErr, false)
// Equal(t, innerFieldError.IsMap, false)
// Equal(t, len(innerFieldError.MapErrs), 0)
// Equal(t, innerFieldError.Field, "Errs[3]")
// Equal(t, innerFieldError.Tag, "required")
// type TestMapStructPtr2 struct {
// Errs map[int]*Inner `validate:"gt=0,dive,omitempty,required"`
// }
// mip2 := map[int]*Inner{0: &Inner{"ok"}, 3: nil, 4: &Inner{"ok"}}
// msp2 := &TestMapStructPtr2{
// Errs: mip2,
// }
// errs = validate.Struct(msp2)
// Equal(t, errs, nil)
// }
// func TestArrayDiveValidation(t *testing.T) {
// arr := []string{"ok", "", "ok"}
// err := validate.Field(arr, "len=3,dive,required")
// NotEqual(t, err, nil)
// Equal(t, err.IsPlaceholderErr, true)
// Equal(t, err.IsSliceOrArray, true)
// Equal(t, len(err.SliceOrArrayErrs), 1)
// // flat := err.Flatten()
// // fe, ok := flat["[1]"]
// // Equal(t, ok, true)
// // Equal(t, fe.Tag, "required")
// err = validate.Field(arr, "len=2,dive,required")
// NotEqual(t, err, nil)
// Equal(t, err.IsPlaceholderErr, false)
// Equal(t, err.IsSliceOrArray, false)
// Equal(t, len(err.SliceOrArrayErrs), 0)
// 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.Errors), 1)
// // flat = errs.Flatten()
// // me, ok := flat["Errs[1]"]
// // Equal(t, ok, true)
// // Equal(t, me.Field, "Errs[1]")
// // Equal(t, me.Tag, "required")
// fieldErr, ok := errs.Errors["Errs"]
// Equal(t, ok, true)
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, len(fieldErr.SliceOrArrayErrs), 1)
// innerErr, ok := fieldErr.SliceOrArrayErrs[1].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerErr.Tag, required)
// Equal(t, innerErr.IsPlaceholderErr, false)
// Equal(t, innerErr.Field, "Errs[1]")
// test = &Test{
// Errs: []string{"ok", "ok", ""},
// }
// errs = validate.Struct(test)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// fieldErr, ok = errs.Errors["Errs"]
// Equal(t, ok, true)
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, len(fieldErr.SliceOrArrayErrs), 1)
// innerErr, ok = fieldErr.SliceOrArrayErrs[2].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerErr.Tag, required)
// Equal(t, innerErr.IsPlaceholderErr, false)
// Equal(t, innerErr.Field, "Errs[2]")
// 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.Errors), 1)
// fieldErr, ok = errs.Errors["Errs"]
// Equal(t, ok, true)
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, len(fieldErr.SliceOrArrayErrs), 2)
// sliceError1, ok := fieldErr.SliceOrArrayErrs[0].(*FieldError)
// Equal(t, ok, true)
// Equal(t, sliceError1.IsPlaceholderErr, true)
// Equal(t, sliceError1.IsSliceOrArray, true)
// Equal(t, len(sliceError1.SliceOrArrayErrs), 2)
// Equal(t, sliceError1.Field, "Errs[0]")
// innerSliceError1, ok := sliceError1.SliceOrArrayErrs[1].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerSliceError1.IsPlaceholderErr, false)
// Equal(t, innerSliceError1.Tag, required)
// Equal(t, innerSliceError1.IsSliceOrArray, false)
// Equal(t, len(innerSliceError1.SliceOrArrayErrs), 0)
// Equal(t, innerSliceError1.Field, "Errs[0][1]")
// type Inner struct {
// Name string `validate:"required"`
// }
// type TestMultiDimensionalStructs struct {
// Errs [][]Inner `validate:"gt=0,dive,dive"`
// }
// var errStructArray [][]Inner
// errStructArray = append(errStructArray, []Inner{Inner{"ok"}, Inner{""}, Inner{""}})
// errStructArray = append(errStructArray, []Inner{Inner{"ok"}, Inner{""}, Inner{""}})
// tms := &TestMultiDimensionalStructs{
// Errs: errStructArray,
// }
// errs = validate.Struct(tms)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// fieldErr, ok = errs.Errors["Errs"]
// Equal(t, ok, true)
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, len(fieldErr.SliceOrArrayErrs), 2)
// sliceError1, ok = fieldErr.SliceOrArrayErrs[0].(*FieldError)
// Equal(t, ok, true)
// Equal(t, sliceError1.IsPlaceholderErr, true)
// Equal(t, sliceError1.IsSliceOrArray, true)
// Equal(t, len(sliceError1.SliceOrArrayErrs), 2)
// innerSliceStructError1, ok := sliceError1.SliceOrArrayErrs[1].(*StructErrors)
// Equal(t, ok, true)
// Equal(t, len(innerSliceStructError1.Errors), 1)
// innerInnersliceError1 := innerSliceStructError1.Errors["Name"]
// Equal(t, innerInnersliceError1.IsPlaceholderErr, false)
// Equal(t, innerInnersliceError1.IsSliceOrArray, false)
// Equal(t, len(innerInnersliceError1.SliceOrArrayErrs), 0)
// type TestMultiDimensionalStructsPtr struct {
// Errs [][]*Inner `validate:"gt=0,dive,dive"`
// }
// var errStructPtrArray [][]*Inner
// errStructPtrArray = append(errStructPtrArray, []*Inner{&Inner{"ok"}, &Inner{""}, &Inner{""}})
// errStructPtrArray = append(errStructPtrArray, []*Inner{&Inner{"ok"}, &Inner{""}, &Inner{""}})
// errStructPtrArray = append(errStructPtrArray, []*Inner{&Inner{"ok"}, &Inner{""}, nil})
// tmsp := &TestMultiDimensionalStructsPtr{
// Errs: errStructPtrArray,
// }
// errs = validate.Struct(tmsp)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// // for full test coverage
// fmt.Sprint(errs.Error())
// // flat := errs.Flatten()
// // // fmt.Println(errs)
// // fmt.Println(flat)
// // expect Errs[0][1].Inner.Name
// // me, ok := flat["Errs[1]"]
// // Equal(t, ok, true)
// // Equal(t, me.Field, "Errs[1]")
// // Equal(t, me.Tag, "required")
// fieldErr, ok = errs.Errors["Errs"]
// Equal(t, ok, true)
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, len(fieldErr.SliceOrArrayErrs), 3)
// // flat := fieldErr.Flatten()
// // fmt.Println(errs)
// // fmt.Println(flat)
// sliceError1, ok = fieldErr.SliceOrArrayErrs[0].(*FieldError)
// Equal(t, ok, true)
// Equal(t, sliceError1.IsPlaceholderErr, true)
// Equal(t, sliceError1.IsSliceOrArray, true)
// Equal(t, len(sliceError1.SliceOrArrayErrs), 2)
// innerSliceStructError1, ok = sliceError1.SliceOrArrayErrs[1].(*StructErrors)
// Equal(t, ok, true)
// Equal(t, len(innerSliceStructError1.Errors), 1)
// innerInnersliceError1 = innerSliceStructError1.Errors["Name"]
// Equal(t, innerInnersliceError1.IsPlaceholderErr, false)
// Equal(t, innerInnersliceError1.IsSliceOrArray, false)
// Equal(t, len(innerInnersliceError1.SliceOrArrayErrs), 0)
// type TestMultiDimensionalStructsPtr2 struct {
// Errs [][]*Inner `validate:"gt=0,dive,dive,required"`
// }
// var errStructPtr2Array [][]*Inner
// errStructPtr2Array = append(errStructPtr2Array, []*Inner{&Inner{"ok"}, &Inner{""}, &Inner{""}})
// errStructPtr2Array = append(errStructPtr2Array, []*Inner{&Inner{"ok"}, &Inner{""}, &Inner{""}})
// errStructPtr2Array = append(errStructPtr2Array, []*Inner{&Inner{"ok"}, &Inner{""}, nil})
// tmsp2 := &TestMultiDimensionalStructsPtr2{
// Errs: errStructPtr2Array,
// }
// errs = validate.Struct(tmsp2)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// fieldErr, ok = errs.Errors["Errs"]
// Equal(t, ok, true)
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, len(fieldErr.SliceOrArrayErrs), 3)
// sliceError1, ok = fieldErr.SliceOrArrayErrs[2].(*FieldError)
// Equal(t, ok, true)
// Equal(t, sliceError1.IsPlaceholderErr, true)
// Equal(t, sliceError1.IsSliceOrArray, true)
// Equal(t, len(sliceError1.SliceOrArrayErrs), 2)
// innerSliceStructError1, ok = sliceError1.SliceOrArrayErrs[1].(*StructErrors)
// Equal(t, ok, true)
// Equal(t, len(innerSliceStructError1.Errors), 1)
// innerSliceStructError2, ok := sliceError1.SliceOrArrayErrs[2].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerSliceStructError2.IsPlaceholderErr, false)
// Equal(t, innerSliceStructError2.IsSliceOrArray, false)
// Equal(t, len(innerSliceStructError2.SliceOrArrayErrs), 0)
// Equal(t, innerSliceStructError2.Field, "Errs[2][2]")
// innerInnersliceError1 = innerSliceStructError1.Errors["Name"]
// Equal(t, innerInnersliceError1.IsPlaceholderErr, false)
// Equal(t, innerInnersliceError1.IsSliceOrArray, false)
// Equal(t, len(innerInnersliceError1.SliceOrArrayErrs), 0)
// type TestMultiDimensionalStructsPtr3 struct {
// Errs [][]*Inner `validate:"gt=0,dive,dive,omitempty"`
// }
// var errStructPtr3Array [][]*Inner
// errStructPtr3Array = append(errStructPtr3Array, []*Inner{&Inner{"ok"}, &Inner{""}, &Inner{""}})
// errStructPtr3Array = append(errStructPtr3Array, []*Inner{&Inner{"ok"}, &Inner{""}, &Inner{""}})
// errStructPtr3Array = append(errStructPtr3Array, []*Inner{&Inner{"ok"}, &Inner{""}, nil})
// tmsp3 := &TestMultiDimensionalStructsPtr3{
// Errs: errStructPtr3Array,
// }
// errs = validate.Struct(tmsp3)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.Errors), 1)
// fieldErr, ok = errs.Errors["Errs"]
// Equal(t, ok, true)
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, len(fieldErr.SliceOrArrayErrs), 3)
// sliceError1, ok = fieldErr.SliceOrArrayErrs[0].(*FieldError)
// Equal(t, ok, true)
// Equal(t, sliceError1.IsPlaceholderErr, true)
// Equal(t, sliceError1.IsSliceOrArray, true)
// Equal(t, len(sliceError1.SliceOrArrayErrs), 2)
// innerSliceStructError1, ok = sliceError1.SliceOrArrayErrs[1].(*StructErrors)
// Equal(t, ok, true)
// Equal(t, len(innerSliceStructError1.Errors), 1)
// innerInnersliceError1 = innerSliceStructError1.Errors["Name"]
// Equal(t, innerInnersliceError1.IsPlaceholderErr, false)
// Equal(t, innerInnersliceError1.IsSliceOrArray, false)
// Equal(t, len(innerInnersliceError1.SliceOrArrayErrs), 0)
// 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.Errors), 1)
// fieldErr, ok = errs.Errors["Errs"]
// Equal(t, ok, true)
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, len(fieldErr.SliceOrArrayErrs), 2)
// sliceError1, ok = fieldErr.SliceOrArrayErrs[2].(*FieldError)
// Equal(t, ok, true)
// Equal(t, sliceError1.IsPlaceholderErr, true)
// Equal(t, sliceError1.IsSliceOrArray, true)
// Equal(t, len(sliceError1.SliceOrArrayErrs), 2)
// innerSliceError1, ok = sliceError1.SliceOrArrayErrs[1].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerSliceError1.IsPlaceholderErr, false)
// Equal(t, innerSliceError1.IsSliceOrArray, false)
// Equal(t, len(innerSliceError1.SliceOrArrayErrs), 0)
// Equal(t, innerSliceError1.Field, "Errs[2][1]")
// Equal(t, innerSliceError1.Tag, 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.Errors), 1)
// fieldErr, ok = errs.Errors["Errs"]
// Equal(t, ok, true)
// Equal(t, fieldErr.IsPlaceholderErr, true)
// Equal(t, fieldErr.IsSliceOrArray, true)
// Equal(t, len(fieldErr.SliceOrArrayErrs), 2)
// sliceError1, ok = fieldErr.SliceOrArrayErrs[2].(*FieldError)
// Equal(t, ok, true)
// Equal(t, sliceError1.IsPlaceholderErr, true)
// Equal(t, sliceError1.IsSliceOrArray, true)
// Equal(t, len(sliceError1.SliceOrArrayErrs), 2)
// innerSliceError1, ok = sliceError1.SliceOrArrayErrs[1].(*FieldError)
// Equal(t, ok, true)
// Equal(t, innerSliceError1.IsPlaceholderErr, false)
// Equal(t, innerSliceError1.IsSliceOrArray, false)
// Equal(t, len(innerSliceError1.SliceOrArrayErrs), 0)
// Equal(t, innerSliceError1.Field, "Errs[2][1]")
// Equal(t, innerSliceError1.Tag, 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)
// 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 {
// err := validate.Field(test.param, "ssn")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d SSN failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "ssn") {
// t.Fatalf("Index: %d SSN failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "longitude")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d Longitude failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "longitude") {
// t.Fatalf("Index: %d Longitude failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "latitude")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d Latitude failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "latitude") {
// t.Fatalf("Index: %d Latitude failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "datauri")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d DataURI failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "datauri") {
// t.Fatalf("Index: %d DataURI failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "multibyte")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d Multibyte failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "multibyte") {
// t.Fatalf("Index: %d Multibyte failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "printascii")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d Printable ASCII failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "printascii") {
// t.Fatalf("Index: %d Printable ASCII failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "ascii")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d ASCII failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "ascii") {
// t.Fatalf("Index: %d ASCII failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "uuid5")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d UUID5 failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "uuid5") {
// t.Fatalf("Index: %d UUID5 failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "uuid4")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d UUID4 failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "uuid4") {
// t.Fatalf("Index: %d UUID4 failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "uuid3")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d UUID3 failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "uuid3") {
// t.Fatalf("Index: %d UUID3 failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "uuid")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d UUID failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "uuid") {
// t.Fatalf("Index: %d UUID failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "isbn")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d ISBN failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "isbn") {
// t.Fatalf("Index: %d ISBN failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "isbn13")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d ISBN13 failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "isbn13") {
// t.Fatalf("Index: %d ISBN13 failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "isbn10")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d ISBN10 failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "isbn10") {
// t.Fatalf("Index: %d ISBN10 failed Error: %s", i, err)
// }
// }
// }
// }
// 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 {
// err := validate.Field(s.Value, s.Tag)
// if (s.ExpectedNil && err != nil) || (!s.ExpectedNil && err == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, err)
// }
// 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 {
// err := validate.Field(s.Value, s.Tag)
// if (s.ExpectedNil && err != nil) || (!s.ExpectedNil && err == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, err)
// }
// errs := validate.Struct(s)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// }
// username := "joeybloggs "
// err := validate.Field(username, "excludesall=@ ")
// NotEqual(t, err, nil)
// excluded := ","
// err = validate.Field(excluded, "excludesall=!@#$%^&*()_+.0x2C?")
// NotEqual(t, err, nil)
// excluded = "="
// err = validate.Field(excluded, "excludesall=!@#$%^&*()_+.0x2C=?")
// NotEqual(t, err, nil)
// }
// 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 {
// err := validate.Field(s.Value, s.Tag)
// if (s.ExpectedNil && err != nil) || (!s.ExpectedNil && err == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, err)
// }
// 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 {
// err := validate.Field(s.Value, s.Tag)
// if (s.ExpectedNil && err != nil) || (!s.ExpectedNil && err == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, err)
// }
// 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 {
// err := validate.Field(s.Value, s.Tag)
// if (s.ExpectedNil && err != nil) || (!s.ExpectedNil && err == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, err)
// }
// 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 {
// err := validate.Field(s.Value, s.Tag)
// if (s.ExpectedNil && err != nil) || (!s.ExpectedNil && err == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, err)
// }
// 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
// err := validate.FieldWithValue(s, s2, "nefield")
// Equal(t, err, nil)
// err = validate.FieldWithValue(i2, i, "nefield")
// Equal(t, err, nil)
// err = validate.FieldWithValue(j2, j, "nefield")
// Equal(t, err, nil)
// err = validate.FieldWithValue(k2, k, "nefield")
// Equal(t, err, nil)
// err = validate.FieldWithValue(arr2, arr, "nefield")
// Equal(t, err, nil)
// err = validate.FieldWithValue(now2, now, "nefield")
// NotEqual(t, err, nil)
// err = validate.FieldWithValue(arr3, arr, "nefield")
// NotEqual(t, err, nil)
// 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)
// now3 := time.Now().UTC()
// sv = &Test{
// Start: &now,
// End: &now3,
// }
// errs = validate.Struct(sv)
// Equal(t, errs, nil)
// channel := make(chan string)
// PanicMatches(t, func() { validate.FieldWithValue(nil, 1, "nefield") }, "struct not passed for cross validation")
// PanicMatches(t, func() { validate.FieldWithValue(5, channel, "nefield") }, "Bad field type chan string")
// PanicMatches(t, func() { validate.FieldWithValue(5, now, "nefield") }, "Bad Top Level field type")
// type Test2 struct {
// Start *time.Time `validate:"nefield=NonExistantField"`
// End *time.Time
// }
// sv2 := &Test2{
// Start: &now,
// End: &now,
// }
// PanicMatches(t, func() { validate.Struct(sv2) }, "Field \"NonExistantField\" not found in struct")
// }
// 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()
// err := validate.Field(s, "ne=abcd")
// Equal(t, err, nil)
// err = validate.Field(i, "ne=1")
// Equal(t, err, nil)
// err = validate.Field(j, "ne=1")
// Equal(t, err, nil)
// err = validate.Field(k, "ne=1.543")
// Equal(t, err, nil)
// err = validate.Field(arr, "ne=2")
// Equal(t, err, nil)
// err = validate.Field(arr, "ne=1")
// NotEqual(t, err, nil)
// 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
// err := validate.FieldWithValue(s, s2, "eqfield")
// Equal(t, err, nil)
// err = validate.FieldWithValue(i2, i, "eqfield")
// Equal(t, err, nil)
// err = validate.FieldWithValue(j2, j, "eqfield")
// Equal(t, err, nil)
// err = validate.FieldWithValue(k2, k, "eqfield")
// Equal(t, err, nil)
// err = validate.FieldWithValue(arr2, arr, "eqfield")
// Equal(t, err, nil)
// err = validate.FieldWithValue(now2, now, "eqfield")
// Equal(t, err, nil)
// err = validate.FieldWithValue(arr3, arr, "eqfield")
// NotEqual(t, err, nil)
// 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)
// channel := make(chan string)
// PanicMatches(t, func() { validate.FieldWithValue(nil, 1, "eqfield") }, "struct not passed for cross validation")
// PanicMatches(t, func() { validate.FieldWithValue(5, channel, "eqfield") }, "Bad field type chan string")
// PanicMatches(t, func() { validate.FieldWithValue(5, now, "eqfield") }, "Bad Top Level field type")
// type Test2 struct {
// Start *time.Time `validate:"eqfield=NonExistantField"`
// End *time.Time
// }
// sv2 := &Test2{
// Start: &now,
// End: &now,
// }
// PanicMatches(t, func() { validate.Struct(sv2) }, "Field \"NonExistantField\" not found in struct")
// }
// 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()
// err := validate.Field(s, "eq=abcd")
// Equal(t, err, nil)
// err = validate.Field(i, "eq=1")
// Equal(t, err, nil)
// err = validate.Field(j, "eq=1")
// Equal(t, err, nil)
// err = validate.Field(k, "eq=1.543")
// Equal(t, err, nil)
// err = validate.Field(arr, "eq=1")
// Equal(t, err, nil)
// err = validate.Field(arr, "eq=2")
// NotEqual(t, err, nil)
// PanicMatches(t, func() { validate.Field(now, "eq=now") }, "Bad field type time.Time")
// }
// func TestBase64Validation(t *testing.T) {
// s := "dW5pY29ybg=="
// err := validate.Field(s, "base64")
// Equal(t, err, nil)
// s = "dGhpIGlzIGEgdGVzdCBiYXNlNjQ="
// err = validate.Field(s, "base64")
// Equal(t, err, nil)
// s = ""
// err = validate.Field(s, "base64")
// NotEqual(t, err, nil)
// s = "dW5pY29ybg== foo bar"
// err = validate.Field(s, "base64")
// NotEqual(t, err, 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)
// 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,
// }
// errs2 := validate.Struct(timeTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "End", "gtfield")
// err3 := validate.FieldWithValue(&start, &end, "gtfield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(&end, &start, "gtfield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "gtfield")
// 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,
// }
// errs2 = validate.Struct(intTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Val2", "gtfield")
// err3 = validate.FieldWithValue(int(1), int(5), "gtfield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(int(5), int(1), "gtfield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "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,
// }
// errs2 = validate.Struct(uIntTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Val2", "gtfield")
// err3 = validate.FieldWithValue(uint(1), uint(5), "gtfield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(uint(5), uint(1), "gtfield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "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,
// }
// errs2 = validate.Struct(floatTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Val2", "gtfield")
// err3 = validate.FieldWithValue(float32(1), float32(5), "gtfield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(float32(5), float32(1), "gtfield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "gtfield")
// PanicMatches(t, func() { validate.FieldWithValue(nil, 1, "gtfield") }, "struct not passed for cross validation")
// PanicMatches(t, func() { validate.FieldWithValue(5, "T", "gtfield") }, "Bad field type string")
// PanicMatches(t, func() { validate.FieldWithValue(5, start, "gtfield") }, "Bad Top Level field type")
// type TimeTest2 struct {
// Start *time.Time `validate:"required"`
// End *time.Time `validate:"required,gtfield=NonExistantField"`
// }
// timeTest2 := &TimeTest2{
// Start: &start,
// End: &end,
// }
// PanicMatches(t, func() { validate.Struct(timeTest2) }, "Field \"NonExistantField\" not found in struct")
// }
// 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,
// }
// errs2 := validate.Struct(timeTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Start", "ltfield")
// err3 := validate.FieldWithValue(&end, &start, "ltfield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(&start, &end, "ltfield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "ltfield")
// 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,
// }
// errs2 = validate.Struct(intTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Val2", "ltfield")
// err3 = validate.FieldWithValue(int(5), int(1), "ltfield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(int(1), int(5), "ltfield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "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,
// }
// errs2 = validate.Struct(uIntTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Val2", "ltfield")
// err3 = validate.FieldWithValue(uint(5), uint(1), "ltfield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(uint(1), uint(5), "ltfield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "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,
// }
// errs2 = validate.Struct(floatTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Val2", "ltfield")
// err3 = validate.FieldWithValue(float32(5), float32(1), "ltfield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(float32(1), float32(5), "ltfield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "ltfield")
// PanicMatches(t, func() { validate.FieldWithValue(nil, 5, "ltfield") }, "struct not passed for cross validation")
// PanicMatches(t, func() { validate.FieldWithValue(1, "T", "ltfield") }, "Bad field type string")
// PanicMatches(t, func() { validate.FieldWithValue(1, end, "ltfield") }, "Bad Top Level field type")
// type TimeTest2 struct {
// Start *time.Time `validate:"required"`
// End *time.Time `validate:"required,ltfield=NonExistantField"`
// }
// timeTest2 := &TimeTest2{
// Start: &end,
// End: &start,
// }
// PanicMatches(t, func() { validate.Struct(timeTest2) }, "Field \"NonExistantField\" not found in struct")
// }
// 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,
// }
// errs2 := validate.Struct(timeTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Start", "ltefield")
// err3 := validate.FieldWithValue(&end, &start, "ltefield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(&start, &end, "ltefield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "ltefield")
// 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,
// }
// errs2 = validate.Struct(intTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Val2", "ltefield")
// err3 = validate.FieldWithValue(int(5), int(1), "ltefield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(int(1), int(5), "ltefield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "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,
// }
// errs2 = validate.Struct(uIntTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Val2", "ltefield")
// err3 = validate.FieldWithValue(uint(5), uint(1), "ltefield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(uint(1), uint(5), "ltefield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "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,
// }
// errs2 = validate.Struct(floatTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Val2", "ltefield")
// err3 = validate.FieldWithValue(float32(5), float32(1), "ltefield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(float32(1), float32(5), "ltefield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "ltefield")
// PanicMatches(t, func() { validate.FieldWithValue(nil, 5, "ltefield") }, "struct not passed for cross validation")
// PanicMatches(t, func() { validate.FieldWithValue(1, "T", "ltefield") }, "Bad field type string")
// PanicMatches(t, func() { validate.FieldWithValue(1, end, "ltefield") }, "Bad Top Level field type")
// type TimeTest2 struct {
// Start *time.Time `validate:"required"`
// End *time.Time `validate:"required,ltefield=NonExistantField"`
// }
// timeTest2 := &TimeTest2{
// Start: &end,
// End: &start,
// }
// PanicMatches(t, func() { validate.Struct(timeTest2) }, "Field \"NonExistantField\" not found in struct")
// }
// 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,
// }
// errs2 := validate.Struct(timeTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "End", "gtefield")
// err3 := validate.FieldWithValue(&start, &end, "gtefield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(&end, &start, "gtefield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "gtefield")
// 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,
// }
// errs2 = validate.Struct(intTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Val2", "gtefield")
// err3 = validate.FieldWithValue(int(1), int(5), "gtefield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(int(5), int(1), "gtefield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "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,
// }
// errs2 = validate.Struct(uIntTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Val2", "gtefield")
// err3 = validate.FieldWithValue(uint(1), uint(5), "gtefield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(uint(5), uint(1), "gtefield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "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,
// }
// errs2 = validate.Struct(floatTest).Flatten()
// NotEqual(t, errs2, nil)
// AssertMapFieldError(t, errs2, "Val2", "gtefield")
// err3 = validate.FieldWithValue(float32(1), float32(5), "gtefield")
// Equal(t, err3, nil)
// err3 = validate.FieldWithValue(float32(5), float32(1), "gtefield")
// NotEqual(t, err3, nil)
// Equal(t, err3.Tag, "gtefield")
// PanicMatches(t, func() { validate.FieldWithValue(nil, 1, "gtefield") }, "struct not passed for cross validation")
// PanicMatches(t, func() { validate.FieldWithValue(5, "T", "gtefield") }, "Bad field type string")
// PanicMatches(t, func() { validate.FieldWithValue(5, start, "gtefield") }, "Bad Top Level field type")
// type TimeTest2 struct {
// Start *time.Time `validate:"required"`
// End *time.Time `validate:"required,gtefield=NonExistantField"`
// }
// timeTest2 := &TimeTest2{
// Start: &start,
// End: &end,
// }
// PanicMatches(t, func() { validate.Struct(timeTest2) }, "Field \"NonExistantField\" not found in struct")
// }
// func TestValidateByTagAndValue(t *testing.T) {
// val := "test"
// field := "test"
// err := validate.FieldWithValue(val, field, "required")
// Equal(t, err, nil)
// fn := func(val interface{}, current interface{}, field interface{}, param string) bool {
// return current.(string) == field.(string)
// }
// validate.AddFunction("isequaltestfunc", fn)
// err = validate.FieldWithValue(val, field, "isequaltestfunc")
// Equal(t, err, nil)
// val = "unequal"
// err = validate.FieldWithValue(val, field, "isequaltestfunc")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "isequaltestfunc")
// }
// func TestAddFunctions(t *testing.T) {
// fn := func(val interface{}, current interface{}, field interface{}, param string) bool {
// return true
// }
// validate := New("validateme", BakedInValidators)
// err := validate.AddFunction("new", fn)
// Equal(t, err, nil)
// err = validate.AddFunction("", fn)
// NotEqual(t, err, nil)
// validate.AddFunction("new", nil)
// NotEqual(t, err, nil)
// err = validate.AddFunction("new", fn)
// Equal(t, err, nil)
// }
// func TestChangeTag(t *testing.T) {
// validate := New("validateme", BakedInValidators)
// validate.SetTag("val")
// type Test struct {
// Name string `val:"len=4"`
// }
// s := &Test{
// Name: "TEST",
// }
// err := validate.Struct(s)
// Equal(t, err, nil)
// }
// func TestUnexposedStruct(t *testing.T) {
// type Test struct {
// Name string
// unexposed struct {
// A string `validate:"required"`
// }
// }
// s := &Test{
// Name: "TEST",
// }
// err := validate.Struct(s)
// Equal(t, err, nil)
// }
// func TestBadParams(t *testing.T) {
// i := 1
// err := validate.Field(i, "-")
// Equal(t, err, 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{}
// err := validate.Field(myMap, "gt=0")
// NotEqual(t, err, nil)
// f := 1.23
// err = validate.Field(f, "gt=5")
// NotEqual(t, err, nil)
// var ui uint = 5
// err = validate.Field(ui, "gt=10")
// NotEqual(t, err, nil)
// i := true
// PanicMatches(t, func() { validate.Field(i, "gt") }, "Bad field type bool")
// tm := time.Now().UTC()
// tm = tm.Add(time.Hour * 24)
// err = validate.Field(tm, "gt")
// Equal(t, err, nil)
// t2 := time.Now().UTC()
// err = validate.Field(t2, "gt")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "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)
// }
// 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)
// err := validate.Field(t1, "gte")
// Equal(t, err, nil)
// t2 := time.Now().UTC()
// err = validate.Field(t2, "gte")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "gte")
// Equal(t, err.Type, reflect.TypeOf(time.Time{}))
// 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)
// }
// func TestIsLt(t *testing.T) {
// myMap := map[string]string{}
// err := validate.Field(myMap, "lt=0")
// NotEqual(t, err, nil)
// f := 1.23
// err = validate.Field(f, "lt=0")
// NotEqual(t, err, nil)
// var ui uint = 5
// err = validate.Field(ui, "lt=0")
// NotEqual(t, err, nil)
// i := true
// PanicMatches(t, func() { validate.Field(i, "lt") }, "Bad field type bool")
// t1 := time.Now().UTC()
// err = validate.Field(t1, "lt")
// Equal(t, err, nil)
// t2 := time.Now().UTC()
// t2 = t2.Add(time.Hour * 24)
// err = validate.Field(t2, "lt")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "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)
// }
// func TestIsLte(t *testing.T) {
// i := true
// PanicMatches(t, func() { validate.Field(i, "lte") }, "Bad field type bool")
// t1 := time.Now().UTC()
// err := validate.Field(t1, "lte")
// Equal(t, err, nil)
// t2 := time.Now().UTC()
// t2 = t2.Add(time.Hour * 24)
// err = validate.Field(t2, "lte")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "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=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 {
// err := validate.Field(test.param, "url")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d URL failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "url") {
// t.Fatalf("Index: %d URL failed Error: %s", i, err)
// }
// }
// }
// 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 {
// err := validate.Field(test.param, "uri")
// if test.expected == true {
// if !IsEqual(t, err, nil) {
// t.Fatalf("Index: %d URI failed Error: %s", i, err)
// }
// } else {
// if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "uri") {
// t.Fatalf("Index: %d URI failed Error: %s", i, err)
// }
// }
// }
// 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)"
// err := validate.Field(s, "rgb|rgba")
// Equal(t, err, nil)
// s = "rgba(0,31,255,0.5)"
// err = validate.Field(s, "rgb|rgba|len=18")
// Equal(t, err, nil)
// s = "this ain't right"
// err = validate.Field(s, "rgb|rgba")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "rgb|rgba")
// s = "this ain't right"
// err = validate.Field(s, "rgb|rgba|len=10")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "rgb|rgba|len")
// s = "this is right"
// err = validate.Field(s, "rgb|rgba|len=13")
// Equal(t, err, nil)
// s = ""
// err = validate.Field(s, "omitempty,rgb|rgba")
// Equal(t, err, nil)
// }
// func TestHsla(t *testing.T) {
// s := "hsla(360,100%,100%,1)"
// err := validate.Field(s, "hsla")
// Equal(t, err, nil)
// s = "hsla(360,100%,100%,0.5)"
// err = validate.Field(s, "hsla")
// Equal(t, err, nil)
// s = "hsla(0,0%,0%, 0)"
// err = validate.Field(s, "hsla")
// Equal(t, err, nil)
// s = "hsl(361,100%,50%,1)"
// err = validate.Field(s, "hsla")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "hsla")
// s = "hsl(361,100%,50%)"
// err = validate.Field(s, "hsla")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "hsla")
// s = "hsla(361,100%,50%)"
// err = validate.Field(s, "hsla")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "hsla")
// s = "hsla(360,101%,50%)"
// err = validate.Field(s, "hsla")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "hsla")
// s = "hsla(360,100%,101%)"
// err = validate.Field(s, "hsla")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "hsla")
// i := 1
// PanicMatches(t, func() { validate.Field(i, "hsla") }, "interface conversion: interface is int, not string")
// }
// func TestHsl(t *testing.T) {
// s := "hsl(360,100%,50%)"
// err := validate.Field(s, "hsl")
// Equal(t, err, nil)
// s = "hsl(0,0%,0%)"
// err = validate.Field(s, "hsl")
// Equal(t, err, nil)
// s = "hsl(361,100%,50%)"
// err = validate.Field(s, "hsl")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "hsl")
// s = "hsl(361,101%,50%)"
// err = validate.Field(s, "hsl")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "hsl")
// s = "hsl(361,100%,101%)"
// err = validate.Field(s, "hsl")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "hsl")
// s = "hsl(-10,100%,100%)"
// err = validate.Field(s, "hsl")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "hsl")
// i := 1
// PanicMatches(t, func() { validate.Field(i, "hsl") }, "interface conversion: interface is int, not string")
// }
// func TestRgba(t *testing.T) {
// s := "rgba(0,31,255,0.5)"
// err := validate.Field(s, "rgba")
// Equal(t, err, nil)
// s = "rgba(0,31,255,0.12)"
// err = validate.Field(s, "rgba")
// Equal(t, err, nil)
// s = "rgba(12%,55%,100%,0.12)"
// err = validate.Field(s, "rgba")
// Equal(t, err, nil)
// s = "rgba( 0, 31, 255, 0.5)"
// err = validate.Field(s, "rgba")
// Equal(t, err, nil)
// s = "rgba(12%,55,100%,0.12)"
// err = validate.Field(s, "rgba")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "rgba")
// s = "rgb(0, 31, 255)"
// err = validate.Field(s, "rgba")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "rgba")
// s = "rgb(1,349,275,0.5)"
// err = validate.Field(s, "rgba")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "rgba")
// s = "rgb(01,31,255,0.5)"
// err = validate.Field(s, "rgba")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "rgba")
// i := 1
// PanicMatches(t, func() { validate.Field(i, "rgba") }, "interface conversion: interface is int, not string")
// }
// func TestRgb(t *testing.T) {
// s := "rgb(0,31,255)"
// err := validate.Field(s, "rgb")
// Equal(t, err, nil)
// s = "rgb(0, 31, 255)"
// err = validate.Field(s, "rgb")
// Equal(t, err, nil)
// s = "rgb(10%, 50%, 100%)"
// err = validate.Field(s, "rgb")
// Equal(t, err, nil)
// s = "rgb(10%, 50%, 55)"
// err = validate.Field(s, "rgb")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "rgb")
// s = "rgb(1,349,275)"
// err = validate.Field(s, "rgb")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "rgb")
// s = "rgb(01,31,255)"
// err = validate.Field(s, "rgb")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "rgb")
// s = "rgba(0,31,255)"
// err = validate.Field(s, "rgb")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "rgb")
// i := 1
// PanicMatches(t, func() { validate.Field(i, "rgb") }, "interface conversion: interface is int, not string")
// }
// func TestEmail(t *testing.T) {
// s := "test@mail.com"
// err := validate.Field(s, "email")
// Equal(t, err, nil)
// s = ""
// err = validate.Field(s, "email")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "email")
// s = "test@email"
// err = validate.Field(s, "email")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "email")
// s = "test@email."
// err = validate.Field(s, "email")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "email")
// s = "@email.com"
// err = validate.Field(s, "email")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "email")
// i := true
// PanicMatches(t, func() { validate.Field(i, "email") }, "interface conversion: interface is bool, not string")
// }
// func TestHexColor(t *testing.T) {
// s := "#fff"
// err := validate.Field(s, "hexcolor")
// Equal(t, err, nil)
// s = "#c2c2c2"
// err = validate.Field(s, "hexcolor")
// Equal(t, err, nil)
// s = "fff"
// err = validate.Field(s, "hexcolor")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "hexcolor")
// s = "fffFF"
// err = validate.Field(s, "hexcolor")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "hexcolor")
// i := true
// PanicMatches(t, func() { validate.Field(i, "hexcolor") }, "interface conversion: interface is bool, not string")
// }
// func TestHexadecimal(t *testing.T) {
// s := "ff0044"
// err := validate.Field(s, "hexadecimal")
// Equal(t, err, nil)
// s = "abcdefg"
// err = validate.Field(s, "hexadecimal")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "hexadecimal")
// i := true
// PanicMatches(t, func() { validate.Field(i, "hexadecimal") }, "interface conversion: interface is bool, not string")
// }
// func TestNumber(t *testing.T) {
// s := "1"
// err := validate.Field(s, "number")
// Equal(t, err, nil)
// s = "+1"
// err = validate.Field(s, "number")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "number")
// s = "-1"
// err = validate.Field(s, "number")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "number")
// s = "1.12"
// err = validate.Field(s, "number")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "number")
// s = "+1.12"
// err = validate.Field(s, "number")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "number")
// s = "-1.12"
// err = validate.Field(s, "number")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "number")
// s = "1."
// err = validate.Field(s, "number")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "number")
// s = "1.o"
// err = validate.Field(s, "number")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "number")
// i := 1
// PanicMatches(t, func() { validate.Field(i, "number") }, "interface conversion: interface is int, not string")
// }
// func TestNumeric(t *testing.T) {
// s := "1"
// err := validate.Field(s, "numeric")
// Equal(t, err, nil)
// s = "+1"
// err = validate.Field(s, "numeric")
// Equal(t, err, nil)
// s = "-1"
// err = validate.Field(s, "numeric")
// Equal(t, err, nil)
// s = "1.12"
// err = validate.Field(s, "numeric")
// Equal(t, err, nil)
// s = "+1.12"
// err = validate.Field(s, "numeric")
// Equal(t, err, nil)
// s = "-1.12"
// err = validate.Field(s, "numeric")
// Equal(t, err, nil)
// s = "1."
// err = validate.Field(s, "numeric")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "numeric")
// s = "1.o"
// err = validate.Field(s, "numeric")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "numeric")
// i := 1
// PanicMatches(t, func() { validate.Field(i, "numeric") }, "interface conversion: interface is int, not string")
// }
// func TestAlphaNumeric(t *testing.T) {
// s := "abcd123"
// err := validate.Field(s, "alphanum")
// Equal(t, err, nil)
// s = "abc!23"
// err = validate.Field(s, "alphanum")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "alphanum")
// PanicMatches(t, func() { validate.Field(1, "alphanum") }, "interface conversion: interface is int, not string")
// }
// func TestAlpha(t *testing.T) {
// s := "abcd"
// err := validate.Field(s, "alpha")
// Equal(t, err, nil)
// s = "abc1"
// err = validate.Field(s, "alpha")
// NotEqual(t, err, nil)
// Equal(t, err.Tag, "alpha")
// PanicMatches(t, func() { validate.Field(1, "alpha") }, "interface conversion: interface is int, not string")
// }
// func TestFlattening(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",
// },
// }
// err1 := validate.Struct(tSuccess).Flatten()
// Equal(t, len(err1), 0)
// tFail := &TestString{
// Required: "",
// Len: "",
// Min: "",
// Max: "12345678901",
// MinMax: "",
// OmitEmpty: "12345678901",
// Sub: &SubTest{
// Test: "",
// },
// Anonymous: struct {
// A string `validate:"required"`
// }{
// A: "",
// },
// Iface: &Impl{
// F: "12",
// },
// }
// err2 := validate.Struct(tFail).Flatten()
// // Assert Top Level
// NotEqual(t, err2, nil)
// // Assert Fields
// AssertMapFieldError(t, err2, "Len", "len")
// AssertMapFieldError(t, err2, "Gt", "gt")
// AssertMapFieldError(t, err2, "Gte", "gte")
// // Assert Struct Field
// AssertMapFieldError(t, err2, "Sub.Test", "required")
// // Assert Anonymous Struct Field
// AssertMapFieldError(t, err2, "Anonymous.A", "required")
// // Assert Interface Field
// AssertMapFieldError(t, err2, "Iface.F", "len")
// }
// func TestStructStringValidation(t *testing.T) {
// validate.SetMaxStructPoolSize(11)
// 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",
// },
// }
// err := validate.Struct(tSuccess)
// Equal(t, err, 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",
// },
// }
// err = validate.Struct(tFail)
// // Assert Top Level
// NotEqual(t, err, nil)
// Equal(t, err.Struct, "TestString")
// Equal(t, len(err.Errors), 10)
// Equal(t, len(err.StructErrors), 3)
// // Assert Fields
// AssertFieldError(t, err, "Required", "required")
// AssertFieldError(t, err, "Len", "len")
// AssertFieldError(t, err, "Min", "min")
// AssertFieldError(t, err, "Max", "max")
// AssertFieldError(t, err, "MinMax", "min")
// AssertFieldError(t, err, "Gt", "gt")
// AssertFieldError(t, err, "Gte", "gte")
// AssertFieldError(t, err, "OmitEmpty", "max")
// // Assert Anonymous embedded struct
// AssertStruct(t, err, "Anonymous", "")
// // Assert SubTest embedded struct
// val := AssertStruct(t, err, "Sub", "SubTest")
// Equal(t, len(val.Errors), 1)
// Equal(t, len(val.StructErrors), 0)
// AssertFieldError(t, val, "Test", "required")
// errors := err.Error()
// NotEqual(t, errors, nil)
// }
// 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,
// }
// err := validate.Struct(tSuccess)
// Equal(t, err, nil)
// tFail := &TestInt32{
// Required: 0,
// Len: 11,
// Min: -1,
// Max: 11,
// MinMax: -1,
// Lt: 10,
// Lte: 11,
// Gt: 10,
// Gte: 9,
// OmitEmpty: 11,
// }
// err = validate.Struct(tFail)
// // Assert Top Level
// NotEqual(t, err, nil)
// Equal(t, err.Struct, "TestInt32")
// Equal(t, len(err.Errors), 10)
// Equal(t, len(err.StructErrors), 0)
// // Assert Fields
// AssertFieldError(t, err, "Required", "required")
// AssertFieldError(t, err, "Len", "len")
// AssertFieldError(t, err, "Min", "min")
// AssertFieldError(t, err, "Max", "max")
// AssertFieldError(t, err, "MinMax", "min")
// AssertFieldError(t, err, "Lt", "lt")
// AssertFieldError(t, err, "Lte", "lte")
// AssertFieldError(t, err, "Gt", "gt")
// AssertFieldError(t, err, "Gte", "gte")
// AssertFieldError(t, err, "OmitEmpty", "max")
// }
// func TestStructUint64Validation(t *testing.T) {
// tSuccess := &TestUint64{
// Required: 1,
// Len: 10,
// Min: 1,
// Max: 10,
// MinMax: 5,
// OmitEmpty: 0,
// }
// err := validate.Struct(tSuccess)
// Equal(t, err, nil)
// tFail := &TestUint64{
// Required: 0,
// Len: 11,
// Min: 0,
// Max: 11,
// MinMax: 0,
// OmitEmpty: 11,
// }
// err = validate.Struct(tFail)
// // Assert Top Level
// NotEqual(t, err, nil)
// Equal(t, err.Struct, "TestUint64")
// Equal(t, len(err.Errors), 6)
// Equal(t, len(err.StructErrors), 0)
// // Assert Fields
// AssertFieldError(t, err, "Required", "required")
// AssertFieldError(t, err, "Len", "len")
// AssertFieldError(t, err, "Min", "min")
// AssertFieldError(t, err, "Max", "max")
// AssertFieldError(t, err, "MinMax", "min")
// AssertFieldError(t, err, "OmitEmpty", "max")
// }
// func TestStructFloat64Validation(t *testing.T) {
// tSuccess := &TestFloat64{
// Required: 1,
// Len: 10,
// Min: 1,
// Max: 10,
// MinMax: 5,
// OmitEmpty: 0,
// }
// err := validate.Struct(tSuccess)
// Equal(t, err, nil)
// tFail := &TestFloat64{
// Required: 0,
// Len: 11,
// Min: 0,
// Max: 11,
// MinMax: 0,
// OmitEmpty: 11,
// }
// err = validate.Struct(tFail)
// // Assert Top Level
// NotEqual(t, err, nil)
// Equal(t, err.Struct, "TestFloat64")
// Equal(t, len(err.Errors), 6)
// Equal(t, len(err.StructErrors), 0)
// // Assert Fields
// AssertFieldError(t, err, "Required", "required")
// AssertFieldError(t, err, "Len", "len")
// AssertFieldError(t, err, "Min", "min")
// AssertFieldError(t, err, "Max", "max")
// AssertFieldError(t, err, "MinMax", "min")
// AssertFieldError(t, err, "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: []int{},
// }
// err := validate.Struct(tSuccess)
// Equal(t, err, nil)
// tFail := &TestSlice{
// Required: []int{},
// 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},
// }
// err = validate.Struct(tFail)
// // Assert Top Level
// NotEqual(t, err, nil)
// Equal(t, err.Struct, "TestSlice")
// Equal(t, len(err.Errors), 6)
// Equal(t, len(err.StructErrors), 0)
// // Assert Fields
// AssertFieldError(t, err, "Required", "required")
// AssertFieldError(t, err, "Len", "len")
// AssertFieldError(t, err, "Min", "min")
// AssertFieldError(t, err, "Max", "max")
// AssertFieldError(t, err, "MinMax", "min")
// AssertFieldError(t, err, "OmitEmpty", "max")
// }
// func TestInvalidStruct(t *testing.T) {
// s := &SubTest{
// Test: "1",
// }
// PanicMatches(t, func() { validate.Struct(s.Test) }, "interface passed for validation is not a struct")
// }
// func TestInvalidField(t *testing.T) {
// s := &SubTest{
// Test: "1",
// }
// PanicMatches(t, func() { validate.Field(s, "required") }, "Invalid field passed to fieldWithNameAndValue")
// }
// func TestInvalidTagField(t *testing.T) {
// s := &SubTest{
// Test: "1",
// }
// PanicMatches(t, func() { validate.Field(s.Test, "") }, fmt.Sprintf("Invalid validation tag on field %s", ""))
// }
// func TestInvalidValidatorFunction(t *testing.T) {
// s := &SubTest{
// Test: "1",
// }
// PanicMatches(t, func() { validate.Field(s.Test, "zzxxBadFunction") }, fmt.Sprintf("Undefined validation function on field %s", ""))
// }
// func TestPoolObjectMaxSizeValidation(t *testing.T) {
// // this will ensure that the pool objects are let go
// // when the pool is saturated
// validate.SetMaxStructPoolSize(0)
// 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: []int{},
// }
// for i := 0; i < 2; i++ {
// err := validate.Struct(tSuccess)
// Equal(t, err, nil)
// }
// }