XsltResultMatcher

A specs2 matcher that matches against the result of an XSLT transformation.

The result of an XSLT transformation can either be a node, which can be one of:

Element
Document
Processing instruction
Text
Attribute
Comment

Or it can be an atomic value, which, when converted into a native Java type, can be one of:

String
BigInteger
BigDecimal
Double
Float
Boolean
QName
URI

Element and document nodes are converted into Source so that we can compare them with XMLUnit.

Node instances in the expected Vector are also converted into a Source so that we can compare those to XSLT transformation results.

Other node types are kept as is and we compare their string representations.

Atomic values that are the result of an XSLT transformation are converted to native Java types with Saxon's XdmAtomicValue.getValue() method and compared to the expected values.

Linear Supertypes

MatchResultCombinators, ResultLogicalCombinators, Results, MatchResultLogicalCombinators, Expectations, ExpectationsDescription, TypedEqual, ExpectationsCreation, MatchResultStackTrace, Matcher[T], AnyRef, Any

Instance Constructors

new XsltResultMatcher(expected: Vector[Any])(implicit matcher: (Source) ⇒ CompareMatcher)

Type Members

class Descriptible[T] extends AnyRef

Definition Classes
ExpectationsDescription
class ExpectationDescription extends AnyRef

Definition Classes
ExpectationsDescription
class MatchResultCombinator[T] extends AnyRef

Definition Classes
MatchResultLogicalCombinators
class ResultLogicalCombinator extends AnyRef

Definition Classes
ResultLogicalCombinators
class TypedEqualExpectation[T] extends AnyRef

Definition Classes
TypedEqual

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ^^[S](f: (S) ⇒ Expectable[T], dummy: Int): Matcher[S]

Definition Classes
Matcher
def ^^[S](f: (S) ⇒ T): Matcher[S]

Definition Classes
Matcher
def and[S <: T](m: ⇒ Matcher[S]): Matcher[S]

Definition Classes
Matcher
def apply[S <: T](expectable: Expectable[S]): MatchResult[S]

Definition Classes
XsltResultMatcher → Matcher
final def asInstanceOf[T0]: T0

Definition Classes
Any
def booleanToSimpleResult(b: Boolean): Result

Definition Classes
Results
def checkFailure[T](m: MatchResult[T]): MatchResult[T]

Attributes
protected
Definition Classes
ExpectationsCreation
def checkMatchResultFailure[T](m: MatchResult[T]): MatchResult[T]

Attributes
protected
Definition Classes
ExpectationsCreation
def checkResultFailure(r: ⇒ Result): Result

Attributes
protected
Definition Classes
ExpectationsCreation
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit def combineBoolean(b: ⇒ Boolean): ResultLogicalCombinator

Definition Classes
ResultLogicalCombinators
implicit def combineMatchResult[T](m: ⇒ MatchResult[T]): MatchResultCombinator[T]

Definition Classes
MatchResultLogicalCombinators
implicit def combineResult(r: ⇒ Result): ResultLogicalCombinator

Definition Classes
ResultLogicalCombinators
def createExpectable[T](t: ⇒ T, alias: Option[(String) ⇒ String]): Expectable[T]

Definition Classes
ExpectationsCreation
def createExpectable[T](t: ⇒ T, alias: (String) ⇒ String): Expectable[T]

Definition Classes
ExpectationsCreation
def createExpectable[T](t: ⇒ T, alias: ⇒ String): Expectable[T]

Definition Classes
ExpectationsCreation
def createExpectable[T](t: ⇒ T): Expectable[T]

Definition Classes
ExpectationsCreation
def createExpectableWithShowAs[T](t: ⇒ T, showAs: ⇒ String): Expectable[T]

Definition Classes
ExpectationsCreation
implicit def describe[T](t: ⇒ T): Descriptible[T]

Definition Classes
ExpectationsDescription
implicit def describeExpectation(description: String): ExpectationDescription

Definition Classes
ExpectationsDescription
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def eventually(retries: Int, sleep: Duration): Matcher[T]

Definition Classes
Matcher
def eventually: Matcher[T]

Definition Classes
Matcher
def failure[S <: T](message: ⇒ String, value: Expectable[S]): MatchResult[S]

Attributes
protected
Definition Classes
Matcher
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def iff(b: Boolean): Matcher[T]

Definition Classes
Matcher
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def lazily: Matcher[() ⇒ T]

Definition Classes
Matcher
def mapMatchResult[T](m: MatchResult[T]): MatchResult[T]

Attributes
protected
Definition Classes
ExpectationsCreation
def mute: Matcher[T]

Definition Classes
Matcher
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def negate(r: Result): Result

Definition Classes
Results
def negateWhen(condition: Boolean)(r: Result): Result

Definition Classes
Results
def not: Matcher[T]

Definition Classes
Matcher
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def or[S <: T](m: ⇒ Matcher[S]): Matcher[S]

Definition Classes
Matcher
def orPending(message: (String) ⇒ String): Matcher[T]

Definition Classes
Matcher
def orPending(m: String): Matcher[T]

Definition Classes
Matcher
def orPending: Matcher[T]

Definition Classes
Matcher
def orSkip(message: (String) ⇒ String): Matcher[T]

Definition Classes
Matcher
def orSkip(m: String): Matcher[T]

Definition Classes
Matcher
def orSkip: Matcher[T]

Definition Classes
Matcher
def result[S <: T](other: org.specs2.matcher.MatchResultMessages.MatchResultMessage, value: Expectable[S]): MatchResult[S]

Attributes
protected
Definition Classes
Matcher
def result[S <: T](other: Result, value: Expectable[S]): MatchResult[S]

Attributes
protected
Definition Classes
Matcher
def result[S <: T](other: MatchResult[_], value: Expectable[S]): MatchResult[S]

Attributes
protected
Definition Classes
Matcher
def result[S <: T](test: ⇒ Boolean, okMessage: ⇒ String, koMessage: ⇒ String, value: Expectable[S], details: Details): MatchResult[S]

Attributes
protected
Definition Classes
Matcher
def result[S <: T](test: ⇒ Boolean, okMessage: ⇒ String, koMessage: ⇒ String, value: Expectable[S], expected: String, actual: String): MatchResult[S]

Attributes
protected
Definition Classes
Matcher
def result[S <: T](triplet: ⇒ (Boolean, String, String), value: Expectable[S]): MatchResult[S]

Attributes
protected
Definition Classes
Matcher
def result[S <: T](test: ⇒ Boolean, okMessage: ⇒ String, koMessage: ⇒ String, value: Expectable[S]): MatchResult[S]

Attributes
protected
Definition Classes
Matcher
def sandboxMatchResult[T](mr: ⇒ MatchResult[T]): MatchResult[T]

Attributes
protected
Definition Classes
ExpectationsCreation
def setMessage(message: String): Matcher[T]

Definition Classes
Matcher
def setStacktrace[T](m: MatchResult[T]): MatchResult[T]

Attributes
protected
Definition Classes
MatchResultStackTrace
def success[S <: T](message: ⇒ String, value: Expectable[S]): MatchResult[S]

Attributes
protected
Definition Classes
Matcher
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def test: (T) ⇒ Boolean

Definition Classes
Matcher
implicit def toResult(b: Boolean): Result

Definition Classes
Results
def toString(): String

Definition Classes
AnyRef → Any
implicit def typedEqualExpectation[T](t: ⇒ T): TypedEqualExpectation[T]

Definition Classes
TypedEqual
def unless(b: Boolean, m: String): Matcher[T]

Definition Classes
Matcher
def updateMessage(f: (String) ⇒ String): Matcher[T]

Definition Classes
Matcher
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def when(b: Boolean, m: String): Matcher[T]

Definition Classes
Matcher

Related Doc: package expek

sealed class XsltResultMatcher[T <: Transformation] extends Matcher[T] with MatchResultCombinators

Instance Constructors

new XsltResultMatcher(expected: Vector[Any])(implicit matcher: (Source) ⇒ CompareMatcher)

Type Members

class Descriptible[T] extends AnyRef

class ExpectationDescription extends AnyRef

class MatchResultCombinator[T] extends AnyRef

class ResultLogicalCombinator extends AnyRef

class TypedEqualExpectation[T] extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def ^^[S](f: (S) ⇒ Expectable[T], dummy: Int): Matcher[S]

def ^^[S](f: (S) ⇒ T): Matcher[S]

def and[S <: T](m: ⇒ Matcher[S]): Matcher[S]

def apply[S <: T](expectable: Expectable[S]): MatchResult[S]

final def asInstanceOf[T0]: T0

def booleanToSimpleResult(b: Boolean): Result

def checkFailure[T](m: MatchResult[T]): MatchResult[T]

def checkMatchResultFailure[T](m: MatchResult[T]): MatchResult[T]

def checkResultFailure(r: ⇒ Result): Result

def clone(): AnyRef

implicit def combineBoolean(b: ⇒ Boolean): ResultLogicalCombinator

implicit def combineMatchResult[T](m: ⇒ MatchResult[T]): MatchResultCombinator[T]

implicit def combineResult(r: ⇒ Result): ResultLogicalCombinator

def createExpectable[T](t: ⇒ T, alias: Option[(String) ⇒ String]): Expectable[T]

def createExpectable[T](t: ⇒ T, alias: (String) ⇒ String): Expectable[T]

def createExpectable[T](t: ⇒ T, alias: ⇒ String): Expectable[T]

def createExpectable[T](t: ⇒ T): Expectable[T]

def createExpectableWithShowAs[T](t: ⇒ T, showAs: ⇒ String): Expectable[T]

implicit def describe[T](t: ⇒ T): Descriptible[T]

implicit def describeExpectation(description: String): ExpectationDescription

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eventually(retries: Int, sleep: Duration): Matcher[T]

def eventually: Matcher[T]

def failure[S <: T](message: ⇒ String, value: Expectable[S]): MatchResult[S]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def iff(b: Boolean): Matcher[T]

final def isInstanceOf[T0]: Boolean

def lazily: Matcher[() ⇒ T]

def mapMatchResult[T](m: MatchResult[T]): MatchResult[T]

def mute: Matcher[T]

final def ne(arg0: AnyRef): Boolean

def negate(r: Result): Result

def negateWhen(condition: Boolean)(r: Result): Result

def not: Matcher[T]

final def notify(): Unit

final def notifyAll(): Unit

def or[S <: T](m: ⇒ Matcher[S]): Matcher[S]

def orPending(message: (String) ⇒ String): Matcher[T]

def orPending(m: String): Matcher[T]

def orPending: Matcher[T]

def orSkip(message: (String) ⇒ String): Matcher[T]

def orSkip(m: String): Matcher[T]

def orSkip: Matcher[T]

def result[S <: T](other: org.specs2.matcher.MatchResultMessages.MatchResultMessage, value: Expectable[S]): MatchResult[S]

def result[S <: T](other: Result, value: Expectable[S]): MatchResult[S]

def result[S <: T](other: MatchResult[_], value: Expectable[S]): MatchResult[S]

def result[S <: T](test: ⇒ Boolean, okMessage: ⇒ String, koMessage: ⇒ String, value: Expectable[S], details: Details): MatchResult[S]

def result[S <: T](test: ⇒ Boolean, okMessage: ⇒ String, koMessage: ⇒ String, value: Expectable[S], expected: String, actual: String): MatchResult[S]

def result[S <: T](triplet: ⇒ (Boolean, String, String), value: Expectable[S]): MatchResult[S]

def result[S <: T](test: ⇒ Boolean, okMessage: ⇒ String, koMessage: ⇒ String, value: Expectable[S]): MatchResult[S]

def sandboxMatchResult[T](mr: ⇒ MatchResult[T]): MatchResult[T]

def setMessage(message: String): Matcher[T]

def setStacktrace[T](m: MatchResult[T]): MatchResult[T]

def success[S <: T](message: ⇒ String, value: Expectable[S]): MatchResult[S]

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

def test: (T) ⇒ Boolean

implicit def toResult(b: Boolean): Result

def toString(): String

implicit def typedEqualExpectation[T](t: ⇒ T): TypedEqualExpectation[T]

def unless(b: Boolean, m: String): Matcher[T]

def updateMessage(f: (String) ⇒ String): Matcher[T]

final def wait(): Unit