From 5a99cf6052148a4ab9fb4ced60d1da20d23a7add Mon Sep 17 00:00:00 2001 From: Hubert Krauze Date: Tue, 19 Jan 2016 13:01:05 +0100 Subject: [PATCH 01/10] Add validation functions for tcp/udp/ip/unix addresses --- baked_in.go | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+) diff --git a/baked_in.go b/baked_in.go index e9fc9a4..88462f3 100644 --- a/baked_in.go +++ b/baked_in.go @@ -84,6 +84,16 @@ var bakedInValidators = map[string]Func{ "cidrv4": IsCIDRv4, "cidrv6": IsCIDRv6, "cidr": IsCIDR, + "tcp4_addr": IsTCP4Addr, + "tcp6_addr": IsTCP6Addr, + "tcp_addr": IsTCPAddr, + "udp4_addr": IsUDP4Addr, + "udp6_addr": IsUDP6Addr, + "udp_addr": IsUDPAddr, + "ip4_addr": IsIP4Addr, + "ip6_addr": IsIP6Addr, + "ip_addr": IsIPAddr, + "unix_addr": IsUnixAddr, "mac": IsMAC, } @@ -1236,3 +1246,73 @@ func IsLt(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Val func HasMaxOf(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { return IsLte(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) } + +// IsTCP4Addr is the validation function for validating if the field's value is a valid tcp4 address. +// NOTE: This is exposed for use within your own custom functions and not intended to be called directly. +func IsTCP4Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + _, err := net.ResolveTCPAddr("tcp4", field.String()) + return err == nil +} + +// IsTCP6Addr is the validation function for validating if the field's value is a valid tcp6 address. +// NOTE: This is exposed for use within your own custom functions and not intended to be called directly. +func IsTCP6Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + _, err := net.ResolveTCPAddr("tcp6", field.String()) + return err == nil +} + +// IsTCPAddr is the validation function for validating if the field's value is a valid tcp address. +// NOTE: This is exposed for use within your own custom functions and not intended to be called directly. +func IsTCPAddr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + _, err := net.ResolveTCPAddr("tcp", field.String()) + return err == nil +} + +// IsUDP4Addr is the validation function for validating if the field's value is a valid udp4 address. +// NOTE: This is exposed for use within your own custom functions and not intended to be called directly. +func IsUDP4Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + _, err := net.ResolveUDPAddr("udp4", field.String()) + return err == nil +} + +// IsUDP6Addr is the validation function for validating if the field's value is a valid udp6 address. +// NOTE: This is exposed for use within your own custom functions and not intended to be called directly. +func IsUDP6Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + _, err := net.ResolveUDPAddr("udp6", field.String()) + return err == nil +} + +// IsUDPAddr is the validation function for validating if the field's value is a valid udp address. +// NOTE: This is exposed for use within your own custom functions and not intended to be called directly. +func IsUDPAddr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + _, err := net.ResolveUDPAddr("udp", field.String()) + return err == nil +} + +// IsIP4Addr is the validation function for validating if the field's value is a valid ip4 address. +// NOTE: This is exposed for use within your own custom functions and not intended to be called directly. +func IsIP4Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + _, err := net.ResolveIPAddr("ip4", field.String()) + return err == nil +} + +// IsIP6Addr is the validation function for validating if the field's value is a valid ip6 address. +// NOTE: This is exposed for use within your own custom functions and not intended to be called directly. +func IsIP6Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + _, err := net.ResolveIPAddr("ip6", field.String()) + return err == nil +} + +// IsIPAddr is the validation function for validating if the field's value is a valid ip address. +// NOTE: This is exposed for use within your own custom functions and not intended to be called directly. +func IsIPAddr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + _, err := net.ResolveIPAddr("ip", field.String()) + return err == nil +} + +// IsUnixAddr is the validation function for validating if the field's value is a valid unix address. +// NOTE: This is exposed for use within your own custom functions and not intended to be called directly. +func IsUnixAddr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + _, err := net.ResolveUnixAddr("unix", field.String()) + return err == nil +} From def24ae6116f0ee0ef8cbe94ce2c0bb017a49a82 Mon Sep 17 00:00:00 2001 From: Hubert Krauze Date: Tue, 19 Jan 2016 15:09:50 +0100 Subject: [PATCH 02/10] Add Resolvable suffix to functions so they can be more meaningful --- baked_in.go | 60 ++++++++++++++++++++++++++--------------------------- 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/baked_in.go b/baked_in.go index 88462f3..0b7542d 100644 --- a/baked_in.go +++ b/baked_in.go @@ -84,16 +84,16 @@ var bakedInValidators = map[string]Func{ "cidrv4": IsCIDRv4, "cidrv6": IsCIDRv6, "cidr": IsCIDR, - "tcp4_addr": IsTCP4Addr, - "tcp6_addr": IsTCP6Addr, - "tcp_addr": IsTCPAddr, - "udp4_addr": IsUDP4Addr, - "udp6_addr": IsUDP6Addr, - "udp_addr": IsUDPAddr, - "ip4_addr": IsIP4Addr, - "ip6_addr": IsIP6Addr, - "ip_addr": IsIPAddr, - "unix_addr": IsUnixAddr, + "tcp4_addr": IsTCP4AddrResolvable, + "tcp6_addr": IsTCP6AddrResolvable, + "tcp_addr": IsTCPAddrResolvable, + "udp4_addr": IsUDP4AddrResolvable, + "udp6_addr": IsUDP6AddrResolvable, + "udp_addr": IsUDPAddrResolvable, + "ip4_addr": IsIP4AddrResolvable, + "ip6_addr": IsIP6AddrResolvable, + "ip_addr": IsIPAddrResolvable, + "unix_addr": IsUnixAddrResolvable, "mac": IsMAC, } @@ -1247,72 +1247,72 @@ func HasMaxOf(v *Validate, topStruct reflect.Value, currentStructOrField reflect return IsLte(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) } -// IsTCP4Addr is the validation function for validating if the field's value is a valid tcp4 address. +// IsTCP4AddrResolvable is the validation function for validating if the field's value is a resolvable tcp4 address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. -func IsTCP4Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { +func IsTCP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { _, err := net.ResolveTCPAddr("tcp4", field.String()) return err == nil } -// IsTCP6Addr is the validation function for validating if the field's value is a valid tcp6 address. +// IsTCP6AddrResolvable is the validation function for validating if the field's value is a resolvable tcp6 address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. -func IsTCP6Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { +func IsTCP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { _, err := net.ResolveTCPAddr("tcp6", field.String()) return err == nil } -// IsTCPAddr is the validation function for validating if the field's value is a valid tcp address. +// IsTCPAddrResolvable is the validation function for validating if the field's value is a resolvable tcp address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. -func IsTCPAddr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { +func IsTCPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { _, err := net.ResolveTCPAddr("tcp", field.String()) return err == nil } -// IsUDP4Addr is the validation function for validating if the field's value is a valid udp4 address. +// IsUDP4AddrResolvable is the validation function for validating if the field's value is a resolvable udp4 address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. -func IsUDP4Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { +func IsUDP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { _, err := net.ResolveUDPAddr("udp4", field.String()) return err == nil } -// IsUDP6Addr is the validation function for validating if the field's value is a valid udp6 address. +// IsUDP6AddrResolvable is the validation function for validating if the field's value is a resolvable udp6 address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. -func IsUDP6Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { +func IsUDP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { _, err := net.ResolveUDPAddr("udp6", field.String()) return err == nil } -// IsUDPAddr is the validation function for validating if the field's value is a valid udp address. +// IsUDPAddrResolvable is the validation function for validating if the field's value is a resolvable udp address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. -func IsUDPAddr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { +func IsUDPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { _, err := net.ResolveUDPAddr("udp", field.String()) return err == nil } -// IsIP4Addr is the validation function for validating if the field's value is a valid ip4 address. +// IsIP4AddrResolvable is the validation function for validating if the field's value is a resolvable ip4 address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. -func IsIP4Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { +func IsIP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { _, err := net.ResolveIPAddr("ip4", field.String()) return err == nil } -// IsIP6Addr is the validation function for validating if the field's value is a valid ip6 address. +// IsIP6AddrResolvable is the validation function for validating if the field's value is a resolvable ip6 address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. -func IsIP6Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { +func IsIP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { _, err := net.ResolveIPAddr("ip6", field.String()) return err == nil } -// IsIPAddr is the validation function for validating if the field's value is a valid ip address. +// IsIPAddrResolvable is the validation function for validating if the field's value is a resolvable ip address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. -func IsIPAddr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { +func IsIPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { _, err := net.ResolveIPAddr("ip", field.String()) return err == nil } -// IsUnixAddr is the validation function for validating if the field's value is a valid unix address. +// IsUnixAddrResolvable is the validation function for validating if the field's value is a resolvable unix address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. -func IsUnixAddr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { +func IsUnixAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { _, err := net.ResolveUnixAddr("unix", field.String()) return err == nil } From 312ba49f28969cea790638a5b9fc8e5a12619066 Mon Sep 17 00:00:00 2001 From: Hubert Krauze Date: Tue, 19 Jan 2016 15:11:08 +0100 Subject: [PATCH 03/10] Remove duplicated "Usage: mac" from docs --- doc.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/doc.go b/doc.go index d9a5270..6b8e968 100644 --- a/doc.go +++ b/doc.go @@ -745,8 +745,6 @@ Note: See Go's ParseMAC for accepted formats and types: http://golang.org/src/net/mac.go?s=866:918#L29 - Usage: mac - Alias Validators and Tags NOTE: When returning an error, the tag returned in "FieldError" will be From ee0ce7d37e2070044b0f1f2853482039722ca861 Mon Sep 17 00:00:00 2001 From: Hubert Krauze Date: Wed, 20 Jan 2016 09:44:06 +0100 Subject: [PATCH 04/10] Add test for tcp/udp/ip/unix addresses resolve --- validator_test.go | 308 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 308 insertions(+) diff --git a/validator_test.go b/validator_test.go index 189e522..82ee592 100644 --- a/validator_test.go +++ b/validator_test.go @@ -1987,6 +1987,314 @@ func TestCIDRv4Validation(t *testing.T) { } } +func TestTCPAddrValidation(t *testing.T) { + tests := []struct { + param string + expected bool + }{ + {":80", true}, + {"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 == true { + 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 + }{ + {":80", true}, + {"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, "tcp6_addr") + if test.expected == true { + 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 + }{ + {":80", true}, + {"127.0.0.1:80", true}, + {"[::1]:80", true}, // 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 == true { + 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 + }{ + {":80", true}, + {"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 == true { + 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 + }{ + {":80", true}, + {"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, "udp6_addr") + if test.expected == true { + 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 + }{ + {":80", true}, + {"127.0.0.1:80", true}, + {"[::1]:80", true}, // 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 == true { + 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 + }{ + {"", true}, + {"127.0.0.1", true}, + {"::1", true}, + {"256.0.0.0", false}, + } + + for i, test := range tests { + errs := validate.Field(test.param, "ip_addr") + if test.expected == true { + 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 + }{ + {"", true}, + {"127.0.0.1", true}, // https://github.com/golang/go/issues/14037 + {"::1", true}, + {"256.0.0.0", false}, + } + + for i, test := range tests { + errs := validate.Field(test.param, "ip6_addr") + if test.expected == true { + 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 + }{ + {"", true}, + {"127.0.0.1", true}, + {"::1", true}, // https://github.com/golang/go/issues/14037 + {"256.0.0.0", false}, + } + + for i, test := range tests { + errs := validate.Field(test.param, "ip4_addr") + if test.expected == true { + 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 == true { + 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 From 3eaf85741901fe9416c91e533c4e86c9e6b6b4ee Mon Sep 17 00:00:00 2001 From: Hubert Krauze Date: Wed, 20 Jan 2016 09:52:59 +0100 Subject: [PATCH 05/10] Add docs tcp/udp/ip/unix addresses resolve --- doc.go | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/doc.go b/doc.go index 6b8e968..c351a61 100644 --- a/doc.go +++ b/doc.go @@ -735,6 +735,66 @@ This validates that a string value contains a valid v6 CIDR Adress. Usage: cidrv6 +Transmission Control Protocol Address TCP + +This validates that a string value contains a valid resolvable TCP Adress. + + Usage: tcp_addr + +Transmission Control Protocol Address TCPv4 + +This validates that a string value contains a valid resolvable v4 TCP Adress. + + Usage: tcp4_addr + +Transmission Control Protocol Address TCPv6 + +This validates that a string value contains a valid resolvable v6 TCP Adress. + + Usage: tcp6_addr + +User Datagram Protocol Address UDP + +This validates that a string value contains a valid resolvable UDP Adress. + + Usage: udp_addr + +User Datagram Protocol Address UDPv4 + +This validates that a string value contains a valid resolvable v4 UDP Adress. + + Usage: udp4_addr + +User Datagram Protocol Address UDPv6 + +This validates that a string value contains a valid resolvable v6 UDP Adress. + + Usage: udp6_addr + +Internet Protocol Address IP + +This validates that a string value contains a valid resolvable IP Adress. + + Usage: ip_addr + +Internet Protocol Address IPv4 + +This validates that a string value contains a valid resolvable v4 IP Adress. + + Usage: ip4_addr + +Internet Protocol Address IPv6 + +This validates that a string value contains a valid resolvable v6 IP Adress. + + Usage: ip6_addr + +Unix domain socket end point Address + +This validates that a string value contains a valid Unix Adress. + + Usage: unix_addr + Media Access Control Address MAC This validates that a string value contains a valid MAC Adress. From 7b758151c6bcf6639a1a0efbae5aaed6ed7bc16a Mon Sep 17 00:00:00 2001 From: joeybloggs Date: Wed, 20 Jan 2016 10:06:30 -0500 Subject: [PATCH 06/10] Add workaround for go issue --- baked_in.go | 42 ++++++++++++++++++++++++++++++++++++++++++ validator_test.go | 25 ++++++++++++++++--------- 2 files changed, 58 insertions(+), 9 deletions(-) diff --git a/baked_in.go b/baked_in.go index 0b7542d..cb9e72b 100644 --- a/baked_in.go +++ b/baked_in.go @@ -1250,6 +1250,17 @@ func HasMaxOf(v *Validate, topStruct reflect.Value, currentStructOrField reflect // IsTCP4AddrResolvable is the validation function for validating if the field's value is a resolvable tcp4 address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsTCP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + + val := field.String() + + if idx := strings.LastIndex(val, ":"); idx != -1 { + val = val[0:idx] + } + + if !IsIPv4(v, topStruct, currentStructOrField, reflect.ValueOf(val), fieldType, fieldKind, param) { + return false + } + _, err := net.ResolveTCPAddr("tcp4", field.String()) return err == nil } @@ -1257,6 +1268,19 @@ func IsTCP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrF // IsTCP6AddrResolvable is the validation function for validating if the field's value is a resolvable tcp6 address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsTCP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + + val := field.String() + + if idx := strings.LastIndex(val, ":"); idx != -1 { + if idx != 0 && val[idx-1:idx] == "]" { + val = val[1 : idx-1] + } + } + + if !IsIPv6(v, topStruct, currentStructOrField, reflect.ValueOf(val), fieldType, fieldKind, param) { + return false + } + _, err := net.ResolveTCPAddr("tcp6", field.String()) return err == nil } @@ -1264,6 +1288,9 @@ func IsTCP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrF // IsTCPAddrResolvable is the validation function for validating if the field's value is a resolvable tcp address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsTCPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + + // if string before the post is blank then invalid + _, err := net.ResolveTCPAddr("tcp", field.String()) return err == nil } @@ -1292,6 +1319,11 @@ func IsUDPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrFi // IsIP4AddrResolvable is the validation function for validating if the field's value is a resolvable ip4 address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsIP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + + if !IsIPv4(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { + return false + } + _, err := net.ResolveIPAddr("ip4", field.String()) return err == nil } @@ -1299,6 +1331,11 @@ func IsIP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrFi // IsIP6AddrResolvable is the validation function for validating if the field's value is a resolvable ip6 address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsIP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + + if !IsIPv6(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { + return false + } + _, err := net.ResolveIPAddr("ip6", field.String()) return err == nil } @@ -1306,6 +1343,11 @@ func IsIP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrFi // IsIPAddrResolvable is the validation function for validating if the field's value is a resolvable ip address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsIPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + + if !IsIP(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { + return false + } + _, err := net.ResolveIPAddr("ip", field.String()) return err == nil } diff --git a/validator_test.go b/validator_test.go index 82ee592..7329e48 100644 --- a/validator_test.go +++ b/validator_test.go @@ -1755,6 +1755,7 @@ func TestIPValidation(t *testing.T) { param string expected bool }{ + {"", false}, {"10.0.0.1", true}, {"172.16.0.1", true}, {"192.168.0.1", true}, @@ -2023,8 +2024,8 @@ func TestTCP6AddrValidation(t *testing.T) { param string expected bool }{ - {":80", true}, - {"127.0.0.1:80", true}, + {":80", false}, + {"127.0.0.1:80", false}, {"[::1]:80", true}, {"256.0.0.0:1", false}, {"[::1]", false}, @@ -2054,9 +2055,9 @@ func TestTCP4AddrValidation(t *testing.T) { param string expected bool }{ - {":80", true}, + {":80", false}, {"127.0.0.1:80", true}, - {"[::1]:80", true}, // https://github.com/golang/go/issues/14037 + {"[::1]:80", false}, // https://github.com/golang/go/issues/14037 {"256.0.0.0:1", false}, {"[::1]", false}, } @@ -2180,10 +2181,12 @@ func TestIPAddrValidation(t *testing.T) { param string expected bool }{ - {"", true}, + {"", 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 { @@ -2210,9 +2213,11 @@ func TestIP6AddrValidation(t *testing.T) { param string expected bool }{ - {"", true}, - {"127.0.0.1", true}, // https://github.com/golang/go/issues/14037 + {"", 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}, } @@ -2240,10 +2245,12 @@ func TestIP4AddrValidation(t *testing.T) { param string expected bool }{ - {"", true}, + {"", false}, {"127.0.0.1", true}, - {"::1", true}, // https://github.com/golang/go/issues/14037 + {"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 { From faf40fd62f4b186f9f5ed57ab25661ff036b944c Mon Sep 17 00:00:00 2001 From: joeybloggs Date: Tue, 2 Feb 2016 08:12:47 -0500 Subject: [PATCH 07/10] Correct validation for TCPAddrResolvable --- baked_in.go | 12 ++++++++---- validator_test.go | 2 +- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/baked_in.go b/baked_in.go index cb9e72b..af0d3fa 100644 --- a/baked_in.go +++ b/baked_in.go @@ -87,13 +87,13 @@ var bakedInValidators = map[string]Func{ "tcp4_addr": IsTCP4AddrResolvable, "tcp6_addr": IsTCP6AddrResolvable, "tcp_addr": IsTCPAddrResolvable, - "udp4_addr": IsUDP4AddrResolvable, - "udp6_addr": IsUDP6AddrResolvable, - "udp_addr": IsUDPAddrResolvable, + "udp4_addr": IsUDP4AddrResolvable, // need to do + "udp6_addr": IsUDP6AddrResolvable, // need to do + "udp_addr": IsUDPAddrResolvable, // need to do "ip4_addr": IsIP4AddrResolvable, "ip6_addr": IsIP6AddrResolvable, "ip_addr": IsIPAddrResolvable, - "unix_addr": IsUnixAddrResolvable, + "unix_addr": IsUnixAddrResolvable, // need to do "mac": IsMAC, } @@ -1290,6 +1290,10 @@ func IsTCP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrF func IsTCPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { // if string before the post is blank then invalid + if !IsTCP4AddrResolvable(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) && + !IsTCP6AddrResolvable(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { + return false + } _, err := net.ResolveTCPAddr("tcp", field.String()) return err == nil diff --git a/validator_test.go b/validator_test.go index 7329e48..ee4309b 100644 --- a/validator_test.go +++ b/validator_test.go @@ -1993,7 +1993,7 @@ func TestTCPAddrValidation(t *testing.T) { param string expected bool }{ - {":80", true}, + {":80", false}, {"127.0.0.1:80", true}, {"[::1]:80", true}, {"256.0.0.0:1", false}, From 4cb9152af0f49e68307d4d30c4f3fef328ec0606 Mon Sep 17 00:00:00 2001 From: joeybloggs Date: Tue, 2 Feb 2016 08:23:37 -0500 Subject: [PATCH 08/10] correct IsUPDAddrResolvable functions --- baked_in.go | 37 ++++++++++++++++++++++++++++++++++--- validator_test.go | 10 +++++----- 2 files changed, 39 insertions(+), 8 deletions(-) diff --git a/baked_in.go b/baked_in.go index af0d3fa..c8f76fd 100644 --- a/baked_in.go +++ b/baked_in.go @@ -87,9 +87,9 @@ var bakedInValidators = map[string]Func{ "tcp4_addr": IsTCP4AddrResolvable, "tcp6_addr": IsTCP6AddrResolvable, "tcp_addr": IsTCPAddrResolvable, - "udp4_addr": IsUDP4AddrResolvable, // need to do - "udp6_addr": IsUDP6AddrResolvable, // need to do - "udp_addr": IsUDPAddrResolvable, // need to do + "udp4_addr": IsUDP4AddrResolvable, + "udp6_addr": IsUDP6AddrResolvable, + "udp_addr": IsUDPAddrResolvable, "ip4_addr": IsIP4AddrResolvable, "ip6_addr": IsIP6AddrResolvable, "ip_addr": IsIPAddrResolvable, @@ -1302,6 +1302,17 @@ func IsTCPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrFi // IsUDP4AddrResolvable is the validation function for validating if the field's value is a resolvable udp4 address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsUDP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + + val := field.String() + + if idx := strings.LastIndex(val, ":"); idx != -1 { + val = val[0:idx] + } + + if !IsIPv4(v, topStruct, currentStructOrField, reflect.ValueOf(val), fieldType, fieldKind, param) { + return false + } + _, err := net.ResolveUDPAddr("udp4", field.String()) return err == nil } @@ -1309,6 +1320,19 @@ func IsUDP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrF // IsUDP6AddrResolvable is the validation function for validating if the field's value is a resolvable udp6 address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsUDP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + + val := field.String() + + if idx := strings.LastIndex(val, ":"); idx != -1 { + if idx != 0 && val[idx-1:idx] == "]" { + val = val[1 : idx-1] + } + } + + if !IsIPv6(v, topStruct, currentStructOrField, reflect.ValueOf(val), fieldType, fieldKind, param) { + return false + } + _, err := net.ResolveUDPAddr("udp6", field.String()) return err == nil } @@ -1316,6 +1340,13 @@ func IsUDP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrF // IsUDPAddrResolvable is the validation function for validating if the field's value is a resolvable udp address. // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsUDPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + + // if string before the post is blank then invalid + if !IsUDP4AddrResolvable(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) && + !IsUDP6AddrResolvable(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { + return false + } + _, err := net.ResolveUDPAddr("udp", field.String()) return err == nil } diff --git a/validator_test.go b/validator_test.go index ee4309b..9b077dc 100644 --- a/validator_test.go +++ b/validator_test.go @@ -2087,7 +2087,7 @@ func TestUDPAddrValidation(t *testing.T) { param string expected bool }{ - {":80", true}, + {":80", false}, {"127.0.0.1:80", true}, {"[::1]:80", true}, {"256.0.0.0:1", false}, @@ -2118,8 +2118,8 @@ func TestUDP6AddrValidation(t *testing.T) { param string expected bool }{ - {":80", true}, - {"127.0.0.1:80", true}, + {":80", false}, + {"127.0.0.1:80", false}, {"[::1]:80", true}, {"256.0.0.0:1", false}, {"[::1]", false}, @@ -2149,9 +2149,9 @@ func TestUDP4AddrValidation(t *testing.T) { param string expected bool }{ - {":80", true}, + {":80", false}, {"127.0.0.1:80", true}, - {"[::1]:80", true}, // https://github.com/golang/go/issues/14037 + {"[::1]:80", false}, // https://github.com/golang/go/issues/14037 {"256.0.0.0:1", false}, {"[::1]", false}, } From 6851add4e4bb9eea822e7bb6b5af051640c74f3b Mon Sep 17 00:00:00 2001 From: joeybloggs Date: Tue, 2 Feb 2016 08:33:55 -0500 Subject: [PATCH 09/10] Update to avoid double resolves --- baked_in.go | 78 ++++++++++++++++++++++++++--------------------------- 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/baked_in.go b/baked_in.go index c8f76fd..2d60162 100644 --- a/baked_in.go +++ b/baked_in.go @@ -93,7 +93,7 @@ var bakedInValidators = map[string]Func{ "ip4_addr": IsIP4AddrResolvable, "ip6_addr": IsIP6AddrResolvable, "ip_addr": IsIPAddrResolvable, - "unix_addr": IsUnixAddrResolvable, // need to do + "unix_addr": IsUnixAddrResolvable, "mac": IsMAC, } @@ -1251,13 +1251,7 @@ func HasMaxOf(v *Validate, topStruct reflect.Value, currentStructOrField reflect // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsTCP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { - val := field.String() - - if idx := strings.LastIndex(val, ":"); idx != -1 { - val = val[0:idx] - } - - if !IsIPv4(v, topStruct, currentStructOrField, reflect.ValueOf(val), fieldType, fieldKind, param) { + if !isIP4Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { return false } @@ -1269,15 +1263,7 @@ func IsTCP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrF // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsTCP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { - val := field.String() - - if idx := strings.LastIndex(val, ":"); idx != -1 { - if idx != 0 && val[idx-1:idx] == "]" { - val = val[1 : idx-1] - } - } - - if !IsIPv6(v, topStruct, currentStructOrField, reflect.ValueOf(val), fieldType, fieldKind, param) { + if !isIP6Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { return false } @@ -1289,9 +1275,8 @@ func IsTCP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrF // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsTCPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { - // if string before the post is blank then invalid - if !IsTCP4AddrResolvable(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) && - !IsTCP6AddrResolvable(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { + if !isIP4Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) && + !isIP6Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { return false } @@ -1303,13 +1288,7 @@ func IsTCPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrFi // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsUDP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { - val := field.String() - - if idx := strings.LastIndex(val, ":"); idx != -1 { - val = val[0:idx] - } - - if !IsIPv4(v, topStruct, currentStructOrField, reflect.ValueOf(val), fieldType, fieldKind, param) { + if !isIP4Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { return false } @@ -1321,15 +1300,7 @@ func IsUDP4AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrF // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsUDP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { - val := field.String() - - if idx := strings.LastIndex(val, ":"); idx != -1 { - if idx != 0 && val[idx-1:idx] == "]" { - val = val[1 : idx-1] - } - } - - if !IsIPv6(v, topStruct, currentStructOrField, reflect.ValueOf(val), fieldType, fieldKind, param) { + if !isIP6Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { return false } @@ -1341,9 +1312,8 @@ func IsUDP6AddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrF // NOTE: This is exposed for use within your own custom functions and not intended to be called directly. func IsUDPAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { - // if string before the post is blank then invalid - if !IsUDP4AddrResolvable(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) && - !IsUDP6AddrResolvable(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { + if !isIP4Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) && + !isIP6Addr(v, topStruct, currentStructOrField, field, fieldType, fieldKind, param) { return false } @@ -1393,3 +1363,33 @@ func IsUnixAddrResolvable(v *Validate, topStruct reflect.Value, currentStructOrF _, err := net.ResolveUnixAddr("unix", field.String()) return err == nil } + +func isIP4Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + val := field.String() + + if idx := strings.LastIndex(val, ":"); idx != -1 { + val = val[0:idx] + } + + if !IsIPv4(v, topStruct, currentStructOrField, reflect.ValueOf(val), fieldType, fieldKind, param) { + return false + } + + return true +} + +func isIP6Addr(v *Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { + val := field.String() + + if idx := strings.LastIndex(val, ":"); idx != -1 { + if idx != 0 && val[idx-1:idx] == "]" { + val = val[1 : idx-1] + } + } + + if !IsIPv6(v, topStruct, currentStructOrField, reflect.ValueOf(val), fieldType, fieldKind, param) { + return false + } + + return true +} From bf5ac690d6339a82f259278cb11a3dc00ff1b229 Mon Sep 17 00:00:00 2001 From: joeybloggs Date: Tue, 2 Feb 2016 08:37:11 -0500 Subject: [PATCH 10/10] Add a couple more test cases --- validator_test.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/validator_test.go b/validator_test.go index 9b077dc..63f3d9b 100644 --- a/validator_test.go +++ b/validator_test.go @@ -1993,6 +1993,7 @@ func TestTCPAddrValidation(t *testing.T) { param string expected bool }{ + {"", false}, {":80", false}, {"127.0.0.1:80", true}, {"[::1]:80", true}, @@ -2024,6 +2025,7 @@ func TestTCP6AddrValidation(t *testing.T) { param string expected bool }{ + {"", false}, {":80", false}, {"127.0.0.1:80", false}, {"[::1]:80", true}, @@ -2055,6 +2057,7 @@ func TestTCP4AddrValidation(t *testing.T) { param string expected bool }{ + {"", false}, {":80", false}, {"127.0.0.1:80", true}, {"[::1]:80", false}, // https://github.com/golang/go/issues/14037 @@ -2087,6 +2090,7 @@ func TestUDPAddrValidation(t *testing.T) { param string expected bool }{ + {"", false}, {":80", false}, {"127.0.0.1:80", true}, {"[::1]:80", true}, @@ -2118,6 +2122,7 @@ func TestUDP6AddrValidation(t *testing.T) { param string expected bool }{ + {"", false}, {":80", false}, {"127.0.0.1:80", false}, {"[::1]:80", true}, @@ -2149,6 +2154,7 @@ func TestUDP4AddrValidation(t *testing.T) { param string expected bool }{ + {"", false}, {":80", false}, {"127.0.0.1:80", true}, {"[::1]:80", false}, // https://github.com/golang/go/issues/14037