qt3

type Assertion struct {
	// Kind is the element name: "assert-eq", "all-of", "error", and so on.
	Kind string
	// Value is the character data, which for most kinds is the expected value.
	Value string
	// Code is the @code of an <error>, and @type of an assert-type.
	Code string
	// Flags is the @flags of a serialization-matches: the regular expression
	// flags fn:matches would be given. It is a field of its own rather than
	// another use of Code because a serialization-matches carries both — the
	// suite writes flags="q" beside no code at all, and folding them together
	// would make a literal-match assertion look like an error assertion.
	Flags string
	// File is the @file of an assert-xml whose expected value is held in a
	// separate document rather than inline. Without it the comparison ran
	// against an empty string, which reported every such case as a mismatch
	// against "".
	File string
	// Children are the operands of all-of / any-of / not.
	Children []Assertion
}

type Catalog struct {
	XMLName      xml.Name      `xml:"catalog"`
	TestSets     []TestSetRef  `xml:"test-set"`
	Environments []Environment `xml:"environment"`
}

type Collation struct {
	URI     string `xml:"uri,attr"`
	Default string `xml:"default,attr"`
}

type Collection struct {
	URI     string   `xml:"uri,attr"`
	Sources []Source `xml:"source"`
}

type ContextItem struct {
	Select string `xml:"select,attr"`
}

type DecimalFormatDecl struct {
	// Name is the lexical QName the declaration carries. Its prefix may be
	// declared on the decimal-format element itself, so the namespace it
	// binds to is recovered from Attrs rather than from the environment.
	Name              string     `xml:"name,attr"`
	Attrs             []xml.Attr `xml:",any,attr"`
	DecimalSeparator  string     `xml:"decimal-separator,attr"`
	GroupingSeparator string     `xml:"grouping-separator,attr"`
	Percent           string     `xml:"percent,attr"`
	PerMille          string     `xml:"per-mille,attr"`
	ZeroDigit         string     `xml:"zero-digit,attr"`
	Digit             string     `xml:"digit,attr"`
	PatternSeparator  string     `xml:"pattern-separator,attr"`
	MinusSign         string     `xml:"minus-sign,attr"`
	Infinity          string     `xml:"infinity,attr"`
	NaN               string     `xml:"NaN,attr"`
	ExponentSeparator string     `xml:"exponent-separator,attr"`
}

type Dependency struct {
	Type      string `xml:"type,attr"`
	Value     string `xml:"value,attr"`
	Satisfied string `xml:"satisfied,attr"`
}

type Environment struct {
	Name    string   `xml:"name,attr"`
	Ref     string   `xml:"ref,attr"`
	Sources []Source `xml:"source"`
	Params  []Param  `xml:"param"`
	// ContextItem supplies the context item as an expression to evaluate,
	// rather than as a document to load the way a "." source does. A handful
	// of environments set an atomic or an array this way — "declare context
	// item as xs:integer external" against a supplied 'London' is how
	// contextDecl-020 asks for XPTY0004 — and without it the item is absent
	// and the case gets XPDY0002 instead.
	ContextItem []ContextItem `xml:"context-item"`
	Namespaces  []Namespace   `xml:"namespace"`
	Schemas     []Schema      `xml:"schema"`
	// Collations and a declared default collation appear on a few
	// environments; a test needing a non-codepoint one is unsupported here.
	Collations []Collation `xml:"collation"`
	// StaticBaseURI supplies the base URI of the expression itself, which is
	// what fn:static-base-uri returns and what fn:resolve-uri resolves
	// against.
	StaticBaseURI []StaticBaseURI `xml:"static-base-uri"`
	// Collections are the document sets fn:collection returns.
	Collections []Collection `xml:"collection"`
	// Resources are the non-XML files fn:unparsed-text reads, mapping the URI
	// a case names to the file in the checkout that holds it.
	Resources []Resource `xml:"resource"`
	// DecimalFormats are the decimal formats fn:format-number reads. Only the
	// unnamed (default) one is used by these cases.
	DecimalFormats []DecimalFormatDecl `xml:"decimal-format"`
}

type Namespace struct {
	Prefix string `xml:"prefix,attr"`
	URI    string `xml:"uri,attr"`
}

type Outcome int

type Param struct {
	Name   string `xml:"name,attr"`
	Select string `xml:"select,attr"`
	As     string `xml:"as,attr"`
	// A param's name may carry a prefix, and the binding for it is declared
	// on the param element rather than on the environment — extvardeclwithtype-24
	// writes xmlns:test on the <param> and names "test:x". Capturing the
	// element's own attributes is the only way to see it, since the
	// environment's <namespace> children do not mention it.
	Attrs []xml.Attr `xml:",any,attr"`
}

type Report struct {
	Set, Case string
	Outcome   Outcome
	Reason    string
	// Expr is the expression the case evaluated. A failure line naming only
	// the case means opening the catalog to find out what it ran; carrying it
	// here makes the report reproducible by hand.
	Expr string
}

type Resource struct {
	File      string `xml:"file,attr"`
	URI       string `xml:"uri,attr"`
	MediaType string `xml:"media-type,attr"`
	Encoding  string `xml:"encoding,attr"`
}

type Result struct {
	Raw []byte `xml:",innerxml"`
}

type Runner struct {
	Root string
	// Target is the language version the run is scoped to. The zero value is
	// XPath20, so an existing caller that does not set it keeps the 2.0 run
	// it had before.
	Target TargetVersion
	// contains filtered or unexported fields
}

type Schema struct {
	URI  string `xml:"uri,attr"`
	File string `xml:"file,attr"`
}

type Source struct {
	Role string `xml:"role,attr"`
	File string `xml:"file,attr"`
	URI  string `xml:"uri,attr"`
}

type StaticBaseURI struct {
	URI string `xml:"uri,attr"`
}

type TargetVersion int

type TestCase struct {
	Name         string        `xml:"name,attr"`
	Description  string        `xml:"description"`
	Environments []Environment `xml:"environment"`
	Dependencies []Dependency  `xml:"dependency"`
	// Test carries the <test> element both ways it can be written: the query
	// inline as character data, or a "file" attribute naming a file beside
	// the test set that holds it. LoadTestSet reads the file form in, so
	// everything downstream reads Test.Query whichever way the case was
	// written.
	//
	// One field rather than two because the decoder refuses to map two struct
	// fields onto the same element name.
	Test struct {
		Query string `xml:",chardata"`
		File  string `xml:"file,attr"`
	} `xml:"test"`
	Modules []struct {
		URI  string `xml:"uri,attr"`
		File string `xml:"file,attr"`
	} `xml:"module"`
	Result Result `xml:"result"`
}

type TestSet struct {
	XMLName      xml.Name      `xml:"test-set"`
	Name         string        `xml:"name,attr"`
	Environments []Environment `xml:"environment"`
	Dependencies []Dependency  `xml:"dependency"`
	Cases        []TestCase    `xml:"test-case"`

	// Dir is the test-set file's directory, relative to the suite root.
	//
	// Source paths are relative to the test-set file, not to the root:
	// fn/collection.xml names "../docs/bib.xml". Joining those against the
	// root walks above it and the file is not found, so the directory has to
	// travel with the parsed set.
	Dir string `xml:"-"`
}

type TestSetRef struct {
	Name string `xml:"name,attr"`
	File string `xml:"file,attr"`
}