func CmpSet(t TestingT, got interface{}, expectedItems []interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Set(expectedItems...), args...)
}
CmpSet is a shortcut for:

td.Cmp(t, got, td.Set(expectedItems...), args...)

See https://pkg.go.dev/github.com/maxatome/go-testdeep/td#Set 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...)
}
func CmpMap(t TestingT, got, model interface{}, expectedEntries MapEntries, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Map(model, expectedEntries), args...)
}
func CmpMapEach(t TestingT, got, expectedValue interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, MapEach(expectedValue), args...)
}
func CmpN(t TestingT, got, num, tolerance interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, N(num, tolerance), args...)
}
func CmpNaN(t TestingT, got interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, NaN(), args...)
}
func CmpNil(t TestingT, got interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Nil(), args...)
}
func CmpNone(t TestingT, got interface{}, notExpectedValues []interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, None(notExpectedValues...), args...)
}
func CmpNot(t TestingT, got, notExpected interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Not(notExpected), args...)
}
func CmpNotAny(t TestingT, got interface{}, notExpectedItems []interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, NotAny(notExpectedItems...), args...)
}
func CmpNotEmpty(t TestingT, got interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, NotEmpty(), args...)
}
func CmpNotNaN(t TestingT, got interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, NotNaN(), args...)
}
func CmpNotNil(t TestingT, got interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, NotNil(), args...)
}
func CmpNotZero(t TestingT, got interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, NotZero(), args...)
}
func CmpPPtr(t TestingT, got, val interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, PPtr(val), args...)
}
func CmpPtr(t TestingT, got, val interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Ptr(val), args...)
}
func CmpRe(t TestingT, got, reg, capture interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, Re(reg, capture), args...)
}
func CmpReAll(t TestingT, got, reg, capture interface{}, args ...interface{}) bool {
	t.Helper()
	return Cmp(t, got, ReAll(reg, capture), args...)
}