refactor tests to guarantee file deletion, fix leftover test output from ScriptingTests

Author: rochala

compiler/test/dotty/tools/scripting/BashExitCodeTests.scala

@@ -8,36 +8,63 @@ import java.io.File
 import java.nio.file.Files
 import org.junit.Test
 import org.junit.Assert.assertEquals
+import org.junit.experimental.categories.Category
 
 import ScriptTestEnv.*
 
 
 object BashExitCodeTests:
-  def testFiles = scripts("/scripting/exit-code-tests")
+  private def testFiles = scripts("/scripting/exit-code-tests")
 
   /*
    * Compiles the class checking exit code
    *
-   * @param testName name of the test containing the extension
+   * @param testName name of the test
    * @param expectedExitCode expected exit code from the output
-   * @param deleteTempDir if temporary directory created for compilation output should delete in this scope
-   *
-   * @return Created temporary directory
    */
-  private def testCompilationExitCode(testName: String, expectedExitCode: Int, deleteTempDir: Boolean = false): File =
-    val temporaryDir = Files.createTempDirectory(testName)
+  private def compileAndVerifyExitCode(
+    testName: String,
+    expectedExitCode: Int,
+  )(using temporaryDir: File): Unit =
     assertTestExists(testName) { testFile =>
-      try {
-        val testFilePath = testFile.absPath
-        val commandline = (Seq(scalacPath, "-d", temporaryDir, testFilePath)).mkString(" ")
-        val (validTest, exitCode, _, _) = bashCommand(commandline)
-        if verifyValid(validTest) then
-          assertEquals(expectedExitCode, exitCode)
-      } finally {
-        if deleteTempDir then Util.deleteFile(temporaryDir.toFile)
-      }
+      val testFilePath = testFile.absPath
+      val commandline = (Seq(scalacPath, "-d", temporaryDir, testFilePath)).mkString(" ")
+      val (validTest, exitCode, _, _) = bashCommand(commandline)
+      if verifyValid(validTest) then
+        assertEquals(expectedExitCode, exitCode)
     }
-    temporaryDir.toFile
+
+  /*
+   * Runs compiled code checking the exit code
+   *
+   * @param className name of compiled class
+   * @param runExitCode expected exit code from the runner
+   */
+  private def runClassAndVerifyExitCode(
+    className: String,
+    expectedExitCode: Int
+  )(using temporaryDir: File): Unit =
+    val testClassFile = temporaryDir.files.find(_.getName == s"$className.class")
+    assert(testClassFile.isDefined)
+    val commandline = (Seq(scalaPath, "-classpath", temporaryDir.getAbsolutePath, className)).mkString(" ")
+    val (validTest, exitCode, o, e) = bashCommand(commandline)
+      if verifyValid(validTest) then
+        assertEquals(expectedExitCode, exitCode)
+
+  /*
+   * Compiles and then runs code verifying runner status code
+   *
+   * @param testName name of the test
+   * @param className name of compiled class
+   * @param expectedRunExitCode expected exit code from the runner
+   */
+  private def compileRunAndVerifyExitCode(
+    testName: String,
+    className: String,
+    expectedRunExitCode: Int,
+  )(using File): Unit =
+    compileAndVerifyExitCode(testName, 0)
+    runClassAndVerifyExitCode(className, expectedRunExitCode)
 
   /*
    * Runs the command and checks the exit code
@@ -51,30 +78,6 @@ object BashExitCodeTests:
     if verifyValid(validTest) then
       assertEquals(expectedExitCode, exitCode)
 
-
-  /* Compiles and then runs the code checking the exit code
-   *
-   * @param testFileName name of the test
-   * @param runExitCode expected exit code from the runner output
-   */
-  private def testCompileAndRun(testFileName: String, runExitCode: Int): Unit =
-    val outputDirectory = testCompilationExitCode(testFileName, 0)
-
-    def testRuntimeExitCode(className: String, expectedExitCode: Int): Unit =
-        val testClassFile = outputDirectory.files.find(_.getName == s"$className.class")
-        assert(testClassFile.isDefined)
-        val commandline = (Seq(scalaPath, "-classpath", outputDirectory.getAbsolutePath, className)).mkString(" ")
-        val (validTest, exitCode, o, e) = bashCommand(commandline)
-          if verifyValid(validTest) then
-            assertEquals(expectedExitCode, exitCode)
-
-    try {
-      val generatedClassName = testFileName.split('.').head
-      testRuntimeExitCode(generatedClassName,  runExitCode)
-    } finally {
-      Util.deleteFile(outputDirectory)
-    }
-
   /*
    * Checks if scripting test resources contains test with given `testName`
    * And then runs function `test`
@@ -87,20 +90,51 @@ object BashExitCodeTests:
     assert(file.isDefined)
     test(file.get)
 
+  /*
+   * Runs test for created temporary file
+   * and ensures it deletion after function execution
+   *
+   * @param test check to be run on found test file
+   */
+  private def withTempFile(test: File => Unit) =
+    val tempFile = Files.createTempFile("temp-file", ".class").toFile
+    try {
+      test(tempFile)
+    } finally {
+      Util.deleteFile(tempFile)
+    }
+
+  /*
+   * Runs test with implicit temporary directory
+   * and ensures it deletion after the function execution
+   *
+   * @param test test to be run with given temporary directory
+   */
+  private def withTempDirectory(test: File ?=> Unit) =
+    given file: File = Files.createTempDirectory("exit-code-tests").toFile
+    try { test } finally { Util.deleteFile(file) }
+
+  /*
+   * Returns path to the generated tasty file for given directory and classname
+   */
+  private def getGeneratedTastyPath(className: String)(using temporaryDir: File): String =
+    temporaryDir.toPath.resolve(s"$className.tasty").toString
+
+@Category(Array(classOf[BootstrappedOnlyTests]))
 class BashExitCodeTests:
   import BashExitCodeTests.*
 
   @Test def verifyExitCodeOnCompileError: Unit =
-    testCompilationExitCode("compileError.scala", 1, true)
+    withTempDirectory(compileAndVerifyExitCode("compileError.scala", 1))
 
   @Test def verifyExitCodeOnRuntimeError: Unit =
-    testCompileAndRun("runtimeError.scala", 1)
+    withTempDirectory(compileRunAndVerifyExitCode("runtimeError.scala", "runtimeError", 1))
 
   @Test def verifyExitCode: Unit =
-    testCompileAndRun("positiveTest.scala", 0)
+    withTempDirectory(compileRunAndVerifyExitCode("positiveTest.scala", "positiveTest", 0))
 
   @Test def verifyExitCodeOnScriptError: Unit =
-    assertTestExists("scriptRuntimeError.sc") { file =>
+    assertTestExists("scriptRuntimeError.sc"){ file =>
       testCommandExitCode(Seq(scalacPath, "-script", file.absPath), 1)
     }
 
@@ -120,28 +154,24 @@ class BashExitCodeTests:
     }
 
   @Test def verifyExitCodeOnDecompilation: Unit =
-    val testName = "positiveTest"
-    val outputDirectory = testCompilationExitCode(s"$testName.scala", 0)
-    val tastyFilePath =  outputDirectory.toPath.resolve(s"$testName.tasty").toString
-    testCommandExitCode(Seq(scalacPath, "-decompile", tastyFilePath), 0)
+    withTempDirectory {
+      compileAndVerifyExitCode("positiveTest.scala", 0)
+      testCommandExitCode(Seq(scalacPath, "-decompile", getGeneratedTastyPath("positiveTest")), 0)
+    }
 
   @Test def verifyExitCodeOnPrintTasty: Unit =
-    val testName = "positiveTest"
-    val outputDirectory = testCompilationExitCode(s"$testName.scala", 0)
-    val tastyFilePath =  outputDirectory.toPath.resolve(s"$testName.tasty").toString
-    testCommandExitCode(Seq(scalacPath, "-print-tasty", tastyFilePath), 0)
+    withTempDirectory {
+      compileAndVerifyExitCode("positiveTest.scala", 0)
+      testCommandExitCode(Seq(scalacPath, "-print-tasty", getGeneratedTastyPath("positiveTest")), 0)
+    }
 
   @Test def verifyExitCodeOnDecompilationFailure: Unit =
-    val tempFile = Files.createTempFile("temp-file", ".class").toFile
+    withTempFile(file => testCommandExitCode(Seq(scalacPath, "-decompile", file.absPath), 1))
     testCommandExitCode(Seq(scalacPath, "-decompile", "non-existing-file.tasty"), 1)
-    testCommandExitCode(Seq(scalacPath, "-decompile", tempFile.absPath), 1)
-    Util.deleteFile(tempFile)
 
   @Test def verifyExitCodeOnPrintTastyFailure: Unit =
-    val tempFile = Files.createTempFile("temp-file", ".class").toFile
+    withTempFile(file => testCommandExitCode(Seq(scalacPath, "-print-tasty", file.absPath), 1))
     testCommandExitCode(Seq(scalacPath, "-print-tasty", "non-existing-file.tasty"), 1)
-    testCommandExitCode(Seq(scalacPath, "-print-tasty", tempFile.absPath), 1)
-    Util.deleteFile(tempFile)
 
   @Test def verifyExitCodeOnExpressionCompileError: Unit =
     testCommandExitCode(Seq(scalaPath, "-e", "'prinln(10*10)'"), 1)

compiler/test/dotty/tools/scripting/ScriptingTests.scala

@@ -122,7 +122,7 @@ class ScriptingTests:
   /*
    * Compile touchFile.sc to create executable jar, verify jar execution succeeds.
    */
-  @Test def scriptingNoCompileJar =
+  @Test def scriptingNoCompileJar: Unit =
     val scriptFile = touchFileScript
     showScriptUnderTest(scriptFile)
     val expectedJar = script2jar(scriptFile)
@@ -146,6 +146,8 @@ class ScriptingTests:
     if touchedFile.exists then
       printf("success: executable jar created file %s\n", touchedFile)
     assert( touchedFile.exists, s"expected to find file ${touchedFile}" )
+    touchedFile.delete
+    assert( !touchedFile.exists, s"unable to delete ${touchedFile}" )
 
 ///////////////////////////////////
   def touchFileScript = testFiles.find(_.getName == "touchFile.sc").get