Check the runtime output of some coverage tests

Author: TheElectronWill

compiler/test/dotty/tools/dotc/coverage/CoverageTests.scala

@@ -16,27 +16,28 @@ import dotty.tools.dotc.Main
 
 @Category(Array(classOf[BootstrappedOnlyTests]))
 class CoverageTests:
-  import CoverageTests.*
-  import CoverageTests.given
+  import CoverageTests.{*, given}
 
   private val scalaFile = FileSystems.getDefault.getPathMatcher("glob:**.scala")
   private val rootSrc = Paths.get(System.getProperty("dotty.tools.dotc.coverage.test"))
-  private val expectDir = rootSrc.resolve("expect")
 
   @Test
-  def checkInstrumentedCode(): Unit =
-    given TestGroup = TestGroup("instrumentCoverage")
-    val updateCheckfiles = dotty.Properties.testsUpdateCheckfile
-    val sourceRoot = rootSrc.toString
+  def checkCoverageStatements(): Unit =
+    checkCoverageIn(rootSrc.resolve("pos"), false)
 
-    Files.walk(expectDir).filter(scalaFile.matches).forEach(p => {
+  @Test
+  def checkInstrumentedRuns(): Unit =
+    checkCoverageIn(rootSrc.resolve("run"), true)
+
+  def checkCoverageIn(dir: Path, run: Boolean)(using TestGroup): Unit =
+    Files.walk(dir).filter(scalaFile.matches).forEach(p => {
       val path = p
       val fileName = path.getFileName.toString.stripSuffix(".scala")
-      val targetDir = computeCoverageInTmp(path, sourceRoot)
+      val targetDir = computeCoverageInTmp(path, dir, run)
       val targetFile = targetDir.resolve(s"scoverage.coverage")
-      val expectFile = expectDir.resolve(s"$fileName.scoverage.check")
+      val expectFile = p.resolveSibling(s"$fileName.scoverage.check")
 
-      if updateCheckfiles then
+      if updateCheckFiles then
         Files.copy(targetFile, expectFile, StandardCopyOption.REPLACE_EXISTING)
       else
         val expected = Files.readAllLines(expectFile).asScala
@@ -51,10 +52,14 @@ class CoverageTests:
     })
 
   /** Generates the coverage report for the given input file, in a temporary directory. */
-  def computeCoverageInTmp(inputFile: Path, sourceRoot: String)(using TestGroup): Path =
+  def computeCoverageInTmp(inputFile: Path, sourceRoot: Path, run: Boolean)(using TestGroup): Path =
     val target = Files.createTempDirectory("coverage")
-    val options = defaultOptions.and("-Ycheck:instrumentCoverage", "-coverage-out", target.toString, "-coverage-sourceroot", sourceRoot)
-    compileFile(inputFile.toString, options).checkCompile()
+    val options = defaultOptions.and("-Ycheck:instrumentCoverage", "-coverage-out", target.toString, "-coverage-sourceroot", sourceRoot.toString)
+    val test = compileFile(inputFile.toString, options)
+    if run then
+      test.checkRuns()
+    else
+      test.checkCompile()
     target
 
 object CoverageTests extends ParallelTesting:
@@ -72,3 +77,5 @@ object CoverageTests extends ParallelTesting:
   @AfterClass def tearDown(): Unit =
     super.cleanup()
     summaryReport.echoSummary()
+
+  given TestGroup = TestGroup("instrumentCoverage")

project/Build.scala

@@ -613,13 +613,15 @@ object Build {
       testCoverage := Def.inputTaskDyn {
         val args = spaceDelimited("<arg>").parsed
         if (args.contains("--help")) {
-          println("usage: testCoverage [--update-checkfiles]")
+          println("usage: testCoverage [--update-checkfiles] [<args>]")
           (Test / testOnly).toTask(" not.a.test")
         } else {
           val updateCheckfile = args.contains("--update-checkfiles")
+          val otherArgs = args.filter(_ != "--update-checkfiles")
           val test = "dotty.tools.dotc.coverage.CoverageTests"
           val argUpdateCheckfile = if (updateCheckfile) "-Ddotty.tests.updateCheckfiles=TRUE" else ""
-          val cmd = s" $test -- $argUpdateCheckfile"
+          val argCustom = if (otherArgs.nonEmpty) otherArgs.mkString(" ") else ""
+          val cmd = s" $test -- $argUpdateCheckfile $argCustom"
           (Test/testOnly).toTask(cmd)
         }
       }.evaluated,