diff --git a/jvm/src/test/scala-2.x/scala/xml/CompilerErrors.scala b/jvm/src/test/scala-2.x/scala/xml/CompilerErrors.scala
index 4d3197890..b847a827c 100644
--- a/jvm/src/test/scala-2.x/scala/xml/CompilerErrors.scala
+++ b/jvm/src/test/scala-2.x/scala/xml/CompilerErrors.scala
@@ -202,7 +202,7 @@ class CompilerTesting {
def expectXmlErrors(msgCount: Int, msg: String, code: String) = {
val errors = xmlErrorMessages(msg, code)
- val errorCount = errors.filter(_ contains msg).length
+ val errorCount = errors.count(_ contains msg)
assert(errorCount == msgCount, s"$errorCount occurrences of \'$msg\' found -- expected $msgCount in:\n${errors mkString "\n"}")
}
}
diff --git a/jvm/src/test/scala/scala/xml/ReuseNodesTest.scala b/jvm/src/test/scala/scala/xml/ReuseNodesTest.scala
index 5d38d74e2..0b0bfd8cb 100644
--- a/jvm/src/test/scala/scala/xml/ReuseNodesTest.scala
+++ b/jvm/src/test/scala/scala/xml/ReuseNodesTest.scala
@@ -20,12 +20,12 @@ object ReuseNodesTest {
class OriginalTranformr(rules: RewriteRule*) extends RuleTransformer(rules:_*) {
override def transform(ns: Seq[Node]): Seq[Node] = {
val xs = ns.toStream map transform
- val (xs1, xs2) = xs zip ns span { case (x, n) => unchanged(n, x) }
+ val (xs1, xs2) = xs.zip(ns).span { case (x, n) => unchanged(n, x) }
if (xs2.isEmpty) ns
- else (xs1 map (_._2)) ++ xs2.head._1 ++ transform(ns drop (xs1.length + 1))
+ else xs1.map(_._2) ++ xs2.head._1 ++ transform(ns.drop(xs1.length + 1))
}
- override def transform(n:Node): Seq[Node] = super.transform(n)
+ override def transform(n: Node): Seq[Node] = super.transform(n)
}
class ModifiedTranformr(rules: RewriteRule*) extends RuleTransformer(rules:_*) {
@@ -35,18 +35,18 @@ object ReuseNodesTest {
if (changed.length != ns.length || changed.zip(ns).exists(p => p._1 != p._2)) changed
else ns
}
- override def transform(n:Node): Seq[Node] = super.transform(n)
+ override def transform(n: Node): Seq[Node] = super.transform(n)
}
class AlternateTranformr(rules: RewriteRule*) extends RuleTransformer(rules:_*) {
override def transform(ns: Seq[Node]): Seq[Node] = {
- val xs = ns.toStream map transform
- val (xs1, xs2) = xs zip ns span { case (x, n) => unchanged(n, x) }
+ val xs = ns.toStream.map(transform)
+ val (xs1, xs2) = xs.zip(ns).span { case (x, n) => unchanged(n, x) }
if (xs2.isEmpty) ns
- else (xs1 map (_._2)) ++ xs2.head._1 ++ transform(ns drop (xs1.length + 1))
+ else xs1.map(_._2) ++ xs2.head._1 ++ transform(ns.drop(xs1.length + 1))
}
- override def transform(n:Node): Seq[Node] = super.transform(n)
+ override def transform(n: Node): Seq[Node] = super.transform(n)
}
def rewriteRule = new RewriteRule {
@@ -68,34 +68,33 @@ object ReuseNodesTest {
class ReuseNodesTest {
@Theory
- def transformReferentialEquality(rt:RuleTransformer) = {
+ def transformReferentialEquality(rt: RuleTransformer) = {
val original =
val tranformed = rt.transform(original)
assertSame(original, tranformed)
}
@Theory
- def transformReferentialEqualityOnly(rt:RuleTransformer) = {
+ def transformReferentialEqualityOnly(rt: RuleTransformer) = {
val original =
val transformed = rt.transform(original)
recursiveAssert(original,transformed)
}
- def recursiveAssert(original:Seq[Node], transformed:Seq[Node]):Unit = {
- original zip transformed foreach {
+ def recursiveAssert(original: Seq[Node], transformed: Seq[Node]): Unit = {
+ original.zip(transformed).foreach {
case (x, y) => recursiveAssert(x, y)
}
}
- def recursiveAssert(original:Node, transformed:Node):Unit = {
+ def recursiveAssert(original: Node, transformed: Node): Unit = {
transformed.label match {
case "changed" => // do nothing expect this node to be changed
recursiveAssert(original.child,transformed.child)
- case _ => {
+ case _ =>
assertSame(original, transformed)
- // No need to check for children, node being immuatable
+ // No need to check for children, node being immuatable
// children can't be different if parents are referentially equal
- }
}
}
}
diff --git a/jvm/src/test/scala/scala/xml/XMLSyntaxTest.scala b/jvm/src/test/scala/scala/xml/XMLSyntaxTest.scala
index 5030dcc04..4225545ee 100644
--- a/jvm/src/test/scala/scala/xml/XMLSyntaxTest.scala
+++ b/jvm/src/test/scala/scala/xml/XMLSyntaxTest.scala
@@ -12,11 +12,11 @@ class XMLSyntaxTestJVM {
object parser extends xml.parsing.ConstructingParser(s, false /*ignore ws*/) {
override def replacementText(entityName: String): io.Source = {
entityName match {
- case "nbsp" => io.Source.fromString("\u0160");
- case _ => super.replacementText(entityName);
+ case "nbsp" => io.Source.fromString("\u0160")
+ case _ => super.replacementText(entityName)
}
}
- nextch(); // !!important, to initialize the parser
+ nextch() // !!important, to initialize the parser
}
val parsed = parser.element(TopScope) // parse the source as element
// alternatively, we could call document()
diff --git a/jvm/src/test/scala/scala/xml/XMLTest.scala b/jvm/src/test/scala/scala/xml/XMLTest.scala
index 3f6eb62ed..812b53680 100644
--- a/jvm/src/test/scala/scala/xml/XMLTest.scala
+++ b/jvm/src/test/scala/scala/xml/XMLTest.scala
@@ -9,8 +9,6 @@ import org.junit.Assert.assertEquals
import java.io.StringWriter
import java.io.ByteArrayOutputStream
import java.io.StringReader
-import scala.collection.Iterable
-import scala.collection.Seq
import scala.xml.Utility.sort
object XMLTestJVM {
@@ -19,14 +17,14 @@ object XMLTestJVM {
}
class XMLTestJVM {
- import XMLTestJVM.{ e, sc }
+ import XMLTestJVM.{e, sc}
def Elem(prefix: String, label: String, attributes: MetaData, scope: NamespaceBinding, child: Node*): Elem =
scala.xml.Elem.apply(prefix, label, attributes, scope, minimizeEmpty = true, child: _*)
lazy val parsedxml1 = XML.load(new InputSource(new StringReader("")))
lazy val parsedxml11 = XML.load(new InputSource(new StringReader("")))
- val xmlFile2 = "Peter BunemanDan SuciuData on ze webJohn MitchellFoundations of Programming Languages";
+ val xmlFile2 = "Peter BunemanDan SuciuData on ze webJohn MitchellFoundations of Programming Languages"
lazy val parsedxml2 = XML.load(new InputSource(new StringReader(xmlFile2)))
@UnitTest
@@ -34,9 +32,9 @@ class XMLTestJVM {
val c = new Node {
def label = "hello"
override def hashCode() =
- Utility.hashCode(prefix, label, this.attributes.hashCode(), scope.hashCode(), child);
- def child = Elem(null, "world", e, sc);
- //def attributes = e;
+ Utility.hashCode(prefix, label, this.attributes.hashCode(), scope.hashCode(), child)
+ def child = Elem(null, "world", e, sc)
+ //def attributes = e
override def text = ""
}
@@ -45,7 +43,7 @@ class XMLTestJVM {
assertTrue(List(parsedxml1) sameElements List(parsedxml11))
assertTrue(Array(parsedxml1).toList sameElements List(parsedxml11))
- val x2 = "Peter BunemanDan SuciuData on ze web";
+ val x2 = "Peter BunemanDan SuciuData on ze web"
val i = new InputSource(new StringReader(x2))
val x2p = scala.xml.XML.load(i)
@@ -115,10 +113,10 @@ class XMLTestJVM {
Elem(null, "title", e, sc, Text("Foundations of Programming Languages"))))
assertEquals("Peter BunemanDan SuciuData on ze web",
- (parsedxml2 \\ "book") { (n: Node) => (n \ "title") xml_== "Data on ze web" } toString)
+ (parsedxml2 \\ "book") { (n: Node) => (n \ "title") xml_== "Data on ze web" }.toString)
assertTrue(
- ((NodeSeq.fromSeq(List(parsedxml2))) \\ "_") sameElements List(
+ (NodeSeq.fromSeq(List(parsedxml2)) \\ "_") sameElements List(
Elem(null, "bib", e, sc,
Elem(null, "book", e, sc,
Elem(null, "author", e, sc, Text("Peter Buneman")),
@@ -144,27 +142,28 @@ class XMLTestJVM {
@UnitTest
def unparsed = {
// println("attribute value normalization")
- val xmlAttrValueNorm = "";
+ val xmlAttrValueNorm = ""
+
{
- val isrcA = new InputSource(new StringReader(xmlAttrValueNorm));
- val parsedxmlA = XML.load(isrcA);
- val c = (parsedxmlA \ "@nom").text.charAt(0);
- assertTrue(c == '\u015e');
+ val isrcA = new InputSource(new StringReader(xmlAttrValueNorm))
+ val parsedxmlA = XML.load(isrcA)
+ val c = (parsedxmlA \ "@nom").text.charAt(0)
+ assertTrue(c == '\u015e')
}
// buraq: if the following test fails with 'character x not allowed', it is
// related to the mutable variable in a closures in MarkupParser.parsecharref
{
- val isr = scala.io.Source.fromString(xmlAttrValueNorm);
- val pxmlB = scala.xml.parsing.ConstructingParser.fromSource(isr, false);
- val parsedxmlB = pxmlB.element(TopScope);
- val c = (parsedxmlB \ "@nom").text.charAt(0);
- assertTrue(c == '\u015e');
+ val isr = scala.io.Source.fromString(xmlAttrValueNorm)
+ val pxmlB = scala.xml.parsing.ConstructingParser.fromSource(isr, false)
+ val parsedxmlB = pxmlB.element(TopScope)
+ val c = (parsedxmlB \ "@nom").text.charAt(0)
+ assertTrue(c == '\u015e')
}
// #60 test by round trip
val p = scala.xml.parsing.ConstructingParser.fromSource(scala.io.Source.fromString(""), true)
- val n = p.element(new scala.xml.NamespaceBinding("bar", "BAR", scala.xml.TopScope))(0)
+ val n = p.element(scala.xml.NamespaceBinding("bar", "BAR", scala.xml.TopScope))(0)
assertTrue(n.attributes.get("BAR", n, "attr").nonEmpty)
}
@@ -181,7 +180,7 @@ class XMLTestJVM {
assertEquals(
"""
abc
- """, f("a,b,c") toString)
+ """, f("a,b,c").toString)
object Serialize {
@throws(classOf[java.io.IOException])
@@ -190,7 +189,7 @@ class XMLTestJVM {
val out = new java.io.ObjectOutputStream(ba)
out.writeObject(o)
out.close()
- ba.toByteArray()
+ ba.toByteArray
}
@throws(classOf[java.io.IOException])
@throws(classOf[ClassNotFoundException])
@@ -231,7 +230,7 @@ class XMLTestJVM {
@UnitTest
def serializeElem = {
// Elem
- val e1 = title;
+ val e1 = title
val _e1: Elem = read(write(e1))
check(e1, _e1)
}
@@ -250,10 +249,10 @@ class XMLTestJVM {
{
for (p <- people) yield
| { p.name } |
- { p.age.toString() } |
+ { p.age.toString } |
}
- ;
+
}
val people = new AddressBook(
@@ -266,7 +265,7 @@ class XMLTestJVM {
{ people.toXHTML }
-