Support order assertions on sort.Interface types

[sjiekak]

Given the following type implementing the sort interface

type segment struct {
    left int
    right int
}

type segments []segment

func (l *segments) Len() int {
	return len([]segment(*l))
}

func (l *segments) Less(i, j int) bool {
	data := []segment(*l)
	return data[i].left < data[j].left  || (data[i].left == data[j].left && data[i].right < data[j].right)
}

func (l *segments) Swap(i, j int) {
	data := []segment(*l)
	data[i], data[j] = data[j], data[i]
}

I should be able to perform sort assertions

sample := segments([]segment{
{1, 2},
{3, 4},
})
assert.IsIncreasing(t, &sample)

[brackendawson]

How about:

assert.True(t, sort.IsSorted(&sample))

I think if we had something like assert.IsSorted() it should also work on types that don't implement sort.Interface, it could also check if slices of Strings, Ints and Float64s are sorted, as per the functions in the sort package?

[sjiekak]

Yes I am already using

assert.True(t, sort.IsSorted(&sample))

The goal of my request is precisely to use functions such as IsIncreasing and IsNonDecreasing such as :

• types which implement sort.Interface may succeed assertion
• other types (other than string, int, etc...) fail the assertion

[brackendawson]

Ah, apologies, I totally missed that IsIncreasing is already a function. Yes, it should be trivial to make these support collections implementing sort.Interface.