Migrate a few partest jvm tests to JUnit tests.

Migrated to JUnit the following tests (from test/files/jvm):

   * t0632.scala
   * t1118.scala
   * unittest_xml.scala

None of those tests were dependent on anything jvm specific.

Author: gkossakowski

build.sbt

@@ -81,6 +81,8 @@ pomExtra := (
 // default value must be set here
 TestKeys.includeTestDependencies := true
 
+libraryDependencies ++= Seq("junit" % "junit" % "4.11" % "test", "com.novocode" % "junit-interface" % "0.10" % "test")
+
 // default
 TestKeys.partestVersion := "1.0.0-RC6"
 

src/test/scala/scala/xml/JUnitAssertsForXML.scala

@@ -0,0 +1,8 @@
+package scala.xml
+
+object JUnitAssertsForXML {
+
+  private[xml] def assertEquals(expected: String, actual: NodeSeq): Unit =
+    org.junit.Assert.assertEquals(expected, actual.toString)
+
+}

src/test/scala/scala/xml/MetaDataTest.scala

@@ -0,0 +1,60 @@
+package scala.xml
+
+import org.junit.Test
+import org.junit.Ignore
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.Assert.assertEquals
+
+class MetaDataTest {
+
+  @Test
+  def absentElementPrefixed1: Unit = {
+    // type ascription to help overload resolution pick the right variant
+    assertEquals(null: Object, Null("za://foo.com", TopScope, "bar"))
+    assertEquals(null, Null("bar"))
+  }
+
+  @Test
+  def absentElementPrefixed2: Unit = {
+    assertEquals(None, Null.get("za://foo.com", TopScope, "bar" ))
+    assertEquals(None, Null.get("bar"))
+  }
+
+  @Test
+  def presentElement1: Unit = {
+    val x = new PrefixedAttribute("zo","bar", new Atom(42), Null)
+    val s = new NamespaceBinding("zo","za://foo.com", TopScope)
+    assertEquals(new Atom(42), x("za://foo.com", s, "bar" ))
+    assertEquals(null, x("bar"))
+    assertEquals(Some(new Atom(42)), x.get("za://foo.com", s, "bar"))
+    assertEquals(None, x.get("bar"))
+  }
+
+  @Test
+  def presentElement2: Unit = {
+    val s = new NamespaceBinding("zo","za://foo.com", TopScope)
+    val x1 = new PrefixedAttribute("zo","bar", new Atom(42), Null)
+    val x = new UnprefixedAttribute("bar","meaning", x1)
+    assertEquals(null, x(null, s, "bar"))
+    assertEquals(Text("meaning"), x("bar"))
+    assertEquals(None, x.get(null, s, "bar" ))
+    assertEquals(Some(Text("meaning")), x.get("bar"))
+  }
+
+  @Test
+  def attributeExtractor: Unit = {
+    def domatch(x:Node): Node = {
+      x match {
+            case Node("foo", md @ UnprefixedAttribute(_, value, _), _*) if !value.isEmpty =>
+                 md("bar")(0)
+            case _ => new Atom(3)
+      }
+    }
+    val z =  <foo bar="gar"/>
+    val z2 = <foo/>
+    assertEquals(Text("gar"), domatch(z))
+    assertEquals(new Atom(3), domatch(z2))
+  }
+
+}

src/test/scala/scala/xml/PrintEmptyElementsTest.scala

@@ -0,0 +1,58 @@
+package scala.xml
+
+import org.junit.Test
+import org.junit.Ignore
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import JUnitAssertsForXML.assertEquals
+
+class PrintEmptyElementsTest {
+
+  @Test
+  def representEmptyXMLElementsInShortForm: Unit = {
+    val expected: String =
+      """|
+         |<hi/> <!-- literal short -->
+         |<there></there> <!-- literal long -->
+         |<guys who="you all"></guys> <!-- literal long with attribute-->
+         |<hows it="going"/> <!-- literal short with attribute -->
+         |<this>is pretty cool</this> <!-- literal not empty -->
+         |""".stripMargin
+    // the xml snippet is not indented because indentation affects pretty printing
+    // results
+    val actual: NodeSeq =
+<xml:group>
+<hi/> <!-- literal short -->
+<there></there> <!-- literal long -->
+<guys who="you all"></guys> <!-- literal long with attribute-->
+<hows it="going"/> <!-- literal short with attribute -->
+<this>is pretty cool</this> <!-- literal not empty -->
+</xml:group>
+    assertEquals(expected, actual)
+  }
+
+  @Test
+  def programmaticLong: Unit = {
+    assertEquals("<emptiness></emptiness> <!--programmatic long-->",
+      Elem(null, "emptiness", Null, TopScope, false) ++ Text(" ") ++ Comment("programmatic long"))
+  }
+
+  @Test
+  def programmaticShort: Unit = {
+    assertEquals("<vide/> <!--programmatic short-->",
+      Elem(null, "vide", Null, TopScope, true) ++ Text(" ") ++ Comment("programmatic short"))
+  }
+
+  @Test
+  def programmaticShortWithAttribute: Unit = {
+    assertEquals("""<elem attr="value"/> <!--programmatic short with attribute-->""",
+      Elem(null, "elem", Attribute("attr", Text("value"), Null), TopScope, true) ++ Text(" ") ++ Comment ("programmatic short with attribute"))
+  }
+
+  @Test
+  def programmaticLongWithAttribute: Unit = {
+    assertEquals("""<elem2 attr2="value2"></elem2> <!--programmatic long with attribute-->""",
+      Elem(null, "elem2", Attribute("attr2", Text("value2"), Null), TopScope, false) ++ Text(" ") ++ Comment ("programmatic long with attribute"))
+  }
+
+}

src/test/scala/scala/xml/UtilityTest.scala

@@ -0,0 +1,57 @@
+package scala.xml
+
+import org.junit.Test
+import org.junit.Ignore
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.Assert.assertTrue
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertEquals
+
+class UtilityTest {
+
+  @Test
+  def isNameStart: Unit = {
+    assertTrue(Utility.isNameStart('b'))
+    assertFalse(Utility.isNameStart(':'))
+  }
+
+  @Test
+  def trim: Unit = {
+    val x = <foo>
+                 <toomuchws/>
+              </foo>
+    val y = xml.Utility.trim(x)
+    assertEquals(1, y match { case <foo><toomuchws/></foo> => 1 })
+
+    val x2 = <foo>
+      <toomuchws>  a b  b a  </toomuchws>
+    </foo>
+    val y2 = xml.Utility.trim(x2)
+    assertEquals(2, y2 match { case <foo><toomuchws>a b b a</toomuchws></foo> => 2 })
+  }
+
+  @Test
+  def aposEscaping: Unit = {
+    val z = <bar>''</bar>
+    val z1 = z.toString
+    assertEquals("<bar>''</bar>", z1)
+  }
+
+  @Test
+  def sort: Unit = {
+    val q = xml.Utility.sort(<a g='3' j='2' oo='2' a='2'/>)
+    assertEquals(" a=\"2\" g=\"3\" j=\"2\" oo=\"2\"", xml.Utility.sort(q.attributes).toString)
+    val pp = new xml.PrettyPrinter(80,5)
+    assertEquals("<a a=\"2\" g=\"3\" j=\"2\" oo=\"2\"/>", pp.format(q))
+  }
+
+  @Test
+  def issue777: Unit = {
+    <hi>
+      <there/>
+      <guys/>
+    </hi>.hashCode // Bug #777
+  }
+
+}

src/test/scala/scala/xml/parsing/Ticket0632Test.scala

@@ -0,0 +1,43 @@
+package scala.xml.parsing
+
+import org.junit.Test
+import org.junit.Ignore
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import scala.xml.JUnitAssertsForXML.assertEquals
+
+class Ticket0632Test {
+
+  import scala.io.Source.fromString
+  import scala.xml.parsing.ConstructingParser.fromSource
+  import scala.xml.{NodeSeq, TopScope}
+  private def parse(s:String) = fromSource(fromString(s), false).element(TopScope)
+
+  @Test
+  def singleAmp: Unit = {
+    val expected = "<foo x=\"&amp;\"/>"
+    assertEquals(expected, parse("<foo x='&amp;'/>"))
+    assertEquals(expected, xml.XML.loadString("<foo x='&amp;'/>"))
+    assertEquals(expected, <foo x="&amp;"/>)
+    assertEquals(expected, <foo x={ "&" }/>)
+  }
+
+  @Test
+  def oneAndHalfAmp: Unit = {
+    val expected = "<foo x=\"&amp;amp;\"/>"
+    assertEquals(expected, xml.XML.loadString("<foo x='&amp;amp;'/>"))
+    assertEquals(expected, parse("<foo x='&amp;amp;'/>"))
+    assertEquals(expected, <foo x="&amp;amp;"/>)
+    assertEquals(expected, <foo x={ "&amp;" }/>)
+  }
+
+  @Test
+  def doubleAmp: Unit = {
+    val expected = "<foo x=\"&amp;&amp;\"/>"
+    assertEquals(expected, xml.XML.loadString("<foo x='&amp;&amp;'/>"))
+    assertEquals(expected, parse("<foo x='&amp;&amp;'/>"))
+    assertEquals(expected, <foo x="&amp;&amp;"/>)
+    assertEquals(expected, <foo x={ "&&" }/>)
+  }
+
+}