Add ScalaCheck specs to test suite

Adds 26 specifications in ScalaCheck, with 154 properties, of 18 are
proofs by example, and the rest are 136 tests using randomly-generated
values.  ScalaCheck requires at least 100 generated tests to pass, by
default.  So that gives 13,618 new tests!

The suite should be a real benefit for future maintenance endeavors,
rewrites, documentation, or finishing a Scala-based parser to avoid
depending on the the Xerces/SAX Java library.

These integrate well with the existing suite of JUnit 4 tests.  If you
want to run both the ScalaCheck and JUnit tests from SBT,

> test
...
[info] Passed: Total 145, Failed 0, Errors 0, Passed 145
[success] Total time: 43 s, completed Sep 30, 2016 2:19:56 PM

If you want to run a single spec,

> testOnly scala.xml.XMLSpec
> testOnly scala.xml.XMLSpec
[info] + XML.write: OK, passed 100 tests.
[info] Passed: Total 1, Failed 0, Errors 0, Passed 1
[success] Total time: 3 s, completed Sep 30, 2016 2:20:28 PM

If you want to run all the ScalaCheck specs,

> testOnly *Spec
...
[info] Passed: Total 26, Failed 0, Errors 0, Passed 26
[success] Total time: 30 s, completed Sep 30, 2016 2:22:58 PM

If you want to run the specs under a namespace,

> testOnly scala.xml.dtd.*Spec
...
[info] + dtd.DTD.toString: OK, passed 100 tests.
[info] + dtd.DocType.new(name): OK, passed 100 tests.
[info] + dtd.DocType.new(name, extId, intSubset): OK, passed 100 tests.
[info] + dtd.DocType.new(name, extId, emptyInt): OK, passed 100 tests.
[info] + dtd.DocType.toString: OK, passed 100 tests.
[info] Passed: Total 4, Failed 0, Errors 0, Passed 4
[success] Total time: 6 s, completed Sep 30, 2016 3:14:05 PM

If you want to generate 1000 tests instead of 100,

> testOnly *Spec -- -s 1000
...
[info] Passed: Total 26, Failed 0, Errors 0, Passed 26
[success] Total time: 217 s, completed Sep 30, 2016 2:27:31 PM

If you want to generate 10 tests, instead of 100,

> testOnly *Spec -- -s 10
...
[info] Passed: Total 26, Failed 0, Errors 0, Passed 26
[success] Total time: 10 s, completed Sep 30, 2016 2:23:49 PM

If you want to generate full back traces on errors and display the elapsed time
for each property,

> testOnly *Spec -- -verbosity 2
...
[info] + parsing.XhtmlParser.initialize: OK, passed 100 tests.
[info] Elapsed time: 0.046 sec
[info] + parsing.XhtmlParser.prolog: OK, passed 100 tests.
[info] Elapsed time: 0.022 sec
[info] + parsing.XhtmlParser.document: OK, passed 100 tests.
[info] Elapsed time: 0.015 sec
[info] Passed: Total 26, Failed 0, Errors 0, Passed 26
[success] Total time: 30 s, completed Sep 30, 2016 2:29:24 PM

The default verbosity is 0,

> testOnly *Spec -- -verbosity 0
...
[info] + parsing.XhtmlParser.initialize: OK, passed 100 tests.
[info] + parsing.XhtmlParser.prolog: OK, passed 100 tests.
[info] + parsing.XhtmlParser.document: OK, passed 100 tests.
[info] Passed: Total 26, Failed 0, Errors 0, Passed 26
[success] Total time: 26 s, completed Sep 30, 2016 2:30:26 PM

To run only the failed tests,

> testQuick
[info] Passed: Total 0, Failed 0, Errors 0, Passed 0
[info] No tests to run for test:testQuick
[success] Total time: 1 s, completed Sep 30, 2016 2:32:50 PM

Currently, these tests in ScalaCheck will cover only 25% of the source
code, and 20% of branches.

Not surprisingly, there are some defects in scala-xml for certain
types and classes.  I am forced to comment out and disable those tests
and generators so that the suite passes.  Those issues should be taken
up separately and in subsequent pull requests.  When those tests and
generators are re-enabled for those types, the code coverage would
most likely increase.

There are no shrink heuristics defined written to help ScalaCheck
identify the minimum value to falsify a property of an XML string or
data structure.  This will be a nice to have, but was too advanced for
me to take on at this time.

Right now, the generators equally weight the Node types among those
that are allowed.  It would probably be worthwhile to have the
frequencies be more realistic.  For example, have a a greater emphasis
on Elem and EntityRef elements over Comment, ProcInstr, nulls,
empty strings and empty lists.  The frequencies should be closer in
line with what a typical XML file would be, but also more broadly
cover the code and sooner using fewer generated values.

Similarly, there is not an appropriate sizing for lists.  Presently,
ScalaCheck randomly selects a number, and then the generators I wrote
will try to approach termination by recursively halving and
square-rooting at each level of descent.

Author: ashawley

src/test/scala/scala/xml/ArbitraryElem.scala

@@ -0,0 +1,11 @@
+package scala.xml
+
+import org.scalacheck.Arbitrary
+import org.scalacheck.Gen
+
+trait ArbitraryElem {
+
+  def genElem(sz: Int): Gen[Elem]
+
+  implicit val arbElem: Arbitrary[Elem]
+}

src/test/scala/scala/xml/ArbitraryGroup.scala

@@ -0,0 +1,11 @@
+package scala.xml
+
+import org.scalacheck.Arbitrary
+import org.scalacheck.Gen
+
+trait ArbitraryGroup {
+
+  def genGroup(sz: Int): Gen[Group]
+
+  implicit val arbGroup: Arbitrary[Group]
+}

src/test/scala/scala/xml/ArbitraryMetaData.scala

@@ -0,0 +1,11 @@
+package scala.xml
+
+import org.scalacheck.Arbitrary
+import org.scalacheck.Gen
+
+trait ArbitraryMetaData {
+
+  val genMetaData: Gen[MetaData]
+
+  implicit val arbMetaData: Arbitrary[MetaData]
+}

src/test/scala/scala/xml/ArbitraryNode.scala

@@ -0,0 +1,11 @@
+package scala.xml
+
+import org.scalacheck.Arbitrary
+import org.scalacheck.Gen
+
+trait ArbitraryNode {
+
+  def genNode(sz: Int): Gen[Node]
+
+  implicit val arbNode: Arbitrary[Node]
+}

src/test/scala/scala/xml/ArbitraryNodeBuffer.scala

@@ -0,0 +1,11 @@
+package scala.xml
+
+import org.scalacheck.Arbitrary
+import org.scalacheck.Gen
+
+trait ArbitraryNodeBuffer {
+
+  val genNodeBuffer: Gen[NodeBuffer]
+
+  implicit val arbNodeBuffer: Arbitrary[NodeBuffer]
+}

src/test/scala/scala/xml/ArbitraryTextBuffer.scala

@@ -0,0 +1,11 @@
+package scala.xml
+
+import org.scalacheck.Arbitrary
+import org.scalacheck.Gen
+
+trait ArbitraryTextBuffer {
+
+  val genTextBuffer: Gen[TextBuffer]
+
+  implicit val arbTextBuffer: Arbitrary[TextBuffer]
+}

src/test/scala/scala/xml/AtomGen.scala

@@ -0,0 +1,16 @@
+package scala.xml
+
+import org.scalacheck.Arbitrary
+import org.scalacheck.Gen
+
+trait AtomGen extends PCDataGen
+    with TextGen
+    with UnparsedGen {
+
+  val genAtom: Gen[Atom[String]] =
+    Gen.oneOf(genPCData, genText, genUnparsed)
+
+  implicit val arbAtom = Arbitrary {
+    genAtom
+  }
+}

src/test/scala/scala/xml/AtomSpec.scala

@@ -0,0 +1,27 @@
+package scala.xml
+
+import org.scalacheck.Prop
+import org.scalacheck.{ Properties => PropertiesFor }
+import org.scalacheck.Prop.AnyOperators
+
+object AtomSpec extends PropertiesFor("Atom")
+    with AtomGen {
+
+  property("new(null).throws[Exception]") = {
+    Prop.throws(classOf[IllegalArgumentException]) {
+      new Atom(null)
+    }
+  }
+
+  property("data") = {
+    Prop.forAll { d: Atom[String] =>
+      d.data ne null
+    }
+  }
+
+  property("text") = {
+    Prop.forAll { a: Atom[String] =>
+      a.text ?= s"${a.data}"
+    }
+  }
+}

src/test/scala/scala/xml/AttributeGen.scala

@@ -0,0 +1,44 @@
+package scala.xml
+
+import org.scalacheck.Arbitrary
+import org.scalacheck.Gen
+
+trait AttributeGen extends TextGen
+    with ArbitraryMetaData
+    with XmlNameGen {
+
+  def genAttribute: Gen[Attribute] =
+    Gen.oneOf(
+      Arbitrary.arbitrary[PrefixedAttribute],
+      Arbitrary.arbitrary[UnprefixedAttribute]
+    )
+
+  val genPrefixedAttribute: Gen[PrefixedAttribute] = for {
+    prefix <- genXmlName: Gen[String]
+    key <- genXmlName: Gen[String]
+    value <- Arbitrary.arbitrary[Text]
+    next <- Gen.delay(genMetaData)
+  } yield {
+    new PrefixedAttribute(prefix, key, value, next)
+  }
+
+  val genUnprefixedAttribute: Gen[UnprefixedAttribute] = for {
+    key <- genXmlName: Gen[String]
+    value <- Arbitrary.arbitrary[Text]
+    next <- Gen.delay(genMetaData)
+  } yield {
+    new UnprefixedAttribute(key, value, next)
+  }
+
+  implicit val arbAttribute: Arbitrary[Attribute] = Arbitrary {
+    genAttribute
+  }
+
+  implicit val arbPrefixedAttribute: Arbitrary[PrefixedAttribute] = Arbitrary {
+    genPrefixedAttribute
+  }
+
+  implicit val arbUnprefixedAttribute: Arbitrary[UnprefixedAttribute] = Arbitrary {
+    genUnprefixedAttribute
+  }
+}

src/test/scala/scala/xml/AttributeSpec.scala

@@ -0,0 +1,137 @@
+package scala.xml
+
+import org.scalacheck.Prop
+import org.scalacheck.{ Properties => PropertiesFor }
+import org.scalacheck.Prop.AnyOperators
+import org.scalacheck.Prop.BooleanOperators
+
+object AttributeSpec extends PropertiesFor("Attribute")
+    with AttributeGen
+    with NamespaceBindingGen
+    with NodeGen
+    with MetaDataGen {
+
+  property("canEqual(this)") = {
+    Prop.forAll { a: Attribute =>
+      a.canEqual(a)
+    }
+  }
+
+  property("apply") = {
+    Prop.forAll { (a: Attribute, s: String) =>
+      (!s.isEmpty && Utility.isNameStart(s(0))) ==>
+        (a(s) != s)
+    }
+  }
+
+  property("apply(key)") = {
+    Prop.forAll { a: Attribute =>
+      Prop.iff[Attribute](a, {
+        case p: PrefixedAttribute =>
+          Prop.passed
+        case u: UnprefixedAttribute if u.key ne null =>
+          u(u.key) ?= u.value
+        case _ => Prop.falsified
+      })
+    }
+  }
+
+  property("apply(uri, namespace, key)") = {
+    Prop.forAll { a: Attribute =>
+      Prop.iff[Attribute](a, {
+        case p: PrefixedAttribute =>
+          val res = p(p.key, NamespaceBinding(p.pre, p.key, TopScope), p.key)
+          res ?= p.value
+        case u: UnprefixedAttribute =>
+          Prop.passed
+        case _ => Prop.falsified
+      })
+    }
+  }
+
+  property("isPrefixed") = {
+    Prop.forAll { a: Attribute =>
+      Prop.iff[Attribute](a, {
+        case p: PrefixedAttribute =>
+          a.isPrefixed ?= true
+        case u: UnprefixedAttribute =>
+          a.isPrefixed ?= false
+        case _ => Prop.falsified
+      })
+    }
+  }
+
+  property("length") = {
+    Prop.forAll { a: Attribute =>
+      a.length >= 0
+    }
+  }
+
+  property("size") = {
+    Prop.forAll { a: Attribute =>
+      a.size >= 0
+    }
+  }
+
+  property("toString") = {
+    Prop.forAll { a: Attribute =>
+      val str = a.toString
+      Prop.iff[Attribute](a, {
+        case a: PrefixedAttribute if a.hasNext =>
+          str ?= s""" ${a.pre}:${a.key}="${a.value}"${a.next}"""
+        case a: UnprefixedAttribute if a.hasNext =>
+          str ?= s""" ${a.key}="${a.value}"${a.next}"""
+        case a: PrefixedAttribute =>
+          str ?= s""" ${a.pre}:${a.key}="${a.value}""""
+        case a: UnprefixedAttribute =>
+          str ?= s""" ${a.key}="${a.value}""""
+        case _ => Prop.falsified
+      })
+    }
+  }
+
+  property("unapply") = {
+    Prop.forAll { a: Attribute =>
+      Attribute.unapply(a) ?= Some((a.key, a.value, a.next))
+    }
+  }
+
+  property("remove(key)") = {
+    Prop.forAll { a: Attribute =>
+      Prop.iff[Attribute](a, {
+        case a: PrefixedAttribute =>
+          a.remove(a.key) ?= a.copy(a.next.remove(a.key)) // FIXME: ???
+        case a: UnprefixedAttribute =>
+          a.remove(a.key) ?= a.next
+        case _ => Prop.falsified
+      })
+    }
+  }
+
+  property("remove") = {
+    Prop.forAll { (a: Attribute, s: String) =>
+      s != a.key ==>
+        (a.remove(s) ?= a.copy(a.next.remove(s)))
+    }
+  }
+
+  property("getNamespace") = {
+    Prop.forAll { (a: Attribute, n: Node) =>
+      a.getNamespace(n) ?= n.getNamespace(a.pre)
+    }
+  }
+
+  property("wellformed") = {
+    Prop.forAll { (a: Attribute, scope: NamespaceBinding) =>
+      Prop.iff[Attribute](a, {
+        case a: PrefixedAttribute =>
+          val res = a.wellformed(scope)
+          res ?= ((null eq a.next(scope.getURI(a.pre), scope, a.key)) && a.next.wellformed(scope))
+        case a: UnprefixedAttribute =>
+          val res = a.wellformed(scope)
+          res ?= ((null eq a.next(null, scope, a.key)) && a.next.wellformed(scope))
+        case _ => Prop.falsified
+      })
+    }
+  }
+}