Map
func Map (model any , expectedEntries MapEntries) TestDeep
Map operator compares the contents of a map against the non-zero
values of model (if any
) and the values of expectedEntries .
model must be the same type as compared data.
expectedEntries can be nil
, if no zero entries are expected and
no TestDeep operators are involved.
During a match, all expected entries must be found and all data
entries must be expected to succeed.
got := map [string ]string {
"foo" : "test" ,
"bar" : "wizz" ,
"zip" : "buzz" ,
}
td.Cmp (t, got, td.Map (
map [string ]string {
"foo" : "test" ,
"bar" : "wizz" ,
},
td.MapEntries{
"zip" : td.HasSuffix ("zz" ),
}),
) // succeeds
TypeBehind
method returns the reflect.Type
of model .
See also SubMapOf
and SuperMapOf
.
See also Map godoc .
Examples
Map example
t := &testing.T{}
got := map [string ]int {"foo" : 12 , "bar" : 42 , "zip" : 89 }
ok := td.Cmp (t, got,
td.Map (map [string ]int {"bar" : 42 },
td.MapEntries{"foo" : td.Lt (15 ), "zip" : td.Ignore ()}),
"checks map %v" , got)
fmt.Println (ok)
ok = td.Cmp (t, got,
td.Map (map [string ]int {},
td.MapEntries{"bar" : 42 , "foo" : td.Lt (15 ), "zip" : td.Ignore ()}),
"checks map %v" , got)
fmt.Println (ok)
ok = td.Cmp (t, got,
td.Map ((map [string ]int )(nil ),
td.MapEntries{"bar" : 42 , "foo" : td.Lt (15 ), "zip" : td.Ignore ()}),
"checks map %v" , got)
fmt.Println (ok)
// Output:
// true
// true
// true
TypedMap example
t := &testing.T{}
type MyMap map [string ]int
got := MyMap{"foo" : 12 , "bar" : 42 , "zip" : 89 }
ok := td.Cmp (t, got,
td.Map (MyMap{"bar" : 42 }, td.MapEntries{"foo" : td.Lt (15 ), "zip" : td.Ignore ()}),
"checks typed map %v" , got)
fmt.Println (ok)
ok = td.Cmp (t, &got,
td.Map (&MyMap{"bar" : 42 }, td.MapEntries{"foo" : td.Lt (15 ), "zip" : td.Ignore ()}),
"checks pointer on typed map %v" , got)
fmt.Println (ok)
ok = td.Cmp (t, &got,
td.Map (&MyMap{}, td.MapEntries{"bar" : 42 , "foo" : td.Lt (15 ), "zip" : td.Ignore ()}),
"checks pointer on typed map %v" , got)
fmt.Println (ok)
ok = td.Cmp (t, &got,
td.Map ((*MyMap)(nil ), td.MapEntries{"bar" : 42 , "foo" : td.Lt (15 ), "zip" : td.Ignore ()}),
"checks pointer on typed map %v" , got)
fmt.Println (ok)
// Output:
// true
// true
// true
// true
CmpMap shortcut
func CmpMap (t TestingT, got, model any , expectedEntries MapEntries, args ...any ) bool
CmpMap is a shortcut for:
td.Cmp (t, got, td.Map (model, expectedEntries), args...)
See above for details.
Returns true if the test is OK, false if it fails.
If t is a *T
then its Config field is inherited.
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.
See also CmpMap godoc .
Examples
Map example
t := &testing.T{}
got := map [string ]int {"foo" : 12 , "bar" : 42 , "zip" : 89 }
ok := td.CmpMap (t, got, map [string ]int {"bar" : 42 }, td.MapEntries{"foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks map %v" , got)
fmt.Println (ok)
ok = td.CmpMap (t, got, map [string ]int {}, td.MapEntries{"bar" : 42 , "foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks map %v" , got)
fmt.Println (ok)
ok = td.CmpMap (t, got, (map [string ]int )(nil ), td.MapEntries{"bar" : 42 , "foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks map %v" , got)
fmt.Println (ok)
// Output:
// true
// true
// true
TypedMap example
t := &testing.T{}
type MyMap map [string ]int
got := MyMap{"foo" : 12 , "bar" : 42 , "zip" : 89 }
ok := td.CmpMap (t, got, MyMap{"bar" : 42 }, td.MapEntries{"foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks typed map %v" , got)
fmt.Println (ok)
ok = td.CmpMap (t, &got, &MyMap{"bar" : 42 }, td.MapEntries{"foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks pointer on typed map %v" , got)
fmt.Println (ok)
ok = td.CmpMap (t, &got, &MyMap{}, td.MapEntries{"bar" : 42 , "foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks pointer on typed map %v" , got)
fmt.Println (ok)
ok = td.CmpMap (t, &got, (*MyMap)(nil ), td.MapEntries{"bar" : 42 , "foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks pointer on typed map %v" , got)
fmt.Println (ok)
// Output:
// true
// true
// true
// true
T.Map shortcut
func (t *T) Map (got, model any , expectedEntries MapEntries, args ...any ) bool
Map is a shortcut for:
t.Cmp (got, td.Map (model, expectedEntries), args...)
See above 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.
See also T.Map godoc .
Examples
Map example
t := td.NewT (&testing.T{})
got := map [string ]int {"foo" : 12 , "bar" : 42 , "zip" : 89 }
ok := t.Map (got, map [string ]int {"bar" : 42 }, td.MapEntries{"foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks map %v" , got)
fmt.Println (ok)
ok = t.Map (got, map [string ]int {}, td.MapEntries{"bar" : 42 , "foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks map %v" , got)
fmt.Println (ok)
ok = t.Map (got, (map [string ]int )(nil ), td.MapEntries{"bar" : 42 , "foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks map %v" , got)
fmt.Println (ok)
// Output:
// true
// true
// true
TypedMap example
t := td.NewT (&testing.T{})
type MyMap map [string ]int
got := MyMap{"foo" : 12 , "bar" : 42 , "zip" : 89 }
ok := t.Map (got, MyMap{"bar" : 42 }, td.MapEntries{"foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks typed map %v" , got)
fmt.Println (ok)
ok = t.Map (&got, &MyMap{"bar" : 42 }, td.MapEntries{"foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks pointer on typed map %v" , got)
fmt.Println (ok)
ok = t.Map (&got, &MyMap{}, td.MapEntries{"bar" : 42 , "foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks pointer on typed map %v" , got)
fmt.Println (ok)
ok = t.Map (&got, (*MyMap)(nil ), td.MapEntries{"bar" : 42 , "foo" : td.Lt (15 ), "zip" : td.Ignore ()},
"checks pointer on typed map %v" , got)
fmt.Println (ok)
// Output:
// true
// true
// true
// true