Added working tests coverage for the StringBuffer and StringBuilder semigroup implementations. Added the Semigroup tests to the list of Scalacheck test suite.

bakeemawaytoys · jbgi · commit aa4de33faacb · 2017-05-10T21:55:58.000+02:00
diff --git a/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala b/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala
@@ -70,27 +70,36 @@ object CheckIOSemigroup extends Properties("ioSemigroup") {
 
 }
 
-object CheckStringBuilder extends Properties("stringBuilderSemigroup") {
-
-  val s: Semigroup[java.lang.StringBuilder] = Semigroup.stringBuilderSemigroup
+/**
+  * A [[Properties]] implementation for testing [[Semigroup]] implementations that
+  * apply to mutable builder style classes such as [[java.lang.StringBuilder]] and
+  * [[java.lang.StringBuffer]].
+  *
+  * @param s          a Semigroup implementation to test.
+  * @param desc       a description of the Semigroup implementation under test.
+  * @param conversion a function that converts a value of type T to a new instance of type S.
+  * @tparam T the type that the builder constructs.
+  * @tparam S the type to which the Semigroup applies.
+  */
+case class CheckMutableBuilder[S, T](s: Semigroup[S], desc: String, conversion: T => S)(implicit val arbitrary: Arbitrary[T]) extends Properties(desc) {
 
-  implicit def toStringBuilder(str: String): java.lang.StringBuilder = new java.lang.StringBuilder(str)
+  implicit def toBuilder(t: T): S = conversion(t)
 
-  property("sum(x,y)") = forAll((x: String, y: String, z: String) =>
+  property("sum(x,y)") = forAll((x: T, y: T, z: T) =>
     s.sum(s.sum(x, y), z).toString == s.sum(x, s.sum(y, z)).toString
   )
 
-  property("sum()") = forAll((x: String, y: String, z: String) => {
+  property("sum()") = forAll((x: T, y: T, z: T) => {
     val sf = s.sum()
-    sf.f(sf.f(x).f(y)).f(z).toString == sf.f(x).f(sf.f(y).f(z.toString))
+    sf.f(sf.f(x).f(y)).f(z).toString == sf.f(x).f(sf.f(y).f(z)).toString
   })
 
-  property("dual()") = forAll((x: String, y: String, z: String) => {
+  property("dual()") = forAll((x: T, y: T, z: T) => {
     val sd = s.dual()
-    sd.sum(sd.sum(x, y), z).toString == sd.sum(x, sd.sum(y, z).toString)
+    sd.sum(sd.sum(x, y), z).toString == sd.sum(x, sd.sum(y, z)).toString
   })
 
-  property("sum(x)") = forAll((x: String, y: String) =>
+  property("sum(x)") = forAll((x: T, y: T) =>
     s.sum(x).f(y).toString == s.sum(x, y).toString)
 
 }
@@ -193,8 +202,8 @@ object CheckSemigroup extends Properties("Semigroup") {
   include(SemigroupProperties(Semigroup.streamSemigroup[Int](), "streamSemigroup"))
 
   include(SemigroupProperties(Semigroup.stringSemigroup, "stringSemigroup"))
-  include(SemigroupProperties(Semigroup.stringBufferSemigroup, "stringBufferSemigroup"))
-  include(SemigroupProperties(Semigroup.stringBuilderSemigroup, "stringBuilderSemigroup"))
+  include(CheckMutableBuilder(Semigroup.stringBufferSemigroup, "stringBufferSemigroup", (s: String) => new java.lang.StringBuffer(s)))
+  include(CheckMutableBuilder(Semigroup.stringBuilderSemigroup, "stringBuilderSemigroup", (s: String) => new java.lang.StringBuilder(s)))
 
 
   include(SemigroupProperties(Semigroup.unitSemigroup, "unitSemigroup"))
diff --git a/props-core-scalacheck/src/test/scala/fj/Tests.scala b/props-core-scalacheck/src/test/scala/fj/Tests.scala
@@ -1,8 +1,9 @@
 package fj
 
 object Tests {
-  def tests = List (
+  def tests = List(
     CheckP2.properties,
+    CheckSemigroup.properties,
     fj.data.CheckArray.properties,
     fj.data.CheckIO.properties,
     fj.data.CheckIteratee.properties,
@@ -19,26 +20,27 @@ object Tests {
 
   def main(args: Array[String]) {
     run(tests)
-//    System.exit(0)
+    //    System.exit(0)
   }
 
-  import org.scalacheck.Prop
-  import org.scalacheck.Test
   import org.scalacheck.Test.check
+  import org.scalacheck.{Prop, Test}
 
   def run(tests: List[(String, Prop)]) =
     tests foreach { case (name, p) => {
-        val c = check(new Test.Parameters.Default { override val maxSize = 20 }, p)
-        c.status match {
-          case Test.Passed => println("Passed " + name)
-          case Test.Proved(_) => println("Proved " + name)
-          case f @ Test.Failed(_, _) => sys.error(name + ": " + f)
-          case Test.Exhausted => println("Exhausted " + name)
-          case f @ Test.PropException(_, e, _) => {
-            e.printStackTrace
-            sys.error(name + ": " + f)
-          }
+      val c = check(new Test.Parameters.Default {
+        override val maxSize = 20
+      }, p)
+      c.status match {
+        case Test.Passed => println("Passed " + name)
+        case Test.Proved(_) => println("Proved " + name)
+        case f@Test.Failed(_, _) => sys.error(name + ": " + f)
+        case Test.Exhausted => println("Exhausted " + name)
+        case f@Test.PropException(_, e, _) => {
+          e.printStackTrace
+          sys.error(name + ": " + f)
         }
       }
     }
+    }
 }
