Migrate partest jvm/xml03syntax.scala test to JUnit.

Author: gkossakowski

test/files/jvm/xml03syntax.scala renamed to src/test/scala/scala/xml/XMLSyntaxTest.scala

@@ -1,83 +1,72 @@
-import scala.xml._
+package scala.xml
 
-object Test {
+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 XMLSyntaxTest {
 
   private def handle[A](x: Node): A = {
-    println(x)
     x.child(0).asInstanceOf[Atom[A]].data
   }
 
-  def main(args: Array[String]) {
-    test1()
-    test2()
-    test3()
-  }
-
-  private def test1() {
+  @Test
+  def test1(): Unit = {
     val xNull = <hello>{null}</hello> // these used to be Atom(unit), changed to empty children
-
-    println(xNull.child sameElements Nil)
+    assertTrue(xNull.child sameElements Nil)
 
     val x0 = <hello>{}</hello> // these used to be Atom(unit), changed to empty children
     val x00 = <hello>{ }</hello> //  dto.
-
     val xa = <hello>{ "world" }</hello>
 
-
-    println(x0.child sameElements Nil)
-    println(x00.child sameElements Nil)
-    println(handle[String](xa) == "world")
+    assertTrue(x0.child sameElements Nil)
+    assertTrue(x00.child sameElements Nil)
+    assertEquals("world", handle[String](xa))
 
     val xb = <hello>{ 1.5 }</hello>
-
-    println(handle[Double](xb) == 1.5)
+    assertEquals(1.5, handle[Double](xb), 0.0)
 
     val xc = <hello>{ 5 }</hello>
-
-    println(handle[Int](xc) == 5)
+    assertEquals(5, handle[Int](xc))
 
     val xd = <hello>{ true }</hello>
-
-    println(handle[Boolean](xd) == true)
+    assertEquals(true, handle[Boolean](xd))
 
     val xe = <hello>{ 5:Short }</hello>
-
-    println(handle[Short](xe) == (5:Short))
+    assertEquals((5:Short), handle[Short](xe))
 
     val xf = <hello>{ val x = 27; x }</hello>
-
-    println(handle[Int](xf) == 27)
+    assertEquals(27, handle[Int](xf))
 
     val xg = <hello>{ List(1,2,3,4) }</hello>
-
-    println(xg)
-    for (z <- xg.child) {
-      println(z.toString() + {if (z.isInstanceOf[Text]) "(is text node ' ')" else ""})
-    }
+    assertEquals("<hello>1 2 3 4</hello>", xg.toString)
+    assertFalse(xg.child.map(_.isInstanceOf[Text]).exists(identity))
 
     val xh = <hello>{ for(x <- List(1,2,3,4) if x % 2 == 0) yield x }</hello>
-
-    println(xh)
-    for (z <- xh.child) {
-      println(z.toString() + {if (z.isInstanceOf[Text]) "(is text node ' ')" else ""})
-    }
-    println
+    assertEquals("<hello>2 4</hello>", xh.toString)
+    assertFalse(xh.child.map(_.isInstanceOf[Text]).exists(identity))
   }
 
   /** see SVN r13821 (emir): support for <elem key={x:Option[Seq[Node]]} />,
    *  so that Options can be used for optional attributes.
    */
-  private def test2() {
+  @Test
+  def test2(): Unit = {
     val x1: Option[Seq[Node]] = Some(<b>hello</b>)
     val n1 = <elem key={x1} />;
-    println("node="+n1+", key="+n1.attribute("key"))
+    assertEquals(x1, n1.attribute("key"))
 
     val x2: Option[Seq[Node]] = None
     val n2 = <elem key={x2} />;
-    println("node="+n2+", key="+n2.attribute("key"))
+    assertEquals(x2, n2.attribute("key"))
   }
 
-  private def test3() {
+  @Test
+  def test3(): Unit = {
     // this demonstrates how to handle entities
     val s = io.Source.fromString("<a>&nbsp;</a>")
     object parser extends xml.parsing.ConstructingParser(s, false /*ignore ws*/) {
@@ -91,7 +80,7 @@ object Test {
     }
     val parsed = parser.element(TopScope) // parse the source as element
     // alternatively, we could call document()
-    println(parsed)
+    assertEquals("<a>Š</a>", parsed.toString)
   }
 
 }