ScalaTest - writing custom matchers

Question

I am running into a problem while writing a custom matcher for NodeSeq:

private def matchXML(expected: NodeSeq) = new Matcher[NodeSeq] {
  def apply(left: NodeSeq): MatchResult = MatchResult(left xml_== expected,
    "XML structure was not the same (watch spaces in tag texts)",
    "XML messages were equal")
}

This compiles, but the following piece of code:

val expected : NodeSeq = ...
val xml : NodeSeq = ... 
xml should matchXML(expected)

causes:

error: overloaded method value should with alternatives:
(beWord: XMLStripDecoratorTests.this.BeWord)XMLStripDecoratorTests.this.ResultOfBeWordForAnyRef[scala.collection.GenSeq[scala.xml.Node]] <and>
(notWord: XMLStripDecoratorTests.this.NotWord)XMLStripDecoratorTests.this.ResultOfNotWordForAnyRef[scala.collection.GenSeq[scala.xml.Node]] <and>
(haveWord: XMLStripDecoratorTests.this.HaveWord)XMLStripDecoratorTests.this.ResultOfHaveWordForSeq[scala.xml.Node] <and>
(rightMatcher: org.scalatest.matchers.Matcher[scala.collection.GenSeq[scala.xml.Node]])Unit
cannot be applied to (org.scalatest.matchers.Matcher[scala.xml.NodeSeq])
xml should (matchXML(expected))

Any ideas what this means?

What is the definition of NodeSeq ? – Mikaël Mayer May 02 '13 at 15:44 — Mikaël Mayer, May 02 '13 at 15:44
@MikaëlMayer I'd suppose `scala.xml.NodeSeq` – gzm0 May 02 '13 at 15:49 — gzm0, May 02 '13 at 15:49

Mikaël Mayer · Accepted Answer · 2013-08-12T09:26:27.477

Why this fails to typecheck:

The type checker works in the following way.

xml.should(matchXML(expected))

Because the method should is not part of a NodeSeq, the compiler tries to find an implicit conversion for xml to a ShouldMatcher. The book "Programming in Scala" specifies that such implicit conversion should be the most specific:

"Up through Scala 2.7, that was the end of the story. Whenever multiple implicit conversions applied, the compiler refused to choose between them. ... Scala 2.8 loosens this rule. If one of the available conversions is strictly more speciﬁc than the others, then the compiler will choose the more speciﬁc one. ... one implicit conversion is more speciﬁc than another if one of the following applies: The argument type of the former is a subtype of the latter’s. .."

Because NodeSeq extends Seq[Node], the following function

convertToSeqShouldWrapper[T](o : scala.GenSeq[T]) : SeqShouldWrapper[T]

is therefore the most specific one among all others.

The program is rewritten as:

`convertToSeqShouldWrapper(xml).should(matchXML(expected))`

where convertToSeqShouldWrapper(xml) is a SeqShouldWrapper[T] where T = GenSeq[Node].

The method should from SeqShouldWrapper accepts a Matcher[T] which is a function of type T => MatchResult. Therefore, it accepts a Matcher[GenSeq[Node]].

Because T is appearing to the left of the arrow, matchers are not covariant in T, but contravariant. A NodeSeq is a GenSeq[Node], so a Matcher[GenSeq[Node]] is a Matcher[NodeSeq], not the opposite.This explains the above error, where the method should cannot accept a Matcher[NodeSeq] and requires a Matcher[GenSeq[Node]].

2 Solutions

Replace All instances of NodeSeq to GenSeq[Node] so that the type matches everywhere.
Alternatively, wrap xml explicitely with the conversion function.

convertToAnyShouldWrapper(xml).should(matchXML(expected))

While the second solution works, the first one (converting everything to `Seq[Node]`) still shows the same error. — HRJ, Aug 11 '13 at 14:46
I was able to solve this by converting everything to `GenSeq[Node]`. I am using `scalatest 2.0 M5`, hence the difference perhaps. — HRJ, Aug 11 '13 at 14:50
Indeed, with this version, the signature of the convertToSeqShouldWrapper method is `GenSeq[T] => SeqShouldWrapper[T]`. So I updated my answer. — Mikaël Mayer, Aug 12 '13 at 09:23

score -1 · Answer 2 · answered May 03 '13 at 16:24

-1

This looks to me like your matchXML method is not in scope.

answered May 03 '13 at 16:24

Jens Schauder

77,657
34
181
348

ScalaTest - writing custom matchers

2 Answers2

Linked