// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package query_checker_test

import (
	"errors"
	"fmt"
	"reflect"
	"testing"

	"v.io/syncbase/v23/syncbase/nosql/internal/query/query_checker"
	"v.io/syncbase/v23/syncbase/nosql/internal/query/query_parser"
	"v.io/syncbase/v23/syncbase/nosql/query_db"
	"v.io/syncbase/v23/syncbase/nosql/syncql"
	"v.io/v23"
	"v.io/v23/context"
	"v.io/v23/verror"
	_ "v.io/x/ref/runtime/factories/generic"
	"v.io/x/ref/test"
	"strings"
)

// oneOf represents an expectation that more than one type of error may be
// returned by the corresponding test.
type oneOf []interface{}

func (o oneOf) matches(err error) bool {
	for _, e := range o {
		switch e := e.(type) {
		case error:
			if e.Error() == err.Error() {
				return true
			}
		case vErrorContaining:
			vErr, ok := err.(verror.E)
			if !ok {
				continue
			}
			if e.matches(vErr) {
				return true
			}
		}
	}
	return false
}

// containing represents an expectation that an error will be of the given
// VError type and will contain the given string.
type vErrorContaining struct {
	id verror.ID
	message string
}

func newVErrorContaining(id verror.ID, message string) vErrorContaining {
	return vErrorContaining{
		id: id,
		message: message,
	}
}

func (v vErrorContaining) matches(err verror.E) bool {
	if err.ID != v.id {
		return false
	}
	if !strings.Contains(err.Error(), v.message) {
		return false
	}
	return true
}

func (v vErrorContaining) String() string {
	return fmt.Sprintf("VError containing ID=%s, message=%s", v.id, v.message)
}

type mockDB struct {
	ctx *context.T
}

func (db *mockDB) GetContext() *context.T {
	return db.ctx
}

type customerTable struct {
}

type invoiceTable struct {
}

func init() {
	var shutdown v23.Shutdown
	db.ctx, shutdown = test.V23Init()
	defer shutdown()
}

func (t invoiceTable) Scan(keyRanges query_db.KeyRanges) (query_db.KeyValueStream, error) {
	return nil, errors.New("unimplemented")
}

func (t customerTable) Scan(keyRanges query_db.KeyRanges) (query_db.KeyValueStream, error) {
	return nil, errors.New("unimplemented")
}

func (db *mockDB) GetTable(table string) (query_db.Table, error) {
	if table == "Customer" {
		var t customerTable
		return t, nil
	} else if table == "Invoice" {
		var t invoiceTable
		return t, nil
	}
	return nil, errors.New(fmt.Sprintf("No such table: %s", table))
}

var db mockDB

type checkSelectTest struct {
	query string
}

type keyRangesTest struct {
	query     string
	keyRanges *query_db.KeyRanges
}

type regularExpressionsTest struct {
	query      string
	regex      string
	matches    []string
	nonMatches []string
}

type parseSelectErrorTest struct {
	query string
	err   interface{}
}

func TestQueryChecker(t *testing.T) {
	basic := []checkSelectTest{
		{"select k, v from Customer"},
		{"select k, v.name from Customer"},
		{"select k, v.name from Customer limit 200"},
		{"select k, v.name from Customer offset 100"},
		{"select k, v.name from Customer where k = \"foo\""},
		{"select v.z from Customer where k = v.y"},
		{"select v.z from Customer where k <> v.y"},
		{"select v.z from Customer where k < v.y"},
		{"select v.z from Customer where k <= v.y"},
		{"select v.z from Customer where k > v.y"},
		{"select v.z from Customer where k >= v.y"},
		{"select v from Customer where k is nil"},
		{"select v from Customer where k is not nil"},
		{"select k, v.name from Customer where \"foo\" = k"},
		{"select v.z from Customer where v.y = k"},
		{"select v.z from Customer where v.y <> k"},
		{"select v.z from Customer where v.y < k"},
		{"select v.z from Customer where v.y <= k"},
		{"select v.z from Customer where v.y > k"},
		{"select v.z from Customer where v.y >= k"},
		{"select v.z from Customer where \"abc%\" = k"},
		{"select v from Customer where k is nil"},
		{"select v from Customer where k is not nil"},
		{"select v from Customer where Type(v) = \"Foo.Bar\""},
		{"select v from Customer where Type(v) <> \"Foo.Bar\""},
		{"select v from Customer where Type(v) < \"Foo.Bar\""},
		{"select v from Customer where Type(v) <= \"Foo.Bar\""},
		{"select v from Customer where Type(v) > \"Foo.Bar\""},
		{"select v from Customer where Type(v) >= \"Foo.Bar\""},
		{"select v from Customer where Type(v) like \"%.Foo.Bar\""},
		{"select v from Customer where Type(v) not like \"%.Foo.Bar\""},
		{"select v from Customer where Type(v) is nil"},
		{"select v from Customer where Type(v) is not nil"},
		{"select v from Customer where \"Foo.Bar\" = Type(v)"},
		{"select v from Customer where \"Foo.Bar\" <> Type(v)"},
		{"select v from Customer where \"Foo.Bar\" < Type(v)"},
		{"select v from Customer where \"Foo.Bar\" > Type(v)"},
		{"select v from Customer where \"Foo.Bar\" <= Type(v)"},
		{"select v from Customer where \"Foo.Bar\" >= Type(v)"},
		{"select v.z from Customer where Type(v) = 2"},
		{"select v.z from Customer where Type(v) <> \"foo\""},
		{"select v.z from Customer where Type(v) < \"foo\""},
		{"select v.z from Customer where Type(v) <= \"foo\""},
		{"select v.z from Customer where Type(v) > \"foo\""},
		{"select v.z from Customer where Type(v) >= \"foo\""},
		{"select v.z from Customer where \"foo\" = Type(v)"},
		{"select k, v from Customer where Type(v) = \"Foo.Bar\" and k like \"abc%\" limit 100 offset 200"},
		{"select v from Customer where Type(v) is nil"},
		{"select v from Customer where Type(v) is not nil"},
		{"select v.z from Customer where k not like \"foo\""},
		{"select v.z from Customer where k not like \"foo%\""},
		{"select v from Customer where v.A = true"},
		{"select v from Customer where v.A <> true"},
		{"select v from Customer where false = v.A"},
		{"select v from Customer where false = false"},
		{"select v from Customer where true = true"},
		{"select v from Customer where false = true"},
		{"select v from Customer where true = false"},
		{"select v from Customer where false <> true"},
		{"select v from Customer where v.ZipCode is nil"},
		{"select v from Customer where v.ZipCode Is Nil"},
		{"select v from Customer where v.ZipCode is not nil"},
		{"select v from Customer where v.ZipCode IS NOT NIL"},
		{"select v from Customer where Now() < 10"},
		{"select Now() from Customer"},
		{"select Time(\"2006-01-02 MST\", \"2015-06-01 PST\"), Time(\"2006-01-02 15:04:05 MST\", \"2015-06-01 12:34:56 PST\"), Year(Now(), \"America/Los_Angeles\") from Customer"},
	}

	for _, test := range basic {
		s, syntaxErr := query_parser.Parse(&db, test.query)
		if syntaxErr != nil {
			t.Errorf("query: %s; unexpected error: got %v, want nil", test.query, syntaxErr)
		}
		err := query_checker.Check(&db, s)
		if err != nil {
			t.Errorf("query: %s; got %v, want: nil", test.query, err)
		}
	}
}

func appendZeroByte(start string) string {
	limit := []byte(start)
	limit = append(limit, 0)
	return string(limit)

}

func TestKeyRanges(t *testing.T) {
	basic := []keyRangesTest{
		{
			"select k, v from Customer",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "", Limit: ""},
			},
		},
		{
			"select k, v from Customer where k = \"abc\" or k = \"def\"",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "abc", Limit: appendZeroByte("abc")},
				query_db.KeyRange{Start: "def", Limit: appendZeroByte("def")},
			},
		},
		{
			"select k, v from Customer where \"abc\" = k or \"def\" = k",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "abc", Limit: appendZeroByte("abc")},
				query_db.KeyRange{Start: "def", Limit: appendZeroByte("def")},
			},
		},
		{
			"select k, v from Customer where k >= \"foo\" and k < \"goo\"",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "foo", Limit: "goo"},
			},
		},
		{
			"select k, v from Customer where \"foo\" <= k and \"goo\" >= k",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "foo", Limit: appendZeroByte("goo")},
			},
		},
		{
			"select k, v from Customer where k <> \"foo\"",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "", Limit: "foo"},
				query_db.KeyRange{Start: appendZeroByte("foo"), Limit: ""},
			},
		},
		{
			"select k, v from Customer where k <> \"foo\" and k > \"bar\"",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: appendZeroByte("bar"), Limit: "foo"},
				query_db.KeyRange{Start: appendZeroByte("foo"), Limit: ""},
			},
		},
		{
			"select k, v from Customer where k <> \"foo\" or k > \"bar\"",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "", Limit: ""},
			},
		},
		{
			"select k, v from Customer where k <> \"bar\" or k > \"foo\"",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "", Limit: "bar"},
				query_db.KeyRange{Start: appendZeroByte("bar"), Limit: ""},
			},
		},
		{
			"select v from Customer where Type(v) = \"Foo.Bar\" and k >= \"100\" and k < \"200\" and v.foo > 50 and v.bar <= 1000 and v.baz <> -20.7",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "100", Limit: "200"},
			},
		},
		{
			"select k, v from Customer where k = \"abc\" and k = \"def\"",
			&query_db.KeyRanges{},
		},
		{
			"select k, v from Customer where Type(v) = \"Foo.Bar\" and k like \"abc%\" limit 100 offset 200",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "abc", Limit: "abd"},
			},
		},
		{
			"select  k,  v from \n  Customer where k like \"002%\" or k like \"001%\" or k like \"%\"",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "", Limit: ""},
			},
		},
		{
			"select k, v from Customer where k = \"Foo.Bar\" and k like \"abc%\" limit 100 offset 200",
			&query_db.KeyRanges{},
		},
		{
			"select k, v from Customer where k like \"foo%\" and k like \"bar%\"",
			&query_db.KeyRanges{},
		},
		{
			"select k, v from Customer where k like \"foo%\" or k like \"bar%\"",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "bar", Limit: "bas"},
				query_db.KeyRange{Start: "foo", Limit: "fop"},
			},
		},
		{
			// Note: 'like "Foo"' is optimized to '= "Foo"
			"select k, v from Customer where k = \"Foo.Bar\" or k like \"Foo\" or k like \"abc%\" limit 100 offset 200",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "Foo", Limit: appendZeroByte("Foo")},
				query_db.KeyRange{Start: "Foo.Bar", Limit: appendZeroByte("Foo.Bar")},
				query_db.KeyRange{Start: "abc", Limit: "abd"},
			},
		},
		{
			"select k, v from Customer where k like \"Foo\\%Bar\" or k like \"abc%\" limit 100 offset 200",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "Foo%Bar", Limit: appendZeroByte("Foo%Bar")},
				query_db.KeyRange{Start: "abc", Limit: "abd"},
			},
		},
		{
			"select k, v from Customer where k like \"Foo\\\\%Bar\" or k like \"abc%\" limit 100 offset 200",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "Foo\\", Limit: "Foo]"},
				query_db.KeyRange{Start: "abc", Limit: "abd"},
			},
		},
		{
			"select k, v from Customer where k like \"Foo\\\\\\%Bar\" or k like \"abc%\" limit 100 offset 200",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "Foo\\%Bar", Limit: appendZeroByte("Foo\\%Bar")},
				query_db.KeyRange{Start: "abc", Limit: "abd"},
			},
		},
		{
			"select k, v from Customer where k not like \"002%\"",
			&query_db.KeyRanges{
				query_db.KeyRange{Start: "", Limit: "002"},
				query_db.KeyRange{Start: "003", Limit: ""},
			},
		},
	}

	for _, test := range basic {
		s, syntaxErr := query_parser.Parse(&db, test.query)
		if syntaxErr != nil {
			t.Errorf("query: %s; unexpected error: got %v, want nil", test.query, syntaxErr)
		}
		err := query_checker.Check(&db, s)
		if err != nil {
			t.Errorf("query: %s; got %v, want: nil", test.query, err)
		}
		switch sel := (*s).(type) {
		case query_parser.SelectStatement:
			keyRanges := query_checker.CompileKeyRanges(sel.Where)
			if !reflect.DeepEqual(test.keyRanges, keyRanges) {
				t.Errorf("query: %s;\nGOT  %v\nWANT %v", test.query, keyRanges, test.keyRanges)
			}
		default:
			t.Errorf("query: %s;\nGOT  %v\nWANT query_parser.SelectStatement", test.query, *s)
		}
	}
}

func TestRegularExpressions(t *testing.T) {
	basic := []regularExpressionsTest{
		{
			"select v from Customer where v like \"abc%\"",
			"^abc.*?$",
			[]string{"abc", "abcd", "abcabc"},
			[]string{"xabcd"},
		},
		{
			"select v from Customer where v like \"abc_\"",
			"^abc.$",
			[]string{"abcd", "abc1"},
			[]string{"abc", "xabcd", "abcde"},
		},
		{
			"select v from Customer where v like \"abc_efg\"",
			"^abc.efg$",
			[]string{"abcdefg"},
			[]string{"abc", "xabcd", "abcde", "abcdefgh"},
		},
		{
			"select v from Customer where v like \"abc\\\\efg\"",
			"^abc\\\\efg$",
			[]string{"abc\\efg"},
			[]string{"abc\\", "xabc\\efg", "abc\\de", "abc\\defgh"},
		},
		{
			"select v from Customer where v like \"abc%def\"",
			"^abc.*?def$",
			[]string{"abcdefdef", "abcdef", "abcdefghidef"},
			[]string{"abcdefg", "abcdefde"},
		},
		{
			"select v from Customer where v like \"[0-9]*abc%def\"",
			"^\\[0-9\\]\\*abc.*?def$",
			[]string{"[0-9]*abcdefdef", "[0-9]*abcdef", "[0-9]*abcdefghidef"},
			[]string{"0abcdefg", "9abcdefde", "[0-9]abcdefg", "[0-9]abcdefg", "[0-9]abcdefg"},
		},
		{
			"select v from Customer where v like \"[0-9]*a\\\\b\\\\c%def\"",
			"^\\[0-9\\]\\*a\\\\b\\\\c.*?def$",
			[]string{"[0-9]*a\\b\\cdefdef", "[0-9]*a\\b\\cdef", "[0-9]*a\\b\\cdefghidef"},
			[]string{"0a\\b\\cdefg", "9a\\\b\\cdefde", "[0-9]a\\\b\\cdefg", "[0-9]a\\b\\cdefg", "[0-9]a\\b\\cdefg"},
		},
	}

	for _, test := range basic {
		s, syntaxErr := query_parser.Parse(&db, test.query)
		if syntaxErr != nil {
			t.Errorf("query: %s; unexpected error: got %v, want nil", test.query, syntaxErr)
		}
		err := query_checker.Check(&db, s)
		if err != nil {
			t.Errorf("query: %s; got %v, want: nil", test.query, err)
		}
		switch sel := (*s).(type) {
		case query_parser.SelectStatement:
			// We know there is exactly one like expression and operand2 contains
			// a regex and compiled regex.
			if sel.Where.Expr.Operand2.Regex != test.regex {
				t.Errorf("query: %s;\nGOT  %s\nWANT %s", test.query, sel.Where.Expr.Operand2.Regex, test.regex)
			}
			regexp := sel.Where.Expr.Operand2.CompRegex
			// Make sure all matches actually match
			for _, m := range test.matches {
				if !regexp.MatchString(m) {
					t.Errorf("query: %s;Expected match: %s; \nGOT  false\nWANT true", test.query, m)
				}
			}
			// Make sure all nonMatches actually don't match
			for _, n := range test.nonMatches {
				if regexp.MatchString(n) {
					t.Errorf("query: %s;Expected nonMatch: %s; \nGOT  true\nWANT false", test.query, n)
				}
			}
		}
	}
}

func TestQueryCheckerErrors(t *testing.T) {
	basic := []parseSelectErrorTest{
		{"select a from Customer", syncql.NewErrInvalidSelectField(db.GetContext(), 7)},
		{"select v from Bob", syncql.NewErrTableCantAccess(db.GetContext(), 14, "Bob", errors.New("No such table: Bob"))},
		{"select k.a from Customer", syncql.NewErrDotNotationDisallowedForKey(db.GetContext(), 9)},
		{"select k from Customer where t.a = \"Foo.Bar\"", syncql.NewErrBadFieldInWhere(db.GetContext(), 29)},
		{"select v from Customer where a=1", syncql.NewErrBadFieldInWhere(db.GetContext(), 29)},
		{"select v from Customer limit 0", syncql.NewErrLimitMustBeGe0(db.GetContext(), 29)},
		{"select v.z from Customer where v.x like v.y", syncql.NewErrLikeExpressionsRequireRhsString(db.GetContext(), 31)},
		{"select v.z from Customer where k like \"a\\bc%\"", syncql.NewErrInvalidEscapedChar(db.GetContext(), 38)},
		{"select v from Customer where v.A > false", syncql.NewErrBoolInvalidExpression(db.GetContext(), 33)},
		{"select v from Customer where true <= v.A", syncql.NewErrBoolInvalidExpression(db.GetContext(), 34)},
		{"select v from Customer where Foo(\"2015/07/22\", true, 3.14157) = true", syncql.NewErrFunctionNotFound(db.GetContext(), 29, "Foo")},
		{"select v from Customer where nil is v.ZipCode", syncql.NewErrIsIsNotRequireLhsValue(db.GetContext(), 29)},
		{"select v from Customer where v.ZipCode is \"94303\"", syncql.NewErrIsIsNotRequireRhsNil(db.GetContext(), 42)},
		{"select v from Customer where v.ZipCode is 94303", syncql.NewErrIsIsNotRequireRhsNil(db.GetContext(), 42)},
		{"select v from Customer where v.ZipCode is true", syncql.NewErrIsIsNotRequireRhsNil(db.GetContext(), 42)},
		{"select v from Customer where v.ZipCode is 943.03", syncql.NewErrIsIsNotRequireRhsNil(db.GetContext(), 42)},
		{"select v from Customer where nil is not v.ZipCode", syncql.NewErrIsIsNotRequireLhsValue(db.GetContext(), 29)},
		{"select v from Customer where v.ZipCode is not \"94303\"", syncql.NewErrIsIsNotRequireRhsNil(db.GetContext(), 46)},
		{"select v from Customer where v.ZipCode is not 94303", syncql.NewErrIsIsNotRequireRhsNil(db.GetContext(), 46)},
		{"select v from Customer where v.ZipCode is not true", syncql.NewErrIsIsNotRequireRhsNil(db.GetContext(), 46)},
		{"select v from Customer where v.ZipCode is not 943.03", syncql.NewErrIsIsNotRequireRhsNil(db.GetContext(), 46)},
		// TODO(jkline): check offset for the 1.5 tests.
		{"select v from Customer where Type(v) = \"Customer\" and Year(v.InvoiceDate, \"ABC\") = 2015", oneOf([]interface{}{
			// Go1.4
			syncql.NewErrLocationConversionError(db.GetContext(), 74, errors.New("unknown time zone ABC")),
			// Go1.5
			newVErrorContaining(syncql.ErrLocationConversionError.ID, "cannot find ABC in zip file"),
		})},
		{"select v from Customer where Type(v) = \"Customer\" and Month(v.InvoiceDate, \"ABC\") = 2015", oneOf([]interface{} {
			// Go1.4
			syncql.NewErrLocationConversionError(db.GetContext(), 75, errors.New("unknown time zone ABC")),
			// Go1.5
			newVErrorContaining(syncql.ErrLocationConversionError.ID, "cannot find ABC in zip file"),
		})},
		{"select v from Customer where Type(v) = \"Customer\" and Day(v.InvoiceDate, \"ABC\") = 2015", oneOf([]interface{} {
			// Go1.4
			syncql.NewErrLocationConversionError(db.GetContext(), 73, errors.New("unknown time zone ABC")),
			// Go1.5
			newVErrorContaining(syncql.ErrLocationConversionError.ID, "cannot find ABC in zip file"),
		})},
		{"select v from Customer where Type(v) = \"Customer\" and Hour(v.InvoiceDate, \"ABC\") = 2015", oneOf([]interface{} {
			// Go1.4
			syncql.NewErrLocationConversionError(db.GetContext(), 74, errors.New("unknown time zone ABC")),
			// Go1.5
			newVErrorContaining(syncql.ErrLocationConversionError.ID, "cannot find ABC in zip file"),
		})},
		{"select v from Customer where Type(v) = \"Customer\" and Minute(v.InvoiceDate, \"ABC\") = 2015", oneOf([]interface{} {
			// Go1.4
			syncql.NewErrLocationConversionError(db.GetContext(), 76, errors.New("unknown time zone ABC")),
			// Go1.5
			newVErrorContaining(syncql.ErrLocationConversionError.ID, "cannot find ABC in zip file"),
		})},
		{"select v from Customer where Type(v) = \"Customer\" and Second(v.InvoiceDate, \"ABC\") = 2015", oneOf([]interface{} {
			// Go1.4
			syncql.NewErrLocationConversionError(db.GetContext(), 76, errors.New("unknown time zone ABC")),
			// Go1.5
			newVErrorContaining(syncql.ErrLocationConversionError.ID, "cannot find ABC in zip file"),
		})},
		{"select v from Customer where Type(v) = \"Customer\" and Now(v.InvoiceDate, \"ABC\") = 2015", syncql.NewErrFunctionArgCount(db.GetContext(), 54, "Now", 0, 2)},
		{"select v from Customer where Type(v) = \"Customer\" and Lowercase(v.Name, 2) = \"smith\"", syncql.NewErrFunctionArgCount(db.GetContext(), 54, "Lowercase", 1, 2)},
		{"select v from Customer where Type(v) = \"Customer\" and Uppercase(v.Name, 2) = \"SMITH\"", syncql.NewErrFunctionArgCount(db.GetContext(), 54, "Uppercase", 1, 2)},
		{"select Time() from Customer", syncql.NewErrFunctionArgCount(db.GetContext(), 7, "Time", 2, 0)},
		{"select Year(v.InvoiceDate, \"Foo\") from Customer where Type(v) = \"Invoice\"", oneOf([]interface{}{
			// Go1.4
			syncql.NewErrLocationConversionError(db.GetContext(), 27, errors.New("unknown time zone Foo")),
			// Go1.5
			newVErrorContaining(syncql.ErrLocationConversionError.ID, "cannot find Foo in zip file"),
		})},
		{"select K from Customer where Type(v) = \"Invoice\"", syncql.NewErrDidYouMeanLowercaseK(db.GetContext(), 7)},
		{"select V from Customer where Type(v) = \"Invoice\"", syncql.NewErrDidYouMeanLowercaseV(db.GetContext(), 7)},
		{"select k from Customer where K = \"001\"", syncql.NewErrDidYouMeanLowercaseK(db.GetContext(), 29)},
		{"select v from Customer where Type(V) = \"Invoice\"", syncql.NewErrDidYouMeanLowercaseV(db.GetContext(), 34)},
		{"select K, V from Customer where Type(V) = \"Invoice\" and K = \"001\"", syncql.NewErrDidYouMeanLowercaseK(db.GetContext(), 7)},
	}

	for _, test := range basic {
		s, syntaxErr := query_parser.Parse(&db, test.query)
		if syntaxErr != nil {
			t.Errorf("query: %s; unexpected error: got %v, want nil", test.query, syntaxErr)
		} else {
			err := query_checker.Check(&db, s)
			// Test both that the IDs compare and the text compares (since the offset needs to match).
			switch e := test.err.(type) {
			case error:
				if verror.ErrorID(err) != verror.ErrorID(e) || err.Error() != e.Error() {
					t.Errorf("query: %s; got %v, want %v", test.query, err, test.err)
				}
			case oneOf:
				if !e.matches(err) {
					t.Errorf("query: %s; got %v, want one of %s", test.query, err, e)
				}
			}
		}
	}
}