func CmpMap(t TestingT, got, model interface{}, expectedEntries MapEntries, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Map(model, expectedEntries), args...)
}
CmpMap is a shortcut for:

td.Cmp(t, got, td.Map(model, expectedEntries), args...)

See https://pkg.go.dev/github.com/maxatome/go-testdeep/td#Map for details.

Returns true if the test is OK, false if it fails.

"args..." are optional and allow to name the test. This name is
used in case of failure to qualify the test. If len(args) > 1 and
the first item of "args" is a string and contains a '%' rune then
fmt.Fprintf is used to compose the name, else "args" are passed to
fmt.Fprint. Do not forget it is the name of the test, not the
reason of a potential failure.
package td
import (
	"time"
)
var allOperators = map[string]interface{}{
	"All":          All,
	"Any":          Any,
	"Array":        nil,
	"ArrayEach":    ArrayEach,
	"Bag":          Bag,
	"Between":      Between,
	"Cap":          nil,
	"Catch":        nil,
	"Code":         nil,
	"Contains":     Contains,
	"ContainsKey":  ContainsKey,
	"Delay":        nil,
	"Empty":        Empty,
	"Gt":           Gt,
	"Gte":          Gte,
	"HasPrefix":    HasPrefix,
	"HasSuffix":    HasSuffix,
	"Ignore":       Ignore,
	"Isa":          nil,
	"JSON":         nil,
	"JSONPointer":  JSONPointer,
	"Keys":         Keys,
	"Lax":          nil,
	"Len":          Len,
	"Lt":           Lt,
	"Lte":          Lte,
	"Map":          nil,
	"MapEach":      MapEach,
	"N":            N,
	"NaN":          NaN,
	"Nil":          Nil,
	"None":         None,
	"Not":          Not,
	"NotAny":       NotAny,
	"NotEmpty":     NotEmpty,
	"NotNaN":       NotNaN,
	"NotNil":       NotNil,
	"NotZero":      NotZero,
	"PPtr":         nil,
	"Ptr":          nil,
	"Re":           Re,
	"ReAll":        ReAll,
	"SStruct":      nil,
	"Set":          Set,
	"Shallow":      nil,
	"Slice":        nil,
	"Smuggle":      nil,
	"String":       nil,
	"Struct":       nil,
	"SubBagOf":     SubBagOf,
	"SubJSONOf":    nil,
	"SubMapOf":     SubMapOf,
	"SubSetOf":     SubSetOf,
	"SuperBagOf":   SuperBagOf,
	"SuperJSONOf":  nil,
	"SuperMapOf":   SuperMapOf,
	"SuperSetOf":   SuperSetOf,
	"SuperSliceOf": nil,
	"Tag":          nil,
	"TruncTime":    nil,
	"Values":       Values,
	"Zero":         Zero,
}
func CmpAll(t TestingT, got interface{}, expectedValues []interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, All(expectedValues...), args...)
}
func CmpAny(t TestingT, got interface{}, expectedValues []interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Any(expectedValues...), args...)
}
func CmpArray(t TestingT, got, model interface{}, expectedEntries ArrayEntries, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Array(model, expectedEntries), args...)
}
func CmpArrayEach(t TestingT, got, expectedValue interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, ArrayEach(expectedValue), args...)
}
func CmpBag(t TestingT, got interface{}, expectedItems []interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Bag(expectedItems...), args...)
}
func CmpBetween(t TestingT, got, from, to interface{}, bounds BoundsKind, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Between(from, to, bounds), args...)
}
func CmpCap(t TestingT, got, expectedCap interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Cap(expectedCap), args...)
}
func CmpCode(t TestingT, got, fn interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Code(fn), args...)
}
func CmpContains(t TestingT, got, expectedValue interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Contains(expectedValue), args...)
}
func CmpContainsKey(t TestingT, got, expectedValue interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, ContainsKey(expectedValue), args...)
}
func CmpEmpty(t TestingT, got interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Empty(), args...)
}
func CmpGt(t TestingT, got, minExpectedValue interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Gt(minExpectedValue), args...)
}
func CmpGte(t TestingT, got, minExpectedValue interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Gte(minExpectedValue), args...)
}
func CmpHasPrefix(t TestingT, got interface{}, expected string, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, HasPrefix(expected), args...)
}
func CmpHasSuffix(t TestingT, got interface{}, expected string, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, HasSuffix(expected), args...)
}
func CmpIsa(t TestingT, got, model interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Isa(model), args...)
}
func CmpJSON(t TestingT, got, expectedJSON interface{}, params []interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, JSON(expectedJSON, params...), args...)
}
func CmpJSONPointer(t TestingT, got interface{}, pointer string, expectedValue interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, JSONPointer(pointer, expectedValue), args...)
}
func CmpKeys(t TestingT, got, val interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Keys(val), args...)
}
func CmpLax(t TestingT, got, expectedValue interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Lax(expectedValue), args...)
}
func CmpLen(t TestingT, got, expectedLen interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Len(expectedLen), args...)
}
func CmpLt(t TestingT, got, maxExpectedValue interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Lt(maxExpectedValue), args...)
}
func CmpLte(t TestingT, got, maxExpectedValue interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Lte(maxExpectedValue), args...)
}