Add EqualLength, AtLeastLength

Author: earthboundkid

README.md

@@ -64,6 +64,18 @@ be.NotIn(t, "\x00", []byte("\a\b\x00\r\t")) // bad
 // t.Fatal("\x00" in "\a\b\x00\r\t")
 ```
 
+Check how long something rangeable is:
+
+```
+seq := strings.FieldsSeq("1 2 3 4")
+be.EqualLength(t, seq, 4)     // good
+be.EqualLength(t, seq, 1)     // bad
+be.AtLeastLength(t, seq, 1)   // good
+be.AtLeastLength(t, seq, 5)   // bad
+be.AtLeastLength(t, "123", 3) // good
+be.AtLeastLength(t, "123", 4) // bad
+```
+
 Test anything else:
 
 ```go

be_example_test.go

@@ -2,6 +2,7 @@ package be_test
 
 import (
 	"errors"
+	"strings"
 
 	"github.com/carlmjohnson/be"
 )
@@ -34,6 +35,14 @@ func Example() {
 	be.NotIn(t, "\x01", []byte("\a\b\x00\r\t")) // good
 	be.NotIn(t, "\x00", []byte("\a\b\x00\r\t")) // bad
 
+	seq := strings.FieldsSeq("1 2 3 4")
+	be.EqualLength(t, 4, seq)     // good
+	be.EqualLength(t, 1, seq)     // bad
+	be.AtLeastLength(t, 1, seq)   // good
+	be.AtLeastLength(t, 5, seq)   // bad
+	be.AtLeastLength(t, 3, "123") // good
+	be.AtLeastLength(t, 4, "123") // bad
+
 	// Output:
 	// want: hello; got: world
 	// got: goodbye
@@ -42,4 +51,7 @@ func Example() {
 	// got: (O_o)
 	// "World" not in "hello, world"
 	// "\x00" in "\a\b\x00\r\t"
+	// want len(seq) == 1; got at least 2
+	// want len(seq) >= 5; got 4
+	// want len(seq) >= 4; got 3
 }

be_test.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"maps"
 	"strings"
 	"testing"
 	"time"
@@ -43,6 +44,14 @@ func Test(t *testing.T) {
 	beOkay(func(tb testing.TB) { be.NilErr(tb, nil) })
 	beOkay(func(tb testing.TB) { be.True(tb, true) })
 	beOkay(func(tb testing.TB) { be.False(tb, false) })
+	beOkay(func(tb testing.TB) { be.EqualLength(tb, 0, map[int]int{}) })
+	beOkay(func(tb testing.TB) { be.EqualLength(tb, 1, map[int]int{1: 1}) })
+	ch := make(chan int, 1)
+	beOkay(func(tb testing.TB) { be.EqualLength(tb, 0, ch) })
+	ch <- 1
+	beOkay(func(tb testing.TB) { be.EqualLength(tb, 1, ch) })
+	seq2 := maps.All(map[int]int{1: 1})
+	beOkay(func(tb testing.TB) { be.EqualLength(tb, 1, seq2) })
 	beBad := func(callback func(tb testing.TB)) {
 		t.Helper()
 		var buf strings.Builder
@@ -62,4 +71,9 @@ func Test(t *testing.T) {
 	beBad(func(tb testing.TB) { be.NilErr(tb, errors.New("")) })
 	beBad(func(tb testing.TB) { be.True(tb, false) })
 	beBad(func(tb testing.TB) { be.False(tb, true) })
+	beBad(func(tb testing.TB) { be.EqualLength(tb, 1, ch) })
+	ch <- 1
+	beBad(func(tb testing.TB) { be.EqualLength(tb, 0, ch) })
+	close(ch)
+	beBad(func(tb testing.TB) { be.EqualLength(tb, 1, ch) })
 }

len.go

@@ -0,0 +1,95 @@
+package be
+
+import (
+	"iter"
+	"reflect"
+	"slices"
+	"testing"
+)
+
+// EqualLength calls t.Fatalf if seq has a length that is not exactly want.
+// The type of seq must be array, array pointer, slice, map, string, channel, [iter.Seq], or [iter.Seq2].
+// For channels and iterators, the values are consumed to get the sequence length.
+func EqualLength(t testing.TB, want int, seq any) {
+	t.Helper()
+	getLen(t, seq, want, false)
+}
+
+func getLen(t testing.TB, seq any, n int, atLeast bool) {
+	rv := reflect.ValueOf(seq)
+	rt := rv.Type()
+	kind := rt.Kind()
+	switch {
+	case slices.Contains([]reflect.Kind{
+		reflect.Array, reflect.Slice, reflect.Map, reflect.String,
+	}, kind) ||
+		(kind == reflect.Pointer && rt.Elem().Kind() == reflect.Array):
+		compareN(t, n, rv.Len(), atLeast)
+	case kind == reflect.Chan:
+		eqchan(t, rv, n, atLeast)
+	case kind == reflect.Func && rt.CanSeq():
+		eqseq(t, rv, n, atLeast)
+	case kind == reflect.Func && rt.CanSeq2():
+		eqseq2(t, rv, n, atLeast)
+	default:
+		panic("seq must be a non-integer rangeable type")
+	}
+}
+
+func eqchan(t testing.TB, rv reflect.Value, n int, atLeast bool) {
+	i := 0
+	for ; i <= n; i++ {
+		chosen, _, recvOK := reflect.Select([]reflect.SelectCase{
+			{Dir: reflect.SelectRecv, Chan: rv},
+			{Dir: reflect.SelectDefault},
+		})
+
+		if chosen == 1 || !recvOK { // default case or channel closed
+			break
+		}
+	}
+	compareN(t, n, i, atLeast)
+}
+
+func eqseq(t testing.TB, rv reflect.Value, n int, atLeast bool) {
+	next, stop := iter.Pull(rv.Seq())
+	defer stop()
+	i := 0
+	for ; i <= n; i++ {
+		if _, ok := next(); !ok {
+			break
+		}
+	}
+	compareN(t, n, i, atLeast)
+}
+
+func eqseq2(t testing.TB, rv reflect.Value, n int, atLeast bool) {
+	next, stop := iter.Pull2(rv.Seq2())
+	defer stop()
+	i := 0
+	for ; i <= n; i++ {
+		if _, _, ok := next(); !ok {
+			break
+		}
+	}
+	compareN(t, n, i, atLeast)
+}
+
+func compareN(t testing.TB, want, got int, atLeast bool) {
+	switch {
+	case atLeast && want > got:
+		t.Fatalf("want len(seq) >= %d; got %d", want, got)
+	case !atLeast && want > got:
+		t.Fatalf("want len(seq) == %d; got %d", want, got)
+	case !atLeast && want < got:
+		t.Fatalf("want len(seq) == %d; got at least %d", want, got)
+	}
+}
+
+// AtLeastLength calls t.Fatalf if seq has a length that is not at least want.
+// The type of seq must be array, array pointer, slice, map, string, channel, [iter.Seq], or [iter.Seq2].
+// For channels and iterators, the values are consumed to get the sequence length.
+func AtLeastLength(t testing.TB, want int, seq any) {
+	t.Helper()
+	getLen(t, seq, want, true)
+}