Allow multiple arguments in ne/ge/gt/le/lt functions

Treat op arg1 arg2 arg3 ... as (arg1 op arg2) && (arg1 op arg3)
and so on for ne/ge/gt/le/lt.

Closes #6619
This commit is contained in:
Tan Yuanhong 2020-01-19 20:52:06 +08:00 committed by Bjørn Erik Pedersen
parent 836c24261f
commit 0c251be66b
2 changed files with 172 additions and 24 deletions

View file

@ -135,33 +135,58 @@ func (n *Namespace) Eq(first interface{}, others ...interface{}) bool {
return false return false
} }
// Ne returns the boolean truth of arg1 != arg2. // Ne returns the boolean truth of arg1 != arg2 && arg1 != arg3 && arg1 != arg4.
func (n *Namespace) Ne(x, y interface{}) bool { func (n *Namespace) Ne(first interface{}, others ...interface{}) bool {
return !n.Eq(x, y) for _, other := range others {
if n.Eq(first, other) {
return false
}
}
return true
} }
// Ge returns the boolean truth of arg1 >= arg2. // Ge returns the boolean truth of arg1 >= arg2 && arg1 >= arg3 && arg1 >= arg4.
func (n *Namespace) Ge(a, b interface{}) bool { func (n *Namespace) Ge(first interface{}, others ...interface{}) bool {
left, right := n.compareGet(a, b) for _, other := range others {
return left >= right left, right := n.compareGet(first, other)
if !(left >= right) {
return false
}
}
return true
} }
// Gt returns the boolean truth of arg1 > arg2. // Gt returns the boolean truth of arg1 > arg2 && arg1 > arg3 && arg1 > arg4.
func (n *Namespace) Gt(a, b interface{}) bool { func (n *Namespace) Gt(first interface{}, others ...interface{}) bool {
left, right := n.compareGet(a, b) for _, other := range others {
return left > right left, right := n.compareGet(first, other)
if !(left > right) {
return false
}
}
return true
} }
// Le returns the boolean truth of arg1 <= arg2. // Le returns the boolean truth of arg1 <= arg2 && arg1 <= arg3 && arg1 <= arg4.
func (n *Namespace) Le(a, b interface{}) bool { func (n *Namespace) Le(first interface{}, others ...interface{}) bool {
left, right := n.compareGet(a, b) for _, other := range others {
return left <= right left, right := n.compareGet(first, other)
if !(left <= right) {
return false
}
}
return true
} }
// Lt returns the boolean truth of arg1 < arg2. // Lt returns the boolean truth of arg1 < arg2 && arg1 < arg3 && arg1 < arg4.
func (n *Namespace) Lt(a, b interface{}) bool { func (n *Namespace) Lt(first interface{}, others ...interface{}) bool {
left, right := n.compareGet(a, b) for _, other := range others {
return left < right left, right := n.compareGet(first, other)
if !(left < right) {
return false
}
}
return true
} }
// Conditional can be used as a ternary operator. // Conditional can be used as a ternary operator.

View file

@ -149,16 +149,36 @@ func TestCompare(t *testing.T) {
return n.Eq(a, b) return n.Eq(a, b)
} }
twoGt := func(a, b interface{}) bool {
return n.Gt(a, b)
}
twoLt := func(a, b interface{}) bool {
return n.Lt(a, b)
}
twoGe := func(a, b interface{}) bool {
return n.Ge(a, b)
}
twoLe := func(a, b interface{}) bool {
return n.Le(a, b)
}
twoNe := func(a, b interface{}) bool {
return n.Ne(a, b)
}
for _, test := range []struct { for _, test := range []struct {
tstCompareType tstCompareType
funcUnderTest func(a, b interface{}) bool funcUnderTest func(a, b interface{}) bool
}{ }{
{tstGt, n.Gt}, {tstGt, twoGt},
{tstLt, n.Lt}, {tstLt, twoLt},
{tstGe, n.Ge}, {tstGe, twoGe},
{tstLe, n.Le}, {tstLe, twoLe},
{tstEq, twoEq}, {tstEq, twoEq},
{tstNe, n.Ne}, {tstNe, twoNe},
} { } {
doTestCompare(t, test.tstCompareType, test.funcUnderTest) doTestCompare(t, test.tstCompareType, test.funcUnderTest)
} }
@ -263,6 +283,109 @@ func TestEqualExtend(t *testing.T) {
} }
} }
func TestNotEqualExtend(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(false)
for _, test := range []struct {
first interface{}
others []interface{}
expect bool
}{
{1, []interface{}{2, 3}, true},
{1, []interface{}{2, 1}, false},
{1, []interface{}{1, 2}, false},
} {
result := ns.Ne(test.first, test.others...)
c.Assert(result, qt.Equals, test.expect)
}
}
func TestGreaterEqualExtend(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(false)
for _, test := range []struct {
first interface{}
others []interface{}
expect bool
}{
{5, []interface{}{2, 3}, true},
{5, []interface{}{5, 5}, true},
{3, []interface{}{4, 2}, false},
{3, []interface{}{2, 4}, false},
} {
result := ns.Ge(test.first, test.others...)
c.Assert(result, qt.Equals, test.expect)
}
}
func TestGreaterThanExtend(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(false)
for _, test := range []struct {
first interface{}
others []interface{}
expect bool
}{
{5, []interface{}{2, 3}, true},
{5, []interface{}{5, 4}, false},
{3, []interface{}{4, 2}, false},
} {
result := ns.Gt(test.first, test.others...)
c.Assert(result, qt.Equals, test.expect)
}
}
func TestLessEqualExtend(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(false)
for _, test := range []struct {
first interface{}
others []interface{}
expect bool
}{
{1, []interface{}{2, 3}, true},
{1, []interface{}{1, 2}, true},
{2, []interface{}{1, 2}, false},
{3, []interface{}{2, 4}, false},
} {
result := ns.Le(test.first, test.others...)
c.Assert(result, qt.Equals, test.expect)
}
}
func TestLessThanExtend(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(false)
for _, test := range []struct {
first interface{}
others []interface{}
expect bool
}{
{1, []interface{}{2, 3}, true},
{1, []interface{}{1, 2}, false},
{2, []interface{}{1, 2}, false},
{3, []interface{}{2, 4}, false},
} {
result := ns.Lt(test.first, test.others...)
c.Assert(result, qt.Equals, test.expect)
}
}
func TestCase(t *testing.T) { func TestCase(t *testing.T) {
c := qt.New(t) c := qt.New(t)
n := New(true) n := New(true)