Reliable initialization of test source path

`testSourcePath` determines where we look for tests, relative to the `testRoot`
As `testSourcePath` and `testRoot` are mutable, all jar paths that depend on it
may change as well.

We don't use system properties to configure partest internally,
as their behavior depends on the security policy in place.
ant, for example, does not allow overwriting properties.

TODO: make all of this immutable, but that's pretty involved.
A lot of stuff depends on it (all the more reason to refactor)

Author: adriaanm

src/main/scala/scala/tools/partest/PartestDefaults.scala

@@ -6,14 +6,6 @@ import scala.tools.nsc.Properties.{ propOrElse, propOrNone, propOrEmpty }
 import java.lang.Runtime.{ getRuntime => runtime }
 
 object PartestDefaults {
-
-  def testRootName  = propOrNone("partest.root")
-  def srcDirName    = propOrElse("partest.srcdir", "files")
-  def testRootDir   = testRootName map (x => Directory(x))
-
-  // def classPath   = propOrElse("partest.classpath", "")
-  def classPath   = ClassPath split PathResolver.Environment.javaUserClassPath    // XXX
-
   def javaCmd     = propOrElse("partest.javacmd", "java")
   def javacCmd    = propOrElse("partest.javac_cmd", "javac")
   def javaOpts    = propOrElse("partest.java_opts", "")

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

@@ -115,7 +115,7 @@ class PartestTask extends Task with CompilationPathProperty with ScalaTask {
       NestUI.setDebug()
     }
 
-    srcDir foreach (x => setProp("partest.srcdir", x))
+    srcDir foreach (nest.PathSettings.testSourcePath = _)
 
     if (compilationPath.isEmpty) sys.error("Mandatory attribute 'compilationPath' is not set.")
 

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

@@ -15,7 +15,7 @@ import scala.tools.nsc.{ io, util }
 import PathResolver.{ Environment, Defaults }
 
 object ConsoleFileManager {
-  val classPath = {
+  def classPath = {
     val srcDir = {
       val src = PathSettings.srcDir
       if (!src.isDirectory) {
@@ -26,14 +26,17 @@ object ConsoleFileManager {
     }
     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 = (PartestDefaults.classPath ++ libs.toList)
+    val cp = (userCp ++ libs.toList)
     vlog("testClassPath: " + cp)
     cp map (Path(_))
   }
 
   def mostRecentTrifecta(testBuild: Option[String], testClasses: Option[String]) = {
-    val testParent     = PathSettings.testRoot.parent
+    import PathSettings.testParent
     val testClassesDir = testClasses map (tc => Path(tc).toCanonical.toDirectory)
     val testBuildDir   = testBuild map (b => (testParent / b).toCanonical.toDirectory)
 

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

@@ -10,7 +10,6 @@ package nest
 import utils.Properties._
 import scala.tools.nsc.Properties.{ versionMsg, setProp }
 import scala.collection.{ mutable, immutable }
-import PathSettings.srcDir
 import TestKinds._
 import scala.reflect.internal.util.Collections.distinctBy
 import scala.tools.cmd.{ CommandLine, CommandLineParser, Instance }
@@ -110,7 +109,7 @@ class ConsoleRunner(argstr: String) extends {
         echoWarning(s"Discarding ${invalid.size} invalid test paths")
     }
 
-    optSourcePath foreach (x => setProp("partest.srcdir", x))
+    optSourcePath foreach (PathSettings.testSourcePath = _)
     optTimeout foreach (x => setProp("partest.timeout", x))
 
     NestUI echo banner

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

@@ -7,35 +7,66 @@ package nest
 
 import scala.tools.nsc.util.ClassPath
 import scala.tools.nsc.io.{ Path, File, Directory }
+import scala.tools.nsc.Properties.{ propOrElse, propOrNone }
 import Path._
 
+/** Get current value for path settings -- these depend on the mutable `testSourcePath`.
+ * Default values are read from system properties `partest.srcdir` and `partest.root`.
+ *
+ * TODO: make `testSourcePath` immutable, but that's pretty involved as a lot of stuff depends on it (all the more reason to refactor)
+ *     (we don't use system properties to configure partest internally,
+ *      as their behavior depends on the security policy in place -- e.g., ant does not allow overwriting properties)
+ *
+ * NOTE: the members are methods because `testSourcePath` changes.
+ */
 object PathSettings {
-  import PartestDefaults.{ testRootDir, srcDirName }
+  private[this] var myTestSourcePath: String = null
+  private def defaultSrcDirName              = propOrElse("partest.srcdir", "files")
+
+  /** testSourcePath determines where we look for tests, relative to the `testRoot`
+   * after it's been read, it cannot be changed
+   */
+  def testSourcePath: String = {
+    if (myTestSourcePath eq null) myTestSourcePath = defaultSrcDirName
+    myTestSourcePath
+  }
+
+  /** testSourcePath determines where we look for tests, relative to the `testRoot`
+   * it can be set only if it hasn't been read yet
+   */
+  def testSourcePath_= (path: String): Unit = {
+    // assert(myTestSourcePath eq null, "Test Source Path set after use.")
+    myTestSourcePath = path
+  }
+
+  // defaults can be set using the environment, but note PathSettings is mutable
+  private def defaultTestRootName  = propOrNone("partest.root")
 
   private def cwd = Directory.Current getOrElse sys.error("user.dir property not set")
-  private def isPartestDir(d: Directory) = (d.name == "test") && (d / srcDirName isDirectory)
+  private def isPartestDir(d: Directory) = (d.name == "test") && (d / testSourcePath isDirectory)
   private def findJar(name: String, ds: Directory*): Either[String, File] =
     ds.toStream flatMap (_.files) filter (_ hasExtension "jar") find ( _.name startsWith name ) map (Right(_)) getOrElse
       Left(s"'${name}.jar' not found in '${ds map (_.path) mkString ", "}'.")
 
   // Directory <root>/test
-  lazy val testRoot: Directory = testRootDir getOrElse {
+  def testRoot: Directory = (defaultTestRootName map (Directory(_))) getOrElse {
     val candidates: List[Directory] = (cwd :: cwd.parents) flatMap (d => List(d, Directory(d / "test")))
 
     candidates find isPartestDir getOrElse sys.error("Directory 'test' not found.")
   }
+  def testParent = testRoot.parent
 
   // Directory <root>/test/files or .../scaladoc
-  lazy val srcDir = Directory(testRoot / srcDirName toCanonical)
+  def srcDir = Directory(testRoot / testSourcePath toCanonical)
 
   // Directory <root>/build/pack/lib
-  lazy val buildPackLibDir = Directory(buildDir / "pack" / "lib")
+  private def buildPackLibDir = Directory(buildDir / "pack" / "lib")
 
   // Directory <root>/test/files/lib
-  lazy val srcLibDir = Directory(srcDir / "lib")
+  private def srcLibDir = Directory(srcDir / "lib")
 
   // Directory <root>/build
-  lazy val buildDir: Directory = {
+  private def buildDir: Directory = {
     val bases      = testRoot :: testRoot.parents
     // In the classic "ant" build, the relevant subdirectory is called build,
     // but in the postmodern "sbt" build, it is called target.  Look for both.
@@ -44,19 +75,10 @@ object PathSettings {
     dirs.headOption getOrElse sys.error("Neither 'build' nor 'target' dir found under test root " + testRoot + ".")
   }
 
-
-  lazy val srcSpecLib     = findJar("instrumented", Directory(srcDir / "speclib"))
-  lazy val srcCodeLib     = findJar("code",  Directory(srcDir / "codelib"), Directory(testRoot / "files" / "codelib") /* work with --srcpath pending */)
-  lazy val agentLib       = findJar("scala-partest-javaagent", buildPackLibDir)
-  lazy val scalaCheck     = findJar("scalacheck", buildPackLibDir, srcLibDir)
-  lazy val testInterface  = findJar("test-interface", buildPackLibDir, srcLibDir)
-  lazy val diffUtils      = findJar("diffutils", buildPackLibDir)
-
-  /** The platform-specific support jar, `tools.jar`.
-   */
-  lazy val platformTools = PathResolver.SupplementalLocations.platformTools
-}
-
-class PathSettings() {
-  // def classpathAsURLs: List[URL]
+  def srcSpecLib     = findJar("instrumented", Directory(srcDir / "speclib"))
+  def srcCodeLib     = findJar("code",  Directory(srcDir / "codelib"), Directory(testRoot / "files" / "codelib") /* work with --srcpath pending */)
+  def agentLib       = findJar("scala-partest-javaagent", buildPackLibDir)
+  def scalaCheck     = findJar("scalacheck", buildPackLibDir, srcLibDir)
+  def testInterface  = findJar("test-interface", buildPackLibDir, srcLibDir)
+  def diffUtils      = findJar("diffutils", buildPackLibDir)
 }