// Copyright 2022 The Dawn & Tint Authors
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package query_test

import (
	"fmt"
	"strings"
	"testing"

	"dawn.googlesource.com/dawn/tools/src/cts/query"
	"github.com/google/go-cmp/cmp"
	"github.com/stretchr/testify/assert"
)

var Q = query.Parse

func TestTargetFormat(t *testing.T) {
	type Test struct {
		target query.Target
		expect string
	}

	for _, test := range []Test{
		{query.Suite, "suite"},
		{query.Files, "files"},
		{query.Tests, "tests"},
		{query.Cases, "cases"},
		{query.Target(-1), "<invalid>"},
	} {
		s := strings.Builder{}
		_, err := fmt.Fprint(&s, test.target)
		if err != nil {
			t.Errorf("Fprint() returned %v", err)
			continue
		}
		if diff := cmp.Diff(s.String(), test.expect); diff != "" {
			t.Errorf("Fprint('%v')\n%v", test.target, diff)
		}
	}
}

func TestAppendFiles(t *testing.T) {
	type Test struct {
		base   query.Query
		files  []string
		expect query.Query
	}

	for _, test := range []Test{
		{Q("suite"), []string{}, Q("suite")},
		{Q("suite"), []string{"x"}, Q("suite:x")},
		{Q("suite"), []string{"x", "y"}, Q("suite:x,y")},
		{Q("suite:a"), []string{}, Q("suite:a")},
		{Q("suite:a"), []string{"x"}, Q("suite:a,x")},
		{Q("suite:a"), []string{"x", "y"}, Q("suite:a,x,y")},
		{Q("suite:a,b"), []string{}, Q("suite:a,b")},
		{Q("suite:a,b"), []string{"x"}, Q("suite:a,b,x")},
		{Q("suite:a,b"), []string{"x", "y"}, Q("suite:a,b,x,y")},
		{Q("suite:a,b:c"), []string{}, Q("suite:a,b:c")},
		{Q("suite:a,b:c"), []string{"x"}, Q("suite:a,b,x:c")},
		{Q("suite:a,b:c"), []string{"x", "y"}, Q("suite:a,b,x,y:c")},
		{Q("suite:a,b:c,d"), []string{}, Q("suite:a,b:c,d")},
		{Q("suite:a,b:c,d"), []string{"x"}, Q("suite:a,b,x:c,d")},
		{Q("suite:a,b:c,d"), []string{"x", "y"}, Q("suite:a,b,x,y:c,d")},
		{Q("suite:a,b:c,d:e"), []string{}, Q("suite:a,b:c,d:e")},
		{Q("suite:a,b:c,d:e"), []string{"x"}, Q("suite:a,b,x:c,d:e")},
		{Q("suite:a,b:c,d:e"), []string{"x", "y"}, Q("suite:a,b,x,y:c,d:e")},
		{Q("suite:a,b:c,d:e;f"), []string{}, Q("suite:a,b:c,d:e;f")},
		{Q("suite:a,b:c,d:e;f"), []string{"x"}, Q("suite:a,b,x:c,d:e;f")},
		{Q("suite:a,b:c,d:e;f"), []string{"x", "y"}, Q("suite:a,b,x,y:c,d:e;f")},
	} {
		got := test.base.AppendFiles(test.files...)
		if diff := cmp.Diff(got, test.expect); diff != "" {
			t.Errorf("'%v'.AppendFiles(%v)\n%v", test.base, test.files, diff)
		}
	}
}

func TestSplitFiles(t *testing.T) {
	type Test struct {
		query  query.Query
		expect []string
	}

	for _, test := range []Test{
		{Q("suite"), nil},
		{Q("suite:a"), []string{"a"}},
		{Q("suite:a,b"), []string{"a", "b"}},
		{Q("suite:a,b:c"), []string{"a", "b"}},
		{Q("suite:a,b:c,d"), []string{"a", "b"}},
		{Q("suite:a,b:c,d:e"), []string{"a", "b"}},
		{Q("suite:a,b:c,d:e;f"), []string{"a", "b"}},
	} {
		got := test.query.SplitFiles()
		if diff := cmp.Diff(got, test.expect); diff != "" {
			t.Errorf("'%v'.SplitFiles()\n%v", test.query, diff)
		}
	}
}

func TestAppendTests(t *testing.T) {
	type Test struct {
		base   query.Query
		files  []string
		expect query.Query
	}

	for _, test := range []Test{
		{Q("suite"), []string{}, Q("suite")},
		{Q("suite"), []string{"x"}, Q("suite::x")},
		{Q("suite"), []string{"x", "y"}, Q("suite::x,y")},
		{Q("suite:a"), []string{}, Q("suite:a")},
		{Q("suite:a"), []string{"x"}, Q("suite:a:x")},
		{Q("suite:a"), []string{"x", "y"}, Q("suite:a:x,y")},
		{Q("suite:a,b"), []string{}, Q("suite:a,b")},
		{Q("suite:a,b"), []string{"x"}, Q("suite:a,b:x")},
		{Q("suite:a,b"), []string{"x", "y"}, Q("suite:a,b:x,y")},
		{Q("suite:a,b:c"), []string{}, Q("suite:a,b:c")},
		{Q("suite:a,b:c"), []string{"x"}, Q("suite:a,b:c,x")},
		{Q("suite:a,b:c"), []string{"x", "y"}, Q("suite:a,b:c,x,y")},
		{Q("suite:a,b:c,d"), []string{}, Q("suite:a,b:c,d")},
		{Q("suite:a,b:c,d"), []string{"x"}, Q("suite:a,b:c,d,x")},
		{Q("suite:a,b:c,d"), []string{"x", "y"}, Q("suite:a,b:c,d,x,y")},
		{Q("suite:a,b:c,d:e"), []string{}, Q("suite:a,b:c,d:e")},
		{Q("suite:a,b:c,d:e"), []string{"x"}, Q("suite:a,b:c,d,x:e")},
		{Q("suite:a,b:c,d:e"), []string{"x", "y"}, Q("suite:a,b:c,d,x,y:e")},
		{Q("suite:a,b:c,d:e;f"), []string{}, Q("suite:a,b:c,d:e;f")},
		{Q("suite:a,b:c,d:e;f"), []string{"x"}, Q("suite:a,b:c,d,x:e;f")},
		{Q("suite:a,b:c,d:e;f"), []string{"x", "y"}, Q("suite:a,b:c,d,x,y:e;f")},
	} {
		got := test.base.AppendTests(test.files...)
		if diff := cmp.Diff(got, test.expect); diff != "" {
			t.Errorf("'%v'.AppendTests(%v)\n%v", test.base, test.files, diff)
		}
	}
}

func TestSplitTests(t *testing.T) {
	type Test struct {
		query query.Query
		tests []string
	}

	for _, test := range []Test{
		{Q("suite"), nil},
		{Q("suite:a"), nil},
		{Q("suite:a,b"), nil},
		{Q("suite:a,b:c"), []string{"c"}},
		{Q("suite:a,b:c,d"), []string{"c", "d"}},
		{Q("suite:a,b:c,d:e"), []string{"c", "d"}},
		{Q("suite:a,b:c,d:e;f"), []string{"c", "d"}},
	} {
		got := test.query.SplitTests()
		if diff := cmp.Diff(got, test.tests); diff != "" {
			t.Errorf("'%v'.SplitTests()\n%v", test.query, diff)
		}
	}
}

func TestAppendCases(t *testing.T) {
	type Test struct {
		base   query.Query
		cases  []string
		expect query.Query
	}

	for _, test := range []Test{
		{Q("suite"), []string{}, Q("suite")},
		{Q("suite"), []string{"x"}, Q("suite:::x")},
		{Q("suite"), []string{"x", "y"}, Q("suite:::x;y")},
		{Q("suite:a"), []string{}, Q("suite:a")},
		{Q("suite:a"), []string{"x"}, Q("suite:a::x")},
		{Q("suite:a"), []string{"x", "y"}, Q("suite:a::x;y")},
		{Q("suite:a,b"), []string{}, Q("suite:a,b")},
		{Q("suite:a,b"), []string{"x"}, Q("suite:a,b::x")},
		{Q("suite:a,b"), []string{"x", "y"}, Q("suite:a,b::x;y")},
		{Q("suite:a,b:c"), []string{}, Q("suite:a,b:c")},
		{Q("suite:a,b:c"), []string{"x"}, Q("suite:a,b:c:x")},
		{Q("suite:a,b:c"), []string{"x", "y"}, Q("suite:a,b:c:x;y")},
		{Q("suite:a,b:c,d"), []string{}, Q("suite:a,b:c,d")},
		{Q("suite:a,b:c,d"), []string{"x"}, Q("suite:a,b:c,d:x")},
		{Q("suite:a,b:c,d"), []string{"x", "y"}, Q("suite:a,b:c,d:x;y")},
		{Q("suite:a,b:c,d:e"), []string{}, Q("suite:a,b:c,d:e")},
		{Q("suite:a,b:c,d:e"), []string{"x"}, Q("suite:a,b:c,d:e;x")},
		{Q("suite:a,b:c,d:e"), []string{"x", "y"}, Q("suite:a,b:c,d:e;x;y")},
		{Q("suite:a,b:c,d:e;f"), []string{}, Q("suite:a,b:c,d:e;f")},
		{Q("suite:a,b:c,d:e;f"), []string{"x"}, Q("suite:a,b:c,d:e;f;x")},
		{Q("suite:a,b:c,d:e;f"), []string{"x", "y"}, Q("suite:a,b:c,d:e;f;x;y")},
	} {
		got := test.base.AppendCases(test.cases...)
		if diff := cmp.Diff(got, test.expect); diff != "" {
			t.Errorf("'%v'.AppendCases(%v)\n%v", test.base, test.cases, diff)
		}
	}
}

func TestAppend(t *testing.T) {
	type Subtest struct {
		target query.Target
		expect query.Query
	}
	type Test struct {
		base    query.Query
		strings []string
		subtest []Subtest
	}
	for _, test := range []Test{
		{
			Q("suite"), []string{}, []Subtest{
				{query.Files, Q("suite")},
				{query.Tests, Q("suite")},
				{query.Cases, Q("suite")},
			},
		}, {
			Q("suite"), []string{"x"}, []Subtest{
				{query.Files, Q("suite:x")},
				{query.Tests, Q("suite::x")},
				{query.Cases, Q("suite:::x")},
			},
		}, {
			Q("suite"), []string{"x", "y"}, []Subtest{
				{query.Files, Q("suite:x,y")},
				{query.Tests, Q("suite::x,y")},
				{query.Cases, Q("suite:::x;y")},
			},
		}, {
			Q("suite:a"), []string{}, []Subtest{
				{query.Files, Q("suite:a")},
				{query.Tests, Q("suite:a")},
				{query.Cases, Q("suite:a")},
			},
		}, {
			Q("suite:a"), []string{"x"}, []Subtest{
				{query.Files, Q("suite:a,x")},
				{query.Tests, Q("suite:a:x")},
				{query.Cases, Q("suite:a::x")},
			},
		}, {
			Q("suite:a"), []string{"x", "y"}, []Subtest{
				{query.Files, Q("suite:a,x,y")},
				{query.Tests, Q("suite:a:x,y")},
				{query.Cases, Q("suite:a::x;y")},
			},
		}, {
			Q("suite:a,b"), []string{}, []Subtest{
				{query.Files, Q("suite:a,b")},
				{query.Tests, Q("suite:a,b")},
				{query.Cases, Q("suite:a,b")},
			},
		}, {
			Q("suite:a,b"), []string{"x"}, []Subtest{
				{query.Files, Q("suite:a,b,x")},
				{query.Tests, Q("suite:a,b:x")},
				{query.Cases, Q("suite:a,b::x")},
			},
		}, {
			Q("suite:a,b"), []string{"x", "y"}, []Subtest{
				{query.Files, Q("suite:a,b,x,y")},
				{query.Tests, Q("suite:a,b:x,y")},
				{query.Cases, Q("suite:a,b::x;y")},
			},
		}, {
			Q("suite:a,b:c"), []string{}, []Subtest{
				{query.Files, Q("suite:a,b:c")},
				{query.Tests, Q("suite:a,b:c")},
				{query.Cases, Q("suite:a,b:c")},
			},
		}, {
			Q("suite:a,b:c"), []string{"x"}, []Subtest{
				{query.Files, Q("suite:a,b,x:c")},
				{query.Tests, Q("suite:a,b:c,x")},
				{query.Cases, Q("suite:a,b:c:x")},
			},
		}, {
			Q("suite:a,b:c"), []string{"x", "y"}, []Subtest{
				{query.Files, Q("suite:a,b,x,y:c")},
				{query.Tests, Q("suite:a,b:c,x,y")},
				{query.Cases, Q("suite:a,b:c:x;y")},
			},
		}, {
			Q("suite:a,b:c,d"), []string{}, []Subtest{
				{query.Files, Q("suite:a,b:c,d")},
				{query.Tests, Q("suite:a,b:c,d")},
				{query.Cases, Q("suite:a,b:c,d")},
			},
		}, {
			Q("suite:a,b:c,d"), []string{"x"}, []Subtest{
				{query.Files, Q("suite:a,b,x:c,d")},
				{query.Tests, Q("suite:a,b:c,d,x")},
				{query.Cases, Q("suite:a,b:c,d:x")},
			},
		}, {
			Q("suite:a,b:c,d"), []string{"x", "y"}, []Subtest{
				{query.Files, Q("suite:a,b,x,y:c,d")},
				{query.Tests, Q("suite:a,b:c,d,x,y")},
				{query.Cases, Q("suite:a,b:c,d:x;y")},
			},
		}, {
			Q("suite:a,b:c,d:e"), []string{}, []Subtest{
				{query.Files, Q("suite:a,b:c,d:e")},
				{query.Tests, Q("suite:a,b:c,d:e")},
				{query.Cases, Q("suite:a,b:c,d:e")},
			},
		}, {
			Q("suite:a,b:c,d:e"), []string{"x"}, []Subtest{
				{query.Files, Q("suite:a,b,x:c,d:e")},
				{query.Tests, Q("suite:a,b:c,d,x:e")},
				{query.Cases, Q("suite:a,b:c,d:e;x")},
			},
		}, {
			Q("suite:a,b:c,d:e"), []string{"x", "y"}, []Subtest{
				{query.Files, Q("suite:a,b,x,y:c,d:e")},
				{query.Tests, Q("suite:a,b:c,d,x,y:e")},
				{query.Cases, Q("suite:a,b:c,d:e;x;y")},
			},
		}, {
			Q("suite:a,b:c,d:e;f"), []string{}, []Subtest{
				{query.Files, Q("suite:a,b:c,d:e;f")},
				{query.Tests, Q("suite:a,b:c,d:e;f")},
				{query.Cases, Q("suite:a,b:c,d:e;f")},
			},
		}, {
			Q("suite:a,b:c,d:e;f"), []string{"x"}, []Subtest{
				{query.Files, Q("suite:a,b,x:c,d:e;f")},
				{query.Tests, Q("suite:a,b:c,d,x:e;f")},
				{query.Cases, Q("suite:a,b:c,d:e;f;x")},
			},
		}, {
			Q("suite:a,b:c,d:e;f"), []string{"x", "y"}, []Subtest{
				{query.Files, Q("suite:a,b,x,y:c,d:e;f")},
				{query.Tests, Q("suite:a,b:c,d,x,y:e;f")},
				{query.Cases, Q("suite:a,b:c,d:e;f;x;y")},
			},
		},
	} {
		for _, subtest := range test.subtest {
			got := test.base.Append(subtest.target, test.strings...)
			if diff := cmp.Diff(got, subtest.expect); diff != "" {
				t.Errorf("'%v'.Append(%v, %v)\n%v", test.base, subtest.target, test.base.Files, diff)
			}
		}
	}
}

func TestSplitCases(t *testing.T) {
	type Test struct {
		query  query.Query
		expect []string
	}

	for _, test := range []Test{
		{Q("suite"), nil},
		{Q("suite:a"), nil},
		{Q("suite:a,b"), nil},
		{Q("suite:a,b:c"), nil},
		{Q("suite:a,b:c,d"), nil},
		{Q("suite:a,b:c,d:e"), []string{"e"}},
		{Q("suite:a,b:c,d:e;f"), []string{"e", "f"}},
	} {
		got := test.query.SplitCases()
		if diff := cmp.Diff(got, test.expect); diff != "" {
			t.Errorf("'%v'.SplitCases()\n%v", test.query, diff)
		}
	}
}

func TestCaseParameters(t *testing.T) {
	type Test struct {
		query  query.Query
		expect query.CaseParameters
	}

	for _, test := range []Test{
		{Q("suite"), nil},
		{Q("suite:a"), nil},
		{Q("suite:a,b"), nil},
		{Q("suite:a,b:c"), nil},
		{Q("suite:a,b:c,d"), nil},
		{Q("suite:a,b:c,d:e"), query.CaseParameters{"e": ""}},
		{Q("suite:a,b:c,d:e;f"), query.CaseParameters{"e": "", "f": ""}},
		{Q("suite:a,b:c,d:e=f;g=h"), query.CaseParameters{"e": "f", "g": "h"}},
	} {
		got := test.query.CaseParameters()
		if diff := cmp.Diff(got, test.expect); diff != "" {
			t.Errorf("'%v'.CaseParameters()\n%v", test.query, diff)
		}
	}
}

func TestTarget(t *testing.T) {
	type Test struct {
		query  query.Query
		expect query.Target
	}

	for _, test := range []Test{
		{Q("suite"), query.Suite},
		{Q("suite:*"), query.Files},
		{Q("suite:a"), query.Files},
		{Q("suite:a,*"), query.Files},
		{Q("suite:a,b"), query.Files},
		{Q("suite:a,b:*"), query.Tests},
		{Q("suite:a,b:c"), query.Tests},
		{Q("suite:a,b:c,*"), query.Tests},
		{Q("suite:a,b:c,d"), query.Tests},
		{Q("suite:a,b:c,d:*"), query.Cases},
		{Q("suite:a,b:c,d:e"), query.Cases},
		{Q("suite:a,b:c,d:e;*"), query.Cases},
		{Q("suite:a,b:c,d:e;f"), query.Cases},
		{Q("suite:a,b:c,d:e;f;*"), query.Cases},
	} {
		got := test.query.Target()
		if diff := cmp.Diff(got, test.expect); diff != "" {
			t.Errorf("'%v'.Target()\n%v", test.query, diff)
		}
	}
}

func TestIsWildcard(t *testing.T) {
	type Test struct {
		query  query.Query
		expect bool
	}

	for _, test := range []Test{
		{Q("suite"), false},
		{Q("suite:*"), true},
		{Q("suite:a"), false},
		{Q("suite:a,*"), true},
		{Q("suite:a,b"), false},
		{Q("suite:a,b:*"), true},
		{Q("suite:a,b:c"), false},
		{Q("suite:a,b:c,*"), true},
		{Q("suite:a,b:c,d"), false},
		{Q("suite:a,b:c,d:*"), true},
		{Q("suite:a,b:c,d:e"), false},
		{Q("suite:a,b:c,d:e;*"), true},
		{Q("suite:a,b:c,d:e;f"), false},
		{Q("suite:a,b:c,d:e;f;*"), true},
	} {
		got := test.query.IsWildcard()
		if diff := cmp.Diff(got, test.expect); diff != "" {
			t.Errorf("'%v'.IsWildcard()\n%v", test.query, diff)
		}
	}
}

func TestParsePrint(t *testing.T) {
	type Test struct {
		in     string
		expect query.Query
	}

	for _, test := range []Test{
		{
			"a",
			query.Query{
				Suite: "a",
			},
		}, {
			"a:*",
			query.Query{
				Suite: "a",
				Files: "*",
			},
		}, {
			"a:b",
			query.Query{
				Suite: "a",
				Files: "b",
			},
		}, {
			"a:b,*",
			query.Query{
				Suite: "a",
				Files: "b,*",
			},
		}, {
			"a:b:*",
			query.Query{
				Suite: "a",
				Files: "b",
				Tests: "*",
			},
		}, {
			"a:b,c",
			query.Query{
				Suite: "a",
				Files: "b,c",
			},
		}, {
			"a:b,c:*",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "*",
			},
		}, {
			"a:b,c:d",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d",
			},
		}, {
			"a:b,c:d,*",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,*",
			},
		}, {
			"a:b,c:d,e",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
			},
		}, {
			"a:b,c:d,e,*",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e,*",
			},
		}, {
			"a:b,c:d,e:*",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
				Cases: "*",
			},
		}, {
			"a:b,c:d,e:f=g",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
				Cases: "f=g",
			},
		}, {
			"a:b,c:d,e:f=g;*",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
				Cases: "f=g;*",
			},
		}, {
			"a:b,c:d,e:f=g;h=i",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
				Cases: "f=g;h=i",
			},
		}, {
			"a:b,c:d,e:f=g;h=i;*",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
				Cases: "f=g;h=i;*",
			},
		}, {
			`a:b,c:d,e:f={"x": 1, "y": 2}`,
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
				Cases: `f={"x": 1, "y": 2}`,
			},
		}, {
			`a:b,c,d:e,f:g="h";i=[10,20,30];j=40`,
			query.Query{
				Suite: "a",
				Files: "b,c,d",
				Tests: "e,f",
				Cases: `g="h";i=[10,20,30];j=40`,
			},
		},
	} {
		parsed := query.Parse(test.in)
		if diff := cmp.Diff(test.expect, parsed); diff != "" {
			t.Errorf("query.Parse('%v')\n%v", test.in, diff)
		}
		str := test.expect.String()
		if diff := cmp.Diff(test.in, str); diff != "" {
			t.Errorf("query.String('%v')\n%v", test.in, diff)
		}
	}
}

// Essentially the same as TestParsePrint(), but calling ExpectationFileString()
// instead of String().
func TestParsePrintExpectationFileString(t *testing.T) {
	type Test struct {
		input    string
		expected query.Query
	}

	for _, test := range []Test{
		{
			"a",
			query.Query{
				Suite: "a",
			},
		}, {
			"a:*",
			query.Query{
				Suite: "a",
				Files: "*",
			},
		}, {
			"a:b",
			query.Query{
				Suite: "a",
				Files: "b",
			},
		}, {
			"a:b,*",
			query.Query{
				Suite: "a",
				Files: "b,*",
			},
		}, {
			"a:b:*",
			query.Query{
				Suite: "a",
				Files: "b",
				Tests: "*",
			},
		}, {
			"a:b,c",
			query.Query{
				Suite: "a",
				Files: "b,c",
			},
		}, {
			"a:b,c:*",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "*",
			},
		}, {
			"a:b,c:d:",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d",
			},
		}, {
			"a:b,c:d,*",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,*",
			},
		}, {
			"a:b,c:d,e:",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
			},
		}, {
			"a:b,c:d,e,*",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e,*",
			},
		}, {
			"a:b,c:d,e:*",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
				Cases: "*",
			},
		}, {
			"a:b,c:d,e:f=g",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
				Cases: "f=g",
			},
		}, {
			"a:b,c:d,e:f=g;*",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
				Cases: "f=g;*",
			},
		}, {
			"a:b,c:d,e:f=g;h=i",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
				Cases: "f=g;h=i",
			},
		}, {
			"a:b,c:d,e:f=g;h=i;*",
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
				Cases: "f=g;h=i;*",
			},
		}, {
			`a:b,c:d,e:f={"x": 1, "y": 2}`,
			query.Query{
				Suite: "a",
				Files: "b,c",
				Tests: "d,e",
				Cases: `f={"x": 1, "y": 2}`,
			},
		}, {
			`a:b,c,d:e,f:g="h";i=[10,20,30];j=40`,
			query.Query{
				Suite: "a",
				Files: "b,c,d",
				Tests: "e,f",
				Cases: `g="h";i=[10,20,30];j=40`,
			},
		},
	} {
		parsed := query.Parse(test.input)
		assert.Equal(t, test.expected, parsed)
		expectationFileString := test.expected.ExpectationFileString()
		assert.Equal(t, test.input, expectationFileString)
	}
}

func TestCompare(t *testing.T) {
	type Test struct {
		a, b   query.Query
		expect int
	}

	for _, test := range []Test{
		{Q("a"), Q("a"), 0},
		{Q("a:*"), Q("a"), 1},
		{Q("a:*"), Q("a:*"), 0},
		{Q("a:*"), Q("b:*"), -1},
		{Q("a:*"), Q("a:b,*"), -1},
		{Q("a:b,*"), Q("a:b"), 1},
		{Q("a:b,*"), Q("a:b,*"), 0},
		{Q("a:b,*"), Q("a:c,*"), -1},
		{Q("a:b,c,*"), Q("a:b,*"), 1},
		{Q("a:b,c,*"), Q("a:b,c,*"), 0},
		{Q("a:b,c,d,*"), Q("a:b,c,*"), 1},
		{Q("a:b,c,*"), Q("a:b,c:d,*"), 1},
		{Q("a:b,c:*"), Q("a:b,c,d,*"), -1},
		{Q("a:b,c:d,*"), Q("a:b,c:d,*"), 0},
		{Q("a:b,c:d,e,*"), Q("a:b,c:d,*"), 1},
		{Q("a:b,c:d,e,*"), Q("a:b,c:d,e,*"), 0},
		{Q("a:b,c:d,e,*"), Q("a:b,c:e,f,*"), -1},
		{Q("a:b:c:d;*"), Q("a:b:c:d;*"), 0},
		{Q("a:b:c:d;e=1;*"), Q("a:b:c:d;*"), 1},
		{Q("a:b:c:d;e=2;*"), Q("a:b:c:d;e=1;*"), 1},
		{Q("a:b:c:d;e=1;f=2;*"), Q("a:b:c:d;*"), 1},
	} {
		if got, expect := test.a.Compare(test.b), test.expect; got != expect {
			t.Errorf("('%v').Compare('%v')\nexpect: %+v\ngot:    %+v", test.a, test.b, expect, got)
		}
		// Check opposite order
		if got, expect := test.b.Compare(test.a), -test.expect; got != expect {
			t.Errorf("('%v').Compare('%v')\nexpect: %+v\ngot:    %+v", test.b, test.a, expect, got)
		}
	}
}

func TestContains(t *testing.T) {
	type Test struct {
		a, b   query.Query
		expect bool
	}

	for _, test := range []Test{
		{Q("a"), Q("a"), true},
		{Q("a"), Q("b"), false},
		{Q("a:*"), Q("a:*"), true},
		{Q("a:*"), Q("a:b"), true},
		{Q("a:*"), Q("b"), false},
		{Q("a:*"), Q("b:c"), false},
		{Q("a:*"), Q("b:*"), false},
		{Q("a:*"), Q("a:b,*"), true},
		{Q("a:b,*"), Q("a:*"), false},
		{Q("a:b,*"), Q("a:b"), true},
		{Q("a:b,*"), Q("a:c"), false},
		{Q("a:b,*"), Q("a:b,*"), true},
		{Q("a:b,*"), Q("a:c,*"), false},
		{Q("a:b,c"), Q("a:b,c,d"), false},
		{Q("a:b,c"), Q("a:b,c:d"), false},
		{Q("a:b,c,*"), Q("a:b,*"), false},
		{Q("a:b,c,*"), Q("a:b,c"), true},
		{Q("a:b,c,*"), Q("a:b,d"), false},
		{Q("a:b,c,*"), Q("a:b,c,*"), true},
		{Q("a:b,c,*"), Q("a:b,c,d,*"), true},
		{Q("a:b,c,*"), Q("a:b,c:d,*"), true},
		{Q("a:b,c:*"), Q("a:b,c,d,*"), false},
		{Q("a:b,c:d"), Q("a:b,c:d,e"), false},
		{Q("a:b,c:d,*"), Q("a:b,c:d"), true},
		{Q("a:b,c:d,*"), Q("a:b,c:e"), false},
		{Q("a:b,c:d,*"), Q("a:b,c:d,*"), true},
		{Q("a:b,c:d,*"), Q("a:b,c:d,e,*"), true},
		{Q("a:b,c:d,e,*"), Q("a:b,c:d,e"), true},
		{Q("a:b,c:d,e,*"), Q("a:b,c:e,e"), false},
		{Q("a:b,c:d,e,*"), Q("a:b,c:d,f"), false},
		{Q("a:b,c:d,e,*"), Q("a:b,c:d,e,*"), true},
		{Q("a:b,c:d,e,*"), Q("a:b,c:e,f,*"), false},
		{Q("a:b,c:d,e,*"), Q("a:b,c:d,*"), false},
		{Q("a:b:c:d;*"), Q("a:b:c:d;*"), true},
		{Q("a:b:c:d;*"), Q("a:b:c:d,e;*"), true},
		{Q("a:b:c:d;*"), Q("a:b:c:d;e=1;*"), true},
		{Q("a:b:c:d;*"), Q("a:b:c:d;e=1;*"), true},
		{Q("a:b:c:d;*"), Q("a:b:c:d;e=1;f=2;*"), true},
		{Q("a:b:c:d;e=1;*"), Q("a:b:c:d;*"), true},
		{Q("a:b:c:d;e=1;f=2;*"), Q("a:b:c:d;*"), true},
		{Q("a:b:c:d;e=1;*"), Q("a:b:c:d;e=2;*"), false},
		{Q("a:b:c:d;e=2;*"), Q("a:b:c:d;e=1;*"), false},
		{Q("a:b:c:d;e;*"), Q("a:b:c:d;e=1;*"), false},
	} {
		if got := test.a.Contains(test.b); got != test.expect {
			t.Errorf("('%v').Contains('%v')\nexpect: %+v\ngot:    %+v", test.a, test.b, test.expect, got)
		}
	}
}

func TestWalk(t *testing.T) {
	type Segment struct {
		Query  query.Query
		Target query.Target
		Name   string
	}
	type Test struct {
		query  query.Query
		expect []Segment
	}

	for _, test := range []Test{
		{
			Q("suite"), []Segment{
				{Q("suite"), query.Suite, "suite"},
			}},
		{
			Q("suite:*"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:*"), query.Files, "*"},
			}},
		{
			Q("suite:a"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:a"), query.Files, "a"},
			}},
		{
			Q("suite:a,*"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:a"), query.Files, "a"},
				{Q("suite:a,*"), query.Files, "*"},
			}},
		{
			Q("suite:a,b"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:a"), query.Files, "a"},
				{Q("suite:a,b"), query.Files, "b"},
			}},
		{
			Q("suite:a,b:*"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:a"), query.Files, "a"},
				{Q("suite:a,b"), query.Files, "b"},
				{Q("suite:a,b:*"), query.Tests, "*"},
			}},
		{
			Q("suite:a,b:c"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:a"), query.Files, "a"},
				{Q("suite:a,b"), query.Files, "b"},
				{Q("suite:a,b:c"), query.Tests, "c"},
			}},
		{
			Q("suite:a,b:c,*"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:a"), query.Files, "a"},
				{Q("suite:a,b"), query.Files, "b"},
				{Q("suite:a,b:c"), query.Tests, "c"},
				{Q("suite:a,b:c,*"), query.Tests, "*"},
			}},
		{
			Q("suite:a,b:c,d"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:a"), query.Files, "a"},
				{Q("suite:a,b"), query.Files, "b"},
				{Q("suite:a,b:c"), query.Tests, "c"},
				{Q("suite:a,b:c,d"), query.Tests, "d"},
			}},
		{
			Q("suite:a,b:c,d:*"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:a"), query.Files, "a"},
				{Q("suite:a,b"), query.Files, "b"},
				{Q("suite:a,b:c"), query.Tests, "c"},
				{Q("suite:a,b:c,d"), query.Tests, "d"},
				{Q("suite:a,b:c,d:*"), query.Cases, "*"},
			}},
		{
			Q("suite:a,b:c,d:e"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:a"), query.Files, "a"},
				{Q("suite:a,b"), query.Files, "b"},
				{Q("suite:a,b:c"), query.Tests, "c"},
				{Q("suite:a,b:c,d"), query.Tests, "d"},
				{Q("suite:a,b:c,d:e"), query.Cases, "e"},
			}},
		{
			Q("suite:a,b:c,d:e;*"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:a"), query.Files, "a"},
				{Q("suite:a,b"), query.Files, "b"},
				{Q("suite:a,b:c"), query.Tests, "c"},
				{Q("suite:a,b:c,d"), query.Tests, "d"},
				{Q("suite:a,b:c,d:e;*"), query.Cases, "e;*"},
			}},
		{
			Q("suite:a,b:c,d:e;f"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:a"), query.Files, "a"},
				{Q("suite:a,b"), query.Files, "b"},
				{Q("suite:a,b:c"), query.Tests, "c"},
				{Q("suite:a,b:c,d"), query.Tests, "d"},
				{Q("suite:a,b:c,d:e;f"), query.Cases, "e;f"},
			}},
		{
			Q("suite:a,b:c,d:e;f;*"), []Segment{
				{Q("suite"), query.Suite, "suite"},
				{Q("suite:a"), query.Files, "a"},
				{Q("suite:a,b"), query.Files, "b"},
				{Q("suite:a,b:c"), query.Tests, "c"},
				{Q("suite:a,b:c,d"), query.Tests, "d"},
				{Q("suite:a,b:c,d:e;f;*"), query.Cases, "e;f;*"},
			}},
	} {
		got := []Segment{}
		err := test.query.Walk(func(q query.Query, t query.Target, n string) error {
			got = append(got, Segment{q, t, n})
			return nil
		})
		if err != nil {
			t.Errorf("'%v'.Walk() returned %v", test.query, err)
			continue
		}
		if diff := cmp.Diff(got, test.expect); diff != "" {
			t.Errorf("'%v'.Walk()\n%v", test.query, diff)
		}
	}
}

type TestError struct{}

func (TestError) Error() string { return "test error" }

func TestWalkErrors(t *testing.T) {
	for _, fq := range []query.Query{
		Q("suite"),
		Q("suite:*"),
		Q("suite:a"),
		Q("suite:a,*"),
		Q("suite:a,b"),
		Q("suite:a,b:*"),
		Q("suite:a,b:c"),
		Q("suite:a,b:c,*"),
		Q("suite:a,b:c,d"),
		Q("suite:a,b:c,d:*"),
		Q("suite:a,b:c,d:e"),
		Q("suite:a,b:c,d:e;*"),
		Q("suite:a,b:c,d:e;f"),
		Q("suite:a,b:c,d:e;f;*"),
	} {
		expect := TestError{}
		got := fq.Walk(func(q query.Query, t query.Target, n string) error {
			if q == fq {
				return expect
			}
			return nil
		})
		if diff := cmp.Diff(got, expect); diff != "" {
			t.Errorf("'%v'.Walk()\n%v", fq, diff)
		}
	}
}