package validator
import (
"database/sql/driver"
"reflect"
"testing"
. "gopkg.in/go-playground/assert.v1"
)
// NOTES:
// - Run "go test" to run tests
// - Run "gocov test | gocov report" to report on test converage by file
// - Run "gocov test | gocov annotate -" to report on all code and functions, those ,marked with "MISS" were never called
//
// or
//
// -- may be a good idea to change to output path to somewherelike /tmp
// go test -coverprofile cover.out && go tool cover -html=cover.out -o cover.html
//
//
// go test -cpuprofile cpu.out
// ./validator.test -test.bench=. -test.cpuprofile=cpu.prof
// go tool pprof validator.test cpu.prof
//
//
// go test -memprofile mem.out
type I interface {
Foo ( ) string
}
type Impl struct {
F string ` validate:"len=3" `
}
func ( i * Impl ) Foo ( ) string {
return i . F
}
type SubTest struct {
Test string ` validate:"required" `
}
type TestInterface struct {
Iface I
}
type TestString struct {
BlankTag string ` validate:"" `
Required string ` validate:"required" `
Len string ` validate:"len=10" `
Min string ` validate:"min=1" `
Max string ` validate:"max=10" `
MinMax string ` validate:"min=1,max=10" `
Lt string ` validate:"lt=10" `
Lte string ` validate:"lte=10" `
Gt string ` validate:"gt=10" `
Gte string ` validate:"gte=10" `
OmitEmpty string ` validate:"omitempty,min=1,max=10" `
Sub * SubTest
SubIgnore * SubTest ` validate:"-" `
Anonymous struct {
A string ` validate:"required" `
}
Iface I
}
// type TestUint64 struct {
// Required uint64 `validate:"required"`
// Len uint64 `validate:"len=10"`
// Min uint64 `validate:"min=1"`
// Max uint64 `validate:"max=10"`
// MinMax uint64 `validate:"min=1,max=10"`
// OmitEmpty uint64 `validate:"omitempty,min=1,max=10"`
// }
// type TestFloat64 struct {
// Required float64 `validate:"required"`
// Len float64 `validate:"len=10"`
// Min float64 `validate:"min=1"`
// Max float64 `validate:"max=10"`
// MinMax float64 `validate:"min=1,max=10"`
// Lte float64 `validate:"lte=10"`
// OmitEmpty float64 `validate:"omitempty,min=1,max=10"`
// }
// type TestSlice struct {
// Required []int `validate:"required"`
// Len []int `validate:"len=10"`
// Min []int `validate:"min=1"`
// Max []int `validate:"max=10"`
// MinMax []int `validate:"min=1,max=10"`
// OmitEmpty []int `validate:"omitempty,min=1,max=10"`
// }
// var validate = New(&Config{TagName: "validate"})
func AssertError ( t * testing . T , err error , key , field , expectedTag string ) {
errs := err . ( ValidationErrors )
found := false
var fe FieldError
for i := 0 ; i < len ( errs ) ; i ++ {
if errs [ i ] . Namespace ( ) == key {
found = true
fe = errs [ i ]
break
}
}
EqualSkip ( t , 2 , found , true )
NotEqualSkip ( t , 2 , fe , nil )
EqualSkip ( t , 2 , fe . Field ( ) , field )
EqualSkip ( t , 2 , fe . Tag ( ) , expectedTag )
}
type valuer struct {
Name string
}
// func (v valuer) Value() (driver.Value, error) {
// if v.Name == "errorme" {
// panic("SQL Driver Valuer error: some kind of error")
// // return nil, errors.New("some kind of error")
// }
// if len(v.Name) == 0 {
// return nil, nil
// }
// return v.Name, nil
// }
// type MadeUpCustomType struct {
// FirstName string
// LastName string
// }
// func ValidateCustomType(field reflect.Value) interface{} {
// if cust, ok := field.Interface().(MadeUpCustomType); ok {
// if len(cust.FirstName) == 0 || len(cust.LastName) == 0 {
// return ""
// }
// return cust.FirstName + " " + cust.LastName
// }
// return ""
// }
// func OverrideIntTypeForSomeReason(field reflect.Value) interface{} {
// if i, ok := field.Interface().(int); ok {
// if i == 1 {
// return "1"
// }
// if i == 2 {
// return "12"
// }
// }
// return ""
// }
// type CustomMadeUpStruct struct {
// MadeUp MadeUpCustomType `validate:"required"`
// OverriddenInt int `validate:"gt=1"`
// }
func ValidateValuerType ( field reflect . Value ) interface { } {
if valuer , ok := field . Interface ( ) . ( driver . Valuer ) ; ok {
val , err := valuer . Value ( )
if err != nil {
// handle the error how you want
return nil
}
return val
}
return nil
}
// type TestPartial struct {
// NoTag string
// BlankTag string `validate:""`
// Required string `validate:"required"`
// SubSlice []*SubTest `validate:"required,dive"`
// Sub *SubTest
// SubIgnore *SubTest `validate:"-"`
// Anonymous struct {
// A string `validate:"required"`
// ASubSlice []*SubTest `validate:"required,dive"`
// SubAnonStruct []struct {
// Test string `validate:"required"`
// OtherTest string `validate:"required"`
// } `validate:"required,dive"`
// }
// }
type TestStruct struct {
String string ` validate:"required" json:"StringVal" `
}
func StructValidationTestStructSuccess ( sl StructLevel ) {
st := sl . Current ( ) . Interface ( ) . ( TestStruct )
if st . String != "good value" {
sl . ReportError ( reflect . ValueOf ( st . String ) , "String" , "StringVal" , "badvalueteststruct" )
}
}
func StructValidationTestStruct ( sl StructLevel ) {
st := sl . Current ( ) . Interface ( ) . ( TestStruct )
if st . String != "bad value" {
sl . ReportError ( reflect . ValueOf ( st . String ) , "String" , "StringVal" , "badvalueteststruct" )
}
}
// func StructValidationBadTestStructFieldName(v *Validate, structLevel *StructLevel) {
// st := structLevel.CurrentStruct.Interface().(TestStruct)
// if st.String != "bad value" {
// structLevel.ReportError(reflect.ValueOf(st.String), "", "StringVal", "badvalueteststruct")
// }
// }
// func StructValidationBadTestStructTag(v *Validate, structLevel *StructLevel) {
// st := structLevel.CurrentStruct.Interface().(TestStruct)
// if st.String != "bad value" {
// structLevel.ReportError(reflect.ValueOf(st.String), "String", "StringVal", "")
// }
// }
// func StructValidationNoTestStructCustomName(v *Validate, structLevel *StructLevel) {
// st := structLevel.CurrentStruct.Interface().(TestStruct)
// if st.String != "bad value" {
// structLevel.ReportError(reflect.ValueOf(st.String), "String", "", "badvalueteststruct")
// }
// }
// func StructValidationTestStructInvalid(v *Validate, structLevel *StructLevel) {
// st := structLevel.CurrentStruct.Interface().(TestStruct)
// if st.String != "bad value" {
// structLevel.ReportError(reflect.ValueOf(nil), "String", "StringVal", "badvalueteststruct")
// }
// }
// func StructValidationTestStructReturnValidationErrors(v *Validate, structLevel *StructLevel) {
// s := structLevel.CurrentStruct.Interface().(TestStructReturnValidationErrors)
// errs := v.Struct(s.Inner1.Inner2)
// if errs == nil {
// return
// }
// structLevel.ReportValidationErrors("Inner1.", errs.(ValidationErrors))
// }
// func StructValidationTestStructReturnValidationErrors2(v *Validate, structLevel *StructLevel) {
// s := structLevel.CurrentStruct.Interface().(TestStructReturnValidationErrors)
// errs := v.Struct(s.Inner1.Inner2)
// if errs == nil {
// return
// }
// structLevel.ReportValidationErrors("Inner1.|Inner1JSON.", errs.(ValidationErrors))
// }
// type TestStructReturnValidationErrorsInner2 struct {
// String string `validate:"required" json:"JSONString"`
// }
// type TestStructReturnValidationErrorsInner1 struct {
// Inner2 *TestStructReturnValidationErrorsInner2
// }
// type TestStructReturnValidationErrors struct {
// Inner1 *TestStructReturnValidationErrorsInner1 `json:"Inner1JSON"`
// }
// type Inner2Namespace struct {
// String []string `validate:"dive,required" json:"JSONString"`
// }
// type Inner1Namespace struct {
// Inner2 *Inner2Namespace `json:"Inner2JSON"`
// }
// type Namespace struct {
// Inner1 *Inner1Namespace `json:"Inner1JSON"`
// }
// func TestNameNamespace(t *testing.T) {
// config := &Config{
// TagName: "validate",
// FieldNameTag: "json",
// }
// v1 := New(config)
// i2 := &Inner2Namespace{String: []string{"ok", "ok", "ok"}}
// i1 := &Inner1Namespace{Inner2: i2}
// ns := &Namespace{Inner1: i1}
// errs := v1.Struct(ns)
// Equal(t, errs, nil)
// i2.String[1] = ""
// errs = v1.Struct(ns)
// NotEqual(t, errs, nil)
// ve := errs.(ValidationErrors)
// Equal(t, len(ve), 1)
// AssertError(t, errs, "Namespace.Inner1.Inner2.String[1]", "String[1]", "required")
// fe, ok := ve["Namespace.Inner1.Inner2.String[1]"]
// Equal(t, ok, true)
// Equal(t, fe.Field, "String[1]")
// Equal(t, fe.FieldNamespace, "Namespace.Inner1.Inner2.String[1]")
// Equal(t, fe.Name, "JSONString[1]")
// Equal(t, fe.NameNamespace, "Namespace.Inner1JSON.Inner2JSON.JSONString[1]")
// }
// func TestAnonymous(t *testing.T) {
// v2 := New(&Config{TagName: "validate", FieldNameTag: "json"})
// type Test struct {
// Anonymous struct {
// A string `validate:"required" json:"EH"`
// }
// AnonymousB struct {
// B string `validate:"required" json:"BEE"`
// }
// anonymousC struct {
// c string `validate:"required"`
// }
// }
// tst := &Test{
// Anonymous: struct {
// A string `validate:"required" json:"EH"`
// }{
// A: "1",
// },
// AnonymousB: struct {
// B string `validate:"required" json:"BEE"`
// }{
// B: "",
// },
// anonymousC: struct {
// c string `validate:"required"`
// }{
// c: "",
// },
// }
// err := v2.Struct(tst)
// NotEqual(t, err, nil)
// errs := err.(ValidationErrors)
// Equal(t, len(errs), 1)
// AssertError(t, errs, "Test.AnonymousB.B", "B", "required")
// Equal(t, errs["Test.AnonymousB.B"].Field, "B")
// Equal(t, errs["Test.AnonymousB.B"].Name, "BEE")
// s := struct {
// c string `validate:"required"`
// }{
// c: "",
// }
// err = v2.Struct(s)
// Equal(t, err, nil)
// }
// func TestAnonymousSameStructDifferentTags(t *testing.T) {
// v2 := New(&Config{TagName: "validate", FieldNameTag: "json"})
// type Test struct {
// A interface{}
// }
// tst := &Test{
// A: struct {
// A string `validate:"required"`
// }{
// A: "",
// },
// }
// err := v2.Struct(tst)
// NotEqual(t, err, nil)
// errs := err.(ValidationErrors)
// Equal(t, len(errs), 1)
// AssertError(t, errs, "Test.A.A", "A", "required")
// tst = &Test{
// A: struct {
// A string `validate:"omitempty,required"`
// }{
// A: "",
// },
// }
// err = v2.Struct(tst)
// Equal(t, err, nil)
// }
// func TestStructLevelReturnValidationErrors(t *testing.T) {
// config := &Config{
// TagName: "validate",
// }
// v1 := New(config)
// v1.RegisterStructValidation(StructValidationTestStructReturnValidationErrors, TestStructReturnValidationErrors{})
// inner2 := &TestStructReturnValidationErrorsInner2{
// String: "I'm HERE",
// }
// inner1 := &TestStructReturnValidationErrorsInner1{
// Inner2: inner2,
// }
// val := &TestStructReturnValidationErrors{
// Inner1: inner1,
// }
// errs := v1.Struct(val)
// Equal(t, errs, nil)
// inner2.String = ""
// errs = v1.Struct(val)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 2)
// AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.Inner2.String", "String", "required")
// // this is an extra error reported from struct validation
// AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.String", "String", "required")
// }
// func TestStructLevelReturnValidationErrorsWithJSON(t *testing.T) {
// config := &Config{
// TagName: "validate",
// FieldNameTag: "json",
// }
// v1 := New(config)
// v1.RegisterStructValidation(StructValidationTestStructReturnValidationErrors2, TestStructReturnValidationErrors{})
// inner2 := &TestStructReturnValidationErrorsInner2{
// String: "I'm HERE",
// }
// inner1 := &TestStructReturnValidationErrorsInner1{
// Inner2: inner2,
// }
// val := &TestStructReturnValidationErrors{
// Inner1: inner1,
// }
// errs := v1.Struct(val)
// Equal(t, errs, nil)
// inner2.String = ""
// errs = v1.Struct(val)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 2)
// AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.Inner2.String", "String", "required")
// // this is an extra error reported from struct validation, it's a badly formatted one, but on purpose
// AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.String", "String", "required")
// fe, ok := errs.(ValidationErrors)["TestStructReturnValidationErrors.Inner1.Inner2.String"]
// Equal(t, ok, true)
// // check for proper JSON namespace
// Equal(t, fe.Field, "String")
// Equal(t, fe.Name, "JSONString")
// Equal(t, fe.FieldNamespace, "TestStructReturnValidationErrors.Inner1.Inner2.String")
// Equal(t, fe.NameNamespace, "TestStructReturnValidationErrors.Inner1JSON.Inner2.JSONString")
// fe, ok = errs.(ValidationErrors)["TestStructReturnValidationErrors.Inner1.String"]
// Equal(t, ok, true)
// // check for proper JSON namespace
// Equal(t, fe.Field, "String")
// Equal(t, fe.Name, "JSONString")
// Equal(t, fe.FieldNamespace, "TestStructReturnValidationErrors.Inner1.String")
// Equal(t, fe.NameNamespace, "TestStructReturnValidationErrors.Inner1JSON.JSONString")
// }
// func TestStructLevelValidations(t *testing.T) {
// config := &Config{
// TagName: "validate",
// }
// v1 := New(config)
// v1.RegisterStructValidation(StructValidationTestStruct, TestStruct{})
// tst := &TestStruct{
// String: "good value",
// }
// errs := v1.Struct(tst)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestStruct.String", "String", "badvalueteststruct")
// v2 := New(config)
// v2.RegisterStructValidation(StructValidationBadTestStructFieldName, TestStruct{})
// PanicMatches(t, func() { v2.Struct(tst) }, fieldNameRequired)
// v3 := New(config)
// v3.RegisterStructValidation(StructValidationBadTestStructTag, TestStruct{})
// PanicMatches(t, func() { v3.Struct(tst) }, tagRequired)
// v4 := New(config)
// v4.RegisterStructValidation(StructValidationNoTestStructCustomName, TestStruct{})
// errs = v4.Struct(tst)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestStruct.String", "String", "badvalueteststruct")
// v5 := New(config)
// v5.RegisterStructValidation(StructValidationTestStructInvalid, TestStruct{})
// errs = v5.Struct(tst)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestStruct.String", "String", "badvalueteststruct")
// v6 := New(config)
// v6.RegisterStructValidation(StructValidationTestStructSuccess, TestStruct{})
// errs = v6.Struct(tst)
// Equal(t, errs, nil)
// }
// func TestAliasTags(t *testing.T) {
// validate.RegisterAliasValidation("iscolor", "hexcolor|rgb|rgba|hsl|hsla")
// s := "rgb(255,255,255)"
// errs := validate.Field(s, "iscolor")
// Equal(t, errs, nil)
// s = ""
// errs = validate.Field(s, "omitempty,iscolor")
// Equal(t, errs, nil)
// s = "rgb(255,255,0)"
// errs = validate.Field(s, "iscolor,len=5")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "len")
// type Test struct {
// Color string `validate:"iscolor"`
// }
// tst := &Test{
// Color: "#000",
// }
// errs = validate.Struct(tst)
// Equal(t, errs, nil)
// tst.Color = "cfvre"
// errs = validate.Struct(tst)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.Color", "Color", "iscolor")
// Equal(t, errs.(ValidationErrors)["Test.Color"].ActualTag, "hexcolor|rgb|rgba|hsl|hsla")
// validate.RegisterAliasValidation("req", "required,dive,iscolor")
// arr := []string{"val1", "#fff", "#000"}
// errs = validate.Field(arr, "req")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "[0]", "[0]", "iscolor")
// PanicMatches(t, func() { validate.RegisterAliasValidation("exists", "gt=5,lt=10") }, "Alias 'exists' either contains restricted characters or is the same as a restricted tag needed for normal operation")
// }
// func TestNilValidator(t *testing.T) {
// type TestStruct struct {
// Test string `validate:"required"`
// }
// ts := TestStruct{}
// var val *Validate
// fn := func(v *Validate, topStruct reflect.Value, current reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
// return current.String() == field.String()
// }
// PanicMatches(t, func() { val.RegisterCustomTypeFunc(ValidateCustomType, MadeUpCustomType{}) }, validatorNotInitialized)
// PanicMatches(t, func() { val.RegisterValidation("something", fn) }, validatorNotInitialized)
// PanicMatches(t, func() { val.Field(ts.Test, "required") }, validatorNotInitialized)
// PanicMatches(t, func() { val.FieldWithValue("test", ts.Test, "required") }, validatorNotInitialized)
// PanicMatches(t, func() { val.Struct(ts) }, validatorNotInitialized)
// PanicMatches(t, func() { val.StructExcept(ts, "Test") }, validatorNotInitialized)
// PanicMatches(t, func() { val.StructPartial(ts, "Test") }, validatorNotInitialized)
// }
// func TestStructPartial(t *testing.T) {
// p1 := []string{
// "NoTag",
// "Required",
// }
// p2 := []string{
// "SubSlice[0].Test",
// "Sub",
// "SubIgnore",
// "Anonymous.A",
// }
// p3 := []string{
// "SubTest.Test",
// }
// p4 := []string{
// "A",
// }
// tPartial := &TestPartial{
// NoTag: "NoTag",
// Required: "Required",
// SubSlice: []*SubTest{
// {
// Test: "Required",
// },
// {
// Test: "Required",
// },
// },
// Sub: &SubTest{
// Test: "1",
// },
// SubIgnore: &SubTest{
// Test: "",
// },
// Anonymous: struct {
// A string `validate:"required"`
// ASubSlice []*SubTest `validate:"required,dive"`
// SubAnonStruct []struct {
// Test string `validate:"required"`
// OtherTest string `validate:"required"`
// } `validate:"required,dive"`
// }{
// A: "1",
// ASubSlice: []*SubTest{
// {
// Test: "Required",
// },
// {
// Test: "Required",
// },
// },
// SubAnonStruct: []struct {
// Test string `validate:"required"`
// OtherTest string `validate:"required"`
// }{
// {"Required", "RequiredOther"},
// {"Required", "RequiredOther"},
// },
// },
// }
// // the following should all return no errors as everything is valid in
// // the default state
// errs := validate.StructPartial(tPartial, p1...)
// Equal(t, errs, nil)
// errs = validate.StructPartial(tPartial, p2...)
// Equal(t, errs, nil)
// // this isn't really a robust test, but is ment to illustrate the ANON CASE below
// errs = validate.StructPartial(tPartial.SubSlice[0], p3...)
// Equal(t, errs, nil)
// errs = validate.StructExcept(tPartial, p1...)
// Equal(t, errs, nil)
// errs = validate.StructExcept(tPartial, p2...)
// Equal(t, errs, nil)
// // mod tParial for required feild and re-test making sure invalid fields are NOT required:
// tPartial.Required = ""
// errs = validate.StructExcept(tPartial, p1...)
// Equal(t, errs, nil)
// errs = validate.StructPartial(tPartial, p2...)
// Equal(t, errs, nil)
// // inversion and retesting Partial to generate failures:
// errs = validate.StructPartial(tPartial, p1...)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestPartial.Required", "Required", "required")
// errs = validate.StructExcept(tPartial, p2...)
// AssertError(t, errs, "TestPartial.Required", "Required", "required")
// // reset Required field, and set nested struct
// tPartial.Required = "Required"
// tPartial.Anonymous.A = ""
// // will pass as unset feilds is not going to be tested
// errs = validate.StructPartial(tPartial, p1...)
// Equal(t, errs, nil)
// errs = validate.StructExcept(tPartial, p2...)
// Equal(t, errs, nil)
// // ANON CASE the response here is strange, it clearly does what it is being told to
// errs = validate.StructExcept(tPartial.Anonymous, p4...)
// Equal(t, errs, nil)
// // will fail as unset feild is tested
// errs = validate.StructPartial(tPartial, p2...)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestPartial.Anonymous.A", "A", "required")
// errs = validate.StructExcept(tPartial, p1...)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestPartial.Anonymous.A", "A", "required")
// // reset nested struct and unset struct in slice
// tPartial.Anonymous.A = "Required"
// tPartial.SubSlice[0].Test = ""
// // these will pass as unset item is NOT tested
// errs = validate.StructPartial(tPartial, p1...)
// Equal(t, errs, nil)
// errs = validate.StructExcept(tPartial, p2...)
// Equal(t, errs, nil)
// // these will fail as unset item IS tested
// errs = validate.StructExcept(tPartial, p1...)
// AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required")
// Equal(t, len(errs.(ValidationErrors)), 1)
// errs = validate.StructPartial(tPartial, p2...)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required")
// Equal(t, len(errs.(ValidationErrors)), 1)
// // Unset second slice member concurrently to test dive behavior:
// tPartial.SubSlice[1].Test = ""
// errs = validate.StructPartial(tPartial, p1...)
// Equal(t, errs, nil)
// // NOTE: When specifying nested items, it is still the users responsibility
// // to specify the dive tag, the library does not override this.
// errs = validate.StructExcept(tPartial, p2...)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required")
// errs = validate.StructExcept(tPartial, p1...)
// Equal(t, len(errs.(ValidationErrors)), 2)
// AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required")
// AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required")
// errs = validate.StructPartial(tPartial, p2...)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required")
// // reset struct in slice, and unset struct in slice in unset posistion
// tPartial.SubSlice[0].Test = "Required"
// // these will pass as the unset item is NOT tested
// errs = validate.StructPartial(tPartial, p1...)
// Equal(t, errs, nil)
// errs = validate.StructPartial(tPartial, p2...)
// Equal(t, errs, nil)
// // testing for missing item by exception, yes it dives and fails
// errs = validate.StructExcept(tPartial, p1...)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required")
// errs = validate.StructExcept(tPartial, p2...)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required")
// tPartial.SubSlice[1].Test = "Required"
// tPartial.Anonymous.SubAnonStruct[0].Test = ""
// // these will pass as the unset item is NOT tested
// errs = validate.StructPartial(tPartial, p1...)
// Equal(t, errs, nil)
// errs = validate.StructPartial(tPartial, p2...)
// Equal(t, errs, nil)
// errs = validate.StructExcept(tPartial, p1...)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestPartial.Anonymous.SubAnonStruct[0].Test", "Test", "required")
// errs = validate.StructExcept(tPartial, p2...)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestPartial.Anonymous.SubAnonStruct[0].Test", "Test", "required")
// }
// func TestCrossStructLteFieldValidation(t *testing.T) {
// type Inner struct {
// CreatedAt *time.Time
// String string
// Int int
// Uint uint
// Float float64
// Array []string
// }
// type Test struct {
// Inner *Inner
// CreatedAt *time.Time `validate:"ltecsfield=Inner.CreatedAt"`
// String string `validate:"ltecsfield=Inner.String"`
// Int int `validate:"ltecsfield=Inner.Int"`
// Uint uint `validate:"ltecsfield=Inner.Uint"`
// Float float64 `validate:"ltecsfield=Inner.Float"`
// Array []string `validate:"ltecsfield=Inner.Array"`
// }
// now := time.Now().UTC()
// then := now.Add(time.Hour * 5)
// inner := &Inner{
// CreatedAt: &then,
// String: "abcd",
// Int: 13,
// Uint: 13,
// Float: 1.13,
// Array: []string{"val1", "val2"},
// }
// test := &Test{
// Inner: inner,
// CreatedAt: &now,
// String: "abc",
// Int: 12,
// Uint: 12,
// Float: 1.12,
// Array: []string{"val1"},
// }
// errs := validate.Struct(test)
// Equal(t, errs, nil)
// test.CreatedAt = &then
// test.String = "abcd"
// test.Int = 13
// test.Uint = 13
// test.Float = 1.13
// test.Array = []string{"val1", "val2"}
// errs = validate.Struct(test)
// Equal(t, errs, nil)
// after := now.Add(time.Hour * 10)
// test.CreatedAt = &after
// test.String = "abce"
// test.Int = 14
// test.Uint = 14
// test.Float = 1.14
// test.Array = []string{"val1", "val2", "val3"}
// errs = validate.Struct(test)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.CreatedAt", "CreatedAt", "ltecsfield")
// AssertError(t, errs, "Test.String", "String", "ltecsfield")
// AssertError(t, errs, "Test.Int", "Int", "ltecsfield")
// AssertError(t, errs, "Test.Uint", "Uint", "ltecsfield")
// AssertError(t, errs, "Test.Float", "Float", "ltecsfield")
// AssertError(t, errs, "Test.Array", "Array", "ltecsfield")
// errs = validate.FieldWithValue(1, "", "ltecsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltecsfield")
// errs = validate.FieldWithValue(test, now, "ltecsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltecsfield")
// }
// func TestCrossStructLtFieldValidation(t *testing.T) {
// type Inner struct {
// CreatedAt *time.Time
// String string
// Int int
// Uint uint
// Float float64
// Array []string
// }
// type Test struct {
// Inner *Inner
// CreatedAt *time.Time `validate:"ltcsfield=Inner.CreatedAt"`
// String string `validate:"ltcsfield=Inner.String"`
// Int int `validate:"ltcsfield=Inner.Int"`
// Uint uint `validate:"ltcsfield=Inner.Uint"`
// Float float64 `validate:"ltcsfield=Inner.Float"`
// Array []string `validate:"ltcsfield=Inner.Array"`
// }
// now := time.Now().UTC()
// then := now.Add(time.Hour * 5)
// inner := &Inner{
// CreatedAt: &then,
// String: "abcd",
// Int: 13,
// Uint: 13,
// Float: 1.13,
// Array: []string{"val1", "val2"},
// }
// test := &Test{
// Inner: inner,
// CreatedAt: &now,
// String: "abc",
// Int: 12,
// Uint: 12,
// Float: 1.12,
// Array: []string{"val1"},
// }
// errs := validate.Struct(test)
// Equal(t, errs, nil)
// test.CreatedAt = &then
// test.String = "abcd"
// test.Int = 13
// test.Uint = 13
// test.Float = 1.13
// test.Array = []string{"val1", "val2"}
// errs = validate.Struct(test)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.CreatedAt", "CreatedAt", "ltcsfield")
// AssertError(t, errs, "Test.String", "String", "ltcsfield")
// AssertError(t, errs, "Test.Int", "Int", "ltcsfield")
// AssertError(t, errs, "Test.Uint", "Uint", "ltcsfield")
// AssertError(t, errs, "Test.Float", "Float", "ltcsfield")
// AssertError(t, errs, "Test.Array", "Array", "ltcsfield")
// errs = validate.FieldWithValue(1, "", "ltcsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltcsfield")
// errs = validate.FieldWithValue(test, now, "ltcsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltcsfield")
// }
// func TestCrossStructGteFieldValidation(t *testing.T) {
// type Inner struct {
// CreatedAt *time.Time
// String string
// Int int
// Uint uint
// Float float64
// Array []string
// }
// type Test struct {
// Inner *Inner
// CreatedAt *time.Time `validate:"gtecsfield=Inner.CreatedAt"`
// String string `validate:"gtecsfield=Inner.String"`
// Int int `validate:"gtecsfield=Inner.Int"`
// Uint uint `validate:"gtecsfield=Inner.Uint"`
// Float float64 `validate:"gtecsfield=Inner.Float"`
// Array []string `validate:"gtecsfield=Inner.Array"`
// }
// now := time.Now().UTC()
// then := now.Add(time.Hour * -5)
// inner := &Inner{
// CreatedAt: &then,
// String: "abcd",
// Int: 13,
// Uint: 13,
// Float: 1.13,
// Array: []string{"val1", "val2"},
// }
// test := &Test{
// Inner: inner,
// CreatedAt: &now,
// String: "abcde",
// Int: 14,
// Uint: 14,
// Float: 1.14,
// Array: []string{"val1", "val2", "val3"},
// }
// errs := validate.Struct(test)
// Equal(t, errs, nil)
// test.CreatedAt = &then
// test.String = "abcd"
// test.Int = 13
// test.Uint = 13
// test.Float = 1.13
// test.Array = []string{"val1", "val2"}
// errs = validate.Struct(test)
// Equal(t, errs, nil)
// before := now.Add(time.Hour * -10)
// test.CreatedAt = &before
// test.String = "abc"
// test.Int = 12
// test.Uint = 12
// test.Float = 1.12
// test.Array = []string{"val1"}
// errs = validate.Struct(test)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.CreatedAt", "CreatedAt", "gtecsfield")
// AssertError(t, errs, "Test.String", "String", "gtecsfield")
// AssertError(t, errs, "Test.Int", "Int", "gtecsfield")
// AssertError(t, errs, "Test.Uint", "Uint", "gtecsfield")
// AssertError(t, errs, "Test.Float", "Float", "gtecsfield")
// AssertError(t, errs, "Test.Array", "Array", "gtecsfield")
// errs = validate.FieldWithValue(1, "", "gtecsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtecsfield")
// errs = validate.FieldWithValue(test, now, "gtecsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtecsfield")
// }
// func TestCrossStructGtFieldValidation(t *testing.T) {
// type Inner struct {
// CreatedAt *time.Time
// String string
// Int int
// Uint uint
// Float float64
// Array []string
// }
// type Test struct {
// Inner *Inner
// CreatedAt *time.Time `validate:"gtcsfield=Inner.CreatedAt"`
// String string `validate:"gtcsfield=Inner.String"`
// Int int `validate:"gtcsfield=Inner.Int"`
// Uint uint `validate:"gtcsfield=Inner.Uint"`
// Float float64 `validate:"gtcsfield=Inner.Float"`
// Array []string `validate:"gtcsfield=Inner.Array"`
// }
// now := time.Now().UTC()
// then := now.Add(time.Hour * -5)
// inner := &Inner{
// CreatedAt: &then,
// String: "abcd",
// Int: 13,
// Uint: 13,
// Float: 1.13,
// Array: []string{"val1", "val2"},
// }
// test := &Test{
// Inner: inner,
// CreatedAt: &now,
// String: "abcde",
// Int: 14,
// Uint: 14,
// Float: 1.14,
// Array: []string{"val1", "val2", "val3"},
// }
// errs := validate.Struct(test)
// Equal(t, errs, nil)
// test.CreatedAt = &then
// test.String = "abcd"
// test.Int = 13
// test.Uint = 13
// test.Float = 1.13
// test.Array = []string{"val1", "val2"}
// errs = validate.Struct(test)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.CreatedAt", "CreatedAt", "gtcsfield")
// AssertError(t, errs, "Test.String", "String", "gtcsfield")
// AssertError(t, errs, "Test.Int", "Int", "gtcsfield")
// AssertError(t, errs, "Test.Uint", "Uint", "gtcsfield")
// AssertError(t, errs, "Test.Float", "Float", "gtcsfield")
// AssertError(t, errs, "Test.Array", "Array", "gtcsfield")
// errs = validate.FieldWithValue(1, "", "gtcsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtcsfield")
// errs = validate.FieldWithValue(test, now, "gtcsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtcsfield")
// }
// func TestCrossStructNeFieldValidation(t *testing.T) {
// type Inner struct {
// CreatedAt *time.Time
// }
// type Test struct {
// Inner *Inner
// CreatedAt *time.Time `validate:"necsfield=Inner.CreatedAt"`
// }
// now := time.Now().UTC()
// then := now.Add(time.Hour * 5)
// inner := &Inner{
// CreatedAt: &then,
// }
// test := &Test{
// Inner: inner,
// CreatedAt: &now,
// }
// errs := validate.Struct(test)
// Equal(t, errs, nil)
// test.CreatedAt = &then
// errs = validate.Struct(test)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.CreatedAt", "CreatedAt", "necsfield")
// var j uint64
// var k float64
// var j2 uint64
// var k2 float64
// s := "abcd"
// i := 1
// j = 1
// k = 1.543
// arr := []string{"test"}
// s2 := "abcd"
// i2 := 1
// j2 = 1
// k2 = 1.543
// arr2 := []string{"test"}
// arr3 := []string{"test", "test2"}
// now2 := now
// errs = validate.FieldWithValue(s, s2, "necsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "necsfield")
// errs = validate.FieldWithValue(i2, i, "necsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "necsfield")
// errs = validate.FieldWithValue(j2, j, "necsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "necsfield")
// errs = validate.FieldWithValue(k2, k, "necsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "necsfield")
// errs = validate.FieldWithValue(arr2, arr, "necsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "necsfield")
// errs = validate.FieldWithValue(now2, now, "necsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "necsfield")
// errs = validate.FieldWithValue(arr3, arr, "necsfield")
// Equal(t, errs, nil)
// type SInner struct {
// Name string
// }
// type TStruct struct {
// Inner *SInner
// CreatedAt *time.Time `validate:"necsfield=Inner"`
// }
// sinner := &SInner{
// Name: "NAME",
// }
// test2 := &TStruct{
// Inner: sinner,
// CreatedAt: &now,
// }
// errs = validate.Struct(test2)
// Equal(t, errs, nil)
// test2.Inner = nil
// errs = validate.Struct(test2)
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(nil, 1, "necsfield")
// Equal(t, errs, nil)
// }
// func TestCrossStructEqFieldValidation(t *testing.T) {
// type Inner struct {
// CreatedAt *time.Time
// }
// type Test struct {
// Inner *Inner
// CreatedAt *time.Time `validate:"eqcsfield=Inner.CreatedAt"`
// }
// now := time.Now().UTC()
// inner := &Inner{
// CreatedAt: &now,
// }
// test := &Test{
// Inner: inner,
// CreatedAt: &now,
// }
// errs := validate.Struct(test)
// Equal(t, errs, nil)
// newTime := time.Now().UTC()
// test.CreatedAt = &newTime
// errs = validate.Struct(test)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.CreatedAt", "CreatedAt", "eqcsfield")
// var j uint64
// var k float64
// s := "abcd"
// i := 1
// j = 1
// k = 1.543
// arr := []string{"test"}
// var j2 uint64
// var k2 float64
// s2 := "abcd"
// i2 := 1
// j2 = 1
// k2 = 1.543
// arr2 := []string{"test"}
// arr3 := []string{"test", "test2"}
// now2 := now
// errs = validate.FieldWithValue(s, s2, "eqcsfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(i2, i, "eqcsfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(j2, j, "eqcsfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(k2, k, "eqcsfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(arr2, arr, "eqcsfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(now2, now, "eqcsfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(arr3, arr, "eqcsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "eqcsfield")
// type SInner struct {
// Name string
// }
// type TStruct struct {
// Inner *SInner
// CreatedAt *time.Time `validate:"eqcsfield=Inner"`
// }
// sinner := &SInner{
// Name: "NAME",
// }
// test2 := &TStruct{
// Inner: sinner,
// CreatedAt: &now,
// }
// errs = validate.Struct(test2)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TStruct.CreatedAt", "CreatedAt", "eqcsfield")
// test2.Inner = nil
// errs = validate.Struct(test2)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TStruct.CreatedAt", "CreatedAt", "eqcsfield")
// errs = validate.FieldWithValue(nil, 1, "eqcsfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "eqcsfield")
// }
// func TestCrossNamespaceFieldValidation(t *testing.T) {
// type SliceStruct struct {
// Name string
// }
// type MapStruct struct {
// Name string
// }
// type Inner struct {
// CreatedAt *time.Time
// Slice []string
// SliceStructs []*SliceStruct
// SliceSlice [][]string
// SliceSliceStruct [][]*SliceStruct
// SliceMap []map[string]string
// Map map[string]string
// MapMap map[string]map[string]string
// MapStructs map[string]*SliceStruct
// MapMapStruct map[string]map[string]*SliceStruct
// MapSlice map[string][]string
// MapInt map[int]string
// MapInt8 map[int8]string
// MapInt16 map[int16]string
// MapInt32 map[int32]string
// MapInt64 map[int64]string
// MapUint map[uint]string
// MapUint8 map[uint8]string
// MapUint16 map[uint16]string
// MapUint32 map[uint32]string
// MapUint64 map[uint64]string
// MapFloat32 map[float32]string
// MapFloat64 map[float64]string
// MapBool map[bool]string
// }
// type Test struct {
// Inner *Inner
// CreatedAt *time.Time
// }
// now := time.Now()
// inner := &Inner{
// CreatedAt: &now,
// Slice: []string{"val1", "val2", "val3"},
// SliceStructs: []*SliceStruct{{Name: "name1"}, {Name: "name2"}, {Name: "name3"}},
// SliceSlice: [][]string{{"1", "2", "3"}, {"4", "5", "6"}, {"7", "8", "9"}},
// SliceSliceStruct: [][]*SliceStruct{{{Name: "name1"}, {Name: "name2"}, {Name: "name3"}}, {{Name: "name4"}, {Name: "name5"}, {Name: "name6"}}, {{Name: "name7"}, {Name: "name8"}, {Name: "name9"}}},
// SliceMap: []map[string]string{{"key1": "val1", "key2": "val2", "key3": "val3"}, {"key4": "val4", "key5": "val5", "key6": "val6"}},
// Map: map[string]string{"key1": "val1", "key2": "val2", "key3": "val3"},
// MapStructs: map[string]*SliceStruct{"key1": {Name: "name1"}, "key2": {Name: "name2"}, "key3": {Name: "name3"}},
// MapMap: map[string]map[string]string{"key1": {"key1-1": "val1"}, "key2": {"key2-1": "val2"}, "key3": {"key3-1": "val3"}},
// MapMapStruct: map[string]map[string]*SliceStruct{"key1": {"key1-1": {Name: "name1"}}, "key2": {"key2-1": {Name: "name2"}}, "key3": {"key3-1": {Name: "name3"}}},
// MapSlice: map[string][]string{"key1": {"1", "2", "3"}, "key2": {"4", "5", "6"}, "key3": {"7", "8", "9"}},
// MapInt: map[int]string{1: "val1", 2: "val2", 3: "val3"},
// MapInt8: map[int8]string{1: "val1", 2: "val2", 3: "val3"},
// MapInt16: map[int16]string{1: "val1", 2: "val2", 3: "val3"},
// MapInt32: map[int32]string{1: "val1", 2: "val2", 3: "val3"},
// MapInt64: map[int64]string{1: "val1", 2: "val2", 3: "val3"},
// MapUint: map[uint]string{1: "val1", 2: "val2", 3: "val3"},
// MapUint8: map[uint8]string{1: "val1", 2: "val2", 3: "val3"},
// MapUint16: map[uint16]string{1: "val1", 2: "val2", 3: "val3"},
// MapUint32: map[uint32]string{1: "val1", 2: "val2", 3: "val3"},
// MapUint64: map[uint64]string{1: "val1", 2: "val2", 3: "val3"},
// MapFloat32: map[float32]string{1.01: "val1", 2.02: "val2", 3.03: "val3"},
// MapFloat64: map[float64]string{1.01: "val1", 2.02: "val2", 3.03: "val3"},
// MapBool: map[bool]string{true: "val1", false: "val2"},
// }
// test := &Test{
// Inner: inner,
// CreatedAt: &now,
// }
// val := reflect.ValueOf(test)
// current, kind, ok := validate.GetStructFieldOK(val, "Inner.CreatedAt")
// Equal(t, ok, true)
// Equal(t, kind, reflect.Struct)
// tm, ok := current.Interface().(time.Time)
// Equal(t, ok, true)
// Equal(t, tm, now)
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.Slice[1]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.CrazyNonExistantField")
// Equal(t, ok, false)
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.Slice[101]")
// Equal(t, ok, false)
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.Map[key3]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val3")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapMap[key2][key2-1]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapStructs[key2].Name")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "name2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapMapStruct[key3][key3-1].Name")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "name3")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.SliceSlice[2][0]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "7")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.SliceSliceStruct[2][1].Name")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "name8")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.SliceMap[1][key5]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val5")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapSlice[key3][2]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "9")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapInt[2]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapInt8[2]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapInt16[2]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapInt32[2]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapInt64[2]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapUint[2]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapUint8[2]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapUint16[2]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapUint32[2]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapUint64[2]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapFloat32[3.03]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val3")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapFloat64[2.02]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val2")
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.MapBool[true]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.String)
// Equal(t, current.String(), "val1")
// inner = &Inner{
// CreatedAt: &now,
// Slice: []string{"val1", "val2", "val3"},
// SliceStructs: []*SliceStruct{{Name: "name1"}, {Name: "name2"}, nil},
// SliceSlice: [][]string{{"1", "2", "3"}, {"4", "5", "6"}, {"7", "8", "9"}},
// SliceSliceStruct: [][]*SliceStruct{{{Name: "name1"}, {Name: "name2"}, {Name: "name3"}}, {{Name: "name4"}, {Name: "name5"}, {Name: "name6"}}, {{Name: "name7"}, {Name: "name8"}, {Name: "name9"}}},
// SliceMap: []map[string]string{{"key1": "val1", "key2": "val2", "key3": "val3"}, {"key4": "val4", "key5": "val5", "key6": "val6"}},
// Map: map[string]string{"key1": "val1", "key2": "val2", "key3": "val3"},
// MapStructs: map[string]*SliceStruct{"key1": {Name: "name1"}, "key2": {Name: "name2"}, "key3": {Name: "name3"}},
// MapMap: map[string]map[string]string{"key1": {"key1-1": "val1"}, "key2": {"key2-1": "val2"}, "key3": {"key3-1": "val3"}},
// MapMapStruct: map[string]map[string]*SliceStruct{"key1": {"key1-1": {Name: "name1"}}, "key2": {"key2-1": {Name: "name2"}}, "key3": {"key3-1": {Name: "name3"}}},
// MapSlice: map[string][]string{"key1": {"1", "2", "3"}, "key2": {"4", "5", "6"}, "key3": {"7", "8", "9"}},
// }
// test = &Test{
// Inner: inner,
// CreatedAt: nil,
// }
// val = reflect.ValueOf(test)
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.SliceStructs[2]")
// Equal(t, ok, true)
// Equal(t, kind, reflect.Ptr)
// Equal(t, current.String(), "<*validator.SliceStruct Value>")
// Equal(t, current.IsNil(), true)
// current, kind, ok = validate.GetStructFieldOK(val, "Inner.SliceStructs[2].Name")
// Equal(t, ok, false)
// Equal(t, kind, reflect.Ptr)
// Equal(t, current.String(), "<*validator.SliceStruct Value>")
// Equal(t, current.IsNil(), true)
// PanicMatches(t, func() { validate.GetStructFieldOK(reflect.ValueOf(1), "crazyinput") }, "Invalid field namespace")
// }
// func TestExistsValidation(t *testing.T) {
// jsonText := "{ \"truthiness2\": true }"
// type Thing struct {
// Truthiness *bool `json:"truthiness" validate:"exists,required"`
// }
// var ting Thing
// err := json.Unmarshal([]byte(jsonText), &ting)
// Equal(t, err, nil)
// NotEqual(t, ting, nil)
// Equal(t, ting.Truthiness, nil)
// errs := validate.Struct(ting)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Thing.Truthiness", "Truthiness", "exists")
// jsonText = "{ \"truthiness\": true }"
// err = json.Unmarshal([]byte(jsonText), &ting)
// Equal(t, err, nil)
// NotEqual(t, ting, nil)
// Equal(t, ting.Truthiness, true)
// errs = validate.Struct(ting)
// Equal(t, errs, nil)
// }
// func TestSQLValue2Validation(t *testing.T) {
// config := &Config{
// TagName: "validate",
// }
// validate := New(config)
// validate.RegisterCustomTypeFunc(ValidateValuerType, valuer{}, (*driver.Valuer)(nil), sql.NullString{}, sql.NullInt64{}, sql.NullBool{}, sql.NullFloat64{})
// validate.RegisterCustomTypeFunc(ValidateCustomType, MadeUpCustomType{})
// validate.RegisterCustomTypeFunc(OverrideIntTypeForSomeReason, 1)
// val := valuer{
// Name: "",
// }
// errs := validate.Field(val, "required")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "required")
// val.Name = "Valid Name"
// errs = validate.Field(val, "required")
// Equal(t, errs, nil)
// val.Name = "errorme"
// PanicMatches(t, func() { validate.Field(val, "required") }, "SQL Driver Valuer error: some kind of error")
// type myValuer valuer
// myVal := valuer{
// Name: "",
// }
// errs = validate.Field(myVal, "required")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "required")
// cust := MadeUpCustomType{
// FirstName: "Joey",
// LastName: "Bloggs",
// }
// c := CustomMadeUpStruct{MadeUp: cust, OverriddenInt: 2}
// errs = validate.Struct(c)
// Equal(t, errs, nil)
// c.MadeUp.FirstName = ""
// c.OverriddenInt = 1
// errs = validate.Struct(c)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 2)
// AssertError(t, errs, "CustomMadeUpStruct.MadeUp", "MadeUp", "required")
// AssertError(t, errs, "CustomMadeUpStruct.OverriddenInt", "OverriddenInt", "gt")
// }
// func TestSQLValueValidation(t *testing.T) {
// validate := New(&Config{TagName: "validate"})
// validate.RegisterCustomTypeFunc(ValidateValuerType, (*driver.Valuer)(nil), valuer{})
// validate.RegisterCustomTypeFunc(ValidateCustomType, MadeUpCustomType{})
// validate.RegisterCustomTypeFunc(OverrideIntTypeForSomeReason, 1)
// val := valuer{
// Name: "",
// }
// errs := validate.Field(val, "required")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "required")
// val.Name = "Valid Name"
// errs = validate.Field(val, "required")
// Equal(t, errs, nil)
// val.Name = "errorme"
// PanicMatches(t, func() { errs = validate.Field(val, "required") }, "SQL Driver Valuer error: some kind of error")
// type myValuer valuer
// myVal := valuer{
// Name: "",
// }
// errs = validate.Field(myVal, "required")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "required")
// cust := MadeUpCustomType{
// FirstName: "Joey",
// LastName: "Bloggs",
// }
// c := CustomMadeUpStruct{MadeUp: cust, OverriddenInt: 2}
// errs = validate.Struct(c)
// Equal(t, errs, nil)
// c.MadeUp.FirstName = ""
// c.OverriddenInt = 1
// errs = validate.Struct(c)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 2)
// AssertError(t, errs, "CustomMadeUpStruct.MadeUp", "MadeUp", "required")
// AssertError(t, errs, "CustomMadeUpStruct.OverriddenInt", "OverriddenInt", "gt")
// }
// func TestMACValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"3D:F2:C9:A6:B3:4F", true},
// {"3D-F2-C9-A6-B3:4F", false},
// {"123", false},
// {"", false},
// {"abacaba", false},
// {"00:25:96:FF:FE:12:34:56", true},
// {"0025:96FF:FE12:3456", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "mac")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d mac failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d mac failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "mac" {
// t.Fatalf("Index: %d mac failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestIPValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"10.0.0.1", true},
// {"172.16.0.1", true},
// {"192.168.0.1", true},
// {"192.168.255.254", true},
// {"192.168.255.256", false},
// {"172.16.255.254", true},
// {"172.16.256.255", false},
// {"2001:cdba:0000:0000:0000:0000:3257:9652", true},
// {"2001:cdba:0:0:0:0:3257:9652", true},
// {"2001:cdba::3257:9652", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "ip")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d ip failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d ip failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "ip" {
// t.Fatalf("Index: %d ip failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestIPv6Validation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"10.0.0.1", false},
// {"172.16.0.1", false},
// {"192.168.0.1", false},
// {"192.168.255.254", false},
// {"192.168.255.256", false},
// {"172.16.255.254", false},
// {"172.16.256.255", false},
// {"2001:cdba:0000:0000:0000:0000:3257:9652", true},
// {"2001:cdba:0:0:0:0:3257:9652", true},
// {"2001:cdba::3257:9652", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "ipv6")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d ipv6 failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d ipv6 failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "ipv6" {
// t.Fatalf("Index: %d ipv6 failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestIPv4Validation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"10.0.0.1", true},
// {"172.16.0.1", true},
// {"192.168.0.1", true},
// {"192.168.255.254", true},
// {"192.168.255.256", false},
// {"172.16.255.254", true},
// {"172.16.256.255", false},
// {"2001:cdba:0000:0000:0000:0000:3257:9652", false},
// {"2001:cdba:0:0:0:0:3257:9652", false},
// {"2001:cdba::3257:9652", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "ipv4")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d ipv4 failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d ipv4 failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "ipv4" {
// t.Fatalf("Index: %d ipv4 failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestCIDRValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"10.0.0.0/0", true},
// {"10.0.0.1/8", true},
// {"172.16.0.1/16", true},
// {"192.168.0.1/24", true},
// {"192.168.255.254/24", true},
// {"192.168.255.254/48", false},
// {"192.168.255.256/24", false},
// {"172.16.255.254/16", true},
// {"172.16.256.255/16", false},
// {"2001:cdba:0000:0000:0000:0000:3257:9652/64", true},
// {"2001:cdba:0000:0000:0000:0000:3257:9652/256", false},
// {"2001:cdba:0:0:0:0:3257:9652/32", true},
// {"2001:cdba::3257:9652/16", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "cidr")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d cidr failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d cidr failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "cidr" {
// t.Fatalf("Index: %d cidr failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestCIDRv6Validation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"10.0.0.0/0", false},
// {"10.0.0.1/8", false},
// {"172.16.0.1/16", false},
// {"192.168.0.1/24", false},
// {"192.168.255.254/24", false},
// {"192.168.255.254/48", false},
// {"192.168.255.256/24", false},
// {"172.16.255.254/16", false},
// {"172.16.256.255/16", false},
// {"2001:cdba:0000:0000:0000:0000:3257:9652/64", true},
// {"2001:cdba:0000:0000:0000:0000:3257:9652/256", false},
// {"2001:cdba:0:0:0:0:3257:9652/32", true},
// {"2001:cdba::3257:9652/16", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "cidrv6")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d cidrv6 failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d cidrv6 failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "cidrv6" {
// t.Fatalf("Index: %d cidrv6 failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestCIDRv4Validation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"10.0.0.0/0", true},
// {"10.0.0.1/8", true},
// {"172.16.0.1/16", true},
// {"192.168.0.1/24", true},
// {"192.168.255.254/24", true},
// {"192.168.255.254/48", false},
// {"192.168.255.256/24", false},
// {"172.16.255.254/16", true},
// {"172.16.256.255/16", false},
// {"2001:cdba:0000:0000:0000:0000:3257:9652/64", false},
// {"2001:cdba:0000:0000:0000:0000:3257:9652/256", false},
// {"2001:cdba:0:0:0:0:3257:9652/32", false},
// {"2001:cdba::3257:9652/16", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "cidrv4")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d cidrv4 failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d cidrv4 failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "cidrv4" {
// t.Fatalf("Index: %d cidrv4 failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestTCPAddrValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {":80", false},
// {"127.0.0.1:80", true},
// {"[::1]:80", true},
// {"256.0.0.0:1", false},
// {"[::1]", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "tcp_addr")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d tcp_addr failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d tcp_addr failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "tcp_addr" {
// t.Fatalf("Index: %d tcp_addr failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestTCP6AddrValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {":80", false},
// {"127.0.0.1:80", false},
// {"[::1]:80", true},
// {"256.0.0.0:1", false},
// {"[::1]", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "tcp6_addr")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d tcp6_addr failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d tcp6_addr failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "tcp6_addr" {
// t.Fatalf("Index: %d tcp6_addr failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestTCP4AddrValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {":80", false},
// {"127.0.0.1:80", true},
// {"[::1]:80", false}, // https://github.com/golang/go/issues/14037
// {"256.0.0.0:1", false},
// {"[::1]", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "tcp4_addr")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d tcp4_addr failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Log(test.param, IsEqual(errs, nil))
// t.Fatalf("Index: %d tcp4_addr failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "tcp4_addr" {
// t.Fatalf("Index: %d tcp4_addr failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestUDPAddrValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {":80", false},
// {"127.0.0.1:80", true},
// {"[::1]:80", true},
// {"256.0.0.0:1", false},
// {"[::1]", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "udp_addr")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d udp_addr failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d udp_addr failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "udp_addr" {
// t.Fatalf("Index: %d udp_addr failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestUDP6AddrValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {":80", false},
// {"127.0.0.1:80", false},
// {"[::1]:80", true},
// {"256.0.0.0:1", false},
// {"[::1]", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "udp6_addr")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d udp6_addr failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d udp6_addr failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "udp6_addr" {
// t.Fatalf("Index: %d udp6_addr failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestUDP4AddrValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {":80", false},
// {"127.0.0.1:80", true},
// {"[::1]:80", false}, // https://github.com/golang/go/issues/14037
// {"256.0.0.0:1", false},
// {"[::1]", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "udp4_addr")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d udp4_addr failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Log(test.param, IsEqual(errs, nil))
// t.Fatalf("Index: %d udp4_addr failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "udp4_addr" {
// t.Fatalf("Index: %d udp4_addr failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestIPAddrValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"127.0.0.1", true},
// {"127.0.0.1:80", false},
// {"::1", true},
// {"256.0.0.0", false},
// {"localhost", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "ip_addr")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d ip_addr failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d ip_addr failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "ip_addr" {
// t.Fatalf("Index: %d ip_addr failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestIP6AddrValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"127.0.0.1", false}, // https://github.com/golang/go/issues/14037
// {"127.0.0.1:80", false},
// {"::1", true},
// {"0:0:0:0:0:0:0:1", true},
// {"256.0.0.0", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "ip6_addr")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d ip6_addr failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d ip6_addr failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "ip6_addr" {
// t.Fatalf("Index: %d ip6_addr failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestIP4AddrValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"127.0.0.1", true},
// {"127.0.0.1:80", false},
// {"::1", false}, // https://github.com/golang/go/issues/14037
// {"256.0.0.0", false},
// {"localhost", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "ip4_addr")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d ip4_addr failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Log(test.param, IsEqual(errs, nil))
// t.Fatalf("Index: %d ip4_addr failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "ip4_addr" {
// t.Fatalf("Index: %d ip4_addr failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestUnixAddrValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", true},
// {"v.sock", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "unix_addr")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d unix_addr failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Log(test.param, IsEqual(errs, nil))
// t.Fatalf("Index: %d unix_addr failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "unix_addr" {
// t.Fatalf("Index: %d unix_addr failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestSliceMapArrayChanFuncPtrInterfaceRequiredValidation(t *testing.T) {
// var m map[string]string
// errs := validate.Field(m, "required")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "required")
// m = map[string]string{}
// errs = validate.Field(m, "required")
// Equal(t, errs, nil)
// var arr [5]string
// errs = validate.Field(arr, "required")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "required")
// arr[0] = "ok"
// errs = validate.Field(arr, "required")
// Equal(t, errs, nil)
// var s []string
// errs = validate.Field(s, "required")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "required")
// s = []string{}
// errs = validate.Field(s, "required")
// Equal(t, errs, nil)
// var c chan string
// errs = validate.Field(c, "required")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "required")
// c = make(chan string)
// errs = validate.Field(c, "required")
// Equal(t, errs, nil)
// var tst *int
// errs = validate.Field(tst, "required")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "required")
// one := 1
// tst = &one
// errs = validate.Field(tst, "required")
// Equal(t, errs, nil)
// var iface interface{}
// errs = validate.Field(iface, "required")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "required")
// errs = validate.Field(iface, "omitempty,required")
// Equal(t, errs, nil)
// errs = validate.Field(iface, "")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(nil, iface, "")
// Equal(t, errs, nil)
// var f func(string)
// errs = validate.Field(f, "required")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "required")
// f = func(name string) {}
// errs = validate.Field(f, "required")
// Equal(t, errs, nil)
// }
// func TestDatePtrValidationIssueValidation(t *testing.T) {
// type Test struct {
// LastViewed *time.Time
// Reminder *time.Time
// }
// test := &Test{}
// errs := validate.Struct(test)
// Equal(t, errs, nil)
// }
// func TestCommaAndPipeObfuscationValidation(t *testing.T) {
// s := "My Name Is, |joeybloggs|"
// errs := validate.Field(s, "excludesall=0x2C")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "excludesall")
// errs = validate.Field(s, "excludesall=0x7C")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "excludesall")
// }
// func TestBadKeyValidation(t *testing.T) {
// type Test struct {
// Name string `validate:"required, "`
// }
// tst := &Test{
// Name: "test",
// }
// PanicMatches(t, func() { validate.Struct(tst) }, "Undefined validation function on field Name")
// type Test2 struct {
// Name string `validate:"required,,len=2"`
// }
// tst2 := &Test2{
// Name: "test",
// }
// PanicMatches(t, func() { validate.Struct(tst2) }, "Invalid validation tag on field Name")
// }
// func TestInterfaceErrValidation(t *testing.T) {
// var v1 interface{}
// var v2 interface{}
// v2 = 1
// v1 = v2
// errs := validate.Field(v1, "len=1")
// Equal(t, errs, nil)
// errs = validate.Field(v2, "len=1")
// Equal(t, errs, nil)
// type ExternalCMD struct {
// Userid string `json:"userid"`
// Action uint32 `json:"action"`
// Data interface{} `json:"data,omitempty" validate:"required"`
// }
// s := &ExternalCMD{
// Userid: "123456",
// Action: 10000,
// // Data: 1,
// }
// errs = validate.Struct(s)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "ExternalCMD.Data", "Data", "required")
// type ExternalCMD2 struct {
// Userid string `json:"userid"`
// Action uint32 `json:"action"`
// Data interface{} `json:"data,omitempty" validate:"len=1"`
// }
// s2 := &ExternalCMD2{
// Userid: "123456",
// Action: 10000,
// // Data: 1,
// }
// errs = validate.Struct(s2)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "ExternalCMD2.Data", "Data", "len")
// s3 := &ExternalCMD2{
// Userid: "123456",
// Action: 10000,
// Data: 2,
// }
// errs = validate.Struct(s3)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "ExternalCMD2.Data", "Data", "len")
// type Inner struct {
// Name string `validate:"required"`
// }
// inner := &Inner{
// Name: "",
// }
// s4 := &ExternalCMD{
// Userid: "123456",
// Action: 10000,
// Data: inner,
// }
// errs = validate.Struct(s4)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "ExternalCMD.Data.Name", "Name", "required")
// type TestMapStructPtr struct {
// Errs map[int]interface{} `validate:"gt=0,dive,len=2"`
// }
// mip := map[int]interface{}{0: &Inner{"ok"}, 3: nil, 4: &Inner{"ok"}}
// msp := &TestMapStructPtr{
// Errs: mip,
// }
// errs = validate.Struct(msp)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "TestMapStructPtr.Errs[3]", "Errs[3]", "len")
// type TestMultiDimensionalStructs struct {
// Errs [][]interface{} `validate:"gt=0,dive,dive"`
// }
// var errStructArray [][]interface{}
// errStructArray = append(errStructArray, []interface{}{&Inner{"ok"}, &Inner{""}, &Inner{""}})
// errStructArray = append(errStructArray, []interface{}{&Inner{"ok"}, &Inner{""}, &Inner{""}})
// tms := &TestMultiDimensionalStructs{
// Errs: errStructArray,
// }
// errs = validate.Struct(tms)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 4)
// AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][2].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructs.Errs[1][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructs.Errs[1][2].Name", "Name", "required")
// type TestMultiDimensionalStructsPtr2 struct {
// Errs [][]*Inner `validate:"gt=0,dive,dive,required"`
// }
// var errStructPtr2Array [][]*Inner
// errStructPtr2Array = append(errStructPtr2Array, []*Inner{{"ok"}, {""}, {""}})
// errStructPtr2Array = append(errStructPtr2Array, []*Inner{{"ok"}, {""}, {""}})
// errStructPtr2Array = append(errStructPtr2Array, []*Inner{{"ok"}, {""}, nil})
// tmsp2 := &TestMultiDimensionalStructsPtr2{
// Errs: errStructPtr2Array,
// }
// errs = validate.Struct(tmsp2)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 6)
// AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][2].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[1][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[1][2].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[2][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[2][2]", "Errs[2][2]", "required")
// m := map[int]interface{}{0: "ok", 3: "", 4: "ok"}
// errs = validate.Field(m, "len=3,dive,len=2")
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "[3]", "[3]", "len")
// errs = validate.Field(m, "len=2,dive,required")
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "", "", "len")
// arr := []interface{}{"ok", "", "ok"}
// errs = validate.Field(arr, "len=3,dive,len=2")
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "[1]", "[1]", "len")
// errs = validate.Field(arr, "len=2,dive,required")
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "", "", "len")
// type MyStruct struct {
// A, B string
// C interface{}
// }
// var a MyStruct
// a.A = "value"
// a.C = "nu"
// errs = validate.Struct(a)
// Equal(t, errs, nil)
// }
// func TestMapDiveValidation(t *testing.T) {
// n := map[int]interface{}{0: nil}
// errs := validate.Field(n, "omitempty,required")
// Equal(t, errs, nil)
// m := map[int]string{0: "ok", 3: "", 4: "ok"}
// errs = validate.Field(m, "len=3,dive,required")
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "[3]", "[3]", "required")
// errs = validate.Field(m, "len=2,dive,required")
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "", "", "len")
// type Inner struct {
// Name string `validate:"required"`
// }
// type TestMapStruct struct {
// Errs map[int]Inner `validate:"gt=0,dive"`
// }
// mi := map[int]Inner{0: {"ok"}, 3: {""}, 4: {"ok"}}
// ms := &TestMapStruct{
// Errs: mi,
// }
// errs = validate.Struct(ms)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "TestMapStruct.Errs[3].Name", "Name", "required")
// // for full test coverage
// s := fmt.Sprint(errs.Error())
// NotEqual(t, s, "")
// type TestMapTimeStruct struct {
// Errs map[int]*time.Time `validate:"gt=0,dive,required"`
// }
// t1 := time.Now().UTC()
// mta := map[int]*time.Time{0: &t1, 3: nil, 4: nil}
// mt := &TestMapTimeStruct{
// Errs: mta,
// }
// errs = validate.Struct(mt)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 2)
// AssertError(t, errs, "TestMapTimeStruct.Errs[3]", "Errs[3]", "required")
// AssertError(t, errs, "TestMapTimeStruct.Errs[4]", "Errs[4]", "required")
// type TestMapStructPtr struct {
// Errs map[int]*Inner `validate:"gt=0,dive,required"`
// }
// mip := map[int]*Inner{0: {"ok"}, 3: nil, 4: {"ok"}}
// msp := &TestMapStructPtr{
// Errs: mip,
// }
// errs = validate.Struct(msp)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "TestMapStructPtr.Errs[3]", "Errs[3]", "required")
// type TestMapStructPtr2 struct {
// Errs map[int]*Inner `validate:"gt=0,dive,omitempty,required"`
// }
// mip2 := map[int]*Inner{0: {"ok"}, 3: nil, 4: {"ok"}}
// msp2 := &TestMapStructPtr2{
// Errs: mip2,
// }
// errs = validate.Struct(msp2)
// Equal(t, errs, nil)
// }
// func TestArrayDiveValidation(t *testing.T) {
// arr := []string{"ok", "", "ok"}
// errs := validate.Field(arr, "len=3,dive,required")
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "[1]", "[1]", "required")
// errs = validate.Field(arr, "len=2,dive,required")
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "", "", "len")
// type BadDive struct {
// Name string `validate:"dive"`
// }
// bd := &BadDive{
// Name: "TEST",
// }
// PanicMatches(t, func() { validate.Struct(bd) }, "dive error! can't dive on a non slice or map")
// type Test struct {
// Errs []string `validate:"gt=0,dive,required"`
// }
// test := &Test{
// Errs: []string{"ok", "", "ok"},
// }
// errs = validate.Struct(test)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "Test.Errs[1]", "Errs[1]", "required")
// test = &Test{
// Errs: []string{"ok", "ok", ""},
// }
// errs = validate.Struct(test)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 1)
// AssertError(t, errs, "Test.Errs[2]", "Errs[2]", "required")
// type TestMultiDimensional struct {
// Errs [][]string `validate:"gt=0,dive,dive,required"`
// }
// var errArray [][]string
// errArray = append(errArray, []string{"ok", "", ""})
// errArray = append(errArray, []string{"ok", "", ""})
// tm := &TestMultiDimensional{
// Errs: errArray,
// }
// errs = validate.Struct(tm)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 4)
// AssertError(t, errs, "TestMultiDimensional.Errs[0][1]", "Errs[0][1]", "required")
// AssertError(t, errs, "TestMultiDimensional.Errs[0][2]", "Errs[0][2]", "required")
// AssertError(t, errs, "TestMultiDimensional.Errs[1][1]", "Errs[1][1]", "required")
// AssertError(t, errs, "TestMultiDimensional.Errs[1][2]", "Errs[1][2]", "required")
// type Inner struct {
// Name string `validate:"required"`
// }
// type TestMultiDimensionalStructs struct {
// Errs [][]Inner `validate:"gt=0,dive,dive"`
// }
// var errStructArray [][]Inner
// errStructArray = append(errStructArray, []Inner{{"ok"}, {""}, {""}})
// errStructArray = append(errStructArray, []Inner{{"ok"}, {""}, {""}})
// tms := &TestMultiDimensionalStructs{
// Errs: errStructArray,
// }
// errs = validate.Struct(tms)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 4)
// AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][2].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructs.Errs[1][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructs.Errs[1][2].Name", "Name", "required")
// type TestMultiDimensionalStructsPtr struct {
// Errs [][]*Inner `validate:"gt=0,dive,dive"`
// }
// var errStructPtrArray [][]*Inner
// errStructPtrArray = append(errStructPtrArray, []*Inner{{"ok"}, {""}, {""}})
// errStructPtrArray = append(errStructPtrArray, []*Inner{{"ok"}, {""}, {""}})
// errStructPtrArray = append(errStructPtrArray, []*Inner{{"ok"}, {""}, nil})
// tmsp := &TestMultiDimensionalStructsPtr{
// Errs: errStructPtrArray,
// }
// errs = validate.Struct(tmsp)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 5)
// AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[0][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[0][2].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[1][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[1][2].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[2][1].Name", "Name", "required")
// // for full test coverage
// s := fmt.Sprint(errs.Error())
// NotEqual(t, s, "")
// type TestMultiDimensionalStructsPtr2 struct {
// Errs [][]*Inner `validate:"gt=0,dive,dive,required"`
// }
// var errStructPtr2Array [][]*Inner
// errStructPtr2Array = append(errStructPtr2Array, []*Inner{{"ok"}, {""}, {""}})
// errStructPtr2Array = append(errStructPtr2Array, []*Inner{{"ok"}, {""}, {""}})
// errStructPtr2Array = append(errStructPtr2Array, []*Inner{{"ok"}, {""}, nil})
// tmsp2 := &TestMultiDimensionalStructsPtr2{
// Errs: errStructPtr2Array,
// }
// errs = validate.Struct(tmsp2)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 6)
// AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][2].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[1][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[1][2].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[2][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[2][2]", "Errs[2][2]", "required")
// type TestMultiDimensionalStructsPtr3 struct {
// Errs [][]*Inner `validate:"gt=0,dive,dive,omitempty"`
// }
// var errStructPtr3Array [][]*Inner
// errStructPtr3Array = append(errStructPtr3Array, []*Inner{{"ok"}, {""}, {""}})
// errStructPtr3Array = append(errStructPtr3Array, []*Inner{{"ok"}, {""}, {""}})
// errStructPtr3Array = append(errStructPtr3Array, []*Inner{{"ok"}, {""}, nil})
// tmsp3 := &TestMultiDimensionalStructsPtr3{
// Errs: errStructPtr3Array,
// }
// errs = validate.Struct(tmsp3)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 5)
// AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[0][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[0][2].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[1][1].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[1][2].Name", "Name", "required")
// AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[2][1].Name", "Name", "required")
// type TestMultiDimensionalTimeTime struct {
// Errs [][]*time.Time `validate:"gt=0,dive,dive,required"`
// }
// var errTimePtr3Array [][]*time.Time
// t1 := time.Now().UTC()
// t2 := time.Now().UTC()
// t3 := time.Now().UTC().Add(time.Hour * 24)
// errTimePtr3Array = append(errTimePtr3Array, []*time.Time{&t1, &t2, &t3})
// errTimePtr3Array = append(errTimePtr3Array, []*time.Time{&t1, &t2, nil})
// errTimePtr3Array = append(errTimePtr3Array, []*time.Time{&t1, nil, nil})
// tmtp3 := &TestMultiDimensionalTimeTime{
// Errs: errTimePtr3Array,
// }
// errs = validate.Struct(tmtp3)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 3)
// AssertError(t, errs, "TestMultiDimensionalTimeTime.Errs[1][2]", "Errs[1][2]", "required")
// AssertError(t, errs, "TestMultiDimensionalTimeTime.Errs[2][1]", "Errs[2][1]", "required")
// AssertError(t, errs, "TestMultiDimensionalTimeTime.Errs[2][2]", "Errs[2][2]", "required")
// type TestMultiDimensionalTimeTime2 struct {
// Errs [][]*time.Time `validate:"gt=0,dive,dive,required"`
// }
// var errTimeArray [][]*time.Time
// t1 = time.Now().UTC()
// t2 = time.Now().UTC()
// t3 = time.Now().UTC().Add(time.Hour * 24)
// errTimeArray = append(errTimeArray, []*time.Time{&t1, &t2, &t3})
// errTimeArray = append(errTimeArray, []*time.Time{&t1, &t2, nil})
// errTimeArray = append(errTimeArray, []*time.Time{&t1, nil, nil})
// tmtp := &TestMultiDimensionalTimeTime2{
// Errs: errTimeArray,
// }
// errs = validate.Struct(tmtp)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 3)
// AssertError(t, errs, "TestMultiDimensionalTimeTime2.Errs[1][2]", "Errs[1][2]", "required")
// AssertError(t, errs, "TestMultiDimensionalTimeTime2.Errs[2][1]", "Errs[2][1]", "required")
// AssertError(t, errs, "TestMultiDimensionalTimeTime2.Errs[2][2]", "Errs[2][2]", "required")
// }
// func TestNilStructPointerValidation(t *testing.T) {
// type Inner struct {
// Data string
// }
// type Outer struct {
// Inner *Inner `validate:"omitempty"`
// }
// inner := &Inner{
// Data: "test",
// }
// outer := &Outer{
// Inner: inner,
// }
// errs := validate.Struct(outer)
// Equal(t, errs, nil)
// outer = &Outer{
// Inner: nil,
// }
// errs = validate.Struct(outer)
// Equal(t, errs, nil)
// type Inner2 struct {
// Data string
// }
// type Outer2 struct {
// Inner2 *Inner2 `validate:"required"`
// }
// inner2 := &Inner2{
// Data: "test",
// }
// outer2 := &Outer2{
// Inner2: inner2,
// }
// errs = validate.Struct(outer2)
// Equal(t, errs, nil)
// outer2 = &Outer2{
// Inner2: nil,
// }
// errs = validate.Struct(outer2)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Outer2.Inner2", "Inner2", "required")
// type Inner3 struct {
// Data string
// }
// type Outer3 struct {
// Inner3 *Inner3
// }
// inner3 := &Inner3{
// Data: "test",
// }
// outer3 := &Outer3{
// Inner3: inner3,
// }
// errs = validate.Struct(outer3)
// Equal(t, errs, nil)
// type Inner4 struct {
// Data string
// }
// type Outer4 struct {
// Inner4 *Inner4 `validate:"-"`
// }
// inner4 := &Inner4{
// Data: "test",
// }
// outer4 := &Outer4{
// Inner4: inner4,
// }
// errs = validate.Struct(outer4)
// Equal(t, errs, nil)
// }
// func TestSSNValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"00-90-8787", false},
// {"66690-76", false},
// {"191 60 2869", true},
// {"191-60-2869", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "ssn")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d SSN failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d SSN failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "ssn" {
// t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestLongitudeValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"-180.000", true},
// {"180.1", false},
// {"+73.234", true},
// {"+382.3811", false},
// {"23.11111111", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "longitude")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d Longitude failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d Longitude failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "longitude" {
// t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestLatitudeValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"-90.000", true},
// {"+90", true},
// {"47.1231231", true},
// {"+99.9", false},
// {"108", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "latitude")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "latitude" {
// t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestDataURIValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"data:image/png;base64,TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdC4=", true},
// {"data:text/plain;base64,Vml2YW11cyBmZXJtZW50dW0gc2VtcGVyIHBvcnRhLg==", true},
// {"image/gif;base64,U3VzcGVuZGlzc2UgbGVjdHVzIGxlbw==", false},
// {"data:image/gif;base64,MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuMPNS1Ufof9EW/M98FNw" +
// "UAKrwflsqVxaxQjBQnHQmiI7Vac40t8x7pIb8gLGV6wL7sBTJiPovJ0V7y7oc0Ye" +
// "rhKh0Rm4skP2z/jHwwZICgGzBvA0rH8xlhUiTvcwDCJ0kc+fh35hNt8srZQM4619" +
// "FTgB66Xmp4EtVyhpQV+t02g6NzK72oZI0vnAvqhpkxLeLiMCyrI416wHm5Tkukhx" +
// "QmcL2a6hNOyu0ixX/x2kSFXApEnVrJ+/IxGyfyw8kf4N2IZpW5nEP847lpfj0SZZ" +
// "Fwrd1mnfnDbYohX2zRptLy2ZUn06Qo9pkG5ntvFEPo9bfZeULtjYzIl6K8gJ2uGZ" + "HQIDAQAB", true},
// {"data:image/png;base64,12345", false},
// {"", false},
// {"data:text,:;base85,U3VzcGVuZGlzc2UgbGVjdHVzIGxlbw==", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "datauri")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d DataURI failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d DataURI failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "datauri" {
// t.Fatalf("Index: %d DataURI failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestMultibyteValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", true},
// {"abc", false},
// {"123", false},
// {"<>@;.-=", false},
// {"ひらがな・カタカナ、．漢字", true},
// {"あいうえお foobar", true},
// {"test＠example.com", true},
// {"test＠example.com", true},
// {"1234abcDEｘｙｚ", true},
// {"ｶﾀｶﾅ", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "multibyte")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d Multibyte failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d Multibyte failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "multibyte" {
// t.Fatalf("Index: %d Multibyte failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestPrintableASCIIValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", true},
// {"ｆｏｏbar", false},
// {"ｘｙｚ０９８", false},
// {"１２３456", false},
// {"ｶﾀｶﾅ", false},
// {"foobar", true},
// {"0987654321", true},
// {"test@example.com", true},
// {"1234abcDEF", true},
// {"newline\n", false},
// {"\x19test\x7F", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "printascii")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d Printable ASCII failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d Printable ASCII failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "printascii" {
// t.Fatalf("Index: %d Printable ASCII failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestASCIIValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", true},
// {"ｆｏｏbar", false},
// {"ｘｙｚ０９８", false},
// {"１２３456", false},
// {"ｶﾀｶﾅ", false},
// {"foobar", true},
// {"0987654321", true},
// {"test@example.com", true},
// {"1234abcDEF", true},
// {"", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "ascii")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d ASCII failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d ASCII failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "ascii" {
// t.Fatalf("Index: %d ASCII failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestUUID5Validation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"xxxa987fbc9-4bed-3078-cf07-9141ba07c9f3", false},
// {"9c858901-8a57-4791-81fe-4c455b099bc9", false},
// {"a987fbc9-4bed-3078-cf07-9141ba07c9f3", false},
// {"987fbc97-4bed-5078-af07-9141ba07c9f3", true},
// {"987fbc97-4bed-5078-9f07-9141ba07c9f3", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "uuid5")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d UUID5 failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d UUID5 failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "uuid5" {
// t.Fatalf("Index: %d UUID5 failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestUUID4Validation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"xxxa987fbc9-4bed-3078-cf07-9141ba07c9f3", false},
// {"a987fbc9-4bed-5078-af07-9141ba07c9f3", false},
// {"934859", false},
// {"57b73598-8764-4ad0-a76a-679bb6640eb1", true},
// {"625e63f3-58f5-40b7-83a1-a72ad31acffb", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "uuid4")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d UUID4 failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d UUID4 failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "uuid4" {
// t.Fatalf("Index: %d UUID4 failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestUUID3Validation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"412452646", false},
// {"xxxa987fbc9-4bed-3078-cf07-9141ba07c9f3", false},
// {"a987fbc9-4bed-4078-8f07-9141ba07c9f3", false},
// {"a987fbc9-4bed-3078-cf07-9141ba07c9f3", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "uuid3")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d UUID3 failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d UUID3 failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "uuid3" {
// t.Fatalf("Index: %d UUID3 failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestUUIDValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"xxxa987fbc9-4bed-3078-cf07-9141ba07c9f3", false},
// {"a987fbc9-4bed-3078-cf07-9141ba07c9f3xxx", false},
// {"a987fbc94bed3078cf079141ba07c9f3", false},
// {"934859", false},
// {"987fbc9-4bed-3078-cf07a-9141ba07c9f3", false},
// {"aaaaaaaa-1111-1111-aaag-111111111111", false},
// {"a987fbc9-4bed-3078-cf07-9141ba07c9f3", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "uuid")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d UUID failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d UUID failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "uuid" {
// t.Fatalf("Index: %d UUID failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestISBNValidation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"foo", false},
// {"3836221195", true},
// {"1-61729-085-8", true},
// {"3 423 21412 0", true},
// {"3 401 01319 X", true},
// {"9784873113685", true},
// {"978-4-87311-368-5", true},
// {"978 3401013190", true},
// {"978-3-8362-2119-1", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "isbn")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d ISBN failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d ISBN failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "isbn" {
// t.Fatalf("Index: %d ISBN failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestISBN13Validation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"foo", false},
// {"3-8362-2119-5", false},
// {"01234567890ab", false},
// {"978 3 8362 2119 0", false},
// {"9784873113685", true},
// {"978-4-87311-368-5", true},
// {"978 3401013190", true},
// {"978-3-8362-2119-1", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "isbn13")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d ISBN13 failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d ISBN13 failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "isbn13" {
// t.Fatalf("Index: %d ISBN13 failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestISBN10Validation(t *testing.T) {
// tests := []struct {
// param string
// expected bool
// }{
// {"", false},
// {"foo", false},
// {"3423214121", false},
// {"978-3836221191", false},
// {"3-423-21412-1", false},
// {"3 423 21412 1", false},
// {"3836221195", true},
// {"1-61729-085-8", true},
// {"3 423 21412 0", true},
// {"3 401 01319 X", true},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "isbn10")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d ISBN10 failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d ISBN10 failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "isbn10" {
// t.Fatalf("Index: %d ISBN10 failed Error: %s", i, errs)
// }
// }
// }
// }
// }
// func TestExcludesRuneValidation(t *testing.T) {
// tests := []struct {
// Value string `validate:"excludesrune=☻"`
// Tag string
// ExpectedNil bool
// }{
// {Value: "a☺b☻c☹d", Tag: "excludesrune=☻", ExpectedNil: false},
// {Value: "abcd", Tag: "excludesrune=☻", ExpectedNil: true},
// }
// for i, s := range tests {
// errs := validate.Field(s.Value, s.Tag)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// errs = validate.Struct(s)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// }
// }
// func TestExcludesAllValidation(t *testing.T) {
// tests := []struct {
// Value string `validate:"excludesall=@!{}[]"`
// Tag string
// ExpectedNil bool
// }{
// {Value: "abcd@!jfk", Tag: "excludesall=@!{}[]", ExpectedNil: false},
// {Value: "abcdefg", Tag: "excludesall=@!{}[]", ExpectedNil: true},
// }
// for i, s := range tests {
// errs := validate.Field(s.Value, s.Tag)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// errs = validate.Struct(s)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// }
// username := "joeybloggs "
// errs := validate.Field(username, "excludesall=@ ")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "excludesall")
// excluded := ","
// errs = validate.Field(excluded, "excludesall=!@#$%^&*()_+.0x2C?")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "excludesall")
// excluded = "="
// errs = validate.Field(excluded, "excludesall=!@#$%^&*()_+.0x2C=?")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "excludesall")
// }
// func TestExcludesValidation(t *testing.T) {
// tests := []struct {
// Value string `validate:"excludes=@"`
// Tag string
// ExpectedNil bool
// }{
// {Value: "abcd@!jfk", Tag: "excludes=@", ExpectedNil: false},
// {Value: "abcdq!jfk", Tag: "excludes=@", ExpectedNil: true},
// }
// for i, s := range tests {
// errs := validate.Field(s.Value, s.Tag)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// errs = validate.Struct(s)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// }
// }
// func TestContainsRuneValidation(t *testing.T) {
// tests := []struct {
// Value string `validate:"containsrune=☻"`
// Tag string
// ExpectedNil bool
// }{
// {Value: "a☺b☻c☹d", Tag: "containsrune=☻", ExpectedNil: true},
// {Value: "abcd", Tag: "containsrune=☻", ExpectedNil: false},
// }
// for i, s := range tests {
// errs := validate.Field(s.Value, s.Tag)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// errs = validate.Struct(s)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// }
// }
// func TestContainsAnyValidation(t *testing.T) {
// tests := []struct {
// Value string `validate:"containsany=@!{}[]"`
// Tag string
// ExpectedNil bool
// }{
// {Value: "abcd@!jfk", Tag: "containsany=@!{}[]", ExpectedNil: true},
// {Value: "abcdefg", Tag: "containsany=@!{}[]", ExpectedNil: false},
// }
// for i, s := range tests {
// errs := validate.Field(s.Value, s.Tag)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// errs = validate.Struct(s)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// }
// }
// func TestContainsValidation(t *testing.T) {
// tests := []struct {
// Value string `validate:"contains=@"`
// Tag string
// ExpectedNil bool
// }{
// {Value: "abcd@!jfk", Tag: "contains=@", ExpectedNil: true},
// {Value: "abcdq!jfk", Tag: "contains=@", ExpectedNil: false},
// }
// for i, s := range tests {
// errs := validate.Field(s.Value, s.Tag)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// errs = validate.Struct(s)
// if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
// t.Fatalf("Index: %d failed Error: %s", i, errs)
// }
// }
// }
// func TestIsNeFieldValidation(t *testing.T) {
// var j uint64
// var k float64
// s := "abcd"
// i := 1
// j = 1
// k = 1.543
// arr := []string{"test"}
// now := time.Now().UTC()
// var j2 uint64
// var k2 float64
// s2 := "abcdef"
// i2 := 3
// j2 = 2
// k2 = 1.5434456
// arr2 := []string{"test", "test2"}
// arr3 := []string{"test"}
// now2 := now
// errs := validate.FieldWithValue(s, s2, "nefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(i2, i, "nefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(j2, j, "nefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(k2, k, "nefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(arr2, arr, "nefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(now2, now, "nefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "nefield")
// errs = validate.FieldWithValue(arr3, arr, "nefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "nefield")
// type Test struct {
// Start *time.Time `validate:"nefield=End"`
// End *time.Time
// }
// sv := &Test{
// Start: &now,
// End: &now,
// }
// errs = validate.Struct(sv)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.Start", "Start", "nefield")
// now3 := time.Now().UTC()
// sv = &Test{
// Start: &now,
// End: &now3,
// }
// errs = validate.Struct(sv)
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(nil, 1, "nefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(sv, now, "nefield")
// Equal(t, errs, nil)
// type Test2 struct {
// Start *time.Time `validate:"nefield=NonExistantField"`
// End *time.Time
// }
// sv2 := &Test2{
// Start: &now,
// End: &now,
// }
// errs = validate.Struct(sv2)
// Equal(t, errs, nil)
// }
// func TestIsNeValidation(t *testing.T) {
// var j uint64
// var k float64
// s := "abcdef"
// i := 3
// j = 2
// k = 1.5434
// arr := []string{"test"}
// now := time.Now().UTC()
// errs := validate.Field(s, "ne=abcd")
// Equal(t, errs, nil)
// errs = validate.Field(i, "ne=1")
// Equal(t, errs, nil)
// errs = validate.Field(j, "ne=1")
// Equal(t, errs, nil)
// errs = validate.Field(k, "ne=1.543")
// Equal(t, errs, nil)
// errs = validate.Field(arr, "ne=2")
// Equal(t, errs, nil)
// errs = validate.Field(arr, "ne=1")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ne")
// PanicMatches(t, func() { validate.Field(now, "ne=now") }, "Bad field type time.Time")
// }
// func TestIsEqFieldValidation(t *testing.T) {
// var j uint64
// var k float64
// s := "abcd"
// i := 1
// j = 1
// k = 1.543
// arr := []string{"test"}
// now := time.Now().UTC()
// var j2 uint64
// var k2 float64
// s2 := "abcd"
// i2 := 1
// j2 = 1
// k2 = 1.543
// arr2 := []string{"test"}
// arr3 := []string{"test", "test2"}
// now2 := now
// errs := validate.FieldWithValue(s, s2, "eqfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(i2, i, "eqfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(j2, j, "eqfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(k2, k, "eqfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(arr2, arr, "eqfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(now2, now, "eqfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(arr3, arr, "eqfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "eqfield")
// type Test struct {
// Start *time.Time `validate:"eqfield=End"`
// End *time.Time
// }
// sv := &Test{
// Start: &now,
// End: &now,
// }
// errs = validate.Struct(sv)
// Equal(t, errs, nil)
// now3 := time.Now().UTC()
// sv = &Test{
// Start: &now,
// End: &now3,
// }
// errs = validate.Struct(sv)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.Start", "Start", "eqfield")
// errs = validate.FieldWithValue(nil, 1, "eqfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "eqfield")
// channel := make(chan string)
// errs = validate.FieldWithValue(5, channel, "eqfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "eqfield")
// errs = validate.FieldWithValue(5, now, "eqfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "eqfield")
// type Test2 struct {
// Start *time.Time `validate:"eqfield=NonExistantField"`
// End *time.Time
// }
// sv2 := &Test2{
// Start: &now,
// End: &now,
// }
// errs = validate.Struct(sv2)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test2.Start", "Start", "eqfield")
// type Inner struct {
// Name string
// }
// type TStruct struct {
// Inner *Inner
// CreatedAt *time.Time `validate:"eqfield=Inner"`
// }
// inner := &Inner{
// Name: "NAME",
// }
// test := &TStruct{
// Inner: inner,
// CreatedAt: &now,
// }
// errs = validate.Struct(test)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TStruct.CreatedAt", "CreatedAt", "eqfield")
// }
// func TestIsEqValidation(t *testing.T) {
// var j uint64
// var k float64
// s := "abcd"
// i := 1
// j = 1
// k = 1.543
// arr := []string{"test"}
// now := time.Now().UTC()
// errs := validate.Field(s, "eq=abcd")
// Equal(t, errs, nil)
// errs = validate.Field(i, "eq=1")
// Equal(t, errs, nil)
// errs = validate.Field(j, "eq=1")
// Equal(t, errs, nil)
// errs = validate.Field(k, "eq=1.543")
// Equal(t, errs, nil)
// errs = validate.Field(arr, "eq=1")
// Equal(t, errs, nil)
// errs = validate.Field(arr, "eq=2")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "eq")
// PanicMatches(t, func() { validate.Field(now, "eq=now") }, "Bad field type time.Time")
// }
// func TestBase64Validation(t *testing.T) {
// s := "dW5pY29ybg=="
// errs := validate.Field(s, "base64")
// Equal(t, errs, nil)
// s = "dGhpIGlzIGEgdGVzdCBiYXNlNjQ="
// errs = validate.Field(s, "base64")
// Equal(t, errs, nil)
// s = ""
// errs = validate.Field(s, "base64")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "base64")
// s = "dW5pY29ybg== foo bar"
// errs = validate.Field(s, "base64")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "base64")
// }
// func TestNoStructLevelValidation(t *testing.T) {
// type Inner struct {
// Test string `validate:"len=5"`
// }
// type Outer struct {
// InnerStruct *Inner `validate:"required,nostructlevel"`
// }
// outer := &Outer{
// InnerStruct: nil,
// }
// errs := validate.Struct(outer)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Outer.InnerStruct", "InnerStruct", "required")
// inner := &Inner{
// Test: "1234",
// }
// outer = &Outer{
// InnerStruct: inner,
// }
// errs = validate.Struct(outer)
// Equal(t, errs, nil)
// }
// func TestStructOnlyValidation(t *testing.T) {
// type Inner struct {
// Test string `validate:"len=5"`
// }
// type Outer struct {
// InnerStruct *Inner `validate:"required,structonly"`
// }
// outer := &Outer{
// InnerStruct: nil,
// }
// errs := validate.Struct(outer)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Outer.InnerStruct", "InnerStruct", "required")
// inner := &Inner{
// Test: "1234",
// }
// outer = &Outer{
// InnerStruct: inner,
// }
// errs = validate.Struct(outer)
// Equal(t, errs, nil)
// }
// func TestGtField(t *testing.T) {
// type TimeTest struct {
// Start *time.Time `validate:"required,gt"`
// End *time.Time `validate:"required,gt,gtfield=Start"`
// }
// now := time.Now()
// start := now.Add(time.Hour * 24)
// end := start.Add(time.Hour * 24)
// timeTest := &TimeTest{
// Start: &start,
// End: &end,
// }
// errs := validate.Struct(timeTest)
// Equal(t, errs, nil)
// timeTest = &TimeTest{
// Start: &end,
// End: &start,
// }
// errs = validate.Struct(timeTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TimeTest.End", "End", "gtfield")
// errs = validate.FieldWithValue(&start, &end, "gtfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(&end, &start, "gtfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtfield")
// errs = validate.FieldWithValue(&timeTest, &end, "gtfield")
// NotEqual(t, errs, nil)
// errs = validate.FieldWithValue("test", "test bigger", "gtfield")
// Equal(t, errs, nil)
// type IntTest struct {
// Val1 int `validate:"required"`
// Val2 int `validate:"required,gtfield=Val1"`
// }
// intTest := &IntTest{
// Val1: 1,
// Val2: 5,
// }
// errs = validate.Struct(intTest)
// Equal(t, errs, nil)
// intTest = &IntTest{
// Val1: 5,
// Val2: 1,
// }
// errs = validate.Struct(intTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "IntTest.Val2", "Val2", "gtfield")
// errs = validate.FieldWithValue(int(1), int(5), "gtfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(int(5), int(1), "gtfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtfield")
// type UIntTest struct {
// Val1 uint `validate:"required"`
// Val2 uint `validate:"required,gtfield=Val1"`
// }
// uIntTest := &UIntTest{
// Val1: 1,
// Val2: 5,
// }
// errs = validate.Struct(uIntTest)
// Equal(t, errs, nil)
// uIntTest = &UIntTest{
// Val1: 5,
// Val2: 1,
// }
// errs = validate.Struct(uIntTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "UIntTest.Val2", "Val2", "gtfield")
// errs = validate.FieldWithValue(uint(1), uint(5), "gtfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(uint(5), uint(1), "gtfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtfield")
// type FloatTest struct {
// Val1 float64 `validate:"required"`
// Val2 float64 `validate:"required,gtfield=Val1"`
// }
// floatTest := &FloatTest{
// Val1: 1,
// Val2: 5,
// }
// errs = validate.Struct(floatTest)
// Equal(t, errs, nil)
// floatTest = &FloatTest{
// Val1: 5,
// Val2: 1,
// }
// errs = validate.Struct(floatTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "FloatTest.Val2", "Val2", "gtfield")
// errs = validate.FieldWithValue(float32(1), float32(5), "gtfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(float32(5), float32(1), "gtfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtfield")
// errs = validate.FieldWithValue(nil, 1, "gtfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtfield")
// errs = validate.FieldWithValue(5, "T", "gtfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtfield")
// errs = validate.FieldWithValue(5, start, "gtfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtfield")
// type TimeTest2 struct {
// Start *time.Time `validate:"required"`
// End *time.Time `validate:"required,gtfield=NonExistantField"`
// }
// timeTest2 := &TimeTest2{
// Start: &start,
// End: &end,
// }
// errs = validate.Struct(timeTest2)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TimeTest2.End", "End", "gtfield")
// }
// func TestLtField(t *testing.T) {
// type TimeTest struct {
// Start *time.Time `validate:"required,lt,ltfield=End"`
// End *time.Time `validate:"required,lt"`
// }
// now := time.Now()
// start := now.Add(time.Hour * 24 * -1 * 2)
// end := start.Add(time.Hour * 24)
// timeTest := &TimeTest{
// Start: &start,
// End: &end,
// }
// errs := validate.Struct(timeTest)
// Equal(t, errs, nil)
// timeTest = &TimeTest{
// Start: &end,
// End: &start,
// }
// errs = validate.Struct(timeTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TimeTest.Start", "Start", "ltfield")
// errs = validate.FieldWithValue(&end, &start, "ltfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(&start, &end, "ltfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltfield")
// errs = validate.FieldWithValue(timeTest, &end, "ltfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltfield")
// errs = validate.FieldWithValue("test", "tes", "ltfield")
// Equal(t, errs, nil)
// type IntTest struct {
// Val1 int `validate:"required"`
// Val2 int `validate:"required,ltfield=Val1"`
// }
// intTest := &IntTest{
// Val1: 5,
// Val2: 1,
// }
// errs = validate.Struct(intTest)
// Equal(t, errs, nil)
// intTest = &IntTest{
// Val1: 1,
// Val2: 5,
// }
// errs = validate.Struct(intTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "IntTest.Val2", "Val2", "ltfield")
// errs = validate.FieldWithValue(int(5), int(1), "ltfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(int(1), int(5), "ltfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltfield")
// type UIntTest struct {
// Val1 uint `validate:"required"`
// Val2 uint `validate:"required,ltfield=Val1"`
// }
// uIntTest := &UIntTest{
// Val1: 5,
// Val2: 1,
// }
// errs = validate.Struct(uIntTest)
// Equal(t, errs, nil)
// uIntTest = &UIntTest{
// Val1: 1,
// Val2: 5,
// }
// errs = validate.Struct(uIntTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "UIntTest.Val2", "Val2", "ltfield")
// errs = validate.FieldWithValue(uint(5), uint(1), "ltfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(uint(1), uint(5), "ltfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltfield")
// type FloatTest struct {
// Val1 float64 `validate:"required"`
// Val2 float64 `validate:"required,ltfield=Val1"`
// }
// floatTest := &FloatTest{
// Val1: 5,
// Val2: 1,
// }
// errs = validate.Struct(floatTest)
// Equal(t, errs, nil)
// floatTest = &FloatTest{
// Val1: 1,
// Val2: 5,
// }
// errs = validate.Struct(floatTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "FloatTest.Val2", "Val2", "ltfield")
// errs = validate.FieldWithValue(float32(5), float32(1), "ltfield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(float32(1), float32(5), "ltfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltfield")
// errs = validate.FieldWithValue(nil, 5, "ltfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltfield")
// errs = validate.FieldWithValue(1, "T", "ltfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltfield")
// errs = validate.FieldWithValue(1, end, "ltfield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltfield")
// type TimeTest2 struct {
// Start *time.Time `validate:"required"`
// End *time.Time `validate:"required,ltfield=NonExistantField"`
// }
// timeTest2 := &TimeTest2{
// Start: &end,
// End: &start,
// }
// errs = validate.Struct(timeTest2)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TimeTest2.End", "End", "ltfield")
// }
// func TestLteField(t *testing.T) {
// type TimeTest struct {
// Start *time.Time `validate:"required,lte,ltefield=End"`
// End *time.Time `validate:"required,lte"`
// }
// now := time.Now()
// start := now.Add(time.Hour * 24 * -1 * 2)
// end := start.Add(time.Hour * 24)
// timeTest := &TimeTest{
// Start: &start,
// End: &end,
// }
// errs := validate.Struct(timeTest)
// Equal(t, errs, nil)
// timeTest = &TimeTest{
// Start: &end,
// End: &start,
// }
// errs = validate.Struct(timeTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TimeTest.Start", "Start", "ltefield")
// errs = validate.FieldWithValue(&end, &start, "ltefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(&start, &end, "ltefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltefield")
// errs = validate.FieldWithValue(timeTest, &end, "ltefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltefield")
// errs = validate.FieldWithValue("test", "tes", "ltefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue("test", "test", "ltefield")
// Equal(t, errs, nil)
// type IntTest struct {
// Val1 int `validate:"required"`
// Val2 int `validate:"required,ltefield=Val1"`
// }
// intTest := &IntTest{
// Val1: 5,
// Val2: 1,
// }
// errs = validate.Struct(intTest)
// Equal(t, errs, nil)
// intTest = &IntTest{
// Val1: 1,
// Val2: 5,
// }
// errs = validate.Struct(intTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "IntTest.Val2", "Val2", "ltefield")
// errs = validate.FieldWithValue(int(5), int(1), "ltefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(int(1), int(5), "ltefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltefield")
// type UIntTest struct {
// Val1 uint `validate:"required"`
// Val2 uint `validate:"required,ltefield=Val1"`
// }
// uIntTest := &UIntTest{
// Val1: 5,
// Val2: 1,
// }
// errs = validate.Struct(uIntTest)
// Equal(t, errs, nil)
// uIntTest = &UIntTest{
// Val1: 1,
// Val2: 5,
// }
// errs = validate.Struct(uIntTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "UIntTest.Val2", "Val2", "ltefield")
// errs = validate.FieldWithValue(uint(5), uint(1), "ltefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(uint(1), uint(5), "ltefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltefield")
// type FloatTest struct {
// Val1 float64 `validate:"required"`
// Val2 float64 `validate:"required,ltefield=Val1"`
// }
// floatTest := &FloatTest{
// Val1: 5,
// Val2: 1,
// }
// errs = validate.Struct(floatTest)
// Equal(t, errs, nil)
// floatTest = &FloatTest{
// Val1: 1,
// Val2: 5,
// }
// errs = validate.Struct(floatTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "FloatTest.Val2", "Val2", "ltefield")
// errs = validate.FieldWithValue(float32(5), float32(1), "ltefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(float32(1), float32(5), "ltefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltefield")
// errs = validate.FieldWithValue(nil, 5, "ltefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltefield")
// errs = validate.FieldWithValue(1, "T", "ltefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltefield")
// errs = validate.FieldWithValue(1, end, "ltefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "ltefield")
// type TimeTest2 struct {
// Start *time.Time `validate:"required"`
// End *time.Time `validate:"required,ltefield=NonExistantField"`
// }
// timeTest2 := &TimeTest2{
// Start: &end,
// End: &start,
// }
// errs = validate.Struct(timeTest2)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TimeTest2.End", "End", "ltefield")
// }
// func TestGteField(t *testing.T) {
// type TimeTest struct {
// Start *time.Time `validate:"required,gte"`
// End *time.Time `validate:"required,gte,gtefield=Start"`
// }
// now := time.Now()
// start := now.Add(time.Hour * 24)
// end := start.Add(time.Hour * 24)
// timeTest := &TimeTest{
// Start: &start,
// End: &end,
// }
// errs := validate.Struct(timeTest)
// Equal(t, errs, nil)
// timeTest = &TimeTest{
// Start: &end,
// End: &start,
// }
// errs = validate.Struct(timeTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TimeTest.End", "End", "gtefield")
// errs = validate.FieldWithValue(&start, &end, "gtefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(&end, &start, "gtefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtefield")
// errs = validate.FieldWithValue(timeTest, &start, "gtefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtefield")
// errs = validate.FieldWithValue("test", "test", "gtefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue("test", "test bigger", "gtefield")
// Equal(t, errs, nil)
// type IntTest struct {
// Val1 int `validate:"required"`
// Val2 int `validate:"required,gtefield=Val1"`
// }
// intTest := &IntTest{
// Val1: 1,
// Val2: 5,
// }
// errs = validate.Struct(intTest)
// Equal(t, errs, nil)
// intTest = &IntTest{
// Val1: 5,
// Val2: 1,
// }
// errs = validate.Struct(intTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "IntTest.Val2", "Val2", "gtefield")
// errs = validate.FieldWithValue(int(1), int(5), "gtefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(int(5), int(1), "gtefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtefield")
// type UIntTest struct {
// Val1 uint `validate:"required"`
// Val2 uint `validate:"required,gtefield=Val1"`
// }
// uIntTest := &UIntTest{
// Val1: 1,
// Val2: 5,
// }
// errs = validate.Struct(uIntTest)
// Equal(t, errs, nil)
// uIntTest = &UIntTest{
// Val1: 5,
// Val2: 1,
// }
// errs = validate.Struct(uIntTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "UIntTest.Val2", "Val2", "gtefield")
// errs = validate.FieldWithValue(uint(1), uint(5), "gtefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(uint(5), uint(1), "gtefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtefield")
// type FloatTest struct {
// Val1 float64 `validate:"required"`
// Val2 float64 `validate:"required,gtefield=Val1"`
// }
// floatTest := &FloatTest{
// Val1: 1,
// Val2: 5,
// }
// errs = validate.Struct(floatTest)
// Equal(t, errs, nil)
// floatTest = &FloatTest{
// Val1: 5,
// Val2: 1,
// }
// errs = validate.Struct(floatTest)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "FloatTest.Val2", "Val2", "gtefield")
// errs = validate.FieldWithValue(float32(1), float32(5), "gtefield")
// Equal(t, errs, nil)
// errs = validate.FieldWithValue(float32(5), float32(1), "gtefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtefield")
// errs = validate.FieldWithValue(nil, 1, "gtefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtefield")
// errs = validate.FieldWithValue(5, "T", "gtefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtefield")
// errs = validate.FieldWithValue(5, start, "gtefield")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gtefield")
// type TimeTest2 struct {
// Start *time.Time `validate:"required"`
// End *time.Time `validate:"required,gtefield=NonExistantField"`
// }
// timeTest2 := &TimeTest2{
// Start: &start,
// End: &end,
// }
// errs = validate.Struct(timeTest2)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TimeTest2.End", "End", "gtefield")
// }
// func TestValidateByTagAndValue(t *testing.T) {
// val := "test"
// field := "test"
// errs := validate.FieldWithValue(val, field, "required")
// Equal(t, errs, nil)
// fn := func(v *Validate, topStruct reflect.Value, current reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
// return current.String() == field.String()
// }
// validate.RegisterValidation("isequaltestfunc", fn)
// errs = validate.FieldWithValue(val, field, "isequaltestfunc")
// Equal(t, errs, nil)
// val = "unequal"
// errs = validate.FieldWithValue(val, field, "isequaltestfunc")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "isequaltestfunc")
// }
// func TestAddFunctions(t *testing.T) {
// fn := func(v *Validate, topStruct reflect.Value, currentStruct reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool {
// return true
// }
// config := &Config{
// TagName: "validateme",
// }
// validate := New(config)
// errs := validate.RegisterValidation("new", fn)
// Equal(t, errs, nil)
// errs = validate.RegisterValidation("", fn)
// NotEqual(t, errs, nil)
// validate.RegisterValidation("new", nil)
// NotEqual(t, errs, nil)
// errs = validate.RegisterValidation("new", fn)
// Equal(t, errs, nil)
// PanicMatches(t, func() { validate.RegisterValidation("dive", fn) }, "Tag 'dive' either contains restricted characters or is the same as a restricted tag needed for normal operation")
// }
// func TestChangeTag(t *testing.T) {
// config := &Config{
// TagName: "val",
// }
// validate := New(config)
// type Test struct {
// Name string `val:"len=4"`
// }
// s := &Test{
// Name: "TEST",
// }
// errs := validate.Struct(s)
// Equal(t, errs, nil)
// }
// func TestUnexposedStruct(t *testing.T) {
// type Test struct {
// Name string
// unexposed struct {
// A string `validate:"required"`
// }
// }
// s := &Test{
// Name: "TEST",
// }
// errs := validate.Struct(s)
// Equal(t, errs, nil)
// }
// func TestBadParams(t *testing.T) {
// i := 1
// errs := validate.Field(i, "-")
// Equal(t, errs, nil)
// PanicMatches(t, func() { validate.Field(i, "len=a") }, "strconv.ParseInt: parsing \"a\": invalid syntax")
// PanicMatches(t, func() { validate.Field(i, "len=a") }, "strconv.ParseInt: parsing \"a\": invalid syntax")
// var ui uint = 1
// PanicMatches(t, func() { validate.Field(ui, "len=a") }, "strconv.ParseUint: parsing \"a\": invalid syntax")
// f := 1.23
// PanicMatches(t, func() { validate.Field(f, "len=a") }, "strconv.ParseFloat: parsing \"a\": invalid syntax")
// }
// func TestLength(t *testing.T) {
// i := true
// PanicMatches(t, func() { validate.Field(i, "len") }, "Bad field type bool")
// }
// func TestIsGt(t *testing.T) {
// myMap := map[string]string{}
// errs := validate.Field(myMap, "gt=0")
// NotEqual(t, errs, nil)
// f := 1.23
// errs = validate.Field(f, "gt=5")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gt")
// var ui uint = 5
// errs = validate.Field(ui, "gt=10")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gt")
// i := true
// PanicMatches(t, func() { validate.Field(i, "gt") }, "Bad field type bool")
// tm := time.Now().UTC()
// tm = tm.Add(time.Hour * 24)
// errs = validate.Field(tm, "gt")
// Equal(t, errs, nil)
// t2 := time.Now().UTC()
// errs = validate.Field(t2, "gt")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gt")
// type Test struct {
// Now *time.Time `validate:"gt"`
// }
// s := &Test{
// Now: &tm,
// }
// errs = validate.Struct(s)
// Equal(t, errs, nil)
// s = &Test{
// Now: &t2,
// }
// errs = validate.Struct(s)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.Now", "Now", "gt")
// }
// func TestIsGte(t *testing.T) {
// i := true
// PanicMatches(t, func() { validate.Field(i, "gte") }, "Bad field type bool")
// t1 := time.Now().UTC()
// t1 = t1.Add(time.Hour * 24)
// errs := validate.Field(t1, "gte")
// Equal(t, errs, nil)
// t2 := time.Now().UTC()
// errs = validate.Field(t2, "gte")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "gte")
// type Test struct {
// Now *time.Time `validate:"gte"`
// }
// s := &Test{
// Now: &t1,
// }
// errs = validate.Struct(s)
// Equal(t, errs, nil)
// s = &Test{
// Now: &t2,
// }
// errs = validate.Struct(s)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.Now", "Now", "gte")
// }
// func TestIsLt(t *testing.T) {
// myMap := map[string]string{}
// errs := validate.Field(myMap, "lt=0")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "lt")
// f := 1.23
// errs = validate.Field(f, "lt=0")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "lt")
// var ui uint = 5
// errs = validate.Field(ui, "lt=0")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "lt")
// i := true
// PanicMatches(t, func() { validate.Field(i, "lt") }, "Bad field type bool")
// t1 := time.Now().UTC()
// errs = validate.Field(t1, "lt")
// Equal(t, errs, nil)
// t2 := time.Now().UTC()
// t2 = t2.Add(time.Hour * 24)
// errs = validate.Field(t2, "lt")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "lt")
// type Test struct {
// Now *time.Time `validate:"lt"`
// }
// s := &Test{
// Now: &t1,
// }
// errs = validate.Struct(s)
// Equal(t, errs, nil)
// s = &Test{
// Now: &t2,
// }
// errs = validate.Struct(s)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.Now", "Now", "lt")
// }
// func TestIsLte(t *testing.T) {
// i := true
// PanicMatches(t, func() { validate.Field(i, "lte") }, "Bad field type bool")
// t1 := time.Now().UTC()
// errs := validate.Field(t1, "lte")
// Equal(t, errs, nil)
// t2 := time.Now().UTC()
// t2 = t2.Add(time.Hour * 24)
// errs = validate.Field(t2, "lte")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "lte")
// type Test struct {
// Now *time.Time `validate:"lte"`
// }
// s := &Test{
// Now: &t1,
// }
// errs = validate.Struct(s)
// Equal(t, errs, nil)
// s = &Test{
// Now: &t2,
// }
// errs = validate.Struct(s)
// NotEqual(t, errs, nil)
// }
// func TestUrl(t *testing.T) {
// var tests = []struct {
// param string
// expected bool
// }{
// {"http://foo.bar#com", true},
// {"http://foobar.com", true},
// {"https://foobar.com", true},
// {"foobar.com", false},
// {"http://foobar.coffee/", true},
// {"http://foobar.中文网/", true},
// {"http://foobar.org/", true},
// {"http://foobar.org:8080/", true},
// {"ftp://foobar.ru/", true},
// {"http://user:pass@www.foobar.com/", true},
// {"http://127.0.0.1/", true},
// {"http://duckduckgo.com/?q=%2F", true},
// {"http://localhost:3000/", true},
// {"http://foobar.com/?foo=bar#baz=qux", true},
// {"http://foobar.com?foo=bar", true},
// {"http://www.xn--froschgrn-x9a.net/", true},
// {"", false},
// {"xyz://foobar.com", true},
// {"invalid.", false},
// {".com", false},
// {"rtmp://foobar.com", true},
// {"http://www.foo_bar.com/", true},
// {"http://localhost:3000/", true},
// {"http://foobar.com/#baz", true},
// {"http://foobar.com#baz=qux", true},
// {"http://foobar.com/t$-_.+!*\\'(),", true},
// {"http://www.foobar.com/~foobar", true},
// {"http://www.-foobar.com/", true},
// {"http://www.foo---bar.com/", true},
// {"mailto:someone@example.com", true},
// {"irc://irc.server.org/channel", true},
// {"irc://#channel@network", true},
// {"/abs/test/dir", false},
// {"./rel/test/dir", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "url")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d URL failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d URL failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "url" {
// t.Fatalf("Index: %d URL failed Error: %s", i, errs)
// }
// }
// }
// }
// i := 1
// PanicMatches(t, func() { validate.Field(i, "url") }, "Bad field type int")
// }
// func TestUri(t *testing.T) {
// var tests = []struct {
// param string
// expected bool
// }{
// {"http://foo.bar#com", true},
// {"http://foobar.com", true},
// {"https://foobar.com", true},
// {"foobar.com", false},
// {"http://foobar.coffee/", true},
// {"http://foobar.中文网/", true},
// {"http://foobar.org/", true},
// {"http://foobar.org:8080/", true},
// {"ftp://foobar.ru/", true},
// {"http://user:pass@www.foobar.com/", true},
// {"http://127.0.0.1/", true},
// {"http://duckduckgo.com/?q=%2F", true},
// {"http://localhost:3000/", true},
// {"http://foobar.com/?foo=bar#baz=qux", true},
// {"http://foobar.com?foo=bar", true},
// {"http://www.xn--froschgrn-x9a.net/", true},
// {"", false},
// {"xyz://foobar.com", true},
// {"invalid.", false},
// {".com", false},
// {"rtmp://foobar.com", true},
// {"http://www.foo_bar.com/", true},
// {"http://localhost:3000/", true},
// {"http://foobar.com#baz=qux", true},
// {"http://foobar.com/t$-_.+!*\\'(),", true},
// {"http://www.foobar.com/~foobar", true},
// {"http://www.-foobar.com/", true},
// {"http://www.foo---bar.com/", true},
// {"mailto:someone@example.com", true},
// {"irc://irc.server.org/channel", true},
// {"irc://#channel@network", true},
// {"/abs/test/dir", true},
// {"./rel/test/dir", false},
// }
// for i, test := range tests {
// errs := validate.Field(test.param, "uri")
// if test.expected {
// if !IsEqual(errs, nil) {
// t.Fatalf("Index: %d URI failed Error: %s", i, errs)
// }
// } else {
// if IsEqual(errs, nil) {
// t.Fatalf("Index: %d URI failed Error: %s", i, errs)
// } else {
// val := errs.(ValidationErrors)[""]
// if val.Tag != "uri" {
// t.Fatalf("Index: %d URI failed Error: %s", i, errs)
// }
// }
// }
// }
// i := 1
// PanicMatches(t, func() { validate.Field(i, "uri") }, "Bad field type int")
// }
// func TestOrTag(t *testing.T) {
// s := "rgba(0,31,255,0.5)"
// errs := validate.Field(s, "rgb|rgba")
// Equal(t, errs, nil)
// s = "rgba(0,31,255,0.5)"
// errs = validate.Field(s, "rgb|rgba|len=18")
// Equal(t, errs, nil)
// s = "this ain't right"
// errs = validate.Field(s, "rgb|rgba")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "rgb|rgba")
// s = "this ain't right"
// errs = validate.Field(s, "rgb|rgba|len=10")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "rgb|rgba|len")
// s = "this is right"
// errs = validate.Field(s, "rgb|rgba|len=13")
// Equal(t, errs, nil)
// s = ""
// errs = validate.Field(s, "omitempty,rgb|rgba")
// Equal(t, errs, nil)
// s = "this is right, but a blank or isn't"
// PanicMatches(t, func() { validate.Field(s, "rgb||len=13") }, "Invalid validation tag on field")
// PanicMatches(t, func() { validate.Field(s, "rgb|rgbaa|len=13") }, "Undefined validation function on field")
// }
// func TestHsla(t *testing.T) {
// s := "hsla(360,100%,100%,1)"
// errs := validate.Field(s, "hsla")
// Equal(t, errs, nil)
// s = "hsla(360,100%,100%,0.5)"
// errs = validate.Field(s, "hsla")
// Equal(t, errs, nil)
// s = "hsla(0,0%,0%, 0)"
// errs = validate.Field(s, "hsla")
// Equal(t, errs, nil)
// s = "hsl(361,100%,50%,1)"
// errs = validate.Field(s, "hsla")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hsla")
// s = "hsl(361,100%,50%)"
// errs = validate.Field(s, "hsla")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hsla")
// s = "hsla(361,100%,50%)"
// errs = validate.Field(s, "hsla")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hsla")
// s = "hsla(360,101%,50%)"
// errs = validate.Field(s, "hsla")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hsla")
// s = "hsla(360,100%,101%)"
// errs = validate.Field(s, "hsla")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hsla")
// i := 1
// validate.Field(i, "hsla")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hsla")
// }
// func TestHsl(t *testing.T) {
// s := "hsl(360,100%,50%)"
// errs := validate.Field(s, "hsl")
// Equal(t, errs, nil)
// s = "hsl(0,0%,0%)"
// errs = validate.Field(s, "hsl")
// Equal(t, errs, nil)
// s = "hsl(361,100%,50%)"
// errs = validate.Field(s, "hsl")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hsl")
// s = "hsl(361,101%,50%)"
// errs = validate.Field(s, "hsl")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hsl")
// s = "hsl(361,100%,101%)"
// errs = validate.Field(s, "hsl")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hsl")
// s = "hsl(-10,100%,100%)"
// errs = validate.Field(s, "hsl")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hsl")
// i := 1
// errs = validate.Field(i, "hsl")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hsl")
// }
// func TestRgba(t *testing.T) {
// s := "rgba(0,31,255,0.5)"
// errs := validate.Field(s, "rgba")
// Equal(t, errs, nil)
// s = "rgba(0,31,255,0.12)"
// errs = validate.Field(s, "rgba")
// Equal(t, errs, nil)
// s = "rgba(12%,55%,100%,0.12)"
// errs = validate.Field(s, "rgba")
// Equal(t, errs, nil)
// s = "rgba( 0, 31, 255, 0.5)"
// errs = validate.Field(s, "rgba")
// Equal(t, errs, nil)
// s = "rgba(12%,55,100%,0.12)"
// errs = validate.Field(s, "rgba")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "rgba")
// s = "rgb(0, 31, 255)"
// errs = validate.Field(s, "rgba")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "rgba")
// s = "rgb(1,349,275,0.5)"
// errs = validate.Field(s, "rgba")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "rgba")
// s = "rgb(01,31,255,0.5)"
// errs = validate.Field(s, "rgba")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "rgba")
// i := 1
// errs = validate.Field(i, "rgba")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "rgba")
// }
// func TestRgb(t *testing.T) {
// s := "rgb(0,31,255)"
// errs := validate.Field(s, "rgb")
// Equal(t, errs, nil)
// s = "rgb(0, 31, 255)"
// errs = validate.Field(s, "rgb")
// Equal(t, errs, nil)
// s = "rgb(10%, 50%, 100%)"
// errs = validate.Field(s, "rgb")
// Equal(t, errs, nil)
// s = "rgb(10%, 50%, 55)"
// errs = validate.Field(s, "rgb")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "rgb")
// s = "rgb(1,349,275)"
// errs = validate.Field(s, "rgb")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "rgb")
// s = "rgb(01,31,255)"
// errs = validate.Field(s, "rgb")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "rgb")
// s = "rgba(0,31,255)"
// errs = validate.Field(s, "rgb")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "rgb")
// i := 1
// errs = validate.Field(i, "rgb")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "rgb")
// }
// func TestEmail(t *testing.T) {
// s := "test@mail.com"
// errs := validate.Field(s, "email")
// Equal(t, errs, nil)
// s = "Dörte@Sörensen.example.com"
// errs = validate.Field(s, "email")
// Equal(t, errs, nil)
// s = "θσερ@εχαμπλε.ψομ"
// errs = validate.Field(s, "email")
// Equal(t, errs, nil)
// s = "юзер@екзампл.ком"
// errs = validate.Field(s, "email")
// Equal(t, errs, nil)
// s = "उपयो ् ा ा ॉ
// errs = validate.Field(s, "email")
// Equal(t, errs, nil)
// s = "用户@例子.广告"
// errs = validate.Field(s, "email")
// Equal(t, errs, nil)
// s = ""
// errs = validate.Field(s, "email")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "email")
// s = "test@email"
// errs = validate.Field(s, "email")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "email")
// s = "test@email."
// errs = validate.Field(s, "email")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "email")
// s = "@email.com"
// errs = validate.Field(s, "email")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "email")
// i := true
// errs = validate.Field(i, "email")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "email")
// }
// func TestHexColor(t *testing.T) {
// s := "#fff"
// errs := validate.Field(s, "hexcolor")
// Equal(t, errs, nil)
// s = "#c2c2c2"
// errs = validate.Field(s, "hexcolor")
// Equal(t, errs, nil)
// s = "fff"
// errs = validate.Field(s, "hexcolor")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hexcolor")
// s = "fffFF"
// errs = validate.Field(s, "hexcolor")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hexcolor")
// i := true
// errs = validate.Field(i, "hexcolor")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hexcolor")
// }
// func TestHexadecimal(t *testing.T) {
// s := "ff0044"
// errs := validate.Field(s, "hexadecimal")
// Equal(t, errs, nil)
// s = "abcdefg"
// errs = validate.Field(s, "hexadecimal")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hexadecimal")
// i := true
// errs = validate.Field(i, "hexadecimal")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "hexadecimal")
// }
// func TestNumber(t *testing.T) {
// s := "1"
// errs := validate.Field(s, "number")
// Equal(t, errs, nil)
// s = "+1"
// errs = validate.Field(s, "number")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "number")
// s = "-1"
// errs = validate.Field(s, "number")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "number")
// s = "1.12"
// errs = validate.Field(s, "number")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "number")
// s = "+1.12"
// errs = validate.Field(s, "number")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "number")
// s = "-1.12"
// errs = validate.Field(s, "number")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "number")
// s = "1."
// errs = validate.Field(s, "number")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "number")
// s = "1.o"
// errs = validate.Field(s, "number")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "number")
// i := 1
// errs = validate.Field(i, "number")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "number")
// }
// func TestNumeric(t *testing.T) {
// s := "1"
// errs := validate.Field(s, "numeric")
// Equal(t, errs, nil)
// s = "+1"
// errs = validate.Field(s, "numeric")
// Equal(t, errs, nil)
// s = "-1"
// errs = validate.Field(s, "numeric")
// Equal(t, errs, nil)
// s = "1.12"
// errs = validate.Field(s, "numeric")
// Equal(t, errs, nil)
// s = "+1.12"
// errs = validate.Field(s, "numeric")
// Equal(t, errs, nil)
// s = "-1.12"
// errs = validate.Field(s, "numeric")
// Equal(t, errs, nil)
// s = "1."
// errs = validate.Field(s, "numeric")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "numeric")
// s = "1.o"
// errs = validate.Field(s, "numeric")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "numeric")
// i := 1
// errs = validate.Field(i, "numeric")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "numeric")
// }
// func TestAlphaNumeric(t *testing.T) {
// s := "abcd123"
// errs := validate.Field(s, "alphanum")
// Equal(t, errs, nil)
// s = "abc!23"
// errs = validate.Field(s, "alphanum")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "alphanum")
// errs = validate.Field(1, "alphanum")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "alphanum")
// }
// func TestAlpha(t *testing.T) {
// s := "abcd"
// errs := validate.Field(s, "alpha")
// Equal(t, errs, nil)
// s = "abc®"
// errs = validate.Field(s, "alpha")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "alpha")
// s = "abc÷"
// errs = validate.Field(s, "alpha")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "alpha")
// s = "abc1"
// errs = validate.Field(s, "alpha")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "alpha")
// errs = validate.Field(1, "alpha")
// NotEqual(t, errs, nil)
// AssertError(t, errs, "", "", "alpha")
// }
// func TestStructStringValidation(t *testing.T) {
// tSuccess := &TestString{
// Required: "Required",
// Len: "length==10",
// Min: "min=1",
// Max: "1234567890",
// MinMax: "12345",
// Lt: "012345678",
// Lte: "0123456789",
// Gt: "01234567890",
// Gte: "0123456789",
// OmitEmpty: "",
// Sub: &SubTest{
// Test: "1",
// },
// SubIgnore: &SubTest{
// Test: "",
// },
// Anonymous: struct {
// A string `validate:"required"`
// }{
// A: "1",
// },
// Iface: &Impl{
// F: "123",
// },
// }
// errs := validate.Struct(tSuccess)
// Equal(t, errs, nil)
// tFail := &TestString{
// Required: "",
// Len: "",
// Min: "",
// Max: "12345678901",
// MinMax: "",
// Lt: "0123456789",
// Lte: "01234567890",
// Gt: "1",
// Gte: "1",
// OmitEmpty: "12345678901",
// Sub: &SubTest{
// Test: "",
// },
// Anonymous: struct {
// A string `validate:"required"`
// }{
// A: "",
// },
// Iface: &Impl{
// F: "12",
// },
// }
// errs = validate.Struct(tFail)
// // Assert Top Level
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 13)
// // Assert Fields
// AssertError(t, errs, "TestString.Required", "Required", "required")
// AssertError(t, errs, "TestString.Len", "Len", "len")
// AssertError(t, errs, "TestString.Min", "Min", "min")
// AssertError(t, errs, "TestString.Max", "Max", "max")
// AssertError(t, errs, "TestString.MinMax", "MinMax", "min")
// AssertError(t, errs, "TestString.Lt", "Lt", "lt")
// AssertError(t, errs, "TestString.Lte", "Lte", "lte")
// AssertError(t, errs, "TestString.Gt", "Gt", "gt")
// AssertError(t, errs, "TestString.Gte", "Gte", "gte")
// AssertError(t, errs, "TestString.OmitEmpty", "OmitEmpty", "max")
// // Nested Struct Field Errs
// AssertError(t, errs, "TestString.Anonymous.A", "A", "required")
// AssertError(t, errs, "TestString.Sub.Test", "Test", "required")
// AssertError(t, errs, "TestString.Iface.F", "F", "len")
// }
func TestStructInt32Validation ( t * testing . T ) {
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" `
}
tSuccess := & TestInt32 {
Required : 1 ,
Len : 10 ,
Min : 1 ,
Max : 10 ,
MinMax : 5 ,
Lt : 9 ,
Lte : 10 ,
Gt : 11 ,
Gte : 10 ,
OmitEmpty : 0 ,
}
validate := New ( )
errs := validate . Struct ( tSuccess )
Equal ( t , errs , nil )
tFail := & TestInt32 {
Required : 0 ,
Len : 11 ,
Min : - 1 ,
Max : 11 ,
MinMax : - 1 ,
Lt : 10 ,
Lte : 11 ,
Gt : 10 ,
Gte : 9 ,
OmitEmpty : 11 ,
}
errs = validate . Struct ( tFail )
// Assert Top Level
NotEqual ( t , errs , nil )
Equal ( t , len ( errs . ( ValidationErrors ) ) , 10 )
// Assert Fields
AssertError ( t , errs , "TestInt32.Required" , "Required" , "required" )
AssertError ( t , errs , "TestInt32.Len" , "Len" , "len" )
AssertError ( t , errs , "TestInt32.Min" , "Min" , "min" )
AssertError ( t , errs , "TestInt32.Max" , "Max" , "max" )
AssertError ( t , errs , "TestInt32.MinMax" , "MinMax" , "min" )
AssertError ( t , errs , "TestInt32.Lt" , "Lt" , "lt" )
AssertError ( t , errs , "TestInt32.Lte" , "Lte" , "lte" )
AssertError ( t , errs , "TestInt32.Gt" , "Gt" , "gt" )
AssertError ( t , errs , "TestInt32.Gte" , "Gte" , "gte" )
AssertError ( t , errs , "TestInt32.OmitEmpty" , "OmitEmpty" , "max" )
}
// func TestStructUint64Validation(t *testing.T) {
// tSuccess := &TestUint64{
// Required: 1,
// Len: 10,
// Min: 1,
// Max: 10,
// MinMax: 5,
// OmitEmpty: 0,
// }
// errs := validate.Struct(tSuccess)
// Equal(t, errs, nil)
// tFail := &TestUint64{
// Required: 0,
// Len: 11,
// Min: 0,
// Max: 11,
// MinMax: 0,
// OmitEmpty: 11,
// }
// errs = validate.Struct(tFail)
// // Assert Top Level
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 6)
// // Assert Fields
// AssertError(t, errs, "TestUint64.Required", "Required", "required")
// AssertError(t, errs, "TestUint64.Len", "Len", "len")
// AssertError(t, errs, "TestUint64.Min", "Min", "min")
// AssertError(t, errs, "TestUint64.Max", "Max", "max")
// AssertError(t, errs, "TestUint64.MinMax", "MinMax", "min")
// AssertError(t, errs, "TestUint64.OmitEmpty", "OmitEmpty", "max")
// }
// func TestStructFloat64Validation(t *testing.T) {
// tSuccess := &TestFloat64{
// Required: 1,
// Len: 10,
// Min: 1,
// Max: 10,
// MinMax: 5,
// OmitEmpty: 0,
// }
// errs := validate.Struct(tSuccess)
// Equal(t, errs, nil)
// tFail := &TestFloat64{
// Required: 0,
// Len: 11,
// Min: 0,
// Max: 11,
// MinMax: 0,
// OmitEmpty: 11,
// }
// errs = validate.Struct(tFail)
// // Assert Top Level
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 6)
// // Assert Fields
// AssertError(t, errs, "TestFloat64.Required", "Required", "required")
// AssertError(t, errs, "TestFloat64.Len", "Len", "len")
// AssertError(t, errs, "TestFloat64.Min", "Min", "min")
// AssertError(t, errs, "TestFloat64.Max", "Max", "max")
// AssertError(t, errs, "TestFloat64.MinMax", "MinMax", "min")
// AssertError(t, errs, "TestFloat64.OmitEmpty", "OmitEmpty", "max")
// }
// func TestStructSliceValidation(t *testing.T) {
// tSuccess := &TestSlice{
// Required: []int{1},
// Len: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
// Min: []int{1, 2},
// Max: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
// MinMax: []int{1, 2, 3, 4, 5},
// OmitEmpty: nil,
// }
// errs := validate.Struct(tSuccess)
// Equal(t, errs, nil)
// tFail := &TestSlice{
// Required: nil,
// Len: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
// Min: []int{},
// Max: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
// MinMax: []int{},
// OmitEmpty: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
// }
// errs = validate.Struct(tFail)
// NotEqual(t, errs, nil)
// Equal(t, len(errs.(ValidationErrors)), 6)
// // Assert Field Errors
// AssertError(t, errs, "TestSlice.Required", "Required", "required")
// AssertError(t, errs, "TestSlice.Len", "Len", "len")
// AssertError(t, errs, "TestSlice.Min", "Min", "min")
// AssertError(t, errs, "TestSlice.Max", "Max", "max")
// AssertError(t, errs, "TestSlice.MinMax", "MinMax", "min")
// AssertError(t, errs, "TestSlice.OmitEmpty", "OmitEmpty", "max")
// }
// func TestInvalidStruct(t *testing.T) {
// s := &SubTest{
// Test: "1",
// }
// PanicMatches(t, func() { validate.Struct(s.Test) }, "value passed for validation is not a struct")
// }
// func TestInvalidValidatorFunction(t *testing.T) {
// s := &SubTest{
// Test: "1",
// }
// PanicMatches(t, func() { validate.Field(s.Test, "zzxxBadFunction") }, "Undefined validation function on field")
// }
// func TestCustomFieldName(t *testing.T) {
// type A struct {
// B string `schema:"b" validate:"required"`
// C string `schema:"c" validate:"required"`
// D []bool `schema:"d" validate:"required"`
// E string `schema:"-" validate:"required"`
// }
// a := &A{}
// errs := New(&Config{TagName: "validate", FieldNameTag: "schema"}).Struct(a).(ValidationErrors)
// NotEqual(t, errs, nil)
// Equal(t, len(errs), 4)
// Equal(t, errs["A.B"].Name, "b")
// Equal(t, errs["A.C"].Name, "c")
// Equal(t, errs["A.D"].Name, "d")
// Equal(t, errs["A.E"].Name, "E")
// errs = New(&Config{TagName: "validate"}).Struct(a).(ValidationErrors)
// NotEqual(t, errs, nil)
// Equal(t, len(errs), 4)
// Equal(t, errs["A.B"].Name, "B")
// Equal(t, errs["A.C"].Name, "C")
// Equal(t, errs["A.D"].Name, "D")
// Equal(t, errs["A.E"].Name, "E")
// }
// func TestMutipleRecursiveExtractStructCache(t *testing.T) {
// type Recursive struct {
// Field *string `validate:"exists,required,len=5,ne=string"`
// }
// var test Recursive
// current := reflect.ValueOf(test)
// name := "Recursive"
// proceed := make(chan struct{})
// sc := validate.extractStructCache(current, name)
// ptr := fmt.Sprintf("%p", sc)
// for i := 0; i < 100; i++ {
// go func() {
// <-proceed
// sc := validate.extractStructCache(current, name)
// Equal(t, ptr, fmt.Sprintf("%p", sc))
// }()
// }
// close(proceed)
// }
// // Thanks @robbrockbank, see https://github.com/go-playground/validator/issues/249
// func TestPointerAndOmitEmpty(t *testing.T) {
// type Test struct {
// MyInt *int `validate:"omitempty,gte=2,lte=255"`
// }
// val1 := 0
// val2 := 256
// t1 := Test{MyInt: &val1} // This should fail validation on gte because value is 0
// t2 := Test{MyInt: &val2} // This should fail validate on lte because value is 256
// t3 := Test{MyInt: nil} // This should succeed validation because pointer is nil
// errs := validate.Struct(t1)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.MyInt", "MyInt", "gte")
// errs = validate.Struct(t2)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "Test.MyInt", "MyInt", "lte")
// errs = validate.Struct(t3)
// Equal(t, errs, nil)
// type TestIface struct {
// MyInt interface{} `validate:"omitempty,gte=2,lte=255"`
// }
// ti1 := TestIface{MyInt: &val1} // This should fail validation on gte because value is 0
// ti2 := TestIface{MyInt: &val2} // This should fail validate on lte because value is 256
// ti3 := TestIface{MyInt: nil} // This should succeed validation because pointer is nil
// errs = validate.Struct(ti1)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestIface.MyInt", "MyInt", "gte")
// errs = validate.Struct(ti2)
// NotEqual(t, errs, nil)
// AssertError(t, errs, "TestIface.MyInt", "MyInt", "lte")
// errs = validate.Struct(ti3)
// Equal(t, errs, nil)
// }
