Removed the partest restriction that individual...

Removed the partest restriction that individual files must be in the
same set. Haven't you always wanted to do this? Now you can. Review by
phaller.

% ./partest `ack --type=scala -l HashSet | head -6`

Testing individual files
testing: [...]/files/jvm/serialization.scala                          [  OK  ]
testing: [...]/files/jvm/t1600.scala                                  [  OK  ]

Testing individual files
testing: [...]/files/pos/collections.scala                            [  OK  ]
testing: [...]/files/pos/t2183.scala                                  [  OK  ]

Testing individual files
testing: [...]/files/run/bug1074.scala                                [  OK  ]
testing: [...]/files/run/bug2512.scala                                [  OK  ]

3 files changed, 69 insertions, 110 deletions

diff --git a/src/partest/scala/tools/partest/PartestTask.scala b/src/partest/scala/tools/partest/PartestTask.scala
index 79fed51898..757a53813d 100644
--- a/src/partest/scala/tools/partest/PartestTask.scala
+++ b/src/partest/scala/tools/partest/PartestTask.scala
@@ -13,6 +13,8 @@ package partest
 
 import scala.actors.Actor._
 import scala.util.Properties.setProp
+import scala.tools.nsc.io
+import io.{ Directory }
 import nsc.Settings
 import nsc.util.ClassPath
 import util.PathResolver
@@ -140,30 +142,26 @@ class PartestTask extends Task {
   private var jUnitReportDir: Option[File] = None
   private var debug = false
 
-  private def getFiles(fileSet: Option[FileSet]): Array[File] =
-    if (fileSet.isEmpty) Array()
-    else {
-      val files = fileSet.get
-      files.getDirectoryScanner(getProject).getIncludedFiles.map(
-        fs => new File(files.getDir(getProject), fs)
-      ).filter(file => !file.getCanonicalPath().endsWith(".log"))
-    }
+  def fileSetToDir(fs: FileSet) = Directory(fs getDir getProject)
+  def fileSetToArray(fs: FileSet): Array[io.Path] = {
+    val root = fileSetToDir(fs)
+    (fs getDirectoryScanner getProject).getIncludedFiles map (root / _)
+  }
 
-  private def getFilesAndDirs(fileSet: Option[FileSet]): Array[File] =
-    if (!fileSet.isEmpty) {
-      val files = fileSet.get
-      val fileTests = getFiles(fileSet)
-      val dir = files.getDir(getProject)
-      val dirTests = dir.listFiles(new java.io.FileFilter {
-        def accept(file: File) =
-          file.isDirectory &&
-          (!file.getName().equals(".svn")) &&
-          (!file.getName().endsWith(".obj"))
-      })
-      (dirTests ++ fileTests).toArray
-    }
-    else
-      Array()
+  private def getFiles(fileSet: Option[FileSet]): Array[File] = fileSet match {
+    case None     => Array()
+    case Some(fs) => fileSetToArray(fs) filterNot (_ hasExtension "log") map (_.jfile)
+  }
+
+  private def getFilesAndDirs(fileSet: Option[FileSet]): Array[File] = fileSet match {
+    case None     => Array()
+    case Some(fs) =>
+      val fileTests = getFiles(Some(fs))
+      val dirTests: Iterator[io.Path] = fileSetToDir(fs).dirs filterNot (x => (x hasExtension "svn") || (x hasExtension "obj"))
+      val dirResult = dirTests.toList.toArray map (_.jfile)
+
+      dirResult ++ fileTests
+  }
 
   private def getPosFiles          = getFilesAndDirs(posFiles)
   private def getNegFiles          = getFilesAndDirs(negFiles)
diff --git a/src/partest/scala/tools/partest/nest/ConsoleFileManager.scala b/src/partest/scala/tools/partest/nest/ConsoleFileManager.scala
index 617ef642de..3277db2ba7 100644
--- a/src/partest/scala/tools/partest/nest/ConsoleFileManager.scala
+++ b/src/partest/scala/tools/partest/nest/ConsoleFileManager.scala
@@ -177,43 +177,20 @@ class ConsoleFileManager extends FileManager {
   // initialize above fields
   findLatest()
 
-  var testFiles: List[File] = List()
-
-  def getFiles(kind: String, doCheck: Boolean, filter: Option[(String, Boolean)]): List[File] = {
-
-    val dir = new File(srcDir, kind)
-    NestUI.verbose("look in "+dir+" for tests")
-    val files = if (dir.isDirectory) {
-      if (!testFiles.isEmpty) {
-        val dirpath = dir.getAbsolutePath
-        testFiles filter { _.getParentFile.getAbsolutePath == dirpath }
-      } else if (doCheck) filter match {
-        case Some((ending, enableDirs)) =>
-          val filter = new FilenameFilter {
-            def accept(dir: File, name: String) =
-              name.endsWith(ending) ||
-              (enableDirs && (name != ".svn") && (!name.endsWith(".obj")) &&
-              (new File(dir, name)).isDirectory)
-          }
-          dir.listFiles(filter).toList
-        case None =>
-          val filter = new FilenameFilter {
-            def accept(dir: File, name: String) = name != ".svn"
-          }
-          dir.listFiles(filter).toList
-      } else // skip
-        Nil
-    } else {
-      NestUI.failure("Directory \"" + dir.getPath + "\" not found")
-      Nil
-    }
-    if (failed)
-      files filter { logFileExists(_, kind) }
-    else
-      files
-  }
+  var testFiles: List[io.Path] = Nil
+
+  def getFiles(kind: String, cond: Path => Boolean): List[File] = {
+    def ignoreDir(p: Path) = List("svn", "obj") exists (p hasExtension _)
 
-  def getFiles(kind: String, doCheck: Boolean): List[File] =
-    getFiles(kind, doCheck, Some((".scala", true)))
+    val dir = Directory(srcDir / kind)
 
+    if (dir.isDirectory) NestUI.verbose("look in %s for tests" format dir)
+    else NestUI.failure("Directory '%s' not found" format dir)
+
+    val files =
+      if (testFiles.nonEmpty) testFiles filter (_.parent isSame dir)
+      else dir.list filterNot ignoreDir filter cond toList
+
+    ( if (failed) files filter (x => logFileExists(x, kind)) else files ) map (_.jfile)
+  }
 }
diff --git a/src/partest/scala/tools/partest/nest/ConsoleRunner.scala b/src/partest/scala/tools/partest/nest/ConsoleRunner.scala
index 467aa7dc60..3701985e1a 100644
--- a/src/partest/scala/tools/partest/nest/ConsoleRunner.scala
+++ b/src/partest/scala/tools/partest/nest/ConsoleRunner.scala
@@ -19,38 +19,35 @@ import scala.tools.nsc.interpreter.returning
 import io.{ Path }
 
 class ConsoleRunner extends DirectRunner {
+  import PathSettings.srcDir
 
-  case class TestSet(loc: String,
-                     filter: Option[(String, Boolean)],
-                     kind: String,
-                     msg: String)
+  case class TestSet(kind: String, filter: Path => Boolean, msg: String)
 
   val testSets = {
-    val fileFilter = Some((".scala", true))
+    val pathFilter: Path => Boolean = _ hasExtension "scala"
+
     List(
-      TestSet("pos", fileFilter, "pos",
-              "Testing compiler (on files whose compilation should succeed)"),
-      TestSet("neg", fileFilter, "neg",
-              "Testing compiler (on files whose compilation should fail)"),
-      TestSet("run", fileFilter, "run", "Testing JVM backend"),
-      TestSet("jvm", fileFilter, "jvm", "Testing JVM backend"),
-      TestSet("res", Some((".res", false)), "res",
-              "Testing resident compiler"),
-      TestSet("buildmanager", Some((".nothing", true)), "buildmanager", "Testing Build Manager"),
-      TestSet("shootout", fileFilter, "shootout", "Testing shootout tests"),
-      TestSet("script", fileFilter, "script", "Testing script tests"),
-      TestSet("scalacheck", fileFilter, "scalacheck", "Testing ScalaCheck tests"),
-      TestSet("scalap", fileFilter, "scalap", "Run scalap decompiler tests"))
+      TestSet("pos", pathFilter, "Testing compiler (on files whose compilation should succeed)"),
+      TestSet("neg", pathFilter, "Testing compiler (on files whose compilation should fail)"),
+      TestSet("run", pathFilter, "Testing JVM backend"),
+      TestSet("jvm", pathFilter, "Testing JVM backend"),
+      TestSet("res", x => x.isFile && (x hasExtension "res"), "Testing resident compiler"),
+      TestSet("buildmanager", _.isDirectory, "Testing Build Manager"),
+      TestSet("shootout", pathFilter, "Testing shootout tests"),
+      TestSet("script", pathFilter, "Testing script tests"),
+      TestSet("scalacheck", pathFilter, "Testing ScalaCheck tests"),
+      TestSet("scalap", pathFilter, "Run scalap decompiler tests")
+    )
   }
 
   var fileManager: ConsoleFileManager = _
 
   private var testFiles: List[File] = List()
   private val errors = PartestDefaults.errorCount
+  private val testSetKinds  = testSets map (_.kind)
+  private val testSetArgs   = testSets map ("--" + _.kind)
+  private val testSetArgMap = testSetArgs zip testSets toMap
 
-  private val testSetKinds = testSets map (_.kind)
-  private val testSetArgMap = testSets map (x => ("--" + x.loc) -> x) toMap
-  private val testSetArgs = testSets map ("--" + _.loc)
   def denotesTestSet(arg: String) = testSetArgs contains arg
   def denotesTestFile(arg: String) = (arg endsWith ".scala") || (arg endsWith ".res")
   def denotesTestDir(arg: String) = Path(arg).isDirectory
@@ -85,7 +82,7 @@ class ConsoleRunner extends DirectRunner {
       else new ConsoleFileManager  // auto detection, see ConsoleFileManager.findLatest
 
     def argNarrowsTests(x: String) = denotesTestSet(x) || denotesTestFile(x) || denotesTestDir(x)
-    val enabledTestSets = {
+    val enabledTestSets: List[TestSet] = {
       val enabledArgs = testSetArgs filter parsed.isSet
 
       if (args.isEmpty && (enabledArgs.isEmpty || (parsed isSet "--all"))) testSets
@@ -121,7 +118,7 @@ class ConsoleRunner extends DirectRunner {
     val vmName = "%s (build %s, %s)".format(javaVmName, javaVmVersion, javaVmInfo)
     val vmOpts = fileManager.JAVA_OPTS
 
-    NestUI.verbose("enabled test sets: " + (enabledTestSets map (_.loc) mkString " "))
+    NestUI.verbose("enabled test sets: " + (enabledTestSets map (_.kind) mkString " "))
 
     List(
       "Scala compiler classes in: " + dir,
@@ -130,7 +127,8 @@ class ConsoleRunner extends DirectRunner {
       "Java binaries in:          " + vmBin,
       "Java runtime is:           " + vmName,
       "Java options are:          " + vmOpts,
-      "Source directory is:       " + fileManager.srcDir.path
+      "Source directory is:       " + srcDir,
+      ""
     ) foreach (x => NestUI outline (x + "\n"))
 
     val start = System.currentTimeMillis
@@ -160,9 +158,9 @@ class ConsoleRunner extends DirectRunner {
   }
 
   def runTests(testSet: TestSet): (Int, Int) = {
-    val TestSet(loc, filter, kind, msg) = testSet
+    val TestSet(kind, filter, msg) = testSet
 
-    fileManager.getFiles(loc, true, filter) match {
+    fileManager.getFiles(kind, filter) match {
       case Nil    => NestUI.verbose("test dir empty\n") ; (0, 0)
       case files  =>
         NestUI.verbose("test files: "+files)
@@ -175,34 +173,20 @@ class ConsoleRunner extends DirectRunner {
    * @return (success count, failure count)
    */
   def testCheckAll(enabledSets: List[TestSet]): (Int, Int) = {
-    def runTestsFiles = if (!testFiles.isEmpty) {
-      def kindOf(f: File) = {
-        val srcDirSegments = PathSettings.srcDir.segments
-        val segments = Path(f).normalize.segments
-        lazy val kind = (segments drop srcDirSegments.size).head
-
-        if ((segments startsWith srcDirSegments) && (testSetKinds contains kind)) kind
-        else {
-          NestUI.failure("invalid test file: "+f.getPath+"\n")
-          Predef.exit(1)
-        }
-      }
+    def kindOf(f: File) = (srcDir relativize Path(f).normalize).segments.head
 
-      val fstKind = kindOf(testFiles.head)
-      NestUI.verbose("all test files expected to have kind "+fstKind)
-      if (!testFiles.forall(kindOf(_) equals fstKind)) {
-        NestUI.failure("test files have different kinds\n")
-        Predef.exit(1)
-      } else {
+    val (valid, invalid) = testFiles partition (x => testSetKinds contains kindOf(x))
+    invalid foreach (x => NestUI.failure("Invalid test file '%s', skipping.\n" format x))
+
+    val runTestsFileLists =
+      for ((kind, files) <- valid groupBy kindOf toList) yield {
         NestUI.outline("\nTesting individual files\n")
-        resultsToStatistics(runTestsForFiles(testFiles, fstKind))
+        resultsToStatistics(runTestsForFiles(files, kind))
       }
-    } else (0, 0)
 
-    NestUI.verbose("run sets: "+enabledSets)
+    NestUI.verbose("Run sets: "+enabledSets)
+    val results = runTestsFileLists ::: (enabledSets map runTests)
 
-    val results = List(runTestsFiles) ::: (enabledSets map runTests)
-    results reduceLeft { (p: (Int, Int), q: (Int, Int)) =>
-      (p._1+q._1, p._2+q._2) }
+    (results map (_._1) sum, results map (_._2) sum)
   }
 }