func Len(expectedLen interface{}) TestDeep {
	l := tdLen{}
	l.initLenCapBase(expectedLen)
	return &l
}
summary(Len): checks an array, slice, map, string or channel length
input(Len): array,slice,map,chan
Len is a smuggler operator. It takes data, applies len() function
on it and compares its result to "expectedLen". Of course, the
compared value must be an array, a channel, a map, a slice or a
string.

"expectedLen" can be an int value:

td.Cmp(t, gotSlice, td.Len(12))

as well as an other operator:

td.Cmp(t, gotSlice, td.Len(td.Between(3, 4)))
package td
import (
	"fmt"
	"math"
	"reflect"
	"github.com/maxatome/go-testdeep/internal/ctxerr"
	"github.com/maxatome/go-testdeep/internal/types"
)
type tdLenCapBase struct {
	tdSmugglerBase
}
func (b *tdLenCapBase) initLenCapBase(val interface{}) {
	b.tdSmugglerBase = newSmugglerBase(val, 1)
	const (
		maxUint = ^uint(0)
		maxInt  = int(maxUint >> 1)
		minInt  = -maxInt - 1
		usage   = "(TESTDEEP_OPERATOR|INT)"
	)
	if val == nil {
		b.err = ctxerr.OpBadUsage(b.GetLocation().Func, usage, val, 1, true)
		return
	}
	if b.isTestDeeper {
		return
	}
	vval := reflect.ValueOf(val)
	switch vval.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		num := vval.Int()
		if num >= int64(minInt) && num <= int64(maxInt) {
			b.expectedValue = reflect.ValueOf(int(num))
			return
		}
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		num := vval.Uint()
		if num <= uint64(maxInt) {
			b.expectedValue = reflect.ValueOf(int(num))
			return
		}
	case reflect.Float32, reflect.Float64:
		num := vval.Float()
		if num == math.Trunc(num) && num >= float64(minInt) && num <= float64(maxInt) {
			b.expectedValue = reflect.ValueOf(int(num))
			return
		}
	default:
		b.err = ctxerr.OpBadUsage(b.GetLocation().Func, usage, val, 1, true)
		return
	}
	op := b.GetLocation().Func
	b.err = ctxerr.OpBad(op, "usage: "+op+usage+
		", but received an out of bounds or not integer 1st parameter (%v), should be in int range", val)
}
func (b *tdLenCapBase) isEqual(ctx ctxerr.Context, got int) (bool, *ctxerr.Error) {
	if b.isTestDeeper {
		return true, deepValueEqual(ctx, reflect.ValueOf(got), b.expectedValue)
	}
	if int64(got) == b.expectedValue.Int() {
		return true, nil
	}
	return false, nil
}
type tdLen struct {
	tdLenCapBase
}
var _ TestDeep = &tdLen{}