a bunch of refactoring and cleanup

1 files changed, 78 insertions, 27 deletions

diff --git a/src/main/scala/org/perl8/test/harness/SummaryReporter.scala b/src/main/scala/org/perl8/test/harness/SummaryReporter.scala
index a215be0..08544ce 100644
--- a/src/main/scala/org/perl8/test/harness/SummaryReporter.scala
+++ b/src/main/scala/org/perl8/test/harness/SummaryReporter.scala
@@ -4,45 +4,74 @@ import java.io.{OutputStream,ByteArrayOutputStream}
 
 import org.perl8.test.Test
 import org.perl8.test.tap
+import org.perl8.test.tap.{TAPResult,TodoDirective}
 import Utils._
 
 class SummaryReporter extends MultiTestReporter {
   def run (testNames: Seq[String]): Int = {
+    val results = runTests(testNames)
+    val success = results.values.map(_._1).forall(_ == 0)
+    printTestSummary(success, results)
+    if (success) 0 else 1
+  }
+
+  def runTests (testNames: Seq[String]): Map[String, (Int, TAPResult)] = {
     val maxLength = testNames.map(_.length).max
-    val (exits, results) = testNames.map { name =>
+
+    testNames.map { name =>
       print(name + ("." * (maxLength - name.length)) + "... ")
+
       val out = new ByteArrayOutputStream
       val test = newInstance[Test, OutputStream](name, out)
       val exitCode = test.run
       val result = tap.Consumer.parse(out)
+
       if (exitCode == 0) {
         println("ok")
       }
       else {
-        val results = result.results
-        val failed = results.filter(t => !t.passed && !t.directive.isDefined)
+        val results = result.results.length
+        val failed = result.results.count { t =>
+          !t.passed && !t.directive.isDefined
+        }
+
         println("Dubious, test returned " + exitCode)
-        println("Failed " + failed.length + "/" + results.length + " subtests")
+        println("Failed " + failed + "/" + results + " subtests")
       }
-      (exitCode, result)
-    }.unzip
 
-    val exitMap   = (testNames zip exits).toMap
-    val resultMap = (testNames zip results).toMap
+      name -> (exitCode, result)
+    }.toMap
+  }
 
-    val exitCode = if (exits.filter(_ != 0).nonEmpty) { 1 } else { 0 }
+  def printTestSummary (
+    success: Boolean,
+    results: Map[String, (Int, TAPResult)]
+  ) {
+    printSuccess(success)
+    printShortSummary(results)
+    printLongSummary(results)
+    printPassFail(success, results)
+  }
 
-    if (exitCode == 0) {
+  private def printSuccess (success: Boolean) {
+    if (success) {
       println("All tests successful.")
     }
+  }
 
-    val tests = results.map(_.results.length).sum
-    println("Files=" + testNames.length + ", Tests=" + tests)
+  private def printShortSummary (results: Map[String, (Int, TAPResult)]) {
+    val files = results.size
+    val tests = results.values.map(_._2.results.length).sum
+    println("Files=" + files + ", Tests=" + tests)
+  }
+
+  private def printLongSummary (results: Map[String, (Int, TAPResult)]) {
+    val resultMap = results.map { case (s, r) => s -> r._2 }
 
     val todoSucceeded = resultMap.mapValues { r =>
       r.results.filter { t =>
         t.directive match {
-          case Some(tap.TodoDirective(_)) => t.passed
+          case Some(TodoDirective(_)) => t.passed
           case _                      => false
         }
       }
@@ -57,17 +86,24 @@ class SummaryReporter extends MultiTestReporter {
       }
     }.filter(_._2.length > 0)
 
-    if (todoSucceeded.nonEmpty || testsFailed.nonEmpty) {
+    val testNames = (todoSucceeded ++ testsFailed).keys
+
+    if (testNames.nonEmpty) {
       println("")
       println("Test Summary Report")
       println("-------------------")
-      for (name <- (todoSucceeded ++ testsFailed).keys) {
+
+      val maxLength = testNames.map(_.length).max
+
+      for (name <- testNames) {
         val result = resultMap(name)
+
         println(
           name + (" " * (maxLength - name.length)) + "               " +
           "(Tests: " + result.results.length + " " +
           "Failed: " + testsFailed.getOrElse(name, Seq()).length + ")"
         )
+
         if (testsFailed.isDefinedAt(name)) {
           val fails = testsFailed(name)
           println(
@@ -75,38 +111,53 @@ class SummaryReporter extends MultiTestReporter {
             fails.map(_.number).mkString(", ")
           )
         }
+
         if (todoSucceeded.isDefinedAt(name)) {
+          val todos = todoSucceeded(name)
           println(
             "  TODO passed: " +
-            todoSucceeded(name).map(_.number).mkString(", ")
+            todos.map(_.number).mkString(", ")
           )
         }
-        if (exitMap(name) != 0) {
-          println("  Non-zero exit status: " + exitMap(name))
+
+        val exitCode = results(name)._1
+        if (exitCode != 0) {
+          println("  Non-zero exit status: " + exitCode)
         }
       }
     }
+  }
 
-    if (exitCode == 0) {
+  private def printPassFail (
+    success: Boolean,
+    results: Map[String, (Int, TAPResult)]
+  ) {
+    if (success) {
       println("Result: PASS")
     }
     else {
       println("Result: FAIL")
-      val failedFiles = results.filter { r =>
-        r.results.exists { t =>
+
+      val testResults = results.values.map(_._2)
+
+      val testsFailed = testResults.map { r =>
+        r.results.count { t =>
           t.directive match {
             case None => !t.passed
             case _    => false
           }
         }
-      }.length
-      val failedTests = testsFailed.mapValues(_.length).values.sum
+      }.filter(_ > 0)
+      val failedFiles = testsFailed.size
+      val failedTests = testsFailed.sum
+
+      val allFiles = testResults.size
+      val allTests = testResults.map(_.results.length).sum
+
       println(
-        "Failed " + failedFiles + "/" + testNames.length + " test programs. " +
-        failedTests + "/" + tests + " subtests failed."
+        "Failed " + failedFiles + "/" + allFiles + " test programs. " +
+        failedTests + "/" + allTests + " subtests failed."
       )
     }
-
-    exitCode
   }
 }