test locky

Author: felixmulder

compiler/test/dotty/tools/dotc/ParallelTesting.scala

@@ -174,6 +174,8 @@ trait ParallelTesting { self =>
    *  according to the implementing class "neg", "run" or "pos".
    */
   private abstract class Test(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean) {
+    protected final val realStdout = System.out
+    protected final val realStderr = System.err
 
     /** Actual compilation run logic, the test behaviour is defined here */
     protected def compilationRunnable(testSource: TestSource): Runnable
@@ -192,10 +194,10 @@ trait ParallelTesting { self =>
     val sourceCount = filteredSources.length
 
     private[this] var _errorCount =  0
-    def errorCount: Int = synchronized { _errorCount }
+    def errorCount: Int = _errorCount
 
     private[this] var _testSourcesCompiled = 0
-    private def testSourcesCompiled : Int = synchronized { _testSourcesCompiled }
+    private def testSourcesCompiled: Int = _testSourcesCompiled
 
     /** Complete the current compilation with the amount of errors encountered */
     protected final def registerCompilation(errors: Int) = synchronized {
@@ -227,8 +229,9 @@ trait ParallelTesting { self =>
     }
 
     /** Prints to `System.err` if we're not suppressing all output */
-    protected def echo(msg: String): Unit =
-      if (!suppressAllOutput) System.err.println(msg)
+    protected def echo(msg: String): Unit = realStderr.synchronized {
+      if (!suppressAllOutput) realStderr.println(msg)
+    }
 
     /** A single `Runnable` that prints a progress bar for the curent `Test` */
     private def createProgressMonitor: Runnable = new Runnable {
@@ -238,17 +241,21 @@ trait ParallelTesting { self =>
         while (tCompiled < sourceCount) {
           val timestamp = (System.currentTimeMillis - start) / 1000
           val progress = (tCompiled.toDouble / sourceCount * 40).toInt
-          print(
-            "[" + ("=" * (math.max(progress - 1, 0))) +
-            (if (progress > 0) ">" else "") +
-            (" " * (39 - progress)) +
-            s"] compiling ($tCompiled/$sourceCount, ${timestamp}s)\r"
-          )
+
+          realStdout.synchronized {
+            realStdout.print(
+              "[" + ("=" * (math.max(progress - 1, 0))) +
+              (if (progress > 0) ">" else "") +
+              (" " * (39 - progress)) +
+              s"] compiling ($tCompiled/$sourceCount, ${timestamp}s)\r"
+            )
+          }
+
           Thread.sleep(100)
           tCompiled = testSourcesCompiled
         }
         // println, otherwise no newline and cursor at start of line
-        println(
+        realStdout.println(
           s"[=======================================] compiled ($sourceCount/$sourceCount, " +
           s"${(System.currentTimeMillis - start) / 1000}s)  "
         )
@@ -259,7 +266,12 @@ trait ParallelTesting { self =>
      *  if it did, the test should automatically fail.
      */
     protected def tryCompile(testSource: TestSource)(op: => Unit): Unit =
-      try op catch {
+      try {
+        if (!isInteractive) realStdout.synchronized {
+          realStdout.println(s"Testing ${testSource.title}")
+        }
+        op
+      } catch {
         case NonFatal(e) => {
           // if an exception is thrown during compilation, the complete test
           // run should fail
@@ -309,8 +321,10 @@ trait ParallelTesting { self =>
         Runtime.getRuntime.exec(fullArgs).waitFor() == 0
       } else true
 
-      val reporter = TestReporter.parallelReporter(self, logLevel =
-        if (suppressErrors || suppressAllOutput) ERROR + 1 else ERROR)
+      val reporter = System.out.synchronized {
+        TestReporter.parallelReporter(System.out, logLevel =
+          if (suppressErrors || suppressAllOutput) ERROR + 1 else ERROR)
+      }
       val driver =
         if (times == 1) new Driver { def newCompiler(implicit ctx: Context) = new Compiler }
         else new Driver {
@@ -426,7 +440,7 @@ trait ParallelTesting { self =>
         val cls = ucl.loadClass("Test")
         val meth = cls.getMethod("main", classOf[Array[String]])
 
-        self.synchronized {
+        oldOut.synchronized {
           try {
             val ps = new PrintStream(printStream)
             System.setOut(ps)