Add lte and gte

rules.go

@@ -90,6 +90,28 @@ var funcs = map[string]listFuncInfo{
 	}},
 
 	// Integers
+	`gte`: {InputSame, Kinds{
+		reflect.Int: func(rv reflect.Value, val interface{}) bool {
+			return rv.Int() >= val.(int64)
+		},
+		reflect.Uint: func(rv reflect.Value, val interface{}) bool {
+			return rv.Uint() >= val.(uint64)
+		},
+		reflect.Float64: func(rv reflect.Value, val interface{}) bool {
+			return rv.Float() >= val.(float64)
+		},
+	}},
+	`lte`: {InputSame, Kinds{
+		reflect.Int: func(rv reflect.Value, val interface{}) bool {
+			return rv.Int() <= val.(int64)
+		},
+		reflect.Uint: func(rv reflect.Value, val interface{}) bool {
+			return rv.Uint() <= val.(uint64)
+		},
+		reflect.Float64: func(rv reflect.Value, val interface{}) bool {
+			return rv.Float() <= val.(float64)
+		},
+	}},
 	`gt`: {InputSame, Kinds{
 		reflect.Int: func(rv reflect.Value, val interface{}) bool {
 			return rv.Int() > val.(int64)

rules_test.go

@@ -16,9 +16,9 @@ func TestAddRule(t *testing.T) {
 		},
 	})
 
-	var pass = s{`custom`}
+	pass := s{`custom`}
 
-	var fail = s{`somethingelse`}
+	fail := s{`somethingelse`}
 
 	check(t, pass, 0)
 	check(t, fail, 1)
@@ -38,9 +38,9 @@ func TestRuleRequired(t *testing.T) {
 	}
 
 	str := ``
-	var pass = s{&str, make([]int, 1), make([]int, 1), ` `, -1, 1, 0.01, ``, map[int]int{0: 1}}
+	pass := s{&str, make([]int, 1), make([]int, 1), ` `, -1, 1, 0.01, ``, map[int]int{0: 1}}
 
-	var fail = s{nil, nil, make([]int, 0), ``, 0, 0, 0.000, nil, nil}
+	fail := s{nil, nil, make([]int, 0), ``, 0, 0, 0.000, nil, nil}
 
 	check(t, pass, 0)
 	check(t, fail, 9)
@@ -52,9 +52,9 @@ func TestRulePrefixSuffix(t *testing.T) {
 		B string `validate:"suffix=@"`
 	}
 
-	var pass = s{`#a`, `a@`}
+	pass := s{`#a`, `a@`}
 
-	var fail = s{`a#`, `@a`}
+	fail := s{`a#`, `@a`}
 
 	check(t, pass, 0)
 	check(t, fail, 2)
@@ -65,12 +65,12 @@ func TestRuleContains(t *testing.T) {
 		A string `validate:"contains=%"`
 	}
 
-	var pass1 = s{`a%`}
-	var pass2 = s{`%a`}
-	var pass3 = s{`%`}
-	var pass4 = s{`a%a`}
+	pass1 := s{`a%`}
+	pass2 := s{`%a`}
+	pass3 := s{`%`}
+	pass4 := s{`a%a`}
 
-	var fail = s{`aa`}
+	fail := s{`aa`}
 
 	check(t, pass1, 0)
 	check(t, pass2, 0)
@@ -84,11 +84,11 @@ func TestRuleRegexp(t *testing.T) {
 		A string `validate:"regexp=^[0-9]$"`
 	}
 
-	var pass1 = s{`0`}
-	var pass2 = s{`7`}
+	pass1 := s{`0`}
+	pass2 := s{`7`}
 
-	var fail1 = s{`A`}
-	var fail2 = s{`11`}
+	fail1 := s{`A`}
+	fail2 := s{`11`}
 
 	check(t, pass1, 0)
 	check(t, pass2, 0)
@@ -103,16 +103,46 @@ func TestRuleEqGtLt(t *testing.T) {
 		C uint    `validate:"lt=1"`
 	}
 
-	var pass = s{3, 100001, 0}
+	pass := s{3, 100001, 0}
 
-	var fail1 = s{2, 1e5, 1}
-	var fail2 = s{4, 9999, 2}
+	fail1 := s{2, 1e5, 1}
+	fail2 := s{4, 9999, 2}
 
 	check(t, pass, 0)
 	check(t, fail1, 3)
 	check(t, fail2, 3)
 }
 
+func TestRuleGteLte(t *testing.T) {
+	type s struct {
+		U uint    `validate:"gte=0,lte=10"`
+		I int     `validate:"gte=-10,lte=0"`
+		F float64 `validate:"gte=0,lte=10"`
+	}
+
+	pass1 := s{0, -10, 0}
+	pass2 := s{10, 0, 10}
+
+	// Uint
+	fail1 := s{11, -10, 0}
+
+	// Int
+	fail2 := s{0, -11, 0}
+	fail3 := s{0, 1, 0}
+
+	// Float
+	fail4 := s{0, -10, -0.0001}
+	fail5 := s{0, -10, 10.0001}
+
+	check(t, pass1, 0)
+	check(t, pass2, 0)
+	check(t, fail1, 1)
+	check(t, fail2, 1)
+	check(t, fail3, 1)
+	check(t, fail4, 1)
+	check(t, fail5, 1)
+}
+
 func TestLenMinMax(t *testing.T) {
 	type s struct {
 		A string         `validate:"len=3"`
@@ -120,10 +150,10 @@ func TestLenMinMax(t *testing.T) {
 		C map[int]string `validate:"max=1"`
 	}
 
-	var pass = s{`abc`, []int{1, 2}, nil}
+	pass := s{`abc`, []int{1, 2}, nil}
 
-	var fail1 = s{`ab`, []int{1}, map[int]string{1: `a`, 2: `b`}}
-	var fail2 = s{`abcd`, nil, nil}
+	fail1 := s{`ab`, []int{1}, map[int]string{1: `a`, 2: `b`}}
+	fail2 := s{`abcd`, nil, nil}
 
 	check(t, pass, 0)
 	check(t, fail1, 3)