| package util |
| |
| import ( |
| "bytes" |
| "errors" |
| "io" |
| "io/ioutil" |
| "os" |
| "path" |
| "regexp" |
| "testing" |
| "time" |
| |
| assert "github.com/stretchr/testify/require" |
| "go.skia.org/infra/go/deepequal" |
| "go.skia.org/infra/go/testutils/unittest" |
| ) |
| |
| func TestAtMost(t *testing.T) { |
| unittest.SmallTest(t) |
| a := AtMost([]string{"a", "b"}, 3) |
| if got, want := len(a), 2; got != want { |
| t.Errorf("Wrong length: Got %v Want %v", got, want) |
| } |
| |
| a = AtMost([]string{"a", "b"}, 1) |
| if got, want := len(a), 1; got != want { |
| t.Errorf("Wrong length: Got %v Want %v", got, want) |
| } |
| |
| a = AtMost([]string{"a", "b"}, 0) |
| if got, want := len(a), 0; got != want { |
| t.Errorf("Wrong length: Got %v Want %v", got, want) |
| } |
| } |
| |
| func TestSSliceEqual(t *testing.T) { |
| unittest.SmallTest(t) |
| testcases := []struct { |
| a []string |
| b []string |
| want bool |
| }{ |
| { |
| a: []string{}, |
| b: []string{}, |
| want: true, |
| }, |
| { |
| a: nil, |
| b: []string{}, |
| want: false, |
| }, |
| { |
| a: nil, |
| b: nil, |
| want: true, |
| }, |
| { |
| a: []string{"foo"}, |
| b: []string{}, |
| want: false, |
| }, |
| { |
| a: []string{"foo", "bar"}, |
| b: []string{"bar", "foo"}, |
| want: true, |
| }, |
| } |
| |
| for _, tc := range testcases { |
| if got, want := SSliceEqual(tc.a, tc.b), tc.want; got != want { |
| t.Errorf("SSliceEqual(%#v, %#v): Got %v Want %v", tc.a, tc.b, got, want) |
| } |
| } |
| } |
| |
| func TestInsertString(t *testing.T) { |
| unittest.SmallTest(t) |
| deepequal.AssertDeepEqual(t, []string{"a"}, InsertString([]string{}, 0, "a")) |
| deepequal.AssertDeepEqual(t, []string{"b", "a"}, InsertString([]string{"a"}, 0, "b")) |
| deepequal.AssertDeepEqual(t, []string{"b", "c", "a"}, InsertString([]string{"b", "a"}, 1, "c")) |
| deepequal.AssertDeepEqual(t, []string{"b", "c", "a", "d"}, InsertString([]string{"b", "c", "a"}, 3, "d")) |
| } |
| |
| func TestInsertStringSorted(t *testing.T) { |
| unittest.SmallTest(t) |
| deepequal.AssertDeepEqual(t, []string{"a"}, InsertStringSorted([]string{}, "a")) |
| deepequal.AssertDeepEqual(t, []string{"a"}, InsertStringSorted([]string{"a"}, "a")) |
| deepequal.AssertDeepEqual(t, []string{"a", "b"}, InsertStringSorted([]string{"a"}, "b")) |
| deepequal.AssertDeepEqual(t, []string{"0", "a", "b"}, InsertStringSorted([]string{"a", "b"}, "0")) |
| deepequal.AssertDeepEqual(t, []string{"0", "a", "b"}, InsertStringSorted([]string{"0", "a", "b"}, "b")) |
| } |
| |
| func TestIntersectIntSets(t *testing.T) { |
| unittest.SmallTest(t) |
| sets := []map[int]bool{ |
| {1: true, 2: true, 3: true, 4: true}, |
| {2: true, 4: true, 5: true, 7: true}, |
| } |
| minIdx := 1 |
| intersect := IntersectIntSets(sets, minIdx) |
| assert.Equal(t, map[int]bool{2: true, 4: true}, intersect) |
| } |
| |
| func TestAddParamsToParamSet(t *testing.T) { |
| unittest.SmallTest(t) |
| testCases := []struct { |
| a map[string][]string |
| b map[string]string |
| wantFoo []string |
| }{ |
| { |
| a: map[string][]string{ |
| "foo": {"a", "b"}, |
| }, |
| b: map[string]string{ |
| "foo": "c", |
| }, |
| wantFoo: []string{"a", "b", "c"}, |
| }, |
| { |
| a: map[string][]string{ |
| "foo": {}, |
| }, |
| b: map[string]string{ |
| "foo": "c", |
| }, |
| wantFoo: []string{"c"}, |
| }, |
| { |
| a: map[string][]string{ |
| "foo": {"c"}, |
| }, |
| b: map[string]string{ |
| "foo": "c", |
| }, |
| wantFoo: []string{"c"}, |
| }, |
| { |
| a: map[string][]string{}, |
| b: map[string]string{ |
| "foo": "c", |
| }, |
| wantFoo: []string{"c"}, |
| }, |
| { |
| a: map[string][]string{ |
| "foo": {"c"}, |
| }, |
| b: map[string]string{}, |
| wantFoo: []string{"c"}, |
| }, |
| } |
| for _, tc := range testCases { |
| if got, want := AddParamsToParamSet(tc.a, tc.b)["foo"], tc.wantFoo; !SSliceEqual(got, want) { |
| t.Errorf("Merge failed: Got %v Want %v", got, want) |
| } |
| } |
| } |
| |
| func TestAddParamSetToParamSet(t *testing.T) { |
| unittest.SmallTest(t) |
| testCases := []struct { |
| a map[string][]string |
| b map[string][]string |
| wantFoo []string |
| }{ |
| { |
| a: map[string][]string{ |
| "foo": {"a", "b"}, |
| }, |
| b: map[string][]string{ |
| "foo": {"c"}, |
| }, |
| wantFoo: []string{"a", "b", "c"}, |
| }, |
| { |
| a: map[string][]string{ |
| "foo": {}, |
| }, |
| b: map[string][]string{ |
| "foo": {"c"}, |
| }, |
| wantFoo: []string{"c"}, |
| }, |
| { |
| a: map[string][]string{ |
| "foo": {"c"}, |
| }, |
| b: map[string][]string{ |
| "foo": {}, |
| }, |
| wantFoo: []string{"c"}, |
| }, |
| { |
| a: map[string][]string{ |
| "foo": {"c"}, |
| }, |
| b: map[string][]string{ |
| "bar": {"b"}, |
| }, |
| wantFoo: []string{"c"}, |
| }, |
| } |
| for _, tc := range testCases { |
| if got, want := AddParamSetToParamSet(tc.a, tc.b)["foo"], tc.wantFoo; !SSliceEqual(got, want) { |
| t.Errorf("Merge failed: Got %v Want %v", got, want) |
| } |
| } |
| } |
| |
| func TestAnyMatch(t *testing.T) { |
| unittest.SmallTest(t) |
| slice := []*regexp.Regexp{ |
| regexp.MustCompile("somestring"), |
| regexp.MustCompile("^abcdefg$"), |
| regexp.MustCompile("^defg123"), |
| regexp.MustCompile("abc\\.xyz"), |
| } |
| tc := map[string]bool{ |
| "somestring": true, |
| "somestringother": true, |
| "abcdefg": true, |
| "abcdefgh": false, |
| "defg1234": true, |
| "cdefg123": false, |
| "abc.xyz": true, |
| "abcqxyz": false, |
| } |
| for s, e := range tc { |
| assert.Equal(t, e, AnyMatch(slice, s)) |
| } |
| } |
| |
| func TestIsNil(t *testing.T) { |
| unittest.SmallTest(t) |
| assert.True(t, IsNil(nil)) |
| assert.False(t, IsNil(false)) |
| assert.False(t, IsNil(0)) |
| assert.False(t, IsNil("")) |
| assert.False(t, IsNil([0]int{})) |
| type Empty struct{} |
| assert.False(t, IsNil(Empty{})) |
| assert.True(t, IsNil(chan interface{}(nil))) |
| assert.False(t, IsNil(make(chan interface{}))) |
| var f func() |
| assert.True(t, IsNil(f)) |
| assert.False(t, IsNil(func() {})) |
| assert.True(t, IsNil(map[bool]bool(nil))) |
| assert.False(t, IsNil(make(map[bool]bool))) |
| assert.True(t, IsNil([]int(nil))) |
| assert.False(t, IsNil([][]int{nil})) |
| assert.True(t, IsNil((*int)(nil))) |
| var i int |
| assert.False(t, IsNil(&i)) |
| var pi *int |
| assert.True(t, IsNil(pi)) |
| assert.True(t, IsNil(&pi)) |
| var ppi **int |
| assert.True(t, IsNil(&ppi)) |
| var c chan interface{} |
| assert.True(t, IsNil(&c)) |
| var w io.Writer |
| assert.True(t, IsNil(w)) |
| w = (*bytes.Buffer)(nil) |
| assert.True(t, IsNil(w)) |
| w = &bytes.Buffer{} |
| assert.False(t, IsNil(w)) |
| assert.False(t, IsNil(&w)) |
| var ii interface{} |
| ii = &pi |
| assert.True(t, IsNil(ii)) |
| } |
| |
| func TestUnixFloatToTime(t *testing.T) { |
| unittest.SmallTest(t) |
| cases := []struct { |
| in float64 |
| out time.Time |
| }{ |
| { |
| in: 1414703190.292151927, |
| out: time.Unix(1414703190, 292000000), |
| }, |
| } |
| for _, tc := range cases { |
| assert.Equal(t, tc.out, UnixFloatToTime(tc.in)) |
| } |
| } |
| |
| func TestTimeToUnixFloat(t *testing.T) { |
| unittest.SmallTest(t) |
| cases := []struct { |
| in time.Time |
| out float64 |
| }{ |
| { |
| in: time.Unix(1414703190, 292000000), |
| out: 1414703190.292000, |
| }, |
| } |
| for _, tc := range cases { |
| assert.Equal(t, tc.out, TimeToUnixFloat(tc.in)) |
| } |
| } |
| |
| func TestTimeConversion(t *testing.T) { |
| unittest.SmallTest(t) |
| cases := []float64{ |
| 0.0, |
| 1.0, |
| 1414703190.0, |
| 1414703190.292000, |
| } |
| for _, tc := range cases { |
| assert.Equal(t, tc, TimeToUnixFloat(UnixFloatToTime(tc))) |
| } |
| } |
| |
| func TestMD5Hash(t *testing.T) { |
| unittest.SmallTest(t) |
| m_1 := map[string]string{"key1": "val1"} |
| m_2 := map[string]string{} |
| var m_3 map[string]string = nil |
| m_4 := map[string]string{ |
| "k3": "v1", |
| "k2": "v2", |
| "k1": "v3", |
| "k4": "v4", |
| } |
| |
| h_1, err := MD5Sum(m_1) |
| assert.NoError(t, err) |
| |
| h_2, err := MD5Sum(m_2) |
| assert.NoError(t, err) |
| |
| h_3, err := MD5Sum(m_3) |
| assert.NoError(t, err) |
| assert.Equal(t, 32, len(h_1)) |
| assert.Equal(t, 32, len(h_2)) |
| assert.Equal(t, 32, len(h_3)) |
| assert.NotEqual(t, h_1, h_2) |
| assert.NotEqual(t, h_1, h_3) |
| assert.Equal(t, h_2, h_3) |
| |
| // Ensure that we get the same hash every time. |
| h_4, err := MD5Sum(m_4) |
| assert.NoError(t, err) |
| for i := 0; i < 100; i++ { |
| h, err := MD5Sum(m_4) |
| assert.NoError(t, err) |
| assert.Equal(t, h_4, h) |
| } |
| h, err := MD5Sum(map[string]string{ |
| "k4": "v4", |
| "k2": "v2", |
| "k3": "v1", |
| "k1": "v3", |
| }) |
| assert.NoError(t, err) |
| assert.Equal(t, h_4, h) |
| } |
| |
| func TestBugsFromCommitMsg(t *testing.T) { |
| unittest.SmallTest(t) |
| cases := []struct { |
| in string |
| out map[string][]string |
| }{ |
| { |
| in: "BUG=skia:1234", |
| out: map[string][]string{ |
| "skia": {"1234"}, |
| }, |
| }, |
| { |
| in: "BUG=skia:1234,skia:4567", |
| out: map[string][]string{ |
| "skia": {"1234", "4567"}, |
| }, |
| }, |
| { |
| in: "BUG=skia:1234,skia:4567,skia:8901", |
| out: map[string][]string{ |
| "skia": {"1234", "4567", "8901"}, |
| }, |
| }, |
| { |
| in: "BUG=1234", |
| out: map[string][]string{ |
| "chromium": {"1234"}, |
| }, |
| }, |
| { |
| in: "BUG=skia:1234, 456", |
| out: map[string][]string{ |
| "chromium": {"456"}, |
| "skia": {"1234"}, |
| }, |
| }, |
| { |
| in: "BUG=skia:1234,456", |
| out: map[string][]string{ |
| "chromium": {"456"}, |
| "skia": {"1234"}, |
| }, |
| }, |
| { |
| in: `Lorem ipsum dolor sit amet, consectetur adipiscing elit. |
| |
| Quisque feugiat, mi et tristique dignissim, sapien risus tristique mi, non dignissim nibh erat ut ex. |
| |
| BUG=1234, skia:5678 |
| `, |
| out: map[string][]string{ |
| "chromium": {"1234"}, |
| "skia": {"5678"}, |
| }, |
| }, |
| { |
| in: "Bug: skia:1234", |
| out: map[string][]string{ |
| "skia": {"1234"}, |
| }, |
| }, |
| { |
| in: "Bug: skia:1234,skia:4567", |
| out: map[string][]string{ |
| "skia": {"1234", "4567"}, |
| }, |
| }, |
| { |
| in: "Bug: skia:1234,skia:4567,skia:8901", |
| out: map[string][]string{ |
| "skia": {"1234", "4567", "8901"}, |
| }, |
| }, |
| { |
| in: "Bug: 1234", |
| out: map[string][]string{ |
| "chromium": {"1234"}, |
| }, |
| }, |
| { |
| in: "Bug: skia:1234, 456", |
| out: map[string][]string{ |
| "chromium": {"456"}, |
| "skia": {"1234"}, |
| }, |
| }, |
| { |
| in: "Bug: skia:1234,456", |
| out: map[string][]string{ |
| "chromium": {"456"}, |
| "skia": {"1234"}, |
| }, |
| }, |
| { |
| in: "Bug: 1234,456", |
| out: map[string][]string{ |
| "chromium": {"1234", "456"}, |
| }, |
| }, |
| { |
| in: "Bug: skia:1234,chromium:456", |
| out: map[string][]string{ |
| "chromium": {"456"}, |
| "skia": {"1234"}, |
| }, |
| }, |
| { |
| in: `asdf |
| Bug: skia:1234,456 |
| BUG=skia:888 |
| `, |
| out: map[string][]string{ |
| "chromium": {"456"}, |
| "skia": {"1234", "888"}, |
| }, |
| }, |
| } |
| for _, tc := range cases { |
| result := BugsFromCommitMsg(tc.in) |
| assert.Equal(t, tc.out, result) |
| } |
| } |
| |
| func TestIsDirEmpty(t *testing.T) { |
| unittest.SmallTest(t) |
| d, err := ioutil.TempDir(os.TempDir(), "test_empty") |
| assert.NoError(t, err) |
| defer RemoveAll(d) |
| |
| // Directory is initially empty. |
| empty, err := IsDirEmpty(d) |
| assert.NoError(t, err) |
| assert.True(t, empty) |
| |
| // Add a file in the directory. |
| f, err := ioutil.TempFile(d, "test_file") |
| assert.NoError(t, err) |
| _, err = f.WriteString("testing") |
| Close(f) |
| assert.NoError(t, err) |
| empty, err = IsDirEmpty(d) |
| assert.NoError(t, err) |
| assert.False(t, empty) |
| |
| // Test non existent directory. |
| empty, err = IsDirEmpty(path.Join(d, "nonexistent_dir")) |
| assert.NotNil(t, err) |
| } |
| |
| type DomainTestCase struct { |
| DomainA string |
| DomainB string |
| Match bool |
| } |
| |
| func TestCookieDomainMatch(t *testing.T) { |
| unittest.SmallTest(t) |
| // Test cases borrowed from test_domain_match in |
| // https://svn.python.org/projects/python/trunk/Lib/test/test_cookielib.py |
| testCases := []DomainTestCase{ |
| {DomainA: "x.y.com", DomainB: "x.Y.com", Match: true}, |
| {DomainA: "x.y.com", DomainB: ".Y.com", Match: true}, |
| {DomainA: "x.y.com", DomainB: "Y.com", Match: false}, |
| {DomainA: "a.b.c.com", DomainB: ".c.com", Match: true}, |
| {DomainA: ".c.com", DomainB: "a.b.c.com", Match: false}, |
| {DomainA: "example.local", DomainB: ".local", Match: true}, |
| {DomainA: "blah.blah", DomainB: "", Match: false}, |
| {DomainA: "", DomainB: ".rhubarb.rhubarb", Match: false}, |
| {DomainA: "", DomainB: "", Match: true}, |
| |
| {DomainA: "acme.com", DomainB: "acme.com", Match: true}, |
| {DomainA: "acme.com", DomainB: ".acme.com", Match: false}, |
| {DomainA: "rhubarb.acme.com", DomainB: ".acme.com", Match: true}, |
| {DomainA: "www.rhubarb.acme.com", DomainB: ".acme.com", Match: true}, |
| {DomainA: "y.com", DomainB: "Y.com", Match: true}, |
| {DomainA: ".y.com", DomainB: "Y.com", Match: false}, |
| {DomainA: ".y.com", DomainB: ".Y.com", Match: true}, |
| {DomainA: "x.y.com", DomainB: ".com", Match: true}, |
| {DomainA: "x.y.com", DomainB: "com", Match: false}, |
| {DomainA: "x.y.com", DomainB: "m", Match: false}, |
| {DomainA: "x.y.com", DomainB: ".m", Match: false}, |
| {DomainA: "x.y.com", DomainB: "", Match: false}, |
| {DomainA: "x.y.com", DomainB: ".", Match: false}, |
| } |
| for _, tc := range testCases { |
| assert.Equal(t, tc.Match, CookieDomainMatch(tc.DomainA, tc.DomainB)) |
| } |
| } |
| |
| func TestValidateCommit(t *testing.T) { |
| unittest.SmallTest(t) |
| tc := map[string]bool{ |
| "": false, |
| "abc123": false, |
| "abcde12345abcde12345abcde12345abcde12345": true, |
| "abcde12345abcde12345abcde12345abcde1234": false, |
| "abcde12345abcde12345abcde12345abcde123456": false, |
| "abcde12345abcde12345abcde12345abcde1234g": false, |
| "abcde12345abcde12345abcde12345abcde1234 ": false, |
| } |
| for input, expect := range tc { |
| assert.Equal(t, ValidateCommit(input), expect) |
| } |
| } |
| |
| func TestPermute(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| assert.Equal(t, [][]int{}, Permute([]int{})) |
| assert.Equal(t, [][]int{{0}}, Permute([]int{0})) |
| assert.Equal(t, [][]int{{0, 1}, {1, 0}}, Permute([]int{0, 1})) |
| assert.Equal(t, [][]int{ |
| {0, 1, 2}, |
| {0, 2, 1}, |
| {1, 0, 2}, |
| {1, 2, 0}, |
| {2, 0, 1}, |
| {2, 1, 0}, |
| }, Permute([]int{0, 1, 2})) |
| assert.Equal(t, [][]int{ |
| {0, 1, 2, 3}, |
| {0, 1, 3, 2}, |
| {0, 2, 1, 3}, |
| {0, 2, 3, 1}, |
| {0, 3, 1, 2}, |
| {0, 3, 2, 1}, |
| {1, 0, 2, 3}, |
| {1, 0, 3, 2}, |
| {1, 2, 0, 3}, |
| {1, 2, 3, 0}, |
| {1, 3, 0, 2}, |
| {1, 3, 2, 0}, |
| {2, 0, 1, 3}, |
| {2, 0, 3, 1}, |
| {2, 1, 0, 3}, |
| {2, 1, 3, 0}, |
| {2, 3, 0, 1}, |
| {2, 3, 1, 0}, |
| {3, 0, 1, 2}, |
| {3, 0, 2, 1}, |
| {3, 1, 0, 2}, |
| {3, 1, 2, 0}, |
| {3, 2, 0, 1}, |
| {3, 2, 1, 0}, |
| }, Permute([]int{0, 1, 2, 3})) |
| } |
| |
| func TestPermuteStrings(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| assert.Equal(t, [][]string{}, PermuteStrings([]string{})) |
| assert.Equal(t, [][]string{{"a"}}, PermuteStrings([]string{"a"})) |
| assert.Equal(t, [][]string{{"a", "b"}, {"b", "a"}}, PermuteStrings([]string{"a", "b"})) |
| assert.Equal(t, [][]string{ |
| {"a", "b", "c"}, |
| {"a", "c", "b"}, |
| {"b", "a", "c"}, |
| {"b", "c", "a"}, |
| {"c", "a", "b"}, |
| {"c", "b", "a"}, |
| }, PermuteStrings([]string{"a", "b", "c"})) |
| assert.Equal(t, [][]string{ |
| {"a", "b", "c", "d"}, |
| {"a", "b", "d", "c"}, |
| {"a", "c", "b", "d"}, |
| {"a", "c", "d", "b"}, |
| {"a", "d", "b", "c"}, |
| {"a", "d", "c", "b"}, |
| {"b", "a", "c", "d"}, |
| {"b", "a", "d", "c"}, |
| {"b", "c", "a", "d"}, |
| {"b", "c", "d", "a"}, |
| {"b", "d", "a", "c"}, |
| {"b", "d", "c", "a"}, |
| {"c", "a", "b", "d"}, |
| {"c", "a", "d", "b"}, |
| {"c", "b", "a", "d"}, |
| {"c", "b", "d", "a"}, |
| {"c", "d", "a", "b"}, |
| {"c", "d", "b", "a"}, |
| {"d", "a", "b", "c"}, |
| {"d", "a", "c", "b"}, |
| {"d", "b", "a", "c"}, |
| {"d", "b", "c", "a"}, |
| {"d", "c", "a", "b"}, |
| {"d", "c", "b", "a"}, |
| }, PermuteStrings([]string{"a", "b", "c", "d"})) |
| } |
| |
| func TestParseIntSet(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| test := func(input string, expect []int, expectErr string) { |
| res, err := ParseIntSet(input) |
| if expectErr != "" { |
| assert.Contains(t, err.Error(), expectErr) |
| } else { |
| assert.NoError(t, err) |
| assert.Equal(t, expect, res) |
| } |
| } |
| test("", []int{}, "") |
| test("19", []int{19}, "") |
| test("1,2,3", []int{1, 2, 3}, "") |
| test("1-3", []int{1, 2, 3}, "") |
| test("1,2,4-6", []int{1, 2, 4, 5, 6}, "") |
| test("a", nil, "parsing \"a\": invalid syntax") |
| test(" 4, 6, 9 - 11", nil, "parsing \" 4\": invalid syntax") |
| test("4-9-10", nil, "Invalid expression \"4-9-10\"") |
| test("9-3", nil, "Cannot have a range whose beginning is greater than its end (9 vs 3)") |
| test("1-3,11-13,21-23", []int{1, 2, 3, 11, 12, 13, 21, 22, 23}, "") |
| test("-2", nil, "Invalid expression \"-2\"") |
| test("2-", nil, "Invalid expression \"2-\"") |
| } |
| |
| func TestContainsMap(t *testing.T) { |
| unittest.SmallTest(t) |
| child := map[string]string{ |
| "a": "1", |
| "b": "2", |
| } |
| parent := map[string]string{ |
| "a": "1", |
| "b": "2", |
| "c": "3", |
| } |
| // Test success |
| assert.True(t, ContainsMap(parent, child)) |
| // Test map with itself. |
| assert.True(t, ContainsMap(parent, parent)) |
| // Test failure. |
| delete(parent, "b") |
| assert.False(t, ContainsMap(parent, child)) |
| // Test edge cases. |
| assert.True(t, ContainsMap(parent, map[string]string{})) |
| assert.True(t, ContainsMap(map[string]string{}, map[string]string{})) |
| assert.False(t, ContainsMap(map[string]string{}, map[string]string{"a": "1"})) |
| } |
| |
| func TestContainsAnyMap(t *testing.T) { |
| unittest.SmallTest(t) |
| child1 := map[string]string{ |
| "a": "1", |
| "b": "2", |
| } |
| child2 := map[string]string{ |
| "a": "1", |
| "b": "2", |
| "c": "3", |
| } |
| parent := map[string]string{ |
| "a": "1", |
| "b": "2", |
| "c": "3", |
| } |
| // Test success |
| assert.True(t, ContainsAnyMap(parent, child1, child2)) |
| // Test map with itself |
| assert.True(t, ContainsAnyMap(parent, parent)) |
| // Test failure |
| delete(parent, "b") |
| assert.False(t, ContainsAnyMap(parent, child1, child2)) |
| assert.False(t, ContainsAnyMap(parent, map[string]string{"a": "1", "c": "4"})) |
| // Test success with new parent |
| assert.True(t, ContainsAnyMap(parent, map[string]string{"a": "1", "c": "3"})) |
| assert.True(t, ContainsAnyMap(parent, child1, parent)) |
| // Test edge cases. |
| assert.True(t, ContainsAnyMap(parent, map[string]string{}, child1)) |
| assert.True(t, ContainsAnyMap(parent, map[string]string{})) |
| assert.True(t, ContainsAnyMap(map[string]string{}, map[string]string{})) |
| assert.False(t, ContainsAnyMap(map[string]string{}, child1, child2)) |
| } |
| |
| func TestContainsMapInSliceValues(t *testing.T) { |
| unittest.SmallTest(t) |
| child := map[string]string{ |
| "a": "1", |
| "b": "2", |
| } |
| parent := map[string][]string{ |
| "a": {"1", "2"}, |
| "b": {"2", "4"}, |
| "c": {"3"}, |
| } |
| // Test success |
| assert.True(t, ContainsMapInSliceValues(parent, child)) |
| child["b"] = "4" |
| assert.True(t, ContainsMapInSliceValues(parent, child)) |
| // Test failure. |
| child["b"] = "3" |
| assert.False(t, ContainsMapInSliceValues(parent, child)) |
| delete(parent, "b") |
| assert.False(t, ContainsMapInSliceValues(parent, child)) |
| // Test edge cases. |
| assert.True(t, ContainsMapInSliceValues(parent, map[string]string{})) |
| assert.True(t, ContainsMapInSliceValues(map[string][]string{}, map[string]string{})) |
| assert.False(t, ContainsMapInSliceValues(map[string][]string{}, map[string]string{"a": "1"})) |
| } |
| |
| func TestContainsAnyMapInSliceValues(t *testing.T) { |
| unittest.SmallTest(t) |
| child1 := map[string]string{ |
| "a": "1", |
| "b": "2", |
| } |
| child2 := map[string]string{ |
| "a": "1", |
| "b": "2", |
| "c": "3", |
| } |
| parent := map[string][]string{ |
| "a": {"1", "4"}, |
| "b": {"2", "5"}, |
| "c": {"3"}, |
| } |
| // Test success |
| assert.True(t, ContainsAnyMapInSliceValues(parent, child1, child2)) |
| child2["b"] = "5" |
| assert.True(t, ContainsAnyMapInSliceValues(parent, child1, child2)) |
| // Test failure |
| child1["a"] = "2" |
| child2["b"] = "6" |
| assert.False(t, ContainsAnyMapInSliceValues(parent, child1, child2)) |
| delete(parent, "b") |
| assert.False(t, ContainsAnyMapInSliceValues(parent, child1, child2)) |
| assert.False(t, ContainsAnyMapInSliceValues(parent, map[string]string{"a": "1", "c": "4"})) |
| assert.False(t, ContainsAnyMapInSliceValues(parent, map[string]string{"a": "2"})) |
| // Test success with new parent |
| assert.True(t, ContainsAnyMapInSliceValues(parent, map[string]string{"a": "1", "c": "3"})) |
| assert.True(t, ContainsAnyMapInSliceValues(parent, map[string]string{"a": "4", "c": "3"})) |
| // Test edge cases. |
| assert.True(t, ContainsAnyMapInSliceValues(parent, map[string]string{}, child1)) |
| assert.True(t, ContainsAnyMapInSliceValues(parent, map[string]string{})) |
| assert.True(t, ContainsAnyMapInSliceValues(map[string][]string{}, map[string]string{})) |
| assert.False(t, ContainsAnyMapInSliceValues(map[string][]string{}, child1, child2)) |
| } |
| |
| func TestTruncate(t *testing.T) { |
| unittest.SmallTest(t) |
| s := "abcdefghijkl" |
| assert.Equal(t, "", Truncate(s, 0)) |
| assert.Equal(t, "a", Truncate(s, 1)) |
| assert.Equal(t, "ab", Truncate(s, 2)) |
| assert.Equal(t, "abc", Truncate(s, 3)) |
| assert.Equal(t, "a...", Truncate(s, 4)) |
| assert.Equal(t, "ab...", Truncate(s, 5)) |
| assert.Equal(t, s, Truncate(s, len(s))) |
| assert.Equal(t, s, Truncate(s, len(s)+1)) |
| } |
| |
| type fakeWriter struct { |
| writeFn func(p []byte) (int, error) |
| } |
| |
| func (w *fakeWriter) Write(p []byte) (int, error) { |
| return w.writeFn(p) |
| } |
| |
| func TestWithGzipWriter(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| write := func(w io.Writer, msg string) error { |
| _, err := w.Write([]byte(msg)) |
| return err |
| } |
| |
| // No error. |
| assert.NoError(t, WithGzipWriter(ioutil.Discard, func(w io.Writer) error { |
| return write(w, "hi") |
| })) |
| |
| // Contained function returns an error. |
| expectErr := errors.New("nope") |
| assert.EqualError(t, WithGzipWriter(ioutil.Discard, func(w io.Writer) error { |
| return expectErr |
| }), expectErr.Error()) |
| |
| // Underlying io.Writer returns an error. |
| fw := &fakeWriter{ |
| writeFn: func(p []byte) (int, error) { |
| return -1, expectErr |
| }, |
| } |
| assert.EqualError(t, WithGzipWriter(fw, func(w io.Writer) error { |
| return write(w, "hi") |
| }), expectErr.Error()) |
| |
| // Close() returns an error. |
| fw.writeFn = func(p []byte) (int, error) { |
| // Look for the gzip footer and return an error when we see it. |
| // WARNING: this contains a checksum. |
| if string(p) == "\xac*\x93\xd8\x02\x00\x00\x00" { |
| return -1, expectErr |
| } |
| return len(p), nil |
| } |
| assert.EqualError(t, WithGzipWriter(fw, func(w io.Writer) error { |
| return write(w, "hi") |
| }), "Failed to close gzip.Writer: nope") |
| } |
| |
| func TestChunkIter(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| assert.Error(t, ChunkIter(10, -1, func(int, int) error { return nil })) |
| assert.Error(t, ChunkIter(10, 0, func(int, int) error { return nil })) |
| |
| check := func(length, chunkSize int, expect [][]int) { |
| actual := [][]int{} |
| assert.NoError(t, ChunkIter(length, chunkSize, func(start, end int) error { |
| actual = append(actual, []int{start, end}) |
| return nil |
| })) |
| deepequal.AssertDeepEqual(t, expect, actual) |
| } |
| |
| check(10, 5, [][]int{{0, 5}, {5, 10}}) |
| check(4, 1, [][]int{{0, 1}, {1, 2}, {2, 3}, {3, 4}}) |
| check(7, 5, [][]int{{0, 5}, {5, 7}}) |
| } |
| |
| func TestRoundUpToPowerOf2(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| test := func(input, output int32) { |
| assert.Equal(t, output, RoundUpToPowerOf2(input)) |
| } |
| test(0, 1) |
| test(1, 1) |
| test(2, 2) |
| test(3, 4) |
| test(4, 4) |
| test(5, 8) |
| test(7, 8) |
| test(8, 8) |
| test(9, 16) |
| test(16, 16) |
| test(17, 32) |
| test(25, 32) |
| test(32, 32) |
| test(33, 64) |
| test(50, 64) |
| test(64, 64) |
| for i := 64; i < (1 << 31); i = i << 1 { |
| test(int32(i-1), int32(i)) |
| test(int32(i), int32(i)) |
| } |
| } |
| |
| func TestTrunc(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| assert.Equal(t, "foo...", Trunc("foobar", 3)) |
| assert.Equal(t, "fooba...", Trunc("foobar", 5)) |
| assert.Equal(t, "foobar", Trunc("foobar", 6)) |
| assert.Equal(t, "foobar", Trunc("foobar", 7)) |
| } |
| |
| func TestSSliceCmp(t *testing.T) { |
| unittest.SmallTest(t) |
| |
| // "Equal" slices. |
| testEq := func(a, b []string) { |
| assert.Equal(t, 0, SSliceCmp(a, b)) |
| assert.Equal(t, 0, SSliceCmp(b, a)) |
| } |
| testEq(nil, nil) |
| testEq(nil, []string{}) |
| testEq([]string{}, []string{}) |
| testEq([]string{"item"}, []string{"item"}) |
| testEq([]string{"a", "b", "c"}, []string{"a", "b", "c"}) |
| |
| // a > b |
| testGt := func(a, b []string) { |
| assert.Equal(t, 1, SSliceCmp(a, b)) |
| assert.Equal(t, -1, SSliceCmp(b, a)) |
| } |
| testGt([]string{"a"}, nil) |
| testGt([]string{"a"}, []string{}) |
| testGt([]string{"b"}, []string{"a"}) |
| testGt([]string{"a", "b", "d"}, []string{"a", "b", "c"}) |
| testGt([]string{"a", "b", "c", "d"}, []string{"a", "b", "c"}) |
| testGt([]string{"a", "b", "d"}, []string{"a", "b", "c", "d"}) |
| testGt([]string{"a", "c", "b"}, []string{"a", "b", "c"}) |
| } |
| |
| func TestPowerSet(t *testing.T) { |
| unittest.SmallTest(t) |
| test := func(inp int, expect [][]int) { |
| deepequal.AssertDeepEqual(t, expect, PowerSet(inp)) |
| } |
| test(0, [][]int{{}}) |
| test(1, [][]int{{}, {0}}) |
| test(2, [][]int{{}, {0}, {1}, {0, 1}}) |
| test(3, [][]int{{}, {0}, {1}, {0, 1}, {2}, {0, 2}, {1, 2}, {0, 1, 2}}) |
| } |
