blob: a7d6dcea33636d3bae236ba9429b566bc3fa6526 [file] [log] [blame]
package paramtools
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestParamsNew(t *testing.T) {
p := NewParams(",arch=x86,")
assert.Equal(t, Params{"arch": "x86"}, p)
p = NewParams(",arch=x86,config=565,")
assert.Equal(t, Params{"arch": "x86", "config": "565"}, p)
}
func TestAddParamsFromKey(t *testing.T) {
p := ParamSet{}
p.AddParamsFromKey(",arch=x86,")
assert.Equal(t, ParamSet{"arch": []string{"x86"}}, p)
p.AddParamsFromKey(",arch=x86,config=565,")
assert.Equal(t, ParamSet{"arch": []string{"x86"}, "config": []string{"565"}}, p)
}
func TestParams(t *testing.T) {
p := Params{"foo": "1", "bar": "2"}
p2 := p.Copy()
p["baz"] = "3"
assert.NotEqual(t, p["baz"], p2["baz"])
p.Add(p2)
assert.Equal(t, p, Params{"foo": "1", "bar": "2", "baz": "3"})
p.Add(nil)
assert.Equal(t, p, Params{"foo": "1", "bar": "2", "baz": "3"})
assert.True(t, p.Equal(p))
assert.False(t, p2.Equal(p))
assert.False(t, p.Equal(p2))
assert.False(t, p.Equal(nil))
assert.ElementsMatch(t, []string{"bar", "baz", "foo"}, p.Keys())
var pnil Params
assert.True(t, pnil.Equal(Params{}))
assert.Equal(t, []string{}, pnil.Keys())
p4 := Params{}
p5 := Params{"foo": "bar", "fred": "barney"}
p6 := Params{"foo": "baz", "qux": "corge"}
p4.Add(p5, p6)
assert.Equal(t, p4, Params{"foo": "baz", "qux": "corge", "fred": "barney"})
}
func TestParamSet(t *testing.T) {
p := ParamSet{"foo": []string{"bar", "baz"}}
assert.Equal(t, []string{"foo"}, p.Keys())
p = ParamSet{}
assert.Equal(t, []string{}, p.Keys())
}
func TestAddParamsToParamSet(t *testing.T) {
testCases := []struct {
a ParamSet
b Params
wantFoo []string
}{
{
a: ParamSet{
"foo": []string{"a", "b"},
},
b: Params{
"foo": "c",
},
wantFoo: []string{"a", "b", "c"},
},
{
a: ParamSet{
"foo": []string{},
},
b: Params{
"foo": "c",
},
wantFoo: []string{"c"},
},
{
a: ParamSet{
"foo": []string{"c"},
},
b: Params{
"foo": "c",
},
wantFoo: []string{"c"},
},
{
a: ParamSet{},
b: Params{
"foo": "c",
},
wantFoo: []string{"c"},
},
{
a: ParamSet{
"foo": []string{"c"},
},
b: Params{},
wantFoo: []string{"c"},
},
}
for _, tc := range testCases {
tc.a.AddParams(tc.b)
assert.ElementsMatch(t, tc.wantFoo, tc.a["foo"])
}
}
func TestAddParamSetToParamSet(t *testing.T) {
testCases := []struct {
a ParamSet
b ParamSet
wantFoo []string
}{
{
a: ParamSet{
"foo": []string{"a", "b"},
},
b: ParamSet{
"foo": []string{"c"},
},
wantFoo: []string{"a", "b", "c"},
},
{
a: ParamSet{
"foo": []string{},
},
b: ParamSet{
"foo": []string{"c"},
},
wantFoo: []string{"c"},
},
{
a: ParamSet{
"foo": []string{"c"},
},
b: ParamSet{
"foo": []string{},
},
wantFoo: []string{"c"},
},
{
a: ParamSet{
"foo": []string{"c"},
},
b: ParamSet{
"bar": []string{"b"},
},
wantFoo: []string{"c"},
},
{
a: ParamSet{},
b: ParamSet{},
wantFoo: nil,
},
}
for _, tc := range testCases {
tc.a.AddParamSet(tc.b)
assert.ElementsMatch(t, tc.wantFoo, tc.a["foo"])
}
}
func TestParamSetCopy(t *testing.T) {
p := ParamSet{
"foo": []string{"bar", "baz"},
"qux": []string{"quux"},
}
cp := p.Copy()
assert.Equal(t, p, cp)
p["foo"] = []string{"fred"}
assert.NotEqual(t, p, cp)
assert.Equal(t, ParamSet{}, ParamSet{}.Copy())
}
func TestMatchAny(t *testing.T) {
recParams := ParamSet{
"foo": {"1", "2"},
"bar": {"a", "b", "c"},
"baz": {"u", "v", "w"},
}
rule1 := ParamSet{"foo": {"1"}}
rule2 := ParamSet{"bar": {"e"}}
rule3 := ParamSet{"baz": {"v", "w"}}
rule4 := ParamSet{"x": {"something"}}
empty := ParamSet{}
assert.True(t, ParamMatcher{rule1}.MatchAny(recParams))
assert.False(t, ParamMatcher{rule2}.MatchAny(recParams))
assert.True(t, ParamMatcher{rule3}.MatchAny(recParams))
assert.False(t, ParamMatcher{rule4}.MatchAny(recParams))
assert.True(t, ParamMatcher{empty}.MatchAny(recParams))
assert.True(t, ParamMatcher{rule1, rule2}.MatchAny(recParams))
assert.True(t, ParamMatcher{rule1, rule3}.MatchAny(recParams))
assert.True(t, ParamMatcher{rule2, rule3}.MatchAny(recParams))
assert.False(t, ParamMatcher{rule2, rule4}.MatchAny(recParams))
assert.True(t, ParamMatcher{rule2, rule4, empty}.MatchAny(recParams))
assert.False(t, ParamMatcher{rule1}.MatchAny(ParamSet{}))
assert.True(t, ParamMatcher{empty}.MatchAny(ParamSet{}))
assert.False(t, ParamMatcher{}.MatchAny(ParamSet{}))
// Test with some realistic data.
testVal := ParamSet{
"cpu_or_gpu": {"GPU"},
"config": {"gles", "glesdft"},
"ext": {"png"},
"name": {"drrect_small_inner"},
"source_type": {"gm"},
"cpu_or_gpu_value": {"GT7800"},
"os": {"iOS"},
"gamma_correct": {"no"},
"configuration": {"Release"},
"model": {"iPadPro"},
"compiler": {"Clang"},
"arch": {"arm64"},
}
testRule := ParamSet{
"config": {"gldft", "glesdft"},
"model": {"AlphaR2", "AndroidOne", "ShuttleC", "ZBOX", "iPadPro", "iPhone7"},
"name": {"drrect_small_inner"},
"source_type": {"gm"},
}
assert.True(t, ParamMatcher{testRule}.MatchAny(testVal))
}
func TestMatchAnyParams(t *testing.T) {
recParams := Params{
"foo": "1",
"bar": "a",
"baz": "v",
}
rule1 := ParamSet{"foo": {"1"}}
rule2 := ParamSet{"bar": {"e"}}
rule3 := ParamSet{"baz": {"v", "w"}}
rule4 := ParamSet{"x": {"something"}}
empty := ParamSet{}
assert.True(t, ParamMatcher{rule1}.MatchAnyParams(recParams))
assert.False(t, ParamMatcher{rule2}.MatchAnyParams(recParams))
assert.True(t, ParamMatcher{rule3}.MatchAnyParams(recParams))
assert.False(t, ParamMatcher{rule4}.MatchAnyParams(recParams))
assert.True(t, ParamMatcher{empty}.MatchAnyParams(recParams))
assert.True(t, ParamMatcher{rule1, rule2}.MatchAnyParams(recParams))
assert.True(t, ParamMatcher{rule1, rule3}.MatchAnyParams(recParams))
assert.True(t, ParamMatcher{rule2, rule3}.MatchAnyParams(recParams))
assert.False(t, ParamMatcher{rule2, rule4}.MatchAnyParams(recParams))
assert.True(t, ParamMatcher{rule2, rule4, empty}.MatchAnyParams(recParams))
assert.False(t, ParamMatcher{rule1}.MatchAnyParams(Params{}))
assert.True(t, ParamMatcher{empty}.MatchAnyParams(Params{}))
assert.False(t, ParamMatcher{}.MatchAnyParams(Params{}))
}
// roundTripsEncode tests that an Ord
func TestReadOnlyParamSet_NewNonEmptyParamSet_Success(t *testing.T) {
ps := NewReadOnlyParamSet(Params{"a": "b"}, Params{"a": "c"}, Params{"b": "e"})
require.Equal(t, ReadOnlyParamSet{"a": []string{"b", "c"}, "b": []string{"e"}}, ps)
}
func TestReadOnlyParamSet_NewEmptyParamSet_Success(t *testing.T) {
require.Equal(t, ReadOnlyParamSet{}, NewReadOnlyParamSet())
}
func TestParamSet_Freeze_ReturnsReadOnlyParamSet(t *testing.T) {
ps := NewParamSet(Params{"a": "b"}, Params{"a": "c"}, Params{"b": "e"})
require.Equal(t, ReadOnlyParamSet{"a": []string{"b", "c"}, "b": []string{"e"}}, ps.Freeze())
}
func TestParamSetFrozenCopy_NonEmptyParamSet_Success(t *testing.T) {
p := ParamSet{
"foo": []string{"bar", "baz"},
"qux": []string{"quux"},
}
cp := p.FrozenCopy()
assert.Equal(t, ReadOnlyParamSet(p), cp)
// Confirm we made a deep copy by modifying the original.
p["foo"] = []string{"fred"}
assert.NotEqual(t, ReadOnlyParamSet(p), cp)
}
func TestParamSetFrozenCopy_EmptyParamSet_Success(t *testing.T) {
assert.Equal(t, ReadOnlyParamSet{}, ParamSet{}.FrozenCopy())
}
func TestParamSetAddParamSet_NonEmptyReadOnlyParamSet_Success(t *testing.T) {
ps := NewParamSet()
rops := ReadOnlyParamSet{
"foo": {"bar", "baz"},
"qux": {"quux"},
}
ps.AddParamSet(rops)
assert.Equal(t, ReadOnlyParamSet(ps), rops)
}
func TestParamSetEqual_KeysAndValuesMatch_ReturnsTrue(t *testing.T) {
assert.True(t, ParamSet{}.Equal(nil))
assert.True(t, ParamSet{
"alpha": {"beta", "gamma", "delta"},
}.Equal(ReadOnlyParamSet{
"alpha": {"gamma", "delta", "beta"},
}))
assert.True(t, ParamSet{
"alpha": {"beta", "gamma", "delta"},
"epsilon": {},
"lambda": {"mu", "kappa"},
}.Equal(map[string][]string{
"alpha": {"gamma", "delta", "beta"},
"epsilon": {},
"lambda": {"kappa", "mu"},
}))
}
func TestParamSetEqual_KeysAndValuesDoNotMatch_ReturnsFalse(t *testing.T) {
assert.False(t, ParamSet{}.Equal(ParamSet{
"something": {"something else"},
}))
assert.False(t, ParamSet{
"something": {"something else"},
}.Equal(ParamSet{}))
assert.False(t, ParamSet{
"something": {"something else"},
}.Equal(nil))
assert.False(t, ParamSet{
"alpha": {"beta", "gamma", "delta"},
}.Equal(ParamSet{
"alpha": {"gamma", "delta"},
}))
assert.False(t, ParamSet{
"alpha": {"beta", "delta"},
}.Equal(ParamSet{
"alpha": {"gamma", "delta", "beta"},
}))
assert.False(t, ParamSet{
"alpha": {"beta", "delta", "gamma", "gamma"},
}.Equal(ParamSet{
"alpha": {"gamma", "delta", "beta"},
}))
assert.False(t, ParamSet{
"alpha": {"beta", "delta", "gamma"},
}.Equal(ParamSet{
"alpha": {"gamma", "delta", "beta", "gamma"},
}))
assert.False(t, ParamSet{
"alpha": {"beta", "gamma", "delta"},
"epsilon": {},
"lambda": {"mu", "kappa"},
}.Equal(ParamSet{
"alpha": {"gamma", "delta", "beta"},
"lambda": {"kappa", "mu"},
}))
assert.False(t, ParamSet{
"alpha": {"beta", "gamma", "delta"},
"lambda": {"mu", "kappa"},
}.Equal(map[string][]string{
"alpha": {"gamma", "delta", "beta"},
"epsilon": {},
"lambda": {"kappa", "mu"},
}))
assert.False(t, ParamSet{
"alpha": {"beta", "gamma", "delta"},
"delta": {},
"lambda": {"mu", "kappa"},
}.Equal(ParamSet{
"alpha": {"gamma", "delta", "beta"},
"epsilon": {},
"lambda": {"kappa", "mu"},
}))
assert.False(t, ParamSet{
"alpha": {"beta", "gamma", "delta"},
}.Equal(ParamSet{
"alpha": {"gamma", "delta", "bettttttttttta"},
}))
}
func readAllFromChannel(in <-chan Params) []Params {
ret := []Params{}
for s := range in {
ret = append(ret, s)
}
return ret
}
func TestParamSetCartesianProduct_KeyNotPresent_ReturnsError(t *testing.T) {
ps := ParamSet{}
_, err := ps.CartesianProduct([]string{"key_that_is_not_present_in_ps"})
assert.Error(t, err)
}
func TestParamSetCartesianProduct_OneKey_ReturnsAllValues(t *testing.T) {
ps := ParamSet{"arch": []string{"arm", "arm64", "x86", "x86_64"}}
pch, err := ps.CartesianProduct([]string{"arch"})
all := readAllFromChannel(pch)
assert.NoError(t, err)
assert.Equal(t, []Params{
{"arch": "x86_64"},
{"arch": "x86"},
{"arch": "arm64"},
{"arch": "arm"},
}, all)
}
func TestParamSetCartesianProduct_TwoKeys_ReturnsCartesianProduct(t *testing.T) {
ps := ParamSet{
"arch": []string{"arm", "arm64", "x86", "x86_64"},
"config": []string{"8888", "gles"},
}
pch, err := ps.CartesianProduct([]string{"config", "arch"})
all := readAllFromChannel(pch)
assert.NoError(t, err)
assert.Equal(t, []Params{
{"arch": "x86_64", "config": "gles"},
{"arch": "x86_64", "config": "8888"},
{"arch": "x86", "config": "gles"},
{"arch": "x86", "config": "8888"},
{"arch": "arm64", "config": "gles"},
{"arch": "arm64", "config": "8888"},
{"arch": "arm", "config": "gles"},
{"arch": "arm", "config": "8888"},
}, all)
}