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

5935 lines
153 KiB
Raw Blame History Escape

package validator
import (
"database/sql/driver"
"fmt"
"reflect"
"strings"
"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, actualField, 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.StructField(), actualField)
EqualSkip(t, 2, fe.Tag(), expectedTag)
}
func getError(err error, key string) FieldError {
errs := err.(ValidationErrors)
var fe FieldError
for i := 0; i < len(errs); i++ {
if errs[i].Namespace() == key {
fe = errs[i]
break
}
}
return fe
}
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"`
// }
func TestNameNamespace(t *testing.T) {
type Inner2Namespace struct {
String []string `validate:"dive,required" json:"JSONString"`
}
type Inner1Namespace struct {
Inner2 *Inner2Namespace `json:"Inner2JSON"`
}
type Namespace struct {
Inner1 *Inner1Namespace `json:"Inner1JSON"`
}
validate := New()
validate.RegisterTagNameFunc(func(fld reflect.StructField) string {
name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0]
if name == "-" {
return ""
}
return name
})
i2 := &Inner2Namespace{String: []string{"ok", "ok", "ok"}}
i1 := &Inner1Namespace{Inner2: i2}
ns := &Namespace{Inner1: i1}
errs := validate.Struct(ns)
Equal(t, errs, nil)
i2.String[1] = ""
errs = validate.Struct(ns)
NotEqual(t, errs, nil)
ve := errs.(ValidationErrors)
Equal(t, len(ve), 1)
AssertError(t, errs, "Namespace.Inner1.Inner2.String[1]", "JSONString[1]", "String[1]", "required")
fe := getError(ve, "Namespace.Inner1.Inner2.String[1]")
NotEqual(t, fe, nil)
Equal(t, fe.Field(), "JSONString[1]")
Equal(t, fe.StructField(), "String[1]")
fmt.Println(fe.Namespace())
fmt.Println(fe.StructNamespace())
Equal(t, fe.Namespace(), "Namespace.Inner1JSON.Inner2JSON.JSONString[1]")
Equal(t, fe.StructNamespace(), "Namespace.Inner1.Inner2.String[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", "required")
AssertError(t, errs, "TestInt32.Len", "Len", "Len", "len")
AssertError(t, errs, "TestInt32.Min", "Min", "Min", "min")
AssertError(t, errs, "TestInt32.Max", "Max", "Max", "max")
AssertError(t, errs, "TestInt32.MinMax", "MinMax", "MinMax", "min")
AssertError(t, errs, "TestInt32.Lt", "Lt", "Lt", "lt")
AssertError(t, errs, "TestInt32.Lte", "Lte", "Lte", "lte")
AssertError(t, errs, "TestInt32.Gt", "Gt", "Gt", "gt")
AssertError(t, errs, "TestInt32.Gte", "Gte", "Gte", "gte")
AssertError(t, errs, "TestInt32.OmitEmpty", "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)
// }