避免 Scala XML 的 b {"c"} != b c测试中的行为

Question

我正在使用 scalatest，特别想说

actualXML should be === expectedXML

的是 === 不关心属性顺序。然而，当使用 Scala XML 的 { ... } 语法嵌入文本时，断言会失败，因为

scala> <a>b {"c"}</a>.child
res8: scala.xml.Node* = ArrayBuffer(b , c)

：

scala> <a>b c</a>.child
res9: scala.xml.Node* = ArrayBuffer(b c)

我可以编写一个

import scala.xml.Elem
import scala.xml.XML
def launder(xml: Elem): Elem = XML.loadString(xml.toString)

给出的

launder(actualXML) should be === expectedXML

方法，但希望能够使用普通语法。

Answer 1

您可以专门为 Xml Elem 引入自己的 Equalizer 类：

class ElemEqualizer(left: scala.xml.Elem) {
  def ===(right: Any) = new Equalizer(launder(left).===(launder(right))
}
implicit def convertToElemEqualizer(left: scala.xml.Elem) = new ElemEqualizer(left)

@Test def foobar(): Unit = {
  val a = <a>b {"c"}</a>
  val b = <a>b c</a>

  assert(a === b)
}

因此，您将引入另一个隐式转换，但这次专门针对 Elem，它比较经过清洗的 Elem。

Answer 2

请参阅上面的答案 - 我现在更好地了解该地区。下面是修正了括号的代码以及基于 Matthew 和 Dave 评论的测试。

我对它的尺寸表示歉意：

// Tested with Scala 2.9.1

import org.junit.Test
import org.scalatest.Assertions._
import org.scalatest.TestFailedException
import scala.xml.Elem
import scala.xml.Node
import scala.xml.XML
import scala.xml.Utility

class TestEquals {

  val a = <a>b {"c"}</a>
  val b = <a>b c</a>

  @Test def defaultBehaviour {
    assert(a === a)
    assert(b === b)

    // _but_ this fails
    intercept[TestFailedException] { assert(a === b) } // i.e. a != b
  }

  // Add class & implicit to improve the behaviour
  class ElemEqualizer(left: Any) {
    private def launder(x: Any): Node = Utility.trim(x match {
      case xml: String => XML.loadString(xml)
      case xml: Elem => XML.loadString(xml.toString)
    })

    def ===(right: Any): Option[String] =
      new Equalizer(launder(left)).===(launder(right))
  }

  implicit def convertToElemEqualizer(left: Elem) = new ElemEqualizer(left)

  // Retest the behaviour with ElemEqualizer available
  @Test def betterBehaviour {
    assert(a === b)
    assert(a === "<a>b c</a>")  // works for 'right' string that's XML - see launder

    intercept[TestFailedException]
      { assert("<a>b c</a>" === a) } // but not this way round

    // attribute order doesn't matter
    assert(<a attr0="123" attr1="456"/> === <a attr1="456" attr0="123"/>)

    // fails if attribute values don't match - that's good
    intercept[TestFailedException]
      { assert(<a attr0="123" attr1="456"/> === <a attr1="456" attr0="xxx"/>) }

    // and again with 'right' as a string
    intercept[TestFailedException]
      { assert(<a attr0="123" attr1="456"/> === XML.loadString("<a attr1='456' attr0='xxx'/>")) }
  }

  @Test def xmlContainingText {
    // Here left and right wouldn't be equal without use of Utility.trim()
    val left = <a>
 <b>text</b>
</a>
    val right = <a><b>text</b></a>
    assert(left === right)
  }

}