ValidatingXsltSpecification

implicit abstract val outputSchema: Builder

abstract val stylesheet: Source

The stylesheet you want to test.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object XPath

object XSLT

Functions for converting an XSLT stylesheet into a Source.

def applying(query: String)(input: ⇒ Node): TemplateApplication

Apply the XSLT template for the node selected by the given XPath query, using the input Node as the context node.

def applying(input: ⇒ Node): TemplateApplication

Apply the XSLT template for the given Node in the stylesheet defined in this specification.

final def asInstanceOf[T0]: T0

def asMap(tuple: (String, Any)*): Map[QName, XdmValue]

Convert a sequence of tuples into a Map of parameters that Saxon understands.

def attribute(a: (String, String)): XdmNode

Create an XdmNode attribute() node.

def beMatching(query: String): XPathResultMatcher[Transformation]

A specs2 matcher that tests whether a node matches an XPath expression.

applying { <foo>x</foo> } must beMatching("bar[. eq 'x']")

def beValid(implicit outputSchema: Builder): SchemaValidationMatcher[Transformation]

Validate the transformation result against the XML Schema in the implicit scope.

def beValidAgainst(schema: Builder): SchemaValidationMatcher[Transformation]

Validate the transformation result against the given XML Schema.

final val builder: DocumentBuilder

A Saxon DocumentBuilder instance for converting DOM nodes into XML Data Model (XDM) instances

def callingFunction(lexical: String)(parameters: Any*)(implicit namespace: String): FunctionCall

Call an XSLT function, using the namespace URI defined implicitly in the XsltSpecification instance.

def callingFunction(uri: String, lexical: String)(parameters: Any*): FunctionCall

Call an XSLT function with the given parameters.

def callingTemplate(name: String, contextNode: Node): TemplateCall

Call a named XSLT template and supply a context node (as Node) for the transformation.

def callingTemplate(name: String, contextNode: XdmNode): TemplateCall

Call a named XSLT template and supply a context node (as XdmNode) for the transformation.

def callingTemplate(name: String): TemplateCall

Call a named XSLT template

def clone(): AnyRef

final val configuration: Configuration

An extensible Saxon Configuration instance.

def convert(value: Any): Any

val defaultMatcher: (Source) ⇒ CompareMatcher

The default matcher for comparing two XML element or document nodes.

def documentNode(node: Node): XdmNode

Convert an Elem into an XdmNode document-node() node.

def element(node: Node): XdmNode

Convert an Elem into an XdmNode element() node.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

lazy val fileSystem: FileSystem

The in-memory file system that stores MockFile instances and documents generated with <xsl:result-document>.

def filterAttr(f: (Attr) ⇒ Boolean): (Source) ⇒ CompareMatcher

Create a function that takes a Source and returns a CompareMatcher that filters attributes according to the given predicate.

// Apply templates for x, ignore differences in the @id attribute.
applying(<x/>) must produce(<y/>)(filterAttr(!XPath.matches("@id", _))

def filterNode(f: (Node) ⇒ Boolean): (Source) ⇒ CompareMatcher

Create a function that takes a Source and returns a CompareMatcher that filters nodes according to the given predicate.

// Apply templates for a, ignore differences in the d children of c.
applying(<a><b/></a>) must produce(<c/>)(filterNode(!XPath.matches("c/d", _))

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

val inputSchema: Option[Builder]

The XML Schema to use for validating the input XML and loading default attributes

import org.xmlunit.builder.Input

override val inputSchema = Some(Input.fromFile("schema.xsd"))

final def isInstanceOf[T0]: Boolean

implicit def matcher: (Source) ⇒ CompareMatcher

A function that takes a Source and returns a CompareMatcher that compares the given Source to an XML fragment.

class MySpecification extends mutable.Specification with XsltSpecification {
    ...

    // A matcher that ignores @id attributes when comparing elements.
    override implicit def matcher = (s: Source) => defaultMatcher(s).withAttributeFilter(
        filter[Attr](a => a.getName != "id")
    )

    ...
}

"Ignore an attribute" in {
    // Define a custom matcher for this test only.
    val m = (s: Source) => defaultMatcher(s).withAttributeFilter(
    // Ignore any attribute called "ignore-me".
        filter[Attr](a => a.getName != "ignore-me")
    )

    // Pass in the custom matcher.
    applying(<x/>) must produce(<y/>)(m)
}

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val parameters: Map[QName, XdmValue]

Global stylesheet parameters.

scala> asMap("string" -> "foo", "int" -> 1, "uri" -> new URI("http://www.google.com"))
res2: Map[QName, XdmItem] = Map(string -> foo, int -> 1, uri -> http://www.google.com)

def pi(pi: ProcInstr): XdmNode

Convert a ProcInstr into an XdmNode processing-instruction() node.

final val processor: Processor

The Saxon Processor to use for running the stylesheet.

def produce(result: ⇒ Vector[Any])(implicit matcher: (Source) ⇒ CompareMatcher): Matcher[Transformation]

Create a matcher that compares the supplied arguments against the result of an XML transformation.

class MySpecification extends mutable.Specification with XsltSpecification {
    val stylesheet = XSLT.file("my-stylesheet.xsl")

    "Convert a into b" in {
        // Apply the templates for the  element in the XSLT stylesheet and check the result.
        applying { <a>foo</a> } must produce { <b>foo</b> }
    }
}

def produce(any: Any*)(implicit matcher: (Source) ⇒ CompareMatcher): Matcher[Transformation]

final def synchronized[T0](arg0: ⇒ T0): T0

def text(data: String): XdmNode

Convert a String into an XdmNode text() node.

def toString(): String

def transformer: Xslt30Transformer

Get a new Xslt30Transformer instance for the compiled stylesheet.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

lazy val xpathCompiler: XPathCompiler

lazy val xsltCompiler: XsltCompiler