Use classloader as main mechanism to specify test class path.

ConsoleFileManager will soon be a thing of the past when we
switch to using ant + maven for resolving the test classpath
when launching partest from the command line using test/partest.

Author: adriaanm

src/main/scala/scala/tools/partest/PartestTask.scala

@@ -17,6 +17,7 @@ import org.apache.tools.ant.types.{ Reference, FileSet }
 import org.apache.tools.ant.types.Commandline.Argument
 import scala.tools.ant.ScalaTask
 import nest.NestUI
+import java.net.URLClassLoader
 
 /** An Ant task to execute the Scala test suite (NSC).
  *
@@ -123,7 +124,7 @@ class PartestTask extends Task with CompilationPathProperty with ScalaTask {
     })
 
     var failureCount = 0
-    val summary = new scala.tools.partest.nest.AntRunner(srcDir.getOrElse(null), compilationPath.get.list, javacmd.getOrElse(null), javaccmd.getOrElse(null), scalacArgsFlat) {
+    val summary = new scala.tools.partest.nest.AntRunner(srcDir.getOrElse(null), new URLClassLoader(compilationPath.get.list.map(Path(_).toURL)), javacmd.getOrElse(null), javaccmd.getOrElse(null), scalacArgsFlat) {
       def echo(msg: String): Unit = PartestTask.this.log(msg)
       def log(msg: String): Unit = PartestTask.this.log(msg)
 

src/main/scala/scala/tools/partest/nest/AntRunner.scala

@@ -18,11 +18,12 @@ import sbt.testing.Status
 import sbt.testing.OptionalThrowable
 import sbt.testing.SuiteSelector
 import sbt.testing.TestSelector
+import java.net.URLClassLoader
 
 // not using any Scala types to ease calling across different scala versions
-abstract class AntRunner(srcDir: String, compilationPaths: Array[String], javaCmd: File, javacCmd: File, scalacArgs: Array[String]) extends SuiteRunner(
+abstract class AntRunner(srcDir: String, testClassLoader: URLClassLoader, javaCmd: File, javacCmd: File, scalacArgs: Array[String]) extends SuiteRunner(
   testSourcePath = Option(srcDir) getOrElse PartestDefaults.sourcePath,
-  new FileManager(testClassPath = compilationPaths map { fs => Path(fs) } toList),
+  new FileManager(testClassLoader = testClassLoader),
   updateCheck = false,
   failed  = false,
   javaCmdPath = Option(javaCmd).map(_.getAbsolutePath) getOrElse PartestDefaults.javaCmd,
@@ -51,6 +52,7 @@ abstract class AntRunner(srcDir: String, compilationPaths: Array[String], javaCm
     }
   }
 
+  // called reflectively from scala-partest-test-interface
   final def execute(kinds: Array[String]): String = {
     echo(banner)
 
@@ -68,9 +70,10 @@ abstract class AntRunner(srcDir: String, compilationPaths: Array[String], javaCm
   }
 }
 
+// called reflectively from scala-partest-test-interface
 class SBTRunner(partestFingerprint: Fingerprint, eventHandler: EventHandler, loggers: Array[Logger],
-    srcDir: String, compilationPaths: Array[String], javaCmd: File, javacCmd: File, scalacArgs: Array[String])
-    extends AntRunner(srcDir, compilationPaths, javaCmd, javacCmd, scalacArgs) {
+    srcDir: String, testClassLoader: URLClassLoader, javaCmd: File, javacCmd: File, scalacArgs: Array[String])
+    extends AntRunner(srcDir, testClassLoader, javaCmd, javacCmd, scalacArgs) {
   override def error(msg: String): Nothing = sys.error(msg)
   def echo(msg: String): Unit = loggers foreach { l => l.info(msg) }
   def log(msg: String): Unit = loggers foreach { l => l.debug(msg) }

src/main/scala/scala/tools/partest/nest/ConsoleFileManager.scala

@@ -15,27 +15,7 @@ import scala.tools.nsc.{ io, util }
 import PathResolver.{ Environment, Defaults }
 
 object ConsoleFileManager {
-  def classPath = {
-    val srcDir = {
-      val src = PathSettings.srcDir
-      if (!src.isDirectory) {
-        NestUI.failure("Source directory \"" + src.path + "\" not found")
-        sys.exit(1)
-      }
-      src
-    }
-    val libs = (srcDir / Directory("lib")).files filter (_ hasExtension "jar") map (_.toCanonical.path)
-
-    // def classPath   = propOrElse("partest.classpath", "")
-    val userCp = ClassPath split PathResolver.Environment.javaUserClassPath    // XXX
-
-    // add all jars in libs
-    val cp = (userCp ++ libs.toList)
-    vlog("testClassPath: " + cp)
-    cp map (Path(_))
-  }
-
-  def mostRecentTrifecta(testBuild: Option[String], testClasses: Option[String]) = {
+  private def mostRecentTrifecta(testBuild: Option[String], testClasses: Option[String]) = {
     import PathSettings.testParent
     val testClassesDir = testClasses map (tc => Path(tc).toCanonical.toDirectory)
     val testBuildDir   = testBuild map (b => (testParent / b).toCanonical.toDirectory)
@@ -103,7 +83,49 @@ object ConsoleFileManager {
       pairs(pairs.keys max)()
     }
   }
+
+  def classPathFromMostRecentTrifecta(testBuild: Option[String], testClasses: Option[String]): List[Path] = {
+    val (library, reflect, compiler) = mostRecentTrifecta(testBuild, testClasses)
+
+    val srcDir = {
+      val src = PathSettings.srcDir
+      if (!src.isDirectory) {
+        NestUI.failure("Source directory \"" + src.path + "\" not found")
+        sys.exit(1)
+      }
+      src
+    }
+    val libs = (srcDir / Directory("lib")).files filter (_ hasExtension "jar") map (file => Path(file.toCanonical.path))
+
+    // def classPath   = propOrElse("partest.classpath", "")
+    val userCp = ClassPath split PathResolver.Environment.javaUserClassPath map (Path(_))
+
+    val usingJars = library.getAbsolutePath endsWith ".jar"
+    // basedir for jars or classfiles on core classpath
+    val baseDir = SFile(library).parent
+
+    def relativeToLibrary(what: String): Path = {
+      if (usingJars) (baseDir / s"$what.jar")
+      else (baseDir.parent / "classes" / what)
+    }
+
+    // all jars or dirs with prefix `what`
+    def relativeToLibraryAll(what: String): Iterator[Path] = (
+      if (usingJars) FileManager.jarsWithPrefix(baseDir, what)
+      else FileManager.dirsWithPrefix(baseDir.parent / "classes" toDirectory, what)
+    )
+
+    userCp ++ List[Path](
+      library, reflect, compiler,
+      relativeToLibrary("scala-actors"),
+      relativeToLibrary("scala-parser-combinators"),
+      relativeToLibrary("scala-xml"),
+      relativeToLibrary("scala-scaladoc"),
+      relativeToLibrary("scala-interactive"),
+      relativeToLibrary("scalap"),
+      PathSettings.diffUtils.fold(sys.error, identity)
+    ) ++ relativeToLibraryAll("scala-partest") ++ libs
+  }
 }
 
-case class ConsoleFileManager(testBuild: Option[String] = PartestDefaults.testBuild, testClasses: Option[String] = None)
-  extends FileManager(ConsoleFileManager.classPath, ConsoleFileManager.mostRecentTrifecta(testBuild, testClasses))
+case class ConsoleFileManager(testBuild: Option[String] = PartestDefaults.testBuild, testClasses: Option[String] = None) extends FileManager(ConsoleFileManager.classPathFromMostRecentTrifecta(testBuild, testClasses))

src/main/scala/scala/tools/partest/nest/FileManager.scala

@@ -24,6 +24,7 @@ import java.net.URI
 import scala.reflect.io.AbstractFile
 import scala.collection.mutable
 import scala.reflect.internal.util.ScalaClassLoader
+import java.net.URLClassLoader
 
 object FileManager {
   def getLogFile(dir: File, fileBase: String, kind: String): File =
@@ -97,91 +98,41 @@ object FileManager {
     if (diff.getDeltas.isEmpty) ""
     else difflib.DiffUtils.generateUnifiedDiff(originalName, revisedName, original.asJava, diff, 1).asScala.mkString("\n")
   }
-
-  // only used by script-based partest, not recommended for anything else
-  def classPathFromTrifecta(library: Path, reflect: Path, compiler: Path) = {
-    val usingJars = library.getAbsolutePath endsWith ".jar"
-    // basedir for jars or classfiles on core classpath
-    val baseDir = SFile(library).parent
-
-    def relativeToLibrary(what: String): Path = {
-      if (usingJars) (baseDir / s"$what.jar")
-      else (baseDir.parent / "classes" / what)
-    }
-
-    // all jars or dirs with prefix `what`
-    def relativeToLibraryAll(what: String): Iterator[Path] = (
-      if (usingJars) jarsWithPrefix(baseDir, what)
-      else dirsWithPrefix(baseDir.parent / "classes" toDirectory, what)
-    )
-
-    List[Path](
-      library, reflect, compiler,
-      relativeToLibrary("scala-actors"),
-      relativeToLibrary("scala-parser-combinators"),
-      relativeToLibrary("scala-xml"),
-      relativeToLibrary("scala-scaladoc"),
-      relativeToLibrary("scala-interactive"),
-      relativeToLibrary("scalap"),
-      PathSettings.diffUtils.fold(sys.error, identity)
-    ) ++ relativeToLibraryAll("scala-partest")
-  }
-
-  // find library/reflect/compiler jar or subdir under build/$stage/classes/
-  // TODO: make more robust -- for now, only matching on prefix of jar file so it works for ivy/maven-resolved versioned jars
-  // can we use the ClassLoader to find the jar/directory that contains a characteristic class file?
-  def fromClassPath(name: String, testClassPath: List[Path]): Path = {
-    // the old approach:
-    def fallback =
-      testClassPath find (f =>
-          (f.extension == "jar" && f.getName.startsWith(s"scala-$name"))
-            || (f.absolutePathSegments endsWith Seq("classes", name))
-        ) getOrElse sys.error(s"Provided compilationPath does not contain a Scala $name element.\nLooked in: ${testClassPath.mkString(":")}")
-
-    // more precise:
-    try {
-      val classLoader = ScalaClassLoader fromURLs (testClassPath map (_.toURI.toURL))
-      val canaryClass =
-        name match {
-          case "library"  => Class.forName("scala.Unit", false, classLoader)
-          case "reflect"  => Class.forName("scala.reflect.api.Symbols", false, classLoader)
-          case "compiler" => Class.forName("scala.tools.nsc.Main", false, classLoader)
-        }
-      val path = Path(canaryClass.getProtectionDomain.getCodeSource.getLocation.getPath)
-      if (path.extension == "jar" || path.absolutePathSegments.endsWith(Seq("classes", name))) path
-      else fallback
-    } catch {
-      case everything: Exception => fallback
-    }
-  }
 }
 
-class FileManager private (val testClassPath: List[Path],
-                  val libraryUnderTest: Path,
-                  val reflectUnderTest: Path,
-                  val compilerUnderTest: Path) {
-  def this(testClassPath: List[Path]) {
-    this(testClassPath,
-        FileManager.fromClassPath("library", testClassPath),
-        FileManager.fromClassPath("reflect", testClassPath),
-        FileManager.fromClassPath("compiler", testClassPath))
-  }
+class FileManager(val testClassLoader: URLClassLoader) {
+  lazy val libraryUnderTest: Path  = findArtifact("library")
+  lazy val reflectUnderTest: Path  = findArtifact("reflect")
+  lazy val compilerUnderTest: Path = findArtifact("compiler")
 
-  protected[nest] def this(libraryUnderTest: Path, reflectUnderTest: Path, compilerUnderTest: Path) {
-    this(FileManager.classPathFromTrifecta(libraryUnderTest, reflectUnderTest, compilerUnderTest), libraryUnderTest, reflectUnderTest, compilerUnderTest)
-  }
+  lazy val testClassPath = testClassLoader.getURLs().map(url => Path(new File(url.toURI))).toList
 
-  protected[nest] def this(testClassPath: List[Path], trifecta: (Path, Path, Path)) {
-    this(testClassPath, trifecta._1, trifecta._2, trifecta._3)
+  def this(testClassPath: List[Path]) {
+    this(new URLClassLoader(testClassPath.toArray map (_.toURI.toURL)))
   }
 
-  lazy val testClassLoader = ScalaClassLoader fromURLs (testClassPath map (_.toURI.toURL))
-
   def distKind = {
     val p = libraryUnderTest.getAbsolutePath
     if (p endsWith "build/quick/classes/library") "quick"
     else if (p endsWith "build/pack/lib/scala-library.jar") "pack"
     else if (p endsWith "dists/latest/lib/scala-library.jar") "latest"
     else "installed"
   }
+
+  // find library/reflect/compiler jar or subdir under build/$stage/classes/
+  private def findArtifact(name: String): Path = {
+    val canaryClass =
+      name match {
+        case "library"  => Class.forName("scala.Unit", false, testClassLoader)
+        case "reflect"  => Class.forName("scala.reflect.api.Symbols", false, testClassLoader)
+        case "compiler" => Class.forName("scala.tools.nsc.Main", false, testClassLoader)
+      }
+
+    val path = Path(canaryClass.getProtectionDomain.getCodeSource.getLocation.getPath)
+    if (path.extension == "jar"
+      || path.absolutePathSegments.endsWith(Seq("classes", name))) path
+    else sys.error(
+      s"""Test Classloader does not contain a $name jar or classes/$name directory.
+           |Looked in: $testClassPath""")
+  }
 }

src/main/scala/scala/tools/partest/nest/ReflectiveRunner.scala

@@ -41,7 +41,7 @@ class ReflectiveRunner {
     val classPath = searchPath("--classpath", argList)
     val fileManager = new ConsoleFileManager(if (argList contains "--pack") Some("build/pack") else buildPath, classPath)
 
-    val classPathEntries = fileManager.testClassLoader.classPathURLs.map(_.toString)
+    val classPathEntries = fileManager.testClassPath.map(_.toString)
 
     if (isPartestDebug)
       println("Loading classes from:\n  " + classPathEntries.mkString("\n  "))
@@ -63,7 +63,7 @@ class ReflectiveRunner {
       case cnfe: ClassNotFoundException =>
         cnfe.printStackTrace()
         NestUI.failure(runnerClassName + " could not be loaded from:\n")
-        fileManager.testClassLoader.classPathURLs foreach (x => NestUI.failure(x + "\n"))
+        fileManager.testClassPath foreach (x => NestUI.failure(x + "\n"))
     }
   }
 }