package validator_test

import (
	"fmt"
	"reflect"
	"testing"
	"time"

	"gopkg.in/bluesuncorp/validator.v5"
	. "gopkg.in/check.v1"
)

type I interface {
	Foo() string
}

type Impl struct {
	F string `validate:"len=3"`
}

func (i *Impl) Foo() string {
	return i.F
}

type SubTest struct {
	Test string `validate:"required"`
}

type TestInterface struct {
	Iface I
}

type TestString struct {
	BlankTag  string `validate:""`
	Required  string `validate:"required"`
	Len       string `validate:"len=10"`
	Min       string `validate:"min=1"`
	Max       string `validate:"max=10"`
	MinMax    string `validate:"min=1,max=10"`
	Lt        string `validate:"lt=10"`
	Lte       string `validate:"lte=10"`
	Gt        string `validate:"gt=10"`
	Gte       string `validate:"gte=10"`
	OmitEmpty string `validate:"omitempty,min=1,max=10"`
	Sub       *SubTest
	SubIgnore *SubTest `validate:"-"`
	Anonymous struct {
		A string `validate:"required"`
	}
	Iface I
}

type TestInt32 struct {
	Required  int `validate:"required"`
	Len       int `validate:"len=10"`
	Min       int `validate:"min=1"`
	Max       int `validate:"max=10"`
	MinMax    int `validate:"min=1,max=10"`
	Lt        int `validate:"lt=10"`
	Lte       int `validate:"lte=10"`
	Gt        int `validate:"gt=10"`
	Gte       int `validate:"gte=10"`
	OmitEmpty int `validate:"omitempty,min=1,max=10"`
}

type TestUint64 struct {
	Required  uint64 `validate:"required"`
	Len       uint64 `validate:"len=10"`
	Min       uint64 `validate:"min=1"`
	Max       uint64 `validate:"max=10"`
	MinMax    uint64 `validate:"min=1,max=10"`
	OmitEmpty uint64 `validate:"omitempty,min=1,max=10"`
}

type TestFloat64 struct {
	Required  float64 `validate:"required"`
	Len       float64 `validate:"len=10"`
	Min       float64 `validate:"min=1"`
	Max       float64 `validate:"max=10"`
	MinMax    float64 `validate:"min=1,max=10"`
	Lte       float64 `validate:"lte=10"`
	OmitEmpty float64 `validate:"omitempty,min=1,max=10"`
}

type TestSlice struct {
	Required  []int `validate:"required"`
	Len       []int `validate:"len=10"`
	Min       []int `validate:"min=1"`
	Max       []int `validate:"max=10"`
	MinMax    []int `validate:"min=1,max=10"`
	OmitEmpty []int `validate:"omitempty,min=1,max=10"`
}

func Test(t *testing.T) { TestingT(t) }

type MySuite struct{}

var _ = Suite(&MySuite{})

var validate *validator.Validate = validator.New("validate", validator.BakedInValidators)

func AssetStruct(s *validator.StructErrors, structFieldName string, expectedStructName string, c *C) *validator.StructErrors {

	val, ok := s.StructErrors[structFieldName]
	c.Assert(ok, Equals, true)
	c.Assert(val, NotNil)
	c.Assert(val.Struct, Equals, expectedStructName)

	return val
}

func AssertFieldError(s *validator.StructErrors, field string, expectedTag string, c *C) {

	val, ok := s.Errors[field]
	c.Assert(ok, Equals, true)
	c.Assert(val, NotNil)
	c.Assert(val.Field, Equals, field)
	c.Assert(val.Tag, Equals, expectedTag)
}

func AssertMapFieldError(s map[string]*validator.FieldError, field string, expectedTag string, c *C) {

	val, ok := s[field]
	c.Assert(ok, Equals, true)
	c.Assert(val, NotNil)
	c.Assert(val.Field, Equals, field)
	c.Assert(val.Tag, Equals, expectedTag)
}

func newValidatorFunc(val interface{}, current interface{}, field interface{}, param string) bool {

	return true
}

func isEqualFunc(val interface{}, current interface{}, field interface{}, param string) bool {

	return current.(string) == field.(string)
}

func (ms *MySuite) TestStructOnlyValidation(c *C) {

	type Inner struct {
		Test string `validate:"len=5"`
	}

	type Outer struct {
		InnerStruct *Inner `validate:"required,structonly"`
	}

	outer := &Outer{
		InnerStruct: nil,
	}

	errs := validate.Struct(outer).Flatten()
	c.Assert(errs, NotNil)

	inner := &Inner{
		Test: "1234",
	}

	outer = &Outer{
		InnerStruct: inner,
	}

	errs = validate.Struct(outer).Flatten()
	c.Assert(errs, IsNil)
}

func (ms *MySuite) TestGtField(c *C) {

	type TimeTest struct {
		Start *time.Time `validate:"required,gt"`
		End   *time.Time `validate:"required,gt,gtfield=Start"`
	}

	now := time.Now()
	start := now.Add(time.Hour * 24)
	end := start.Add(time.Hour * 24)

	timeTest := &TimeTest{
		Start: &start,
		End:   &end,
	}

	errs := validate.Struct(timeTest)
	c.Assert(errs, IsNil)

	timeTest = &TimeTest{
		Start: &end,
		End:   &start,
	}

	errs2 := validate.Struct(timeTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "End", "gtfield", c)

	err3 := validate.FieldWithValue(&start, &end, "gtfield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(&end, &start, "gtfield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "gtfield")

	type IntTest struct {
		Val1 int `validate:"required"`
		Val2 int `validate:"required,gtfield=Val1"`
	}

	intTest := &IntTest{
		Val1: 1,
		Val2: 5,
	}

	errs = validate.Struct(intTest)
	c.Assert(errs, IsNil)

	intTest = &IntTest{
		Val1: 5,
		Val2: 1,
	}

	errs2 = validate.Struct(intTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Val2", "gtfield", c)

	err3 = validate.FieldWithValue(int(1), int(5), "gtfield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(int(5), int(1), "gtfield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "gtfield")

	type UIntTest struct {
		Val1 uint `validate:"required"`
		Val2 uint `validate:"required,gtfield=Val1"`
	}

	uIntTest := &UIntTest{
		Val1: 1,
		Val2: 5,
	}

	errs = validate.Struct(uIntTest)
	c.Assert(errs, IsNil)

	uIntTest = &UIntTest{
		Val1: 5,
		Val2: 1,
	}

	errs2 = validate.Struct(uIntTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Val2", "gtfield", c)

	err3 = validate.FieldWithValue(uint(1), uint(5), "gtfield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(uint(5), uint(1), "gtfield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "gtfield")

	type FloatTest struct {
		Val1 float64 `validate:"required"`
		Val2 float64 `validate:"required,gtfield=Val1"`
	}

	floatTest := &FloatTest{
		Val1: 1,
		Val2: 5,
	}

	errs = validate.Struct(floatTest)
	c.Assert(errs, IsNil)

	floatTest = &FloatTest{
		Val1: 5,
		Val2: 1,
	}

	errs2 = validate.Struct(floatTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Val2", "gtfield", c)

	err3 = validate.FieldWithValue(float32(1), float32(5), "gtfield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(float32(5), float32(1), "gtfield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "gtfield")

	c.Assert(func() { validate.FieldWithValue(nil, 1, "gtfield") }, PanicMatches, "struct not passed for cross validation")
	c.Assert(func() { validate.FieldWithValue(5, "T", "gtfield") }, PanicMatches, "Bad field type string")
	c.Assert(func() { validate.FieldWithValue(5, start, "gtfield") }, PanicMatches, "Bad Top Level field type")

	type TimeTest2 struct {
		Start *time.Time `validate:"required"`
		End   *time.Time `validate:"required,gtfield=NonExistantField"`
	}

	timeTest2 := &TimeTest2{
		Start: &start,
		End:   &end,
	}

	c.Assert(func() { validate.Struct(timeTest2) }, PanicMatches, "Field \"NonExistantField\" not found in struct")
}

func (ms *MySuite) TestLtField(c *C) {

	type TimeTest struct {
		Start *time.Time `validate:"required,lt,ltfield=End"`
		End   *time.Time `validate:"required,lt"`
	}

	now := time.Now()
	start := now.Add(time.Hour * 24 * -1 * 2)
	end := start.Add(time.Hour * 24)

	timeTest := &TimeTest{
		Start: &start,
		End:   &end,
	}

	errs := validate.Struct(timeTest)
	c.Assert(errs, IsNil)

	timeTest = &TimeTest{
		Start: &end,
		End:   &start,
	}

	errs2 := validate.Struct(timeTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Start", "ltfield", c)

	err3 := validate.FieldWithValue(&end, &start, "ltfield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(&start, &end, "ltfield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "ltfield")

	type IntTest struct {
		Val1 int `validate:"required"`
		Val2 int `validate:"required,ltfield=Val1"`
	}

	intTest := &IntTest{
		Val1: 5,
		Val2: 1,
	}

	errs = validate.Struct(intTest)
	c.Assert(errs, IsNil)

	intTest = &IntTest{
		Val1: 1,
		Val2: 5,
	}

	errs2 = validate.Struct(intTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Val2", "ltfield", c)

	err3 = validate.FieldWithValue(int(5), int(1), "ltfield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(int(1), int(5), "ltfield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "ltfield")

	type UIntTest struct {
		Val1 uint `validate:"required"`
		Val2 uint `validate:"required,ltfield=Val1"`
	}

	uIntTest := &UIntTest{
		Val1: 5,
		Val2: 1,
	}

	errs = validate.Struct(uIntTest)
	c.Assert(errs, IsNil)

	uIntTest = &UIntTest{
		Val1: 1,
		Val2: 5,
	}

	errs2 = validate.Struct(uIntTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Val2", "ltfield", c)

	err3 = validate.FieldWithValue(uint(5), uint(1), "ltfield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(uint(1), uint(5), "ltfield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "ltfield")

	type FloatTest struct {
		Val1 float64 `validate:"required"`
		Val2 float64 `validate:"required,ltfield=Val1"`
	}

	floatTest := &FloatTest{
		Val1: 5,
		Val2: 1,
	}

	errs = validate.Struct(floatTest)
	c.Assert(errs, IsNil)

	floatTest = &FloatTest{
		Val1: 1,
		Val2: 5,
	}

	errs2 = validate.Struct(floatTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Val2", "ltfield", c)

	err3 = validate.FieldWithValue(float32(5), float32(1), "ltfield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(float32(1), float32(5), "ltfield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "ltfield")

	c.Assert(func() { validate.FieldWithValue(nil, 5, "ltfield") }, PanicMatches, "struct not passed for cross validation")
	c.Assert(func() { validate.FieldWithValue(1, "T", "ltfield") }, PanicMatches, "Bad field type string")
	c.Assert(func() { validate.FieldWithValue(1, end, "ltfield") }, PanicMatches, "Bad Top Level field type")

	type TimeTest2 struct {
		Start *time.Time `validate:"required"`
		End   *time.Time `validate:"required,ltfield=NonExistantField"`
	}

	timeTest2 := &TimeTest2{
		Start: &end,
		End:   &start,
	}

	c.Assert(func() { validate.Struct(timeTest2) }, PanicMatches, "Field \"NonExistantField\" not found in struct")
}

func (ms *MySuite) TestLteField(c *C) {

	type TimeTest struct {
		Start *time.Time `validate:"required,lte,ltefield=End"`
		End   *time.Time `validate:"required,lte"`
	}

	now := time.Now()
	start := now.Add(time.Hour * 24 * -1 * 2)
	end := start.Add(time.Hour * 24)

	timeTest := &TimeTest{
		Start: &start,
		End:   &end,
	}

	errs := validate.Struct(timeTest)
	c.Assert(errs, IsNil)

	timeTest = &TimeTest{
		Start: &end,
		End:   &start,
	}

	errs2 := validate.Struct(timeTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Start", "ltefield", c)

	err3 := validate.FieldWithValue(&end, &start, "ltefield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(&start, &end, "ltefield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "ltefield")

	type IntTest struct {
		Val1 int `validate:"required"`
		Val2 int `validate:"required,ltefield=Val1"`
	}

	intTest := &IntTest{
		Val1: 5,
		Val2: 1,
	}

	errs = validate.Struct(intTest)
	c.Assert(errs, IsNil)

	intTest = &IntTest{
		Val1: 1,
		Val2: 5,
	}

	errs2 = validate.Struct(intTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Val2", "ltefield", c)

	err3 = validate.FieldWithValue(int(5), int(1), "ltefield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(int(1), int(5), "ltefield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "ltefield")

	type UIntTest struct {
		Val1 uint `validate:"required"`
		Val2 uint `validate:"required,ltefield=Val1"`
	}

	uIntTest := &UIntTest{
		Val1: 5,
		Val2: 1,
	}

	errs = validate.Struct(uIntTest)
	c.Assert(errs, IsNil)

	uIntTest = &UIntTest{
		Val1: 1,
		Val2: 5,
	}

	errs2 = validate.Struct(uIntTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Val2", "ltefield", c)

	err3 = validate.FieldWithValue(uint(5), uint(1), "ltefield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(uint(1), uint(5), "ltefield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "ltefield")

	type FloatTest struct {
		Val1 float64 `validate:"required"`
		Val2 float64 `validate:"required,ltefield=Val1"`
	}

	floatTest := &FloatTest{
		Val1: 5,
		Val2: 1,
	}

	errs = validate.Struct(floatTest)
	c.Assert(errs, IsNil)

	floatTest = &FloatTest{
		Val1: 1,
		Val2: 5,
	}

	errs2 = validate.Struct(floatTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Val2", "ltefield", c)

	err3 = validate.FieldWithValue(float32(5), float32(1), "ltefield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(float32(1), float32(5), "ltefield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "ltefield")

	c.Assert(func() { validate.FieldWithValue(nil, 5, "ltefield") }, PanicMatches, "struct not passed for cross validation")
	c.Assert(func() { validate.FieldWithValue(1, "T", "ltefield") }, PanicMatches, "Bad field type string")
	c.Assert(func() { validate.FieldWithValue(1, end, "ltefield") }, PanicMatches, "Bad Top Level field type")

	type TimeTest2 struct {
		Start *time.Time `validate:"required"`
		End   *time.Time `validate:"required,ltefield=NonExistantField"`
	}

	timeTest2 := &TimeTest2{
		Start: &end,
		End:   &start,
	}

	c.Assert(func() { validate.Struct(timeTest2) }, PanicMatches, "Field \"NonExistantField\" not found in struct")
}

func (ms *MySuite) TestGteField(c *C) {

	type TimeTest struct {
		Start *time.Time `validate:"required,gte"`
		End   *time.Time `validate:"required,gte,gtefield=Start"`
	}

	now := time.Now()
	start := now.Add(time.Hour * 24)
	end := start.Add(time.Hour * 24)

	timeTest := &TimeTest{
		Start: &start,
		End:   &end,
	}

	errs := validate.Struct(timeTest)
	c.Assert(errs, IsNil)

	timeTest = &TimeTest{
		Start: &end,
		End:   &start,
	}

	errs2 := validate.Struct(timeTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "End", "gtefield", c)

	err3 := validate.FieldWithValue(&start, &end, "gtefield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(&end, &start, "gtefield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "gtefield")

	type IntTest struct {
		Val1 int `validate:"required"`
		Val2 int `validate:"required,gtefield=Val1"`
	}

	intTest := &IntTest{
		Val1: 1,
		Val2: 5,
	}

	errs = validate.Struct(intTest)
	c.Assert(errs, IsNil)

	intTest = &IntTest{
		Val1: 5,
		Val2: 1,
	}

	errs2 = validate.Struct(intTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Val2", "gtefield", c)

	err3 = validate.FieldWithValue(int(1), int(5), "gtefield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(int(5), int(1), "gtefield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "gtefield")

	type UIntTest struct {
		Val1 uint `validate:"required"`
		Val2 uint `validate:"required,gtefield=Val1"`
	}

	uIntTest := &UIntTest{
		Val1: 1,
		Val2: 5,
	}

	errs = validate.Struct(uIntTest)
	c.Assert(errs, IsNil)

	uIntTest = &UIntTest{
		Val1: 5,
		Val2: 1,
	}

	errs2 = validate.Struct(uIntTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Val2", "gtefield", c)

	err3 = validate.FieldWithValue(uint(1), uint(5), "gtefield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(uint(5), uint(1), "gtefield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "gtefield")

	type FloatTest struct {
		Val1 float64 `validate:"required"`
		Val2 float64 `validate:"required,gtefield=Val1"`
	}

	floatTest := &FloatTest{
		Val1: 1,
		Val2: 5,
	}

	errs = validate.Struct(floatTest)
	c.Assert(errs, IsNil)

	floatTest = &FloatTest{
		Val1: 5,
		Val2: 1,
	}

	errs2 = validate.Struct(floatTest).Flatten()
	c.Assert(errs2, NotNil)
	AssertMapFieldError(errs2, "Val2", "gtefield", c)

	err3 = validate.FieldWithValue(float32(1), float32(5), "gtefield")
	c.Assert(err3, IsNil)

	err3 = validate.FieldWithValue(float32(5), float32(1), "gtefield")
	c.Assert(err3, NotNil)
	c.Assert(err3.Tag, Equals, "gtefield")

	c.Assert(func() { validate.FieldWithValue(nil, 1, "gtefield") }, PanicMatches, "struct not passed for cross validation")
	c.Assert(func() { validate.FieldWithValue(5, "T", "gtefield") }, PanicMatches, "Bad field type string")
	c.Assert(func() { validate.FieldWithValue(5, start, "gtefield") }, PanicMatches, "Bad Top Level field type")

	type TimeTest2 struct {
		Start *time.Time `validate:"required"`
		End   *time.Time `validate:"required,gtefield=NonExistantField"`
	}

	timeTest2 := &TimeTest2{
		Start: &start,
		End:   &end,
	}

	c.Assert(func() { validate.Struct(timeTest2) }, PanicMatches, "Field \"NonExistantField\" not found in struct")
}

func (ms *MySuite) TestValidateByTagAndValue(c *C) {

	val := "test"
	field := "test"
	err := validate.FieldWithValue(val, field, "required")
	c.Assert(err, IsNil)

	validate.AddFunction("isequaltestfunc", isEqualFunc)

	err = validate.FieldWithValue(val, field, "isequaltestfunc")
	c.Assert(err, IsNil)

	val = "unequal"

	err = validate.FieldWithValue(val, field, "isequaltestfunc")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "isequaltestfunc")
}

func (ms *MySuite) TestAddFunctions(c *C) {

	validate := validator.New("validateme", validator.BakedInValidators)

	err := validate.AddFunction("new", newValidatorFunc)
	c.Assert(err, IsNil)

	err = validate.AddFunction("", newValidatorFunc)
	c.Assert(err, NotNil)

	validate.AddFunction("new", nil)
	c.Assert(err, NotNil)

	err = validate.AddFunction("new", newValidatorFunc)
	c.Assert(err, IsNil)
}

func (ms *MySuite) TestChangeTag(c *C) {

	validate := validator.New("validateme", validator.BakedInValidators)
	validate.SetTag("val")

	type Test struct {
		Name string `val:"len=4"`
	}
	s := &Test{
		Name: "TEST",
	}

	err := validate.Struct(s)
	c.Assert(err, IsNil)

	// validator.SetTag("v")
	// validator.SetTag("validate")
}

func (ms *MySuite) TestUnexposedStruct(c *C) {

	type Test struct {
		Name      string
		unexposed struct {
			A string `validate:"required"`
		}
	}

	s := &Test{
		Name: "TEST",
	}

	err := validate.Struct(s)
	c.Assert(err, IsNil)
}

func (ms *MySuite) TestBadParams(c *C) {

	i := 1
	err := validate.Field(i, "-")
	c.Assert(err, IsNil)

	c.Assert(func() { validate.Field(i, "len=a") }, PanicMatches, "strconv.ParseInt: parsing \"a\": invalid syntax")
	c.Assert(func() { validate.Field(i, "len=a") }, PanicMatches, "strconv.ParseInt: parsing \"a\": invalid syntax")

	var ui uint = 1
	c.Assert(func() { validate.Field(ui, "len=a") }, PanicMatches, "strconv.ParseUint: parsing \"a\": invalid syntax")

	f := 1.23
	c.Assert(func() { validate.Field(f, "len=a") }, PanicMatches, "strconv.ParseFloat: parsing \"a\": invalid syntax")
}

func (ms *MySuite) TestLength(c *C) {

	i := true
	c.Assert(func() { validate.Field(i, "len") }, PanicMatches, "Bad field type bool")
}

func (ms *MySuite) TestIsGt(c *C) {

	myMap := map[string]string{}
	err := validate.Field(myMap, "gt=0")
	c.Assert(err, NotNil)

	f := 1.23
	err = validate.Field(f, "gt=5")
	c.Assert(err, NotNil)

	var ui uint = 5
	err = validate.Field(ui, "gt=10")
	c.Assert(err, NotNil)

	i := true
	c.Assert(func() { validate.Field(i, "gt") }, PanicMatches, "Bad field type bool")

	t := time.Now().UTC()
	t = t.Add(time.Hour * 24)

	err = validate.Field(t, "gt")
	c.Assert(err, IsNil)

	t2 := time.Now().UTC()

	err = validate.Field(t2, "gt")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "gt")

	type Test struct {
		Now *time.Time `validate:"gt"`
	}
	s := &Test{
		Now: &t,
	}

	errs := validate.Struct(s)
	c.Assert(errs, IsNil)

	s = &Test{
		Now: &t2,
	}

	errs = validate.Struct(s)
	c.Assert(errs, NotNil)
}

func (ms *MySuite) TestIsGte(c *C) {

	i := true
	c.Assert(func() { validate.Field(i, "gte") }, PanicMatches, "Bad field type bool")

	t := time.Now().UTC()
	t = t.Add(time.Hour * 24)

	err := validate.Field(t, "gte")
	c.Assert(err, IsNil)

	t2 := time.Now().UTC()

	err = validate.Field(t2, "gte")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "gte")
	c.Assert(err.Type, Equals, reflect.TypeOf(time.Time{}))

	type Test struct {
		Now *time.Time `validate:"gte"`
	}
	s := &Test{
		Now: &t,
	}

	errs := validate.Struct(s)
	c.Assert(errs, IsNil)

	s = &Test{
		Now: &t2,
	}

	errs = validate.Struct(s)
	c.Assert(errs, NotNil)
}

func (ms *MySuite) TestIsLt(c *C) {

	myMap := map[string]string{}
	err := validate.Field(myMap, "lt=0")
	c.Assert(err, NotNil)

	f := 1.23
	err = validate.Field(f, "lt=0")
	c.Assert(err, NotNil)

	var ui uint = 5
	err = validate.Field(ui, "lt=0")
	c.Assert(err, NotNil)

	i := true
	c.Assert(func() { validate.Field(i, "lt") }, PanicMatches, "Bad field type bool")

	t := time.Now().UTC()

	err = validate.Field(t, "lt")
	c.Assert(err, IsNil)

	t2 := time.Now().UTC()
	t2 = t2.Add(time.Hour * 24)

	err = validate.Field(t2, "lt")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "lt")

	type Test struct {
		Now *time.Time `validate:"lt"`
	}

	s := &Test{
		Now: &t,
	}

	errs := validate.Struct(s)
	c.Assert(errs, IsNil)

	s = &Test{
		Now: &t2,
	}

	errs = validate.Struct(s)
	c.Assert(errs, NotNil)
}

func (ms *MySuite) TestIsLte(c *C) {

	i := true
	c.Assert(func() { validate.Field(i, "lte") }, PanicMatches, "Bad field type bool")

	t := time.Now().UTC()

	err := validate.Field(t, "lte")
	c.Assert(err, IsNil)

	t2 := time.Now().UTC()
	t2 = t2.Add(time.Hour * 24)

	err = validate.Field(t2, "lte")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "lte")

	type Test struct {
		Now *time.Time `validate:"lte"`
	}

	s := &Test{
		Now: &t,
	}

	errs := validate.Struct(s)
	c.Assert(errs, IsNil)

	s = &Test{
		Now: &t2,
	}

	errs = validate.Struct(s)
	c.Assert(errs, NotNil)
}

func (ms *MySuite) TestUrl(c *C) {

	var tests = []struct {
		param    string
		expected bool
	}{
		{"http://foo.bar#com", true},
		{"http://foobar.com", true},
		{"https://foobar.com", true},
		{"foobar.com", false},
		{"http://foobar.coffee/", true},
		{"http://foobar.中文网/", true},
		{"http://foobar.org/", true},
		{"http://foobar.org:8080/", true},
		{"ftp://foobar.ru/", true},
		{"http://user:pass@www.foobar.com/", true},
		{"http://127.0.0.1/", true},
		{"http://duckduckgo.com/?q=%2F", true},
		{"http://localhost:3000/", true},
		{"http://foobar.com/?foo=bar#baz=qux", true},
		{"http://foobar.com?foo=bar", true},
		{"http://www.xn--froschgrn-x9a.net/", true},
		{"", false},
		{"xyz://foobar.com", true},
		{"invalid.", false},
		{".com", false},
		{"rtmp://foobar.com", true},
		{"http://www.foo_bar.com/", true},
		{"http://localhost:3000/", true},
		{"http://foobar.com#baz=qux", true},
		{"http://foobar.com/t$-_.+!*\\'(),", true},
		{"http://www.foobar.com/~foobar", true},
		{"http://www.-foobar.com/", true},
		{"http://www.foo---bar.com/", true},
		{"mailto:someone@example.com", true},
		{"irc://irc.server.org/channel", true},
		{"irc://#channel@network", true},
		{"/abs/test/dir", false},
		{"./rel/test/dir", false},
	}
	for _, test := range tests {

		err := validate.Field(test.param, "url")

		if test.expected == true {
			c.Assert(err, IsNil)
		} else {
			c.Assert(err, NotNil)
			c.Assert(err.Tag, Equals, "url")
		}
	}

	i := 1
	c.Assert(func() { validate.Field(i, "url") }, PanicMatches, "Bad field type int")
}

func (ms *MySuite) TestUri(c *C) {

	var tests = []struct {
		param    string
		expected bool
	}{
		{"http://foo.bar#com", true},
		{"http://foobar.com", true},
		{"https://foobar.com", true},
		{"foobar.com", false},
		{"http://foobar.coffee/", true},
		{"http://foobar.中文网/", true},
		{"http://foobar.org/", true},
		{"http://foobar.org:8080/", true},
		{"ftp://foobar.ru/", true},
		{"http://user:pass@www.foobar.com/", true},
		{"http://127.0.0.1/", true},
		{"http://duckduckgo.com/?q=%2F", true},
		{"http://localhost:3000/", true},
		{"http://foobar.com/?foo=bar#baz=qux", true},
		{"http://foobar.com?foo=bar", true},
		{"http://www.xn--froschgrn-x9a.net/", true},
		{"", false},
		{"xyz://foobar.com", true},
		{"invalid.", false},
		{".com", false},
		{"rtmp://foobar.com", true},
		{"http://www.foo_bar.com/", true},
		{"http://localhost:3000/", true},
		{"http://foobar.com#baz=qux", true},
		{"http://foobar.com/t$-_.+!*\\'(),", true},
		{"http://www.foobar.com/~foobar", true},
		{"http://www.-foobar.com/", true},
		{"http://www.foo---bar.com/", true},
		{"mailto:someone@example.com", true},
		{"irc://irc.server.org/channel", true},
		{"irc://#channel@network", true},
		{"/abs/test/dir", true},
		{"./rel/test/dir", false},
	}
	for _, test := range tests {

		err := validate.Field(test.param, "uri")

		if test.expected == true {
			c.Assert(err, IsNil)
		} else {
			c.Assert(err, NotNil)
			c.Assert(err.Tag, Equals, "uri")
		}
	}

	i := 1
	c.Assert(func() { validate.Field(i, "uri") }, PanicMatches, "Bad field type int")
}

func (ms *MySuite) TestOrTag(c *C) {
	s := "rgba(0,31,255,0.5)"
	err := validate.Field(s, "rgb|rgba")
	c.Assert(err, IsNil)

	s = "rgba(0,31,255,0.5)"
	err = validate.Field(s, "rgb|rgba|len=18")
	c.Assert(err, IsNil)

	s = "this ain't right"
	err = validate.Field(s, "rgb|rgba")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "rgb|rgba")

	s = "this ain't right"
	err = validate.Field(s, "rgb|rgba|len=10")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "rgb|rgba|len")

	s = "this is right"
	err = validate.Field(s, "rgb|rgba|len=13")
	c.Assert(err, IsNil)

	s = ""
	err = validate.Field(s, "omitempty,rgb|rgba")
	c.Assert(err, IsNil)
}

func (ms *MySuite) TestHsla(c *C) {

	s := "hsla(360,100%,100%,1)"
	err := validate.Field(s, "hsla")
	c.Assert(err, IsNil)

	s = "hsla(360,100%,100%,0.5)"
	err = validate.Field(s, "hsla")
	c.Assert(err, IsNil)

	s = "hsla(0,0%,0%, 0)"
	err = validate.Field(s, "hsla")
	c.Assert(err, IsNil)

	s = "hsl(361,100%,50%,1)"
	err = validate.Field(s, "hsla")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "hsla")

	s = "hsl(361,100%,50%)"
	err = validate.Field(s, "hsla")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "hsla")

	s = "hsla(361,100%,50%)"
	err = validate.Field(s, "hsla")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "hsla")

	s = "hsla(360,101%,50%)"
	err = validate.Field(s, "hsla")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "hsla")

	s = "hsla(360,100%,101%)"
	err = validate.Field(s, "hsla")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "hsla")

	i := 1
	c.Assert(func() { validate.Field(i, "hsla") }, PanicMatches, "interface conversion: interface is int, not string")
}

func (ms *MySuite) TestHsl(c *C) {

	s := "hsl(360,100%,50%)"
	err := validate.Field(s, "hsl")
	c.Assert(err, IsNil)

	s = "hsl(0,0%,0%)"
	err = validate.Field(s, "hsl")
	c.Assert(err, IsNil)

	s = "hsl(361,100%,50%)"
	err = validate.Field(s, "hsl")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "hsl")

	s = "hsl(361,101%,50%)"
	err = validate.Field(s, "hsl")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "hsl")

	s = "hsl(361,100%,101%)"
	err = validate.Field(s, "hsl")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "hsl")

	s = "hsl(-10,100%,100%)"
	err = validate.Field(s, "hsl")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "hsl")

	i := 1
	c.Assert(func() { validate.Field(i, "hsl") }, PanicMatches, "interface conversion: interface is int, not string")
}

func (ms *MySuite) TestRgba(c *C) {

	s := "rgba(0,31,255,0.5)"
	err := validate.Field(s, "rgba")
	c.Assert(err, IsNil)

	s = "rgba(0,31,255,0.12)"
	err = validate.Field(s, "rgba")
	c.Assert(err, IsNil)

	s = "rgba( 0,  31, 255, 0.5)"
	err = validate.Field(s, "rgba")
	c.Assert(err, IsNil)

	s = "rgb(0,  31, 255)"
	err = validate.Field(s, "rgba")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "rgba")

	s = "rgb(1,349,275,0.5)"
	err = validate.Field(s, "rgba")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "rgba")

	s = "rgb(01,31,255,0.5)"
	err = validate.Field(s, "rgba")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "rgba")

	i := 1
	c.Assert(func() { validate.Field(i, "rgba") }, PanicMatches, "interface conversion: interface is int, not string")
}

func (ms *MySuite) TestRgb(c *C) {

	s := "rgb(0,31,255)"
	err := validate.Field(s, "rgb")
	c.Assert(err, IsNil)

	s = "rgb(0,  31, 255)"
	err = validate.Field(s, "rgb")
	c.Assert(err, IsNil)

	s = "rgb(1,349,275)"
	err = validate.Field(s, "rgb")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "rgb")

	s = "rgb(01,31,255)"
	err = validate.Field(s, "rgb")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "rgb")

	s = "rgba(0,31,255)"
	err = validate.Field(s, "rgb")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "rgb")

	i := 1
	c.Assert(func() { validate.Field(i, "rgb") }, PanicMatches, "interface conversion: interface is int, not string")
}

func (ms *MySuite) TestEmail(c *C) {

	s := "test@mail.com"
	err := validate.Field(s, "email")
	c.Assert(err, IsNil)

	s = ""
	err = validate.Field(s, "email")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "email")

	s = "test@email"
	err = validate.Field(s, "email")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "email")

	s = "test@email."
	err = validate.Field(s, "email")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "email")

	s = "@email.com"
	err = validate.Field(s, "email")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "email")

	i := true
	c.Assert(func() { validate.Field(i, "email") }, PanicMatches, "interface conversion: interface is bool, not string")
}

func (ms *MySuite) TestHexColor(c *C) {

	s := "#fff"
	err := validate.Field(s, "hexcolor")
	c.Assert(err, IsNil)

	s = "#c2c2c2"
	err = validate.Field(s, "hexcolor")
	c.Assert(err, IsNil)

	s = "fff"
	err = validate.Field(s, "hexcolor")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "hexcolor")

	s = "fffFF"
	err = validate.Field(s, "hexcolor")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "hexcolor")

	i := true
	c.Assert(func() { validate.Field(i, "hexcolor") }, PanicMatches, "interface conversion: interface is bool, not string")
}

func (ms *MySuite) TestHexadecimal(c *C) {

	s := "ff0044"
	err := validate.Field(s, "hexadecimal")
	c.Assert(err, IsNil)

	s = "abcdefg"
	err = validate.Field(s, "hexadecimal")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "hexadecimal")

	i := true
	c.Assert(func() { validate.Field(i, "hexadecimal") }, PanicMatches, "interface conversion: interface is bool, not string")
}

func (ms *MySuite) TestNumber(c *C) {

	s := "1"
	err := validate.Field(s, "number")
	c.Assert(err, IsNil)

	s = "+1"
	err = validate.Field(s, "number")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "number")

	s = "-1"
	err = validate.Field(s, "number")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "number")

	s = "1.12"
	err = validate.Field(s, "number")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "number")

	s = "+1.12"
	err = validate.Field(s, "number")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "number")

	s = "-1.12"
	err = validate.Field(s, "number")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "number")

	s = "1."
	err = validate.Field(s, "number")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "number")

	s = "1.o"
	err = validate.Field(s, "number")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "number")

	i := 1
	c.Assert(func() { validate.Field(i, "number") }, PanicMatches, "interface conversion: interface is int, not string")
}

func (ms *MySuite) TestNumeric(c *C) {

	s := "1"
	err := validate.Field(s, "numeric")
	c.Assert(err, IsNil)

	s = "+1"
	err = validate.Field(s, "numeric")
	c.Assert(err, IsNil)

	s = "-1"
	err = validate.Field(s, "numeric")
	c.Assert(err, IsNil)

	s = "1.12"
	err = validate.Field(s, "numeric")
	c.Assert(err, IsNil)

	s = "+1.12"
	err = validate.Field(s, "numeric")
	c.Assert(err, IsNil)

	s = "-1.12"
	err = validate.Field(s, "numeric")
	c.Assert(err, IsNil)

	s = "1."
	err = validate.Field(s, "numeric")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "numeric")

	s = "1.o"
	err = validate.Field(s, "numeric")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "numeric")

	i := 1
	c.Assert(func() { validate.Field(i, "numeric") }, PanicMatches, "interface conversion: interface is int, not string")
}

func (ms *MySuite) TestAlphaNumeric(c *C) {

	s := "abcd123"
	err := validate.Field(s, "alphanum")
	c.Assert(err, IsNil)

	s = "abc!23"
	err = validate.Field(s, "alphanum")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "alphanum")

	c.Assert(func() { validate.Field(1, "alphanum") }, PanicMatches, "interface conversion: interface is int, not string")
}

func (ms *MySuite) TestAlpha(c *C) {

	s := "abcd"
	err := validate.Field(s, "alpha")
	c.Assert(err, IsNil)

	s = "abc1"
	err = validate.Field(s, "alpha")
	c.Assert(err, NotNil)
	c.Assert(err.Tag, Equals, "alpha")

	c.Assert(func() { validate.Field(1, "alpha") }, PanicMatches, "interface conversion: interface is int, not string")
}

func (ms *MySuite) TestFlattening(c *C) {

	tSuccess := &TestString{
		Required:  "Required",
		Len:       "length==10",
		Min:       "min=1",
		Max:       "1234567890",
		MinMax:    "12345",
		Lt:        "012345678",
		Lte:       "0123456789",
		Gt:        "01234567890",
		Gte:       "0123456789",
		OmitEmpty: "",
		Sub: &SubTest{
			Test: "1",
		},
		SubIgnore: &SubTest{
			Test: "",
		},
		Anonymous: struct {
			A string `validate:"required"`
		}{
			A: "1",
		},
		Iface: &Impl{
			F: "123",
		},
	}

	err1 := validate.Struct(tSuccess).Flatten()
	c.Assert(err1, IsNil)

	tFail := &TestString{
		Required:  "",
		Len:       "",
		Min:       "",
		Max:       "12345678901",
		MinMax:    "",
		OmitEmpty: "12345678901",
		Sub: &SubTest{
			Test: "",
		},
		Anonymous: struct {
			A string `validate:"required"`
		}{
			A: "",
		},
		Iface: &Impl{
			F: "12",
		},
	}

	err2 := validate.Struct(tFail).Flatten()

	// Assert Top Level
	c.Assert(err2, NotNil)

	// Assert Fields
	AssertMapFieldError(err2, "Len", "len", c)
	AssertMapFieldError(err2, "Gt", "gt", c)
	AssertMapFieldError(err2, "Gte", "gte", c)

	// Assert Struct Field
	AssertMapFieldError(err2, "Sub.Test", "required", c)

	// Assert Anonymous Struct Field
	AssertMapFieldError(err2, "Anonymous.A", "required", c)

	// Assert Interface Field
	AssertMapFieldError(err2, "Iface.F", "len", c)
}

func (ms *MySuite) TestStructStringValidation(c *C) {

	tSuccess := &TestString{
		Required:  "Required",
		Len:       "length==10",
		Min:       "min=1",
		Max:       "1234567890",
		MinMax:    "12345",
		Lt:        "012345678",
		Lte:       "0123456789",
		Gt:        "01234567890",
		Gte:       "0123456789",
		OmitEmpty: "",
		Sub: &SubTest{
			Test: "1",
		},
		SubIgnore: &SubTest{
			Test: "",
		},
		Anonymous: struct {
			A string `validate:"required"`
		}{
			A: "1",
		},
		Iface: &Impl{
			F: "123",
		},
	}

	err := validate.Struct(tSuccess)
	c.Assert(err, IsNil)

	tFail := &TestString{
		Required:  "",
		Len:       "",
		Min:       "",
		Max:       "12345678901",
		MinMax:    "",
		Lt:        "0123456789",
		Lte:       "01234567890",
		Gt:        "1",
		Gte:       "1",
		OmitEmpty: "12345678901",
		Sub: &SubTest{
			Test: "",
		},
		Anonymous: struct {
			A string `validate:"required"`
		}{
			A: "",
		},
		Iface: &Impl{
			F: "12",
		},
	}

	err = validate.Struct(tFail)

	// Assert Top Level
	c.Assert(err, NotNil)
	c.Assert(err.Struct, Equals, "TestString")
	c.Assert(len(err.Errors), Equals, 10)
	c.Assert(len(err.StructErrors), Equals, 3)

	// Assert Fields
	AssertFieldError(err, "Required", "required", c)
	AssertFieldError(err, "Len", "len", c)
	AssertFieldError(err, "Min", "min", c)
	AssertFieldError(err, "Max", "max", c)
	AssertFieldError(err, "MinMax", "min", c)
	AssertFieldError(err, "Gt", "gt", c)
	AssertFieldError(err, "Gte", "gte", c)
	AssertFieldError(err, "OmitEmpty", "max", c)

	// Assert Anonymous embedded struct
	AssetStruct(err, "Anonymous", "", c)

	// Assert SubTest embedded struct
	val := AssetStruct(err, "Sub", "SubTest", c)
	c.Assert(len(val.Errors), Equals, 1)
	c.Assert(len(val.StructErrors), Equals, 0)

	AssertFieldError(val, "Test", "required", c)

	errors := err.Error()
	c.Assert(errors, NotNil)
}

func (ms *MySuite) TestStructInt32Validation(c *C) {

	tSuccess := &TestInt32{
		Required:  1,
		Len:       10,
		Min:       1,
		Max:       10,
		MinMax:    5,
		Lt:        9,
		Lte:       10,
		Gt:        11,
		Gte:       10,
		OmitEmpty: 0,
	}

	err := validate.Struct(tSuccess)
	c.Assert(err, IsNil)

	tFail := &TestInt32{
		Required:  0,
		Len:       11,
		Min:       -1,
		Max:       11,
		MinMax:    -1,
		Lt:        10,
		Lte:       11,
		Gt:        10,
		Gte:       9,
		OmitEmpty: 11,
	}

	err = validate.Struct(tFail)

	// Assert Top Level
	c.Assert(err, NotNil)
	c.Assert(err.Struct, Equals, "TestInt32")
	c.Assert(len(err.Errors), Equals, 10)
	c.Assert(len(err.StructErrors), Equals, 0)

	// Assert Fields
	AssertFieldError(err, "Required", "required", c)
	AssertFieldError(err, "Len", "len", c)
	AssertFieldError(err, "Min", "min", c)
	AssertFieldError(err, "Max", "max", c)
	AssertFieldError(err, "MinMax", "min", c)
	AssertFieldError(err, "Lt", "lt", c)
	AssertFieldError(err, "Lte", "lte", c)
	AssertFieldError(err, "Gt", "gt", c)
	AssertFieldError(err, "Gte", "gte", c)
	AssertFieldError(err, "OmitEmpty", "max", c)
}

func (ms *MySuite) TestStructUint64Validation(c *C) {

	tSuccess := &TestUint64{
		Required:  1,
		Len:       10,
		Min:       1,
		Max:       10,
		MinMax:    5,
		OmitEmpty: 0,
	}

	err := validate.Struct(tSuccess)
	c.Assert(err, IsNil)

	tFail := &TestUint64{
		Required:  0,
		Len:       11,
		Min:       0,
		Max:       11,
		MinMax:    0,
		OmitEmpty: 11,
	}

	err = validate.Struct(tFail)

	// Assert Top Level
	c.Assert(err, NotNil)
	c.Assert(err.Struct, Equals, "TestUint64")
	c.Assert(len(err.Errors), Equals, 6)
	c.Assert(len(err.StructErrors), Equals, 0)

	// Assert Fields
	AssertFieldError(err, "Required", "required", c)
	AssertFieldError(err, "Len", "len", c)
	AssertFieldError(err, "Min", "min", c)
	AssertFieldError(err, "Max", "max", c)
	AssertFieldError(err, "MinMax", "min", c)
	AssertFieldError(err, "OmitEmpty", "max", c)
}

func (ms *MySuite) TestStructFloat64Validation(c *C) {

	tSuccess := &TestFloat64{
		Required:  1,
		Len:       10,
		Min:       1,
		Max:       10,
		MinMax:    5,
		OmitEmpty: 0,
	}

	err := validate.Struct(tSuccess)
	c.Assert(err, IsNil)

	tFail := &TestFloat64{
		Required:  0,
		Len:       11,
		Min:       0,
		Max:       11,
		MinMax:    0,
		OmitEmpty: 11,
	}

	err = validate.Struct(tFail)

	// Assert Top Level
	c.Assert(err, NotNil)
	c.Assert(err.Struct, Equals, "TestFloat64")
	c.Assert(len(err.Errors), Equals, 6)
	c.Assert(len(err.StructErrors), Equals, 0)

	// Assert Fields
	AssertFieldError(err, "Required", "required", c)
	AssertFieldError(err, "Len", "len", c)
	AssertFieldError(err, "Min", "min", c)
	AssertFieldError(err, "Max", "max", c)
	AssertFieldError(err, "MinMax", "min", c)
	AssertFieldError(err, "OmitEmpty", "max", c)
}

func (ms *MySuite) TestStructSliceValidation(c *C) {

	tSuccess := &TestSlice{
		Required:  []int{1},
		Len:       []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
		Min:       []int{1, 2},
		Max:       []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
		MinMax:    []int{1, 2, 3, 4, 5},
		OmitEmpty: []int{},
	}

	err := validate.Struct(tSuccess)
	c.Assert(err, IsNil)

	tFail := &TestSlice{
		Required:  []int{},
		Len:       []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
		Min:       []int{},
		Max:       []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
		MinMax:    []int{},
		OmitEmpty: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
	}

	err = validate.Struct(tFail)

	// Assert Top Level
	c.Assert(err, NotNil)
	c.Assert(err.Struct, Equals, "TestSlice")
	c.Assert(len(err.Errors), Equals, 6)
	c.Assert(len(err.StructErrors), Equals, 0)

	// Assert Fields
	AssertFieldError(err, "Required", "required", c)
	AssertFieldError(err, "Len", "len", c)
	AssertFieldError(err, "Min", "min", c)
	AssertFieldError(err, "Max", "max", c)
	AssertFieldError(err, "MinMax", "min", c)
	AssertFieldError(err, "OmitEmpty", "max", c)
}

func (ms *MySuite) TestInvalidStruct(c *C) {
	s := &SubTest{
		Test: "1",
	}

	c.Assert(func() { validate.Struct(s.Test) }, PanicMatches, "interface passed for validation is not a struct")
}

func (ms *MySuite) TestInvalidField(c *C) {
	s := &SubTest{
		Test: "1",
	}

	c.Assert(func() { validate.Field(s, "required") }, PanicMatches, "Invalid field passed to ValidateFieldWithTag")
}

func (ms *MySuite) TestInvalidTagField(c *C) {
	s := &SubTest{
		Test: "1",
	}

	c.Assert(func() { validate.Field(s.Test, "") }, PanicMatches, fmt.Sprintf("Invalid validation tag on field %s", ""))
}

func (ms *MySuite) TestInvalidValidatorFunction(c *C) {
	s := &SubTest{
		Test: "1",
	}

	c.Assert(func() { validate.Field(s.Test, "zzxxBadFunction") }, PanicMatches, fmt.Sprintf("Undefined validation function on field %s", ""))
}