pharnexbase
/
validator
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

linting cleanup

Browse Source
pull/523/head
Dean Karn 5 years ago
parent 6484d9f2fb
commit 06f92248de
9 changed files with 157 additions and 284 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 8
      Makefile
  2. 235
      benchmarks_test.go
  3. 14
      cache.go
  4. 2
      translations/ja/ja.go
  5. 19
      translations/zh/zh.go
  6. 4
      translations/zh/zh_test.go
  7. 21
      translations/zh_tw/zh_tw.go
  8. 4
      translations/zh_tw/zh_tw_test.go
  9. 134
      validator_test.go

8
Makefile
Unescape View File

@ -1,11 +1,13 @@
GOCMD=go GOCMD=go
linters-install: linters-install:
$(GOCMD) get -u github.com/alecthomas/gometalinter @golangci-lint --version >/dev/null 2>&1 || { \
gometalinter --install echo "installing linting tools..."; \
curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh| sh -s v1.19.1; \
}
lint: linters-install lint: linters-install
gometalinter --vendor --disable-all --enable=vet --enable=vetshadow --enable=golint --enable=maligned --enable=megacheck --enable=ineffassign --enable=misspell --enable=errcheck --enable=goconst ./... golangci-lint run
test: test:
$(GOCMD) test -cover -race ./... $(GOCMD) test -cover -race ./...

235
benchmarks_test.go
Unescape View File

@ -8,236 +8,200 @@ import (
) )
func BenchmarkFieldSuccess(b *testing.B) { func BenchmarkFieldSuccess(b *testing.B) {
validate := New() validate := New()
s := "1" s := "1"
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Var(&s, "len=1") _ = validate.Var(&s, "len=1")
} }
} }
func BenchmarkFieldSuccessParallel(b *testing.B) { func BenchmarkFieldSuccessParallel(b *testing.B) {
validate := New() validate := New()
s := "1" s := "1"
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Var(&s, "len=1") _ = validate.Var(&s, "len=1")
} }
}) })
} }
func BenchmarkFieldFailure(b *testing.B) { func BenchmarkFieldFailure(b *testing.B) {
validate := New() validate := New()
s := "12" s := "12"
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Var(&s, "len=1") _ = validate.Var(&s, "len=1")
} }
} }
func BenchmarkFieldFailureParallel(b *testing.B) { func BenchmarkFieldFailureParallel(b *testing.B) {
validate := New() validate := New()
s := "12" s := "12"
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Var(&s, "len=1") _ = validate.Var(&s, "len=1")
} }
}) })
} }
func BenchmarkFieldArrayDiveSuccess(b *testing.B) { func BenchmarkFieldArrayDiveSuccess(b *testing.B) {
validate := New() validate := New()
m := []string{"val1", "val2", "val3"} m := []string{"val1", "val2", "val3"}
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Var(m, "required,dive,required") _ = validate.Var(m, "required,dive,required")
} }
} }
func BenchmarkFieldArrayDiveSuccessParallel(b *testing.B) { func BenchmarkFieldArrayDiveSuccessParallel(b *testing.B) {
validate := New() validate := New()
m := []string{"val1", "val2", "val3"} m := []string{"val1", "val2", "val3"}
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Var(m, "required,dive,required") _ = validate.Var(m, "required,dive,required")
} }
}) })
} }
func BenchmarkFieldArrayDiveFailure(b *testing.B) { func BenchmarkFieldArrayDiveFailure(b *testing.B) {
validate := New() validate := New()
m := []string{"val1", "", "val3"} m := []string{"val1", "", "val3"}
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Var(m, "required,dive,required") _ = validate.Var(m, "required,dive,required")
} }
} }
func BenchmarkFieldArrayDiveFailureParallel(b *testing.B) { func BenchmarkFieldArrayDiveFailureParallel(b *testing.B) {
validate := New() validate := New()
m := []string{"val1", "", "val3"} m := []string{"val1", "", "val3"}
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Var(m, "required,dive,required") _ = validate.Var(m, "required,dive,required")
} }
}) })
} }
func BenchmarkFieldMapDiveSuccess(b *testing.B) { func BenchmarkFieldMapDiveSuccess(b *testing.B) {
validate := New() validate := New()
m := map[string]string{"val1": "val1", "val2": "val2", "val3": "val3"} m := map[string]string{"val1": "val1", "val2": "val2", "val3": "val3"}
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Var(m, "required,dive,required") _ = validate.Var(m, "required,dive,required")
} }
} }
func BenchmarkFieldMapDiveSuccessParallel(b *testing.B) { func BenchmarkFieldMapDiveSuccessParallel(b *testing.B) {
validate := New() validate := New()
m := map[string]string{"val1": "val1", "val2": "val2", "val3": "val3"} m := map[string]string{"val1": "val1", "val2": "val2", "val3": "val3"}
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Var(m, "required,dive,required") _ = validate.Var(m, "required,dive,required")
} }
}) })
} }
func BenchmarkFieldMapDiveFailure(b *testing.B) { func BenchmarkFieldMapDiveFailure(b *testing.B) {
validate := New() validate := New()
m := map[string]string{"": "", "val3": "val3"} m := map[string]string{"": "", "val3": "val3"}
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Var(m, "required,dive,required") _ = validate.Var(m, "required,dive,required")
} }
} }
func BenchmarkFieldMapDiveFailureParallel(b *testing.B) { func BenchmarkFieldMapDiveFailureParallel(b *testing.B) {
validate := New() validate := New()
m := map[string]string{"": "", "val3": "val3"} m := map[string]string{"": "", "val3": "val3"}
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Var(m, "required,dive,required") _ = validate.Var(m, "required,dive,required")
} }
}) })
} }
func BenchmarkFieldMapDiveWithKeysSuccess(b *testing.B) { func BenchmarkFieldMapDiveWithKeysSuccess(b *testing.B) {
validate := New() validate := New()
m := map[string]string{"val1": "val1", "val2": "val2", "val3": "val3"} m := map[string]string{"val1": "val1", "val2": "val2", "val3": "val3"}
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Var(m, "required,dive,keys,required,endkeys,required") _ = validate.Var(m, "required,dive,keys,required,endkeys,required")
} }
} }
func BenchmarkFieldMapDiveWithKeysSuccessParallel(b *testing.B) { func BenchmarkFieldMapDiveWithKeysSuccessParallel(b *testing.B) {
validate := New() validate := New()
m := map[string]string{"val1": "val1", "val2": "val2", "val3": "val3"} m := map[string]string{"val1": "val1", "val2": "val2", "val3": "val3"}
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Var(m, "required,dive,keys,required,endkeys,required") _ = validate.Var(m, "required,dive,keys,required,endkeys,required")
} }
}) })
} }
func BenchmarkFieldMapDiveWithKeysFailure(b *testing.B) { func BenchmarkFieldMapDiveWithKeysFailure(b *testing.B) {
validate := New() validate := New()
m := map[string]string{"": "", "val3": "val3"} m := map[string]string{"": "", "val3": "val3"}
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Var(m, "required,dive,keys,required,endkeys,required") _ = validate.Var(m, "required,dive,keys,required,endkeys,required")
} }
} }
func BenchmarkFieldMapDiveWithKeysFailureParallel(b *testing.B) { func BenchmarkFieldMapDiveWithKeysFailureParallel(b *testing.B) {
validate := New() validate := New()
m := map[string]string{"": "", "val3": "val3"} m := map[string]string{"": "", "val3": "val3"}
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Var(m, "required,dive,keys,required,endkeys,required") _ = validate.Var(m, "required,dive,keys,required,endkeys,required")
} }
}) })
} }
func BenchmarkFieldCustomTypeSuccess(b *testing.B) { func BenchmarkFieldCustomTypeSuccess(b *testing.B) {
validate := New() validate := New()
validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{}) validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
val := valuer{ val := valuer{
Name: "1", Name: "1",
} }
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Var(val, "len=1") _ = validate.Var(val, "len=1")
} }
} }
func BenchmarkFieldCustomTypeSuccessParallel(b *testing.B) { func BenchmarkFieldCustomTypeSuccessParallel(b *testing.B) {
validate := New() validate := New()
validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{}) validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
val := valuer{ val := valuer{
Name: "1", Name: "1",
} }
@ -245,93 +209,80 @@ func BenchmarkFieldCustomTypeSuccessParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Var(val, "len=1") _ = validate.Var(val, "len=1")
} }
}) })
} }
func BenchmarkFieldCustomTypeFailure(b *testing.B) { func BenchmarkFieldCustomTypeFailure(b *testing.B) {
validate := New() validate := New()
validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{}) validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
val := valuer{} val := valuer{}
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Var(val, "len=1") _ = validate.Var(val, "len=1")
} }
} }
func BenchmarkFieldCustomTypeFailureParallel(b *testing.B) { func BenchmarkFieldCustomTypeFailureParallel(b *testing.B) {
validate := New() validate := New()
validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{}) validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
val := valuer{} val := valuer{}
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Var(val, "len=1") _ = validate.Var(val, "len=1")
} }
}) })
} }
func BenchmarkFieldOrTagSuccess(b *testing.B) { func BenchmarkFieldOrTagSuccess(b *testing.B) {
validate := New() validate := New()
s := "rgba(0,0,0,1)" s := "rgba(0,0,0,1)"
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Var(s, "rgb|rgba") _ = validate.Var(s, "rgb|rgba")
} }
} }
func BenchmarkFieldOrTagSuccessParallel(b *testing.B) { func BenchmarkFieldOrTagSuccessParallel(b *testing.B) {
validate := New() validate := New()
s := "rgba(0,0,0,1)" s := "rgba(0,0,0,1)"
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Var(s, "rgb|rgba") _ = validate.Var(s, "rgb|rgba")
} }
}) })
} }
func BenchmarkFieldOrTagFailure(b *testing.B) { func BenchmarkFieldOrTagFailure(b *testing.B) {
validate := New() validate := New()
s := "#000" s := "#000"
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Var(s, "rgb|rgba") _ = validate.Var(s, "rgb|rgba")
} }
} }
func BenchmarkFieldOrTagFailureParallel(b *testing.B) { func BenchmarkFieldOrTagFailureParallel(b *testing.B) {
validate := New() validate := New()
s := "#000" s := "#000"
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Var(s, "rgb|rgba") _ = validate.Var(s, "rgb|rgba")
} }
}) })
} }
func BenchmarkStructLevelValidationSuccess(b *testing.B) { func BenchmarkStructLevelValidationSuccess(b *testing.B) {
validate := New() validate := New()
validate.RegisterStructValidation(StructValidationTestStructSuccess, TestStruct{}) validate.RegisterStructValidation(StructValidationTestStructSuccess, TestStruct{})
@ -341,12 +292,11 @@ func BenchmarkStructLevelValidationSuccess(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Struct(tst) _ = validate.Struct(tst)
} }
} }
func BenchmarkStructLevelValidationSuccessParallel(b *testing.B) { func BenchmarkStructLevelValidationSuccessParallel(b *testing.B) {
validate := New() validate := New()
validate.RegisterStructValidation(StructValidationTestStructSuccess, TestStruct{}) validate.RegisterStructValidation(StructValidationTestStructSuccess, TestStruct{})
@ -357,13 +307,12 @@ func BenchmarkStructLevelValidationSuccessParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Struct(tst) _ = validate.Struct(tst)
} }
}) })
} }
func BenchmarkStructLevelValidationFailure(b *testing.B) { func BenchmarkStructLevelValidationFailure(b *testing.B) {
validate := New() validate := New()
validate.RegisterStructValidation(StructValidationTestStruct, TestStruct{}) validate.RegisterStructValidation(StructValidationTestStruct, TestStruct{})
@ -373,12 +322,11 @@ func BenchmarkStructLevelValidationFailure(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Struct(tst) _ = validate.Struct(tst)
} }
} }
func BenchmarkStructLevelValidationFailureParallel(b *testing.B) { func BenchmarkStructLevelValidationFailureParallel(b *testing.B) {
validate := New() validate := New()
validate.RegisterStructValidation(StructValidationTestStruct, TestStruct{}) validate.RegisterStructValidation(StructValidationTestStruct, TestStruct{})
@ -389,13 +337,12 @@ func BenchmarkStructLevelValidationFailureParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Struct(tst) _ = validate.Struct(tst)
} }
}) })
} }
func BenchmarkStructSimpleCustomTypeSuccess(b *testing.B) { func BenchmarkStructSimpleCustomTypeSuccess(b *testing.B) {
validate := New() validate := New()
validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{}) validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
@ -412,15 +359,13 @@ func BenchmarkStructSimpleCustomTypeSuccess(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Struct(validFoo) _ = validate.Struct(validFoo)
} }
} }
func BenchmarkStructSimpleCustomTypeSuccessParallel(b *testing.B) { func BenchmarkStructSimpleCustomTypeSuccessParallel(b *testing.B) {
validate := New() validate := New()
validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{}) validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
val := valuer{ val := valuer{
Name: "1", Name: "1",
} }
@ -429,19 +374,17 @@ func BenchmarkStructSimpleCustomTypeSuccessParallel(b *testing.B) {
Valuer valuer `validate:"len=1"` Valuer valuer `validate:"len=1"`
IntValue int `validate:"min=5,max=10"` IntValue int `validate:"min=5,max=10"`
} }
validFoo := &Foo{Valuer: val, IntValue: 7} validFoo := &Foo{Valuer: val, IntValue: 7}
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Struct(validFoo) _ = validate.Struct(validFoo)
} }
}) })
} }
func BenchmarkStructSimpleCustomTypeFailure(b *testing.B) { func BenchmarkStructSimpleCustomTypeFailure(b *testing.B) {
validate := New() validate := New()
validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{}) validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
@ -451,17 +394,15 @@ func BenchmarkStructSimpleCustomTypeFailure(b *testing.B) {
Valuer valuer `validate:"len=1"` Valuer valuer `validate:"len=1"`
IntValue int `validate:"min=5,max=10"` IntValue int `validate:"min=5,max=10"`
} }
validFoo := &Foo{Valuer: val, IntValue: 3} validFoo := &Foo{Valuer: val, IntValue: 3}
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Struct(validFoo) _ = validate.Struct(validFoo)
} }
} }
func BenchmarkStructSimpleCustomTypeFailureParallel(b *testing.B) { func BenchmarkStructSimpleCustomTypeFailureParallel(b *testing.B) {
validate := New() validate := New()
validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{}) validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
@ -471,19 +412,17 @@ func BenchmarkStructSimpleCustomTypeFailureParallel(b *testing.B) {
Valuer valuer `validate:"len=1"` Valuer valuer `validate:"len=1"`
IntValue int `validate:"min=5,max=10"` IntValue int `validate:"min=5,max=10"`
} }
validFoo := &Foo{Valuer: val, IntValue: 3} validFoo := &Foo{Valuer: val, IntValue: 3}
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Struct(validate.Struct(validFoo)) _ = validate.Struct(validate.Struct(validFoo))
} }
}) })
} }
func BenchmarkStructFilteredSuccess(b *testing.B) { func BenchmarkStructFilteredSuccess(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -494,21 +433,18 @@ func BenchmarkStructFilteredSuccess(b *testing.B) {
test := &Test{ test := &Test{
Name: "Joey Bloggs", Name: "Joey Bloggs",
} }
byts := []byte("Name") byts := []byte("Name")
fn := func(ns []byte) bool { fn := func(ns []byte) bool {
return !bytes.HasSuffix(ns, byts) return !bytes.HasSuffix(ns, byts)
} }
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.StructFiltered(test, fn) _ = validate.StructFiltered(test, fn)
} }
} }
func BenchmarkStructFilteredSuccessParallel(b *testing.B) { func BenchmarkStructFilteredSuccessParallel(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -519,9 +455,7 @@ func BenchmarkStructFilteredSuccessParallel(b *testing.B) {
test := &Test{ test := &Test{
Name: "Joey Bloggs", Name: "Joey Bloggs",
} }
byts := []byte("Name") byts := []byte("Name")
fn := func(ns []byte) bool { fn := func(ns []byte) bool {
return !bytes.HasSuffix(ns, byts) return !bytes.HasSuffix(ns, byts)
} }
@ -529,13 +463,12 @@ func BenchmarkStructFilteredSuccessParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.StructFiltered(test, fn) _ = validate.StructFiltered(test, fn)
} }
}) })
} }
func BenchmarkStructFilteredFailure(b *testing.B) { func BenchmarkStructFilteredFailure(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -555,12 +488,11 @@ func BenchmarkStructFilteredFailure(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.StructFiltered(test, fn) _ = validate.StructFiltered(test, fn)
} }
} }
func BenchmarkStructFilteredFailureParallel(b *testing.B) { func BenchmarkStructFilteredFailureParallel(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -571,9 +503,7 @@ func BenchmarkStructFilteredFailureParallel(b *testing.B) {
test := &Test{ test := &Test{
Name: "Joey Bloggs", Name: "Joey Bloggs",
} }
byts := []byte("NickName") byts := []byte("NickName")
fn := func(ns []byte) bool { fn := func(ns []byte) bool {
return !bytes.HasSuffix(ns, byts) return !bytes.HasSuffix(ns, byts)
} }
@ -581,13 +511,12 @@ func BenchmarkStructFilteredFailureParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.StructFiltered(test, fn) _ = validate.StructFiltered(test, fn)
} }
}) })
} }
func BenchmarkStructPartialSuccess(b *testing.B) { func BenchmarkStructPartialSuccess(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -601,12 +530,11 @@ func BenchmarkStructPartialSuccess(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.StructPartial(test, "Name") _ = validate.StructPartial(test, "Name")
} }
} }
func BenchmarkStructPartialSuccessParallel(b *testing.B) { func BenchmarkStructPartialSuccessParallel(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -621,13 +549,12 @@ func BenchmarkStructPartialSuccessParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.StructPartial(test, "Name") _ = validate.StructPartial(test, "Name")
} }
}) })
} }
func BenchmarkStructPartialFailure(b *testing.B) { func BenchmarkStructPartialFailure(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -641,12 +568,11 @@ func BenchmarkStructPartialFailure(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.StructPartial(test, "NickName") _ = validate.StructPartial(test, "NickName")
} }
} }
func BenchmarkStructPartialFailureParallel(b *testing.B) { func BenchmarkStructPartialFailureParallel(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -661,13 +587,12 @@ func BenchmarkStructPartialFailureParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.StructPartial(test, "NickName") _ = validate.StructPartial(test, "NickName")
} }
}) })
} }
func BenchmarkStructExceptSuccess(b *testing.B) { func BenchmarkStructExceptSuccess(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -681,12 +606,11 @@ func BenchmarkStructExceptSuccess(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.StructExcept(test, "Nickname") _ = validate.StructExcept(test, "Nickname")
} }
} }
func BenchmarkStructExceptSuccessParallel(b *testing.B) { func BenchmarkStructExceptSuccessParallel(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -701,13 +625,12 @@ func BenchmarkStructExceptSuccessParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.StructExcept(test, "NickName") _ = validate.StructExcept(test, "NickName")
} }
}) })
} }
func BenchmarkStructExceptFailure(b *testing.B) { func BenchmarkStructExceptFailure(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -721,12 +644,11 @@ func BenchmarkStructExceptFailure(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.StructExcept(test, "Name") _ = validate.StructExcept(test, "Name")
} }
} }
func BenchmarkStructExceptFailureParallel(b *testing.B) { func BenchmarkStructExceptFailureParallel(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -741,13 +663,12 @@ func BenchmarkStructExceptFailureParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.StructExcept(test, "Name") _ = validate.StructExcept(test, "Name")
} }
}) })
} }
func BenchmarkStructSimpleCrossFieldSuccess(b *testing.B) { func BenchmarkStructSimpleCrossFieldSuccess(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -757,7 +678,6 @@ func BenchmarkStructSimpleCrossFieldSuccess(b *testing.B) {
now := time.Now().UTC() now := time.Now().UTC()
then := now.Add(time.Hour * 5) then := now.Add(time.Hour * 5)
test := &Test{ test := &Test{
Start: now, Start: now,
End: then, End: then,
@ -765,12 +685,11 @@ func BenchmarkStructSimpleCrossFieldSuccess(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Struct(test) _ = validate.Struct(test)
} }
} }
func BenchmarkStructSimpleCrossFieldSuccessParallel(b *testing.B) { func BenchmarkStructSimpleCrossFieldSuccessParallel(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -780,7 +699,6 @@ func BenchmarkStructSimpleCrossFieldSuccessParallel(b *testing.B) {
now := time.Now().UTC() now := time.Now().UTC()
then := now.Add(time.Hour * 5) then := now.Add(time.Hour * 5)
test := &Test{ test := &Test{
Start: now, Start: now,
End: then, End: then,
@ -789,13 +707,12 @@ func BenchmarkStructSimpleCrossFieldSuccessParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Struct(test) _ = validate.Struct(test)
} }
}) })
} }
func BenchmarkStructSimpleCrossFieldFailure(b *testing.B) { func BenchmarkStructSimpleCrossFieldFailure(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -813,12 +730,11 @@ func BenchmarkStructSimpleCrossFieldFailure(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Struct(test) _ = validate.Struct(test)
} }
} }
func BenchmarkStructSimpleCrossFieldFailureParallel(b *testing.B) { func BenchmarkStructSimpleCrossFieldFailureParallel(b *testing.B) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -828,7 +744,6 @@ func BenchmarkStructSimpleCrossFieldFailureParallel(b *testing.B) {
now := time.Now().UTC() now := time.Now().UTC()
then := now.Add(time.Hour * -5) then := now.Add(time.Hour * -5)
test := &Test{ test := &Test{
Start: now, Start: now,
End: then, End: then,
@ -836,13 +751,12 @@ func BenchmarkStructSimpleCrossFieldFailureParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Struct(test) _ = validate.Struct(test)
} }
}) })
} }
func BenchmarkStructSimpleCrossStructCrossFieldSuccess(b *testing.B) { func BenchmarkStructSimpleCrossStructCrossFieldSuccess(b *testing.B) {
validate := New() validate := New()
type Inner struct { type Inner struct {
@ -855,11 +769,9 @@ func BenchmarkStructSimpleCrossStructCrossFieldSuccess(b *testing.B) {
} }
now := time.Now().UTC() now := time.Now().UTC()
inner := &Inner{ inner := &Inner{
Start: now, Start: now,
} }
outer := &Outer{ outer := &Outer{
Inner: inner, Inner: inner,
CreatedAt: now, CreatedAt: now,
@ -867,12 +779,11 @@ func BenchmarkStructSimpleCrossStructCrossFieldSuccess(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Struct(outer) _ = validate.Struct(outer)
} }
} }
func BenchmarkStructSimpleCrossStructCrossFieldSuccessParallel(b *testing.B) { func BenchmarkStructSimpleCrossStructCrossFieldSuccessParallel(b *testing.B) {
validate := New() validate := New()
type Inner struct { type Inner struct {
@ -885,11 +796,9 @@ func BenchmarkStructSimpleCrossStructCrossFieldSuccessParallel(b *testing.B) {
} }
now := time.Now().UTC() now := time.Now().UTC()
inner := &Inner{ inner := &Inner{
Start: now, Start: now,
} }
outer := &Outer{ outer := &Outer{
Inner: inner, Inner: inner,
CreatedAt: now, CreatedAt: now,
@ -898,15 +807,13 @@ func BenchmarkStructSimpleCrossStructCrossFieldSuccessParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Struct(outer) _ = validate.Struct(outer)
} }
}) })
} }
func BenchmarkStructSimpleCrossStructCrossFieldFailure(b *testing.B) { func BenchmarkStructSimpleCrossStructCrossFieldFailure(b *testing.B) {
validate := New() validate := New()
type Inner struct { type Inner struct {
Start time.Time Start time.Time
} }
@ -930,12 +837,11 @@ func BenchmarkStructSimpleCrossStructCrossFieldFailure(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Struct(outer) _ = validate.Struct(outer)
} }
} }
func BenchmarkStructSimpleCrossStructCrossFieldFailureParallel(b *testing.B) { func BenchmarkStructSimpleCrossStructCrossFieldFailureParallel(b *testing.B) {
validate := New() validate := New()
type Inner struct { type Inner struct {
@ -962,15 +868,13 @@ func BenchmarkStructSimpleCrossStructCrossFieldFailureParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Struct(outer) _ = validate.Struct(outer)
} }
}) })
} }
func BenchmarkStructSimpleSuccess(b *testing.B) { func BenchmarkStructSimpleSuccess(b *testing.B) {
validate := New() validate := New()
type Foo struct { type Foo struct {
StringValue string `validate:"min=5,max=10"` StringValue string `validate:"min=5,max=10"`
IntValue int `validate:"min=5,max=10"` IntValue int `validate:"min=5,max=10"`
@ -980,33 +884,28 @@ func BenchmarkStructSimpleSuccess(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Struct(validFoo) _ = validate.Struct(validFoo)
} }
} }
func BenchmarkStructSimpleSuccessParallel(b *testing.B) { func BenchmarkStructSimpleSuccessParallel(b *testing.B) {
validate := New() validate := New()
type Foo struct { type Foo struct {
StringValue string `validate:"min=5,max=10"` StringValue string `validate:"min=5,max=10"`
IntValue int `validate:"min=5,max=10"` IntValue int `validate:"min=5,max=10"`
} }
validFoo := &Foo{StringValue: "Foobar", IntValue: 7} validFoo := &Foo{StringValue: "Foobar", IntValue: 7}
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Struct(validFoo) _ = validate.Struct(validFoo)
} }
}) })
} }
func BenchmarkStructSimpleFailure(b *testing.B) { func BenchmarkStructSimpleFailure(b *testing.B) {
validate := New() validate := New()
type Foo struct { type Foo struct {
StringValue string `validate:"min=5,max=10"` StringValue string `validate:"min=5,max=10"`
IntValue int `validate:"min=5,max=10"` IntValue int `validate:"min=5,max=10"`
@ -1016,14 +915,12 @@ func BenchmarkStructSimpleFailure(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Struct(invalidFoo) _ = validate.Struct(invalidFoo)
} }
} }
func BenchmarkStructSimpleFailureParallel(b *testing.B) { func BenchmarkStructSimpleFailureParallel(b *testing.B) {
validate := New() validate := New()
type Foo struct { type Foo struct {
StringValue string `validate:"min=5,max=10"` StringValue string `validate:"min=5,max=10"`
IntValue int `validate:"min=5,max=10"` IntValue int `validate:"min=5,max=10"`
@ -1034,15 +931,13 @@ func BenchmarkStructSimpleFailureParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Struct(invalidFoo) _ = validate.Struct(invalidFoo)
} }
}) })
} }
func BenchmarkStructComplexSuccess(b *testing.B) { func BenchmarkStructComplexSuccess(b *testing.B) {
validate := New() validate := New()
tSuccess := &TestString{ tSuccess := &TestString{
Required: "Required", Required: "Required",
Len: "length==10", Len: "length==10",
@ -1072,14 +967,12 @@ func BenchmarkStructComplexSuccess(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Struct(tSuccess) _ = validate.Struct(tSuccess)
} }
} }
func BenchmarkStructComplexSuccessParallel(b *testing.B) { func BenchmarkStructComplexSuccessParallel(b *testing.B) {
validate := New() validate := New()
tSuccess := &TestString{ tSuccess := &TestString{
Required: "Required", Required: "Required",
Len: "length==10", Len: "length==10",
@ -1110,15 +1003,13 @@ func BenchmarkStructComplexSuccessParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Struct(tSuccess) _ = validate.Struct(tSuccess)
} }
}) })
} }
func BenchmarkStructComplexFailure(b *testing.B) { func BenchmarkStructComplexFailure(b *testing.B) {
validate := New() validate := New()
tFail := &TestString{ tFail := &TestString{
Required: "", Required: "",
Len: "", Len: "",
@ -1145,14 +1036,12 @@ func BenchmarkStructComplexFailure(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for n := 0; n < b.N; n++ { for n := 0; n < b.N; n++ {
validate.Struct(tFail) _ = validate.Struct(tFail)
} }
} }
func BenchmarkStructComplexFailureParallel(b *testing.B) { func BenchmarkStructComplexFailureParallel(b *testing.B) {
validate := New() validate := New()
tFail := &TestString{ tFail := &TestString{
Required: "", Required: "",
Len: "", Len: "",
@ -1180,7 +1069,7 @@ func BenchmarkStructComplexFailureParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
validate.Struct(tFail) _ = validate.Struct(tFail)
} }
}) })
} }
@ -1193,7 +1082,7 @@ func BenchmarkOneof(b *testing.B) {
w := &TestOneof{Color: "green"} w := &TestOneof{Color: "green"}
val := New() val := New()
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
val.Struct(w) _ = val.Struct(w)
} }
} }
@ -1204,7 +1093,7 @@ func BenchmarkOneofParallel(b *testing.B) {
b.ResetTimer() b.ResetTimer()
b.RunParallel(func(pb *testing.PB) { b.RunParallel(func(pb *testing.PB) {
for pb.Next() { for pb.Next() {
val.Struct(w) _ = val.Struct(w)
} }
}) })
} }

14
cache.go
Unescape View File

@ -39,9 +39,7 @@ func (sc *structCache) Get(key reflect.Type) (c *cStruct, found bool) {
} }
func (sc *structCache) Set(key reflect.Type, value *cStruct) { func (sc *structCache) Set(key reflect.Type, value *cStruct) {
m := sc.m.Load().(map[reflect.Type]*cStruct) m := sc.m.Load().(map[reflect.Type]*cStruct)
nm := make(map[reflect.Type]*cStruct, len(m)+1) nm := make(map[reflect.Type]*cStruct, len(m)+1)
for k, v := range m { for k, v := range m {
nm[k] = v nm[k] = v
@ -61,9 +59,7 @@ func (tc *tagCache) Get(key string) (c *cTag, found bool) {
} }
func (tc *tagCache) Set(key string, value *cTag) { func (tc *tagCache) Set(key string, value *cTag) {
m := tc.m.Load().(map[string]*cTag) m := tc.m.Load().(map[string]*cTag)
nm := make(map[string]*cTag, len(m)+1) nm := make(map[string]*cTag, len(m)+1)
for k, v := range m { for k, v := range m {
nm[k] = v nm[k] = v
@ -103,7 +99,6 @@ type cTag struct {
} }
func (v *Validate) extractStructCache(current reflect.Value, sName string) *cStruct { func (v *Validate) extractStructCache(current reflect.Value, sName string) *cStruct {
v.structCache.lock.Lock() v.structCache.lock.Lock()
defer v.structCache.lock.Unlock() // leave as defer! because if inner panics, it will never get unlocked otherwise! defer v.structCache.lock.Unlock() // leave as defer! because if inner panics, it will never get unlocked otherwise!
@ -172,15 +167,12 @@ func (v *Validate) extractStructCache(current reflect.Value, sName string) *cStr
} }
func (v *Validate) parseFieldTagsRecursive(tag string, fieldName string, alias string, hasAlias bool) (firstCtag *cTag, current *cTag) { func (v *Validate) parseFieldTagsRecursive(tag string, fieldName string, alias string, hasAlias bool) (firstCtag *cTag, current *cTag) {
var t string var t string
noAlias := len(alias) == 0 noAlias := len(alias) == 0
tags := strings.Split(tag, tagSeparator) tags := strings.Split(tag, tagSeparator)
for i := 0; i < len(tags); i++ { for i := 0; i < len(tags); i++ {
t = tags[i] t = tags[i]
if noAlias { if noAlias {
alias = t alias = t
} }
@ -194,14 +186,13 @@ func (v *Validate) parseFieldTagsRecursive(tag string, fieldName string, alias s
current.next, current = next, curr current.next, current = next, curr
} }
continue continue
} }
var prevTag tagType var prevTag tagType
if i == 0 { if i == 0 {
current = &cTag{aliasTag: alias, hasAlias: hasAlias, hasTag: true} current = &cTag{aliasTag: alias, hasAlias: hasAlias, hasTag: true, typeof: typeDefault}
firstCtag = current firstCtag = current
} else { } else {
prevTag = current.typeof prevTag = current.typeof
@ -210,7 +201,6 @@ func (v *Validate) parseFieldTagsRecursive(tag string, fieldName string, alias s
} }
switch t { switch t {
case diveTag: case diveTag:
current.typeof = typeDive current.typeof = typeDive
continue continue
@ -273,9 +263,7 @@ func (v *Validate) parseFieldTagsRecursive(tag string, fieldName string, alias s
orVals := strings.Split(t, orSeparator) orVals := strings.Split(t, orSeparator)
for j := 0; j < len(orVals); j++ { for j := 0; j < len(orVals); j++ {
vals := strings.SplitN(orVals[j], tagKeySeparator, 2) vals := strings.SplitN(orVals[j], tagKeySeparator, 2)
if noAlias { if noAlias {
alias = vals[0] alias = vals[0]
current.aliasTag = alias current.aliasTag = alias

2
translations/ja/ja.go
Unescape View File

@ -374,9 +374,7 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er
if err != nil { if err != nil {
goto END goto END
} }
t, err = ut.T("ne-items", fe.Field(), c) t, err = ut.T("ne-items", fe.Field(), c)
break
default: default:
t, err = ut.T("ne", fe.Field(), fe.Param()) t, err = ut.T("ne", fe.Field(), fe.Param())
} }

19
translations/zh/zh.go
Unescape View File

@ -9,7 +9,7 @@ import (
"time" "time"
"github.com/go-playground/locales" "github.com/go-playground/locales"
"github.com/go-playground/universal-translator" ut "github.com/go-playground/universal-translator"
"gopkg.in/go-playground/validator.v9" "gopkg.in/go-playground/validator.v9"
) )
@ -430,10 +430,10 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er
case reflect.Struct: case reflect.Struct:
if fe.Type() != reflect.TypeOf(time.Time{}) { if fe.Type() != reflect.TypeOf(time.Time{}) {
err = fmt.Errorf("tag '%s'不能用于struct类型.", fe.Tag()) err = fmt.Errorf("tag '%s'不能用于struct类型.", fe.Tag())
} else {
t, err = ut.T("lt-datetime", fe.Field())
} }
t, err = ut.T("lt-datetime", fe.Field())
default: default:
err = fn() err = fn()
if err != nil { if err != nil {
@ -549,10 +549,10 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er
case reflect.Struct: case reflect.Struct:
if fe.Type() != reflect.TypeOf(time.Time{}) { if fe.Type() != reflect.TypeOf(time.Time{}) {
err = fmt.Errorf("tag '%s'不能用于struct类型.", fe.Tag()) err = fmt.Errorf("tag '%s'不能用于struct类型.", fe.Tag())
} else {
t, err = ut.T("lte-datetime", fe.Field())
} }
t, err = ut.T("lte-datetime", fe.Field())
default: default:
err = fn() err = fn()
if err != nil { if err != nil {
@ -668,9 +668,10 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er
case reflect.Struct: case reflect.Struct:
if fe.Type() != reflect.TypeOf(time.Time{}) { if fe.Type() != reflect.TypeOf(time.Time{}) {
err = fmt.Errorf("tag '%s'不能用于struct类型.", fe.Tag()) err = fmt.Errorf("tag '%s'不能用于struct类型.", fe.Tag())
} } else {
t, err = ut.T("gt-datetime", fe.Field()) t, err = ut.T("gt-datetime", fe.Field())
}
default: default:
err = fn() err = fn()
@ -787,10 +788,10 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er
case reflect.Struct: case reflect.Struct:
if fe.Type() != reflect.TypeOf(time.Time{}) { if fe.Type() != reflect.TypeOf(time.Time{}) {
err = fmt.Errorf("tag '%s'不能用于struct类型.", fe.Tag()) err = fmt.Errorf("tag '%s'不能用于struct类型.", fe.Tag())
} else {
t, err = ut.T("gte-datetime", fe.Field())
} }
t, err = ut.T("gte-datetime", fe.Field())
default: default:
err = fn() err = fn()
if err != nil { if err != nil {

4
translations/zh/zh_test.go
Unescape View File

@ -5,7 +5,7 @@ import (
"time" "time"
zhongwen "github.com/go-playground/locales/zh" zhongwen "github.com/go-playground/locales/zh"
"github.com/go-playground/universal-translator" ut "github.com/go-playground/universal-translator"
. "gopkg.in/go-playground/assert.v1" . "gopkg.in/go-playground/assert.v1"
"gopkg.in/go-playground/validator.v9" "gopkg.in/go-playground/validator.v9"
) )
@ -14,7 +14,7 @@ func TestTranslations(t *testing.T) {
zh := zhongwen.New() zh := zhongwen.New()
uni := ut.New(zh, zh) uni := ut.New(zh, zh)
trans, ok := uni.GetTranslator("zh") trans, _ := uni.GetTranslator("zh")
validate := validator.New() validate := validator.New()

21
translations/zh_tw/zh_tw.go
Unescape View File

@ -9,7 +9,7 @@ import (
"time" "time"
"github.com/go-playground/locales" "github.com/go-playground/locales"
"github.com/go-playground/universal-translator" ut "github.com/go-playground/universal-translator"
"gopkg.in/go-playground/validator.v9" "gopkg.in/go-playground/validator.v9"
) )
@ -430,10 +430,10 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er
case reflect.Struct: case reflect.Struct:
if fe.Type() != reflect.TypeOf(time.Time{}) { if fe.Type() != reflect.TypeOf(time.Time{}) {
err = fmt.Errorf("tag '%s'不能用於struct類型.", fe.Tag()) err = fmt.Errorf("tag '%s'不能用於struct類型.", fe.Tag())
} else {
t, err = ut.T("lt-datetime", fe.Field())
} }
t, err = ut.T("lt-datetime", fe.Field())
default: default:
err = fn() err = fn()
if err != nil { if err != nil {
@ -549,10 +549,10 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er
case reflect.Struct: case reflect.Struct:
if fe.Type() != reflect.TypeOf(time.Time{}) { if fe.Type() != reflect.TypeOf(time.Time{}) {
err = fmt.Errorf("tag '%s'不能用於struct類型.", fe.Tag()) err = fmt.Errorf("tag '%s'不能用於struct類型.", fe.Tag())
} else {
t, err = ut.T("lte-datetime", fe.Field())
} }
t, err = ut.T("lte-datetime", fe.Field())
default: default:
err = fn() err = fn()
if err != nil { if err != nil {
@ -618,13 +618,10 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er
var kind reflect.Kind var kind reflect.Kind
fn := func() (err error) { fn := func() (err error) {
if idx := strings.Index(fe.Param(), "."); idx != -1 { if idx := strings.Index(fe.Param(), "."); idx != -1 {
digits = uint64(len(fe.Param()[idx+1:])) digits = uint64(len(fe.Param()[idx+1:]))
} }
f64, err = strconv.ParseFloat(fe.Param(), 64) f64, err = strconv.ParseFloat(fe.Param(), 64)
return return
} }
@ -668,10 +665,10 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er
case reflect.Struct: case reflect.Struct:
if fe.Type() != reflect.TypeOf(time.Time{}) { if fe.Type() != reflect.TypeOf(time.Time{}) {
err = fmt.Errorf("tag '%s'不能用於struct類型.", fe.Tag()) err = fmt.Errorf("tag '%s'不能用於struct類型.", fe.Tag())
} else {
t, err = ut.T("gt-datetime", fe.Field())
} }
t, err = ut.T("gt-datetime", fe.Field())
default: default:
err = fn() err = fn()
if err != nil { if err != nil {
@ -787,10 +784,10 @@ func RegisterDefaultTranslations(v *validator.Validate, trans ut.Translator) (er
case reflect.Struct: case reflect.Struct:
if fe.Type() != reflect.TypeOf(time.Time{}) { if fe.Type() != reflect.TypeOf(time.Time{}) {
err = fmt.Errorf("tag '%s'不能用於struct類型.", fe.Tag()) err = fmt.Errorf("tag '%s'不能用於struct類型.", fe.Tag())
} else {
t, err = ut.T("gte-datetime", fe.Field())
} }
t, err = ut.T("gte-datetime", fe.Field())
default: default:
err = fn() err = fn()
if err != nil { if err != nil {

4
translations/zh_tw/zh_tw_test.go
Unescape View File

@ -5,7 +5,7 @@ import (
"time" "time"
zhongwen "github.com/go-playground/locales/zh_Hant_TW" zhongwen "github.com/go-playground/locales/zh_Hant_TW"
"github.com/go-playground/universal-translator" ut "github.com/go-playground/universal-translator"
. "gopkg.in/go-playground/assert.v1" . "gopkg.in/go-playground/assert.v1"
"gopkg.in/go-playground/validator.v9" "gopkg.in/go-playground/validator.v9"
) )
@ -14,7 +14,7 @@ func TestTranslations(t *testing.T) {
zh := zhongwen.New() zh := zhongwen.New()
uni := ut.New(zh, zh) uni := ut.New(zh, zh)
trans, ok := uni.GetTranslator("zh") trans, _ := uni.GetTranslator("zh")
validate := validator.New() validate := validator.New()

134
validator_test.go
Unescape View File

@ -462,6 +462,8 @@ func TestAnonymous(t *testing.T) {
}, },
} }
Equal(t, tst.anonymousC.c, "")
err := validate.Struct(tst) err := validate.Struct(tst)
NotEqual(t, err, nil) NotEqual(t, err, nil)
@ -715,16 +717,15 @@ func TestNilValidator(t *testing.T) {
} }
PanicMatches(t, func() { val.RegisterCustomTypeFunc(ValidateCustomType, MadeUpCustomType{}) }, "runtime error: invalid memory address or nil pointer dereference") PanicMatches(t, func() { val.RegisterCustomTypeFunc(ValidateCustomType, MadeUpCustomType{}) }, "runtime error: invalid memory address or nil pointer dereference")
PanicMatches(t, func() { val.RegisterValidation("something", fn) }, "runtime error: invalid memory address or nil pointer dereference") PanicMatches(t, func() { _ = val.RegisterValidation("something", fn) }, "runtime error: invalid memory address or nil pointer dereference")
PanicMatches(t, func() { val.Var(ts.Test, "required") }, "runtime error: invalid memory address or nil pointer dereference") PanicMatches(t, func() { _ = val.Var(ts.Test, "required") }, "runtime error: invalid memory address or nil pointer dereference")
PanicMatches(t, func() { val.VarWithValue("test", ts.Test, "required") }, "runtime error: invalid memory address or nil pointer dereference") PanicMatches(t, func() { _ = val.VarWithValue("test", ts.Test, "required") }, "runtime error: invalid memory address or nil pointer dereference")
PanicMatches(t, func() { val.Struct(ts) }, "runtime error: invalid memory address or nil pointer dereference") PanicMatches(t, func() { _ = val.Struct(ts) }, "runtime error: invalid memory address or nil pointer dereference")
PanicMatches(t, func() { val.StructExcept(ts, "Test") }, "runtime error: invalid memory address or nil pointer dereference") PanicMatches(t, func() { _ = val.StructExcept(ts, "Test") }, "runtime error: invalid memory address or nil pointer dereference")
PanicMatches(t, func() { val.StructPartial(ts, "Test") }, "runtime error: invalid memory address or nil pointer dereference") PanicMatches(t, func() { _ = val.StructPartial(ts, "Test") }, "runtime error: invalid memory address or nil pointer dereference")
} }
func TestStructPartial(t *testing.T) { func TestStructPartial(t *testing.T) {
p1 := []string{ p1 := []string{
"NoTag", "NoTag",
"Required", "Required",
@ -1850,7 +1851,7 @@ func TestSQLValue2Validation(t *testing.T) {
val.Name = "errorme" val.Name = "errorme"
PanicMatches(t, func() { validate.Var(val, "required") }, "SQL Driver Valuer error: some kind of error") PanicMatches(t, func() { _ = validate.Var(val, "required") }, "SQL Driver Valuer error: some kind of error")
myVal := valuer{ myVal := valuer{
Name: "", Name: "",
@ -2675,7 +2676,7 @@ func TestBadKeyValidation(t *testing.T) {
validate := New() validate := New()
PanicMatches(t, func() { validate.Struct(tst) }, "Undefined validation function ' ' on field 'Name'") PanicMatches(t, func() { _ = validate.Struct(tst) }, "Undefined validation function ' ' on field 'Name'")
type Test2 struct { type Test2 struct {
Name string `validate:"required,,len=2"` Name string `validate:"required,,len=2"`
@ -2685,7 +2686,7 @@ func TestBadKeyValidation(t *testing.T) {
Name: "test", Name: "test",
} }
PanicMatches(t, func() { validate.Struct(tst2) }, "Invalid validation tag on field 'Name'") PanicMatches(t, func() { _ = validate.Struct(tst2) }, "Invalid validation tag on field 'Name'")
} }
func TestInterfaceErrValidation(t *testing.T) { func TestInterfaceErrValidation(t *testing.T) {
@ -3009,7 +3010,7 @@ func TestArrayDiveValidation(t *testing.T) {
Name: "TEST", Name: "TEST",
} }
PanicMatches(t, func() { validate.Struct(bd) }, "dive error! can't dive on a non slice or map") PanicMatches(t, func() { _ = validate.Struct(bd) }, "dive error! can't dive on a non slice or map")
type Test struct { type Test struct {
Errs []string `validate:"gt=0,dive,required"` Errs []string `validate:"gt=0,dive,required"`
@ -3372,7 +3373,7 @@ func TestLongitudeValidation(t *testing.T) {
} }
} }
PanicMatches(t, func() { validate.Var(true, "longitude") }, "Bad field type bool") PanicMatches(t, func() { _ = validate.Var(true, "longitude") }, "Bad field type bool")
} }
func TestLatitudeValidation(t *testing.T) { func TestLatitudeValidation(t *testing.T) {
@ -3414,7 +3415,7 @@ func TestLatitudeValidation(t *testing.T) {
} }
} }
PanicMatches(t, func() { validate.Var(true, "latitude") }, "Bad field type bool") PanicMatches(t, func() { _ = validate.Var(true, "latitude") }, "Bad field type bool")
} }
func TestDataURIValidation(t *testing.T) { func TestDataURIValidation(t *testing.T) {
@ -4317,7 +4318,7 @@ func TestIsNeValidation(t *testing.T) {
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
AssertError(t, errs, "", "", "", "", "ne") AssertError(t, errs, "", "", "", "", "ne")
PanicMatches(t, func() { validate.Var(now, "ne=now") }, "Bad field type time.Time") PanicMatches(t, func() { _ = validate.Var(now, "ne=now") }, "Bad field type time.Time")
} }
func TestIsEqFieldValidation(t *testing.T) { func TestIsEqFieldValidation(t *testing.T) {
@ -4471,7 +4472,7 @@ func TestIsEqValidation(t *testing.T) {
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
AssertError(t, errs, "", "", "", "", "eq") AssertError(t, errs, "", "", "", "", "eq")
PanicMatches(t, func() { validate.Var(now, "eq=now") }, "Bad field type time.Time") PanicMatches(t, func() { _ = validate.Var(now, "eq=now") }, "Bad field type time.Time")
} }
func TestOneOfValidation(t *testing.T) { func TestOneOfValidation(t *testing.T) {
@ -4530,7 +4531,7 @@ func TestOneOfValidation(t *testing.T) {
} }
PanicMatches(t, func() { PanicMatches(t, func() {
validate.Var(3.14, "oneof=red green") _ = validate.Var(3.14, "oneof=red green")
}, "Bad field type float64") }, "Bad field type float64")
} }
@ -4634,7 +4635,7 @@ func TestFileValidation(t *testing.T) {
} }
PanicMatches(t, func() { PanicMatches(t, func() {
validate.Var(6, "file") _ = validate.Var(6, "file")
}, "Bad field type int") }, "Bad field type int")
} }
@ -5724,7 +5725,6 @@ func TestGteField(t *testing.T) {
} }
func TestValidateByTagAndValue(t *testing.T) { func TestValidateByTagAndValue(t *testing.T) {
validate := New() validate := New()
val := "test" val := "test"
@ -5737,7 +5737,8 @@ func TestValidateByTagAndValue(t *testing.T) {
return fl.Parent().String() == fl.Field().String() return fl.Parent().String() == fl.Field().String()
} }
validate.RegisterValidation("isequaltestfunc", fn) errs = validate.RegisterValidation("isequaltestfunc", fn)
Equal(t, errs, nil)
errs = validate.VarWithValue(val, field, "isequaltestfunc") errs = validate.VarWithValue(val, field, "isequaltestfunc")
Equal(t, errs, nil) Equal(t, errs, nil)
@ -5768,7 +5769,7 @@ func TestAddFunctions(t *testing.T) {
errs = validate.RegisterValidation("", fn) errs = validate.RegisterValidation("", fn)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
validate.RegisterValidation("new", nil) errs = validate.RegisterValidation("new", nil)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
errs = validate.RegisterValidation("new", fn) errs = validate.RegisterValidation("new", fn)
@ -5777,7 +5778,7 @@ func TestAddFunctions(t *testing.T) {
errs = validate.RegisterValidationCtx("new", fnCtx) errs = validate.RegisterValidationCtx("new", fnCtx)
Equal(t, errs, nil) 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") 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) { func TestChangeTag(t *testing.T) {
@ -5803,7 +5804,6 @@ func TestChangeTag(t *testing.T) {
} }
func TestUnexposedStruct(t *testing.T) { func TestUnexposedStruct(t *testing.T) {
validate := New() validate := New()
type Test struct { type Test struct {
@ -5816,41 +5816,36 @@ func TestUnexposedStruct(t *testing.T) {
s := &Test{ s := &Test{
Name: "TEST", Name: "TEST",
} }
Equal(t, s.unexposed.A, "")
errs := validate.Struct(s) errs := validate.Struct(s)
Equal(t, errs, nil) Equal(t, errs, nil)
} }
func TestBadParams(t *testing.T) { func TestBadParams(t *testing.T) {
validate := New() validate := New()
i := 1 i := 1
errs := validate.Var(i, "-") errs := validate.Var(i, "-")
Equal(t, errs, nil) Equal(t, errs, nil)
PanicMatches(t, func() { validate.Var(i, "len=a") }, "strconv.ParseInt: parsing \"a\": invalid syntax") PanicMatches(t, func() { _ = validate.Var(i, "len=a") }, "strconv.ParseInt: parsing \"a\": invalid syntax")
PanicMatches(t, func() { validate.Var(i, "len=a") }, "strconv.ParseInt: parsing \"a\": invalid syntax") PanicMatches(t, func() { _ = validate.Var(i, "len=a") }, "strconv.ParseInt: parsing \"a\": invalid syntax")
var ui uint = 1 var ui uint = 1
PanicMatches(t, func() { validate.Var(ui, "len=a") }, "strconv.ParseUint: parsing \"a\": invalid syntax") PanicMatches(t, func() { _ = validate.Var(ui, "len=a") }, "strconv.ParseUint: parsing \"a\": invalid syntax")
f := 1.23 f := 1.23
PanicMatches(t, func() { validate.Var(f, "len=a") }, "strconv.ParseFloat: parsing \"a\": invalid syntax") PanicMatches(t, func() { _ = validate.Var(f, "len=a") }, "strconv.ParseFloat: parsing \"a\": invalid syntax")
} }
func TestLength(t *testing.T) { func TestLength(t *testing.T) {
validate := New() validate := New()
i := true i := true
PanicMatches(t, func() { validate.Var(i, "len") }, "Bad field type bool") PanicMatches(t, func() { _ = validate.Var(i, "len") }, "Bad field type bool")
} }
func TestIsGt(t *testing.T) { func TestIsGt(t *testing.T) {
validate := New() validate := New()
myMap := map[string]string{} myMap := map[string]string{}
errs := validate.Var(myMap, "gt=0") errs := validate.Var(myMap, "gt=0")
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
@ -5866,7 +5861,7 @@ func TestIsGt(t *testing.T) {
AssertError(t, errs, "", "", "", "", "gt") AssertError(t, errs, "", "", "", "", "gt")
i := true i := true
PanicMatches(t, func() { validate.Var(i, "gt") }, "Bad field type bool") PanicMatches(t, func() { _ = validate.Var(i, "gt") }, "Bad field type bool")
tm := time.Now().UTC() tm := time.Now().UTC()
tm = tm.Add(time.Hour * 24) tm = tm.Add(time.Hour * 24)
@ -5900,11 +5895,9 @@ func TestIsGt(t *testing.T) {
} }
func TestIsGte(t *testing.T) { func TestIsGte(t *testing.T) {
validate := New() validate := New()
i := true i := true
PanicMatches(t, func() { validate.Var(i, "gte") }, "Bad field type bool") PanicMatches(t, func() { _ = validate.Var(i, "gte") }, "Bad field type bool")
t1 := time.Now().UTC() t1 := time.Now().UTC()
t1 = t1.Add(time.Hour * 24) t1 = t1.Add(time.Hour * 24)
@ -5938,9 +5931,7 @@ func TestIsGte(t *testing.T) {
} }
func TestIsLt(t *testing.T) { func TestIsLt(t *testing.T) {
validate := New() validate := New()
myMap := map[string]string{} myMap := map[string]string{}
errs := validate.Var(myMap, "lt=0") errs := validate.Var(myMap, "lt=0")
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
@ -5957,7 +5948,7 @@ func TestIsLt(t *testing.T) {
AssertError(t, errs, "", "", "", "", "lt") AssertError(t, errs, "", "", "", "", "lt")
i := true i := true
PanicMatches(t, func() { validate.Var(i, "lt") }, "Bad field type bool") PanicMatches(t, func() { _ = validate.Var(i, "lt") }, "Bad field type bool")
t1 := time.Now().UTC().Add(-time.Hour) t1 := time.Now().UTC().Add(-time.Hour)
@ -5996,7 +5987,7 @@ func TestIsLte(t *testing.T) {
validate := New() validate := New()
i := true i := true
PanicMatches(t, func() { validate.Var(i, "lte") }, "Bad field type bool") PanicMatches(t, func() { _ = validate.Var(i, "lte") }, "Bad field type bool")
t1 := time.Now().UTC().Add(-time.Hour) t1 := time.Now().UTC().Add(-time.Hour)
@ -6103,7 +6094,7 @@ func TestUrnRFC2141(t *testing.T) {
} }
i := 1 i := 1
PanicMatches(t, func() { validate.Var(i, tag) }, "Bad field type int") PanicMatches(t, func() { _ = validate.Var(i, tag) }, "Bad field type int")
} }
func TestUrl(t *testing.T) { func TestUrl(t *testing.T) {
@ -6171,7 +6162,7 @@ func TestUrl(t *testing.T) {
} }
i := 1 i := 1
PanicMatches(t, func() { validate.Var(i, "url") }, "Bad field type int") PanicMatches(t, func() { _ = validate.Var(i, "url") }, "Bad field type int")
} }
func TestUri(t *testing.T) { func TestUri(t *testing.T) {
@ -6238,7 +6229,7 @@ func TestUri(t *testing.T) {
} }
i := 1 i := 1
PanicMatches(t, func() { validate.Var(i, "uri") }, "Bad field type int") PanicMatches(t, func() { _ = validate.Var(i, "uri") }, "Bad field type int")
} }
func TestOrTag(t *testing.T) { func TestOrTag(t *testing.T) {
@ -6280,8 +6271,8 @@ func TestOrTag(t *testing.T) {
s = "this is right, but a blank or isn't" s = "this is right, but a blank or isn't"
PanicMatches(t, func() { validate.Var(s, "rgb||len=13") }, "Invalid validation tag on field ''") PanicMatches(t, func() { _ = validate.Var(s, "rgb||len=13") }, "Invalid validation tag on field ''")
PanicMatches(t, func() { validate.Var(s, "rgb|rgbaa|len=13") }, "Undefined validation function 'rgbaa' on field ''") PanicMatches(t, func() { _ = validate.Var(s, "rgb|rgbaa|len=13") }, "Undefined validation function 'rgbaa' on field ''")
v2 := New() v2 := New()
v2.RegisterTagNameFunc(func(fld reflect.StructField) string { v2.RegisterTagNameFunc(func(fld reflect.StructField) string {
@ -6351,7 +6342,7 @@ func TestHsla(t *testing.T) {
AssertError(t, errs, "", "", "", "", "hsla") AssertError(t, errs, "", "", "", "", "hsla")
i := 1 i := 1
validate.Var(i, "hsla") errs = validate.Var(i, "hsla")
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
AssertError(t, errs, "", "", "", "", "hsla") AssertError(t, errs, "", "", "", "", "hsla")
} }
@ -7053,7 +7044,7 @@ func TestInvalidValidatorFunction(t *testing.T) {
Test: "1", Test: "1",
} }
PanicMatches(t, func() { validate.Var(s.Test, "zzxxBadFunction") }, "Undefined validation function 'zzxxBadFunction' on field ''") PanicMatches(t, func() { _ = validate.Var(s.Test, "zzxxBadFunction") }, "Undefined validation function 'zzxxBadFunction' on field ''")
} }
func TestCustomFieldName(t *testing.T) { func TestCustomFieldName(t *testing.T) {
@ -7309,15 +7300,15 @@ func TestTranslations(t *testing.T) {
} }
func TestTranslationErrors(t *testing.T) { func TestTranslationErrors(t *testing.T) {
en := en.New() en := en.New()
uni := ut.New(en, en, fr.New()) uni := ut.New(en, en, fr.New())
trans, _ := uni.GetTranslator("en") trans, _ := uni.GetTranslator("en")
trans.Add("required", "{0} is a required field", false) // using translator outside of validator also err := trans.Add("required", "{0} is a required field", false) // using translator outside of validator also
Equal(t, err, nil)
validate := New() validate := New()
err := validate.RegisterTranslation("required", trans, err = validate.RegisterTranslation("required", trans,
func(ut ut.Translator) (err error) { func(ut ut.Translator) (err error) {
// using this stype because multiple translation may have to be added for the full translation // using this stype because multiple translation may have to be added for the full translation
@ -7766,31 +7757,40 @@ func TestFieldLevelName(t *testing.T) {
return name return name
}) })
validate.RegisterValidation("custom1", func(fl FieldLevel) bool { err := validate.RegisterValidation("custom1", func(fl FieldLevel) bool {
res1 = fl.FieldName() res1 = fl.FieldName()
alt1 = fl.StructFieldName() alt1 = fl.StructFieldName()
return true return true
}) })
validate.RegisterValidation("custom2", func(fl FieldLevel) bool { Equal(t, err, nil)
err = validate.RegisterValidation("custom2", func(fl FieldLevel) bool {
res2 = fl.FieldName() res2 = fl.FieldName()
alt2 = fl.StructFieldName() alt2 = fl.StructFieldName()
return true return true
}) })
validate.RegisterValidation("custom3", func(fl FieldLevel) bool { Equal(t, err, nil)
err = validate.RegisterValidation("custom3", func(fl FieldLevel) bool {
res3 = fl.FieldName() res3 = fl.FieldName()
alt3 = fl.StructFieldName() alt3 = fl.StructFieldName()
return true return true
}) })
validate.RegisterValidation("custom4", func(fl FieldLevel) bool { Equal(t, err, nil)
err = validate.RegisterValidation("custom4", func(fl FieldLevel) bool {
res4 = fl.FieldName() res4 = fl.FieldName()
alt4 = fl.StructFieldName() alt4 = fl.StructFieldName()
return true return true
}) })
validate.RegisterValidation("custom5", func(fl FieldLevel) bool { Equal(t, err, nil)
err = validate.RegisterValidation("custom5", func(fl FieldLevel) bool {
res5 = fl.FieldName() res5 = fl.FieldName()
alt5 = fl.StructFieldName() alt5 = fl.StructFieldName()
return true return true
}) })
Equal(t, err, nil)
test := Test{ test := Test{
String: "test", String: "test",
@ -7813,7 +7813,6 @@ func TestFieldLevelName(t *testing.T) {
} }
func TestValidateStructRegisterCtx(t *testing.T) { func TestValidateStructRegisterCtx(t *testing.T) {
var ctxVal string var ctxVal string
fnCtx := func(ctx context.Context, fl FieldLevel) bool { fnCtx := func(ctx context.Context, fl FieldLevel) bool {
@ -7833,7 +7832,9 @@ func TestValidateStructRegisterCtx(t *testing.T) {
var tst Test var tst Test
validate := New() validate := New()
validate.RegisterValidationCtx("val", fnCtx) err := validate.RegisterValidationCtx("val", fnCtx)
Equal(t, err, nil)
validate.RegisterStructValidationCtx(slFn, Test{}) validate.RegisterStructValidationCtx(slFn, Test{})
ctx := context.WithValue(context.Background(), &ctxVal, "testval") ctx := context.WithValue(context.Background(), &ctxVal, "testval")
@ -8039,7 +8040,6 @@ func TestFQDNValidation(t *testing.T) {
} }
func TestIsDefault(t *testing.T) { func TestIsDefault(t *testing.T) {
validate := New() validate := New()
type Inner struct { type Inner struct {
@ -8066,11 +8066,9 @@ func TestIsDefault(t *testing.T) {
validate.RegisterTagNameFunc(func(fld reflect.StructField) string { validate.RegisterTagNameFunc(func(fld reflect.StructField) string {
name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0] name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0]
if name == "-" { if name == "-" {
return "" return ""
} }
return name return name
}) })
@ -8157,7 +8155,7 @@ func TestUniqueValidation(t *testing.T) {
} }
} }
} }
PanicMatches(t, func() { validate.Var(1.0, "unique") }, "Bad field type float64") PanicMatches(t, func() { _ = validate.Var(1.0, "unique") }, "Bad field type float64")
} }
func TestHTMLValidation(t *testing.T) { func TestHTMLValidation(t *testing.T) {
@ -8362,8 +8360,8 @@ func TestKeys(t *testing.T) {
// test bad tag definitions // test bad tag definitions
PanicMatches(t, func() { validate.Var(map[string]string{"key": "val"}, "endkeys,dive,eq=val") }, "'endkeys' tag encountered without a corresponding 'keys' tag") PanicMatches(t, func() { _ = validate.Var(map[string]string{"key": "val"}, "endkeys,dive,eq=val") }, "'endkeys' tag encountered without a corresponding 'keys' tag")
PanicMatches(t, func() { validate.Var(1, "keys,eq=1,endkeys") }, "'keys' tag must be immediately preceded by the 'dive' tag") PanicMatches(t, func() { _ = validate.Var(1, "keys,eq=1,endkeys") }, "'keys' tag must be immediately preceded by the 'dive' tag")
// test custom tag name // test custom tag name
validate = New() validate = New()
@ -8391,7 +8389,6 @@ func TestKeys(t *testing.T) {
// Thanks @adrian-sgn specific test for your specific scenario // Thanks @adrian-sgn specific test for your specific scenario
func TestKeysCustomValidation(t *testing.T) { func TestKeysCustomValidation(t *testing.T) {
type LangCode string type LangCode string
type Label map[LangCode]string type Label map[LangCode]string
@ -8400,7 +8397,7 @@ func TestKeysCustomValidation(t *testing.T) {
} }
validate := New() validate := New()
validate.RegisterValidation("lang_code", func(fl FieldLevel) bool { err := validate.RegisterValidation("lang_code", func(fl FieldLevel) bool {
validLangCodes := map[LangCode]struct{}{ validLangCodes := map[LangCode]struct{}{
"en": {}, "en": {},
"es": {}, "es": {},
@ -8410,6 +8407,7 @@ func TestKeysCustomValidation(t *testing.T) {
_, ok := validLangCodes[fl.Field().Interface().(LangCode)] _, ok := validLangCodes[fl.Field().Interface().(LangCode)]
return ok return ok
}) })
Equal(t, err, nil)
label := Label{ label := Label{
"en": "Good morning!", "en": "Good morning!",
@ -8419,7 +8417,7 @@ func TestKeysCustomValidation(t *testing.T) {
"xxx": "", "xxx": "",
} }
err := validate.Struct(TestMapStructPtr{label}) err = validate.Struct(TestMapStructPtr{label})
NotEqual(t, err, nil) NotEqual(t, err, nil)
errs := err.(ValidationErrors) errs := err.(ValidationErrors)
@ -8562,7 +8560,7 @@ func TestDirValidation(t *testing.T) {
} }
PanicMatches(t, func() { PanicMatches(t, func() {
validate.Var(2, "dir") _ = validate.Var(2, "dir")
}, "Bad field type int") }, "Bad field type int")
} }

Write Preview
Loading…
Cancel
Save