sbt test-interface for partest

It reflectively calls `SBTRunner`.

Enable it in your `build.sbt` as follows (from the scala-xml build):

```
// for testing with partest (the binary version must be SBT's scala version):
libraryDependencies += "com.typesafe" % "scala-partest-interface_2.10" % "0.1" % "test"

testFrameworks += new TestFramework("com.typesafe.testing.partest.Framework")

// the actual partest the interface calls into -- must be binary version close enough to ours
// so that it can link to the compiler/lib we're using (testing)
libraryDependencies += "org.scala-lang" %% "scala-partest" % "1.0" % "test"

definedTests in Test += (
  new sbt.TestDefinition(
    "partest",
    // marker fingerprint since there are no test classes
    // to be discovered by sbt:
    new sbt.testing.AnnotatedFingerprint {
      def isModule = true
      def annotationName = "partest"
    }, true, Array())
  )
```

You can now invoke partest in SBT using the `test` command.

Author: adriaanm

build.sbt

@@ -25,5 +25,5 @@ libraryDependencies += "org.scala-lang"                 % "scalap"         % "2.
 
 libraryDependencies += "org.scalacheck"                %% "scalacheck"     % "1.10.2-SNAPSHOT"
 
-// libraryDependencies += "org.scala-sbt"                  % "test-interface" % "1.0"
+libraryDependencies += "org.scala-sbt"                  % "test-interface" % "1.0"
 

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

@@ -39,7 +39,7 @@ import nest.NestUI
 class PartestTask extends Task with CompilationPathProperty with ScalaTask {
   type Path = org.apache.tools.ant.types.Path
 
-  private var kinds: List[String] = Nil
+  private var kinds: Array[String] = Array.empty
   private var classpath: Option[Path] = None
   private var debug = false
   private var errorOnFailed: Boolean = true
@@ -84,7 +84,7 @@ class PartestTask extends Task with CompilationPathProperty with ScalaTask {
   }
 
   def setKinds(input: String) {
-    kinds = words(input)
+    kinds = words(input).toArray
   }
 
   def setJavacCmd(input: File) {

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

@@ -6,42 +6,53 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.tools.partest
 package nest
 
+import sbt.testing.EventHandler
+import sbt.testing.Logger
+import sbt.testing.Event
+import sbt.testing.Fingerprint
+import sbt.testing.Selector
+import sbt.testing.Status
+import sbt.testing.OptionalThrowable
+import sbt.testing.SuiteSelector
+import sbt.testing.TestSelector
+
 // not using any Scala types to ease calling across different scala versions
 abstract class AntRunner(compilationPaths: Array[String], javaCmd: File, javacCmd: File, scalacArgs: Array[String]) extends DirectRunner {
+  def error(msg: String): Nothing = sys.error(msg)
+  def echo(msg: String): Unit
+  def log(msg: String): Unit
+  def onFinishKind(kind: String, passed: Array[TestState], failed: Array[TestState]): Unit
+  def onFinishTest(testFile: File, result: TestState): TestState = result
+
   private val cpfiles = compilationPaths map { fs => new File(fs) } toList
   private def findCp(name: String) = cpfiles find (f =>
-       (f.getName == s"scala-$name.jar")
-    || (f.absolutePathSegments endsWith Seq("classes", name))
+    (f.getName == s"scala-$name.jar")
+      || (f.absolutePathSegments endsWith Seq("classes", name))
   ) map (_.getAbsolutePath) getOrElse error(s"Provided compilationPath does not contain a Scala $name element.\nLooked in: ${compilationPaths.mkString(":")}")
 
-
-  val fileManager = new FileManager {
-    val COMPILATION_CLASSPATH: String   = ClassPath.join(compilationPaths: _*)
-    val LATEST_LIB: String              = findCp("library")
-    val LATEST_REFLECT: String          = findCp("reflect")
-    val LATEST_COMP: String             = findCp("compiler")
-    val testRootPath: String            = "test"
-    val testRootDir: Directory          = Directory(testRootPath)
+  final val fileManager = new FileManager {
+    val COMPILATION_CLASSPATH: String = ClassPath.join(compilationPaths: _*)
+    val LATEST_LIB: String = findCp("library")
+    val LATEST_REFLECT: String = findCp("reflect")
+    val LATEST_COMP: String = findCp("compiler")
+    val testRootPath: String = "test"
+    val testRootDir: Directory = Directory(testRootPath)
 
     def failed = false
     def updateCheck = false
 
-    override val JAVACMD: String        = Option(javaCmd)  map (_.getAbsolutePath) getOrElse "java"
-    override val JAVAC_CMD: String      = Option(javacCmd) map (_.getAbsolutePath) getOrElse "javac"
+    override val JAVACMD: String = Option(javaCmd) map (_.getAbsolutePath) getOrElse "java"
+    override val JAVAC_CMD: String = Option(javacCmd) map (_.getAbsolutePath) getOrElse "javac"
     override def SCALAC_OPTS: Seq[String] = super.SCALAC_OPTS ++ scalacArgs
   }
 
+  final override def runTest(manager: RunnerManager, testFile: File): TestState =
+    onFinishTest(testFile, manager runTest testFile)
 
-  def error(msg: String): Nothing = sys.error(msg)
-  def echo(msg: String): Unit
-  def log(msg: String): Unit
-  def onFinishKind(kind: String, passed: Array[TestState], failed: Array[TestState])
-
-  def runSet(kind: String, files: Array[File]): (Int, Int, Array[String]) = {
+  final def runSet(kind: String, files: Array[File]): (Int, Int, Array[String]) = {
     if (files.isEmpty) (0, 0, Array.empty[String])
     else {
       log(s"Running ${files.length} tests in '$kind' at $now")
@@ -58,19 +69,46 @@ abstract class AntRunner(compilationPaths: Array[String], javaCmd: File, javacCm
     }
   }
 
-  def execute(kinds: List[String]): String = {
+  final def execute(kinds: Array[String]): String = {
     echo(banner)
 
-    val _results       = kinds map (k => runSet(k, TestKinds testsFor k map (_.jfile) toArray))
+    val _results = kinds map (k => runSet(k, TestKinds testsFor k map (_.jfile) toArray))
 
-    val allSuccesses   = _results map (_._1) sum
-    val allFailures    = _results map (_._2) sum
+    val allSuccesses = _results map (_._1) sum
+    val allFailures = _results map (_._2) sum
     val allFailedPaths = _results flatMap (_._3)
 
     if (allFailures > 0)
-      s"Test suite finished with $allFailures case${if (allFailures > 1) "s" else ""} failing:\n"+
-      allFailedPaths.mkString("\n")
+      s"Test suite finished with $allFailures case${if (allFailures > 1) "s" else ""} failing:\n" +
+        allFailedPaths.mkString("\n")
     else if (allSuccesses == 0) "There were no tests to run."
     else "Test suite finished with no failures."
   }
 }
+
+class SBTRunner(partestFingerprint: Fingerprint, eventHandler: EventHandler, loggers: Array[Logger], compilationPaths: Array[String], javaCmd: File, javacCmd: File, scalacArgs: Array[String]) extends AntRunner(compilationPaths, 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) }
+  def onFinishKind(kind: String, passed: Array[TestState], failed: Array[TestState]): Unit =
+    eventHandler.handle(new Event {
+      def fullyQualifiedName: String = kind
+      def fingerprint: Fingerprint = partestFingerprint
+      def selector: Selector = new SuiteSelector
+      def status: Status = if (failed.isEmpty) Status.Success else Status.Failure
+      def throwable: OptionalThrowable = new OptionalThrowable
+      def duration: Long = -1
+    })
+
+  override def onFinishTest(testFile: File, result: TestState): TestState = {
+    eventHandler.handle(new Event {
+      def fullyQualifiedName: String = testFile.testIdent
+      def fingerprint: Fingerprint = partestFingerprint
+      def selector: Selector = new TestSelector(testFile.testIdent)
+      def status: Status = if (result.isOk) Status.Success else Status.Failure
+      def throwable: OptionalThrowable = new OptionalThrowable
+      def duration: Long = -1
+    })
+    result
+  }
+}

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

@@ -794,13 +794,15 @@ trait DirectRunner {
     // |Java Classpath:             ${sys.props("java.class.path")}
   }
 
+  def runTest(manager: RunnerManager, testFile: File): TestState = manager runTest testFile
+
   def runTestsForFiles(kindFiles: Array[File], kind: String): Array[TestState] = {
     NestUI.resetTestNumber(kindFiles.size)
 
     val parentClassLoader = ScalaClassLoader fromURLs fileManager.testClassPathUrls
     val pool              = Executors newFixedThreadPool numThreads
     val manager           = new RunnerManager(kind, fileManager, TestRunParams(parentClassLoader))
-    val futures           = kindFiles map (f => pool submit callable(manager runTest f))
+    val futures           = kindFiles map (f => pool submit callable(runTest(manager, f)))
 
     pool.shutdown()
     Try (pool.awaitTermination(waitTime) {