Function TestDictionary

core/data/dictionary/dictionary_test.go:54–134

(t *testing.T)

}

func TestDictionary(t *testing.T) {
	ctx := log.Testing(t)

	assert.For(ctx, "dictionary.From(nil)").That(dictionary.From(nil)).Equals(nil)

	apple := keyTy("apple")
	orange := keyTy("orange")
	grape := keyTy("grape")
	kiwi := keyTy("kiwi")
	lemon := keyTy("lemon")
	banana := keyTy("banana")

	one := valTy(1)
	two := valTy(2)
	three := valTy(3)
	four := valTy(4)
	five := valTy(5)

	newMap := func() map[keyTy]valTy {
		return map[keyTy]valTy{
			apple:  one,
			orange: two,
			grape:  three,
			kiwi:   four,
			lemon:  five,
		}
	}
	newCustom := func() custom { m := newMap(); return custom{&m} }

	for _, test := range []struct {
		name   string
		source interface{}
	}{
		{"map", newMap()},
		{"custom", newCustom()},
	} {
		ctx := log.Enter(ctx, test.name)

		d := dictionary.From(test.source)

		if !assert.For(ctx, "d").That(d).IsNotNil() {
			continue
		}

		assert.For(ctx, "d.Get('apple')").That(d.Get(apple)).Equals(one)
		assert.For(ctx, "d.Get('grape')").That(d.Get(grape)).Equals(three)
		assert.For(ctx, "d.KeyTy()").That(d.KeyTy()).Equals(reflect.TypeOf(apple))
		assert.For(ctx, "d.ValTy()").That(d.ValTy()).Equals(reflect.TypeOf(one))
		assert.For(ctx, "d.Len()").That(d.Len()).Equals(5)
		assert.For(ctx, "d.Keys()").ThatSlice(d.Keys()).Equals([]keyTy{
			apple, grape, kiwi, lemon, orange,
		})

		val, ok := d.Lookup(banana)
		assert.For(ctx, "d.Get('banana').val").That(val).Equals(valTy(0))
		assert.For(ctx, "d.Get('banana').ok").That(ok).Equals(false)
		assert.For(ctx, "d.Contains('banana')").That(d.Contains(banana)).Equals(false)