Add skeleton for debug tests

Author: adpi2

compiler/test/dotty/tools/debug/DebugTests.scala

@@ -0,0 +1,56 @@
+package dotty.tools.debug
+
+import dotty.Properties
+import dotty.tools.dotc.reporting.TestReporter
+import dotty.tools.io.JFile
+import dotty.tools.vulpix.*
+import org.junit.Test
+
+import scala.concurrent.duration.*
+
+class DebugTests:
+  import DebugTests.*
+  @Test def debug: Unit =
+    implicit val testGroup: TestGroup = TestGroup("debug")
+    compileFilesInDir("tests/debug", TestConfiguration.defaultOptions).checkDebug()
+
+end DebugTests
+
+object DebugTests extends ParallelTesting:
+  def maxDuration = 45.seconds
+  def numberOfSlaves = Runtime.getRuntime().availableProcessors()
+  def safeMode = Properties.testsSafeMode
+  def isInteractive = SummaryReport.isInteractive
+  def testFilter = Properties.testsFilter
+  def updateCheckFiles: Boolean = Properties.testsUpdateCheckfile
+  def failedTests = TestReporter.lastRunFailedTests
+
+  implicit val summaryReport: SummaryReporting = new SummaryReport
+
+  extension (test: CompilationTest)
+    private def checkDebug()(implicit summaryReport: SummaryReporting): test.type =
+      import test.*
+      checkPass(new DebugTest(targets, times, threadLimit, shouldFail || shouldSuppressOutput), "Debug")
+
+  private final class DebugTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit summaryReport: SummaryReporting)
+    extends RunTest(testSources, times, threadLimit, suppressAllOutput):
+
+    override def onSuccess(testSource: TestSource, reporters: Seq[TestReporter], logger: LoggedRunnable) =
+      verifyDebug(testSource.outDir, testSource, countWarnings(reporters), reporters, logger)
+
+    private def verifyDebug(dir: JFile, testSource: TestSource, warnings: Int, reporters: Seq[TestReporter], logger: LoggedRunnable) =
+      if Properties.testsNoRun then addNoRunWarning()
+      else runMain(testSource.runClassPath, testSource.allToolArgs) match
+        case Success(output) => ()
+        case Failure(output) =>
+          if output == "" then
+            echo(s"Test '${testSource.title}' failed with no output")
+          else
+            echo(s"Test '${testSource.title}' failed with output:")
+            echo(output)
+          failTestSource(testSource)
+        case Timeout =>
+          echo("failed because test " + testSource.title + " timed out")
+          failTestSource(testSource, TimeoutFailure(testSource.title))
+
+  end DebugTest

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

@@ -226,7 +226,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
         rerun.exists(dir.getPath.contains)
     })
 
-  private trait CompilationLogic { this: Test =>
+  protected trait CompilationLogic { this: Test =>
     def suppressErrors = false
 
     /**
@@ -359,7 +359,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   /** Each `Test` takes the `testSources` and performs the compilation and assertions
    *  according to the implementing class "neg", "run" or "pos".
    */
-  private class Test(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit val summaryReport: SummaryReporting) extends CompilationLogic { test =>
+  protected class Test(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit val summaryReport: SummaryReporting) extends CompilationLogic { test =>
 
     import summaryReport._
 
@@ -913,15 +913,15 @@ trait ParallelTesting extends RunnerOrchestration { self =>
       verifyOutput(testSource, reporters, logger)
   }
 
-  private final class RunTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit summaryReport: SummaryReporting)
+  protected class RunTest(testSources: List[TestSource], times: Int, threadLimit: Option[Int], suppressAllOutput: Boolean)(implicit summaryReport: SummaryReporting)
   extends Test(testSources, times, threadLimit, suppressAllOutput) {
     private var didAddNoRunWarning = false
-    private def addNoRunWarning() = if (!didAddNoRunWarning) {
+    protected def addNoRunWarning() = if (!didAddNoRunWarning) {
       didAddNoRunWarning = true
       summaryReport.addStartingMessage {
         """|WARNING
            |-------
-           |Run tests were only compiled, not run - this is due to the `dotty.tests.norun`
+           |Run and debug tests were only compiled, not run - this is due to the `dotty.tests.norun`
            |property being set
            |""".stripMargin
       }
@@ -1172,12 +1172,12 @@ trait ParallelTesting extends RunnerOrchestration { self =>
    *  `aggregateTests` in the companion, which will ensure that aggregation is allowed.
    */
   final class CompilationTest private (
-    private[ParallelTesting] val targets: List[TestSource],
-    private[ParallelTesting] val times: Int,
-    private[ParallelTesting] val shouldDelete: Boolean,
-    private[ParallelTesting] val threadLimit: Option[Int],
-    private[ParallelTesting] val shouldFail: Boolean,
-    private[ParallelTesting] val shouldSuppressOutput: Boolean
+    val targets: List[TestSource],
+    val times: Int,
+    val shouldDelete: Boolean,
+    val threadLimit: Option[Int],
+    val shouldFail: Boolean,
+    val shouldSuppressOutput: Boolean
   ) {
     import org.junit.Assert.fail
 
@@ -1280,7 +1280,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
       checkFail(test, "Rewrite")
     }
 
-    private def checkPass(test: Test, desc: String): this.type =
+    def checkPass(test: Test, desc: String): this.type =
       test.executeTestSuite()
 
       cleanup()

tests/debug/for.scala

@@ -3,7 +3,7 @@ object Test {
      val b = 8 * 9  // [break] [step: f()]
      f()            // [step: val a]
      20 + b
-     print(b)
+     println(b)
   }
 
   def f(): Unit = {

tests/debug/function.scala

@@ -8,7 +8,7 @@ object Test {
       a + b                             // [next] [next]
     }
     val c = plus(a, b)   // [next: print]
-    print(c)             // [cont]
+    println(c)             // [cont]
   }
 
 }

tests/debug/if.scala

@@ -15,6 +15,6 @@ object Test {
     else
       a = 34 * 23    // [step: print]
 
-    print(a)
+    println(a)
   }
 }

tests/debug/method.scala

@@ -3,7 +3,7 @@ object Test {
     val a = 1 + 2        // [break] [step: a * 9]
     val b = a * 9        // [step: plus]
     val c = plus(a, b)   // [step: x * x]
-    print(c)
+    println(c)
   }
 
   def plus(x: Int, y: Int) = {

tests/debug/nested-method.scala

@@ -10,6 +10,6 @@ object Test {
      }
 
      val c = plus(a, b)            // [step: print] [cont]
-     print(c)
+     println(c)
   }
 }

tests/debug/sequence.scala

@@ -6,6 +6,6 @@ object Test {
     a = a * 8         // [step: 9 * 9]
     a = 9 * 9         // [step: 34 * 23]
     a = 34 * 23       // [step: print]
-    print(a)          // [cont]
+    println(a)          // [cont]
   }
 }

tests/debug/tailrec.scala

@@ -12,6 +12,6 @@ object Test {
      val b = a * 9     // [break] [step: fact]
      val c = fact(a)   // [step: x == 0] [step: fact(x - 1)] [step: x == 0] [cont]
      fact(0)           // [break] [step: x == 0] [step: 1] [step: fact(x - 1)] [step: print]
-     print(c)          // [cont]
+     println(c)          // [cont]
   }
 }

tests/debug/while.scala

@@ -9,6 +9,6 @@ object Test {
       a += 1              // [step: while] [cont: print]
     }
 
-    print(a) // [break] [cont]
+    println(a) // [break] [cont]
   }
 }