diff options
Diffstat (limited to 'project/build/Partest.scala')
| -rwxr-xr-x | project/build/Partest.scala | 370 |
1 files changed, 0 insertions, 370 deletions
diff --git a/project/build/Partest.scala b/project/build/Partest.scala deleted file mode 100755 index 7771c6f208..0000000000 --- a/project/build/Partest.scala +++ /dev/null @@ -1,370 +0,0 @@ -import sbt._ -import java.io.File -import java.net.URLClassLoader -import TestSet.{filter} - -class TestSet(val SType: TestSetType.Value, val kind: String, val description: String, val files: Array[File]){ - /** - * @param a list of file that we want to know wheter they are members of the test set or not - * @return two lists : the first contains files that are member of the test set, the second contains the files that aren't - */ - def splitContent(f: List[File]):(List[File], List[File]) = { - f.partition((f: File) => files.elements.exists((e: File) => f == e)) - } -} - -object TestSet { - def apply(sType: TestSetType.Value, kind: String, description: String, files: PathFinder)= new TestSet(sType, kind, description, filter(files)) - def filter(p: PathFinder): Array[File] =( p --- p **(HiddenFileFilter || GlobFilter("*.obj")||GlobFilter("*.log"))).getFiles.toArray -} - -object TestSetType extends Enumeration { - val Std, Continuations = Value -} - -class TestConfiguration(val library: Path, val classpath: Iterable[Path], val testRoot: Path, - val tests: List[TestSet], val junitReportDir: Option[Path]){ -} - -trait PartestRunner { - self: BasicLayer with Packer => - - import Partest.runTest - import TestSetType._ - - lazy val testRoot = projectRoot / "test" - lazy val testFiles = testRoot / "files" ## - lazy val testLibs = testFiles / "lib" - - lazy val posFilesTest = TestSet(Std,"pos", "Compiling files that are expected to build", testFiles / "pos" * ("*.scala" || DirectoryFilter)) - lazy val negFilesTest = TestSet(Std,"neg", "Compiling files that are expected to fail", testFiles / "neg" * ("*.scala" || DirectoryFilter)) - lazy val runFilesTest = TestSet(Std,"run", "Compiling and running files", testFiles / "run" * ("*.scala" || DirectoryFilter)) - lazy val jvmFilesTest = TestSet(Std,"jvm", "Compiling and running files", testFiles / "jvm" *("*.scala" || DirectoryFilter)) - lazy val resFilesTest = TestSet(Std,"res", "Running resident compiler scenarii", testFiles / "res" * ("*.res")) - lazy val buildmanagerFilesTest = TestSet(Std,"buildmanager", "Running Build Manager scenarii", testFiles / "buildmanager" * DirectoryFilter) - // lazy val scalacheckFilesTest = TestSet(Std,"scalacheck", "Running scalacheck tests", testFiles / "scalacheck" * ("*.scala" || DirectoryFilter)) - lazy val scriptFilesTest = TestSet(Std,"script", "Running script files", testFiles / "script" * ("*.scala")) - lazy val shootoutFilesTest = TestSet(Std,"shootout", "Running shootout tests", testFiles / "shootout" * ("*.scala")) - lazy val scalapFilesTest = TestSet(Std,"scalap", "Running scalap tests", testFiles / "scalap" * ("*.scala")) - lazy val specializedFilesTest = TestSet(Std,"specialized", "Running specialized tests", testFiles / "specialized" * ("*.scala")) - - // lazy val negContinuationTest = TestSet(Continuations,"neg", "Compiling continuations files that are expected to fail", testFiles / "continuations-neg" * ("*.scala" || DirectoryFilter)) - // lazy val runContinuationTest = TestSet(Continuations,"run", "Compiling and running continuations files", testFiles / "continuations-run" ** ("*.scala" )) - // - // lazy val continuationScalaOpts = ( - // "-Xpluginsdir " + - // continuationPluginConfig.packagingConfig.jarDestination.asFile.getParent + - // " -Xplugin-require:continuations -P:continuations:enable" - // ) - - lazy val testSuiteFiles: List[TestSet] = List( - posFilesTest, negFilesTest, runFilesTest, jvmFilesTest, resFilesTest, - buildmanagerFilesTest, - //scalacheckFilesTest, - shootoutFilesTest, scalapFilesTest, - specializedFilesTest - ) - lazy val testSuiteContinuation: List[TestSet] = Nil // List(negContinuationTest, runContinuationTest) - - private lazy val filesTestMap: Map[String, TestSet] = - Map(testSuiteFiles.map(s => (s.kind,s) ):_*) - // + (("continuations-neg",negContinuationTest),("continuations-run", runContinuationTest)) - - private lazy val partestOptions = List("-failed") - - private lazy val partestCompletionList: Seq[String] = { - val len = testFiles.asFile.toString.length + 1 - - filesTestMap.keys.toList ++ partestOptions ++ - (filesTestMap.values.toList flatMap (_.files) map (_.toString take len)) - } - - private def runPartest(tests: List[TestSet], scalacOpts: Option[String], failedOnly: Boolean) = { - - val config = new TestConfiguration( - outputLibraryJar, - (outputLibraryJar +++ outputCompilerJar +++ outputPartestJar +++ outputScalapJar +++ antJar +++ jlineJar +++ (testLibs * "*.jar")).get, - testRoot, - tests, - None - ) - - val javaHome = Path.fromFile(new File(System.getProperty("java.home"))) - val java = Some(javaHome / "bin" / "java" asFile) - val javac = Some(javaHome / "bin" / "javac" asFile) - val timeout = Some("2400000") - val loader = info.launcher.topLoader - - log.debug("Ready to run tests") - - if (tests.isEmpty) { - log.debug("Empty test list") - None - } - else runTest( - loader, config, java, javac, - scalacOpts, timeout, true, true, - failedOnly, true, isDebug, log - ) - } - - def partestDebugProp = - if (isDebug) List("-Dpartest.debug=true") - else Nil - - lazy val externalPartest = task { args => - task { - if (isForked) partest(args).run - else withJVMArgs(partestDebugProp ++ args: _*) { - if (forkTasks("partest")) None - else Some("Some tests failed.") - } - } dependsOn pack - } completeWith partestCompletionList - - lazy val partest = task { args => - var failedOnly = false - - def setOptions(options: List[String], acc: List[String]): List[String] = options match { - case "-failed" :: xs => - failedOnly = true - log.info("Only tests that failed previously will be run") - setOptions(xs, acc) - case x :: xs => - setOptions(xs, x :: acc) - case _ => acc - } - - def resolveSets(l: List[String], rem: List[String], acc: List[TestSet]): (List[String], List[TestSet]) = { - def searchSet(arg: String): Option[TestSet] = filesTestMap get arg - - l match { - case x :: xs => searchSet(x) match { - case Some(s) => resolveSets(xs, rem, s :: acc) - case None => resolveSets(xs, x :: rem, acc) - } - case Nil => (rem, acc) - } - } - - def resolveFiles(l: List[String], sets: List[TestSet]):(List[String], List[TestSet]) = { - def resolve0(filesToResolve: List[File], setsToSearchIn: List[TestSet], setAcc: List[TestSet]):(List[String], List[TestSet])= { - filesToResolve match { - case Nil => (Nil, setAcc) // If we have no files left to resolve, we can return the list of the set we have - case list => { - setsToSearchIn match { - case Nil => (list.map(_.toString), setAcc)// If we already had search all sets to find a match, we return the list of the files that where problematic and the set we have - case x :: xs => { - val (found, notFound)= x.splitContent(list) - if(!found.isEmpty){ - val newSet = new TestSet(x.SType, x.kind, x.description, found.toArray) - resolve0(notFound, xs, newSet :: setAcc) - } else { - resolve0(notFound, xs, setAcc) - } - } - } - } - } - - } - - resolve0(l.map(Path.fromString(testFiles, _).asFile), filesTestMap.values.toList, sets) - } - - val keys = setOptions(args.toList, Nil) - - if (keys.isEmpty) { - task { runPartest(testSuiteFiles, None, failedOnly) } - } - else { - val (fileNames, sets) = resolveSets(keys, Nil, Nil) - val (notFound, allSets) = resolveFiles(fileNames, sets) - if (!notFound.isEmpty) - log.info("Don't know what to do with : \n"+notFound.mkString("\n")) - - task { runPartest(allSets, None, failedOnly) } - } - // if (keys.length == 0) task { - // runPartest(testSuiteFiles, None, failedOnly) orElse { - // runPartest(testSuiteContinuation, None, failedOnly) - // } // this is the case where there were only config options, we will run the standard test suite - // } - // else { - // val (fileNames, sets) = resolveSets(keys, Nil, Nil) - // val (notFound, allSets) = resolveFiles(fileNames, sets) - // if (!notFound.isEmpty) - // log.info("Don't know what to do with : \n"+notFound.mkString("\n")) - // - // val (std, continuations) = allSets partition (_.SType == TestSetType.Std) - // task { - // runPartest(std, None, failedOnly) orElse { - // runPartest(continuations, Some(continuationScalaOpts), failedOnly) - // } - // } - // } - }.completeWith(partestCompletionList) - -} - -object Partest { - def runTest( - parentLoader: ClassLoader, - config: TestConfiguration, - javacmd: Option[File], - javaccmd: Option[File], - scalacOpts: Option[String], - timeout: Option[String], - showDiff: Boolean, - showLog: Boolean, - runFailed: Boolean, - errorOnFailed: Boolean, - debug: Boolean, - log: Logger - ): Option[String] = { - - if (debug) - log.setLevel(Level.Debug) - - if (config.classpath.isEmpty) - return Some("The classpath is empty") - - log.debug("Classpath is "+ config.classpath) - - val classloader = new URLClassLoader( - Array(config.classpath.toSeq.map(_.asURL):_*), - ClassLoader.getSystemClassLoader.getParent - ) - val runner: AnyRef = - classloader.loadClass("scala.tools.partest.nest.SBTRunner").newInstance().asInstanceOf[AnyRef] - val fileManager: AnyRef = - runner.getClass.getMethod("fileManager", Array[Class[_]](): _*).invoke(runner, Array[Object](): _*) - - val runMethod = - runner.getClass.getMethod("reflectiveRunTestsForFiles", Array(classOf[Array[File]], classOf[String]): _*) - - def runTestsForFiles(kindFiles: Array[File], kind: String) = { - val result = runMethod.invoke(runner, Array(kindFiles, kind): _*).asInstanceOf[java.util.HashMap[String, Int]] - scala.collection.jcl.Conversions.convertMap(result) - } - - def setFileManagerBooleanProperty(name: String, value: Boolean) { - log.debug("Setting partest property :"+name+" to :"+value) - val setMethod = - fileManager.getClass.getMethod(name+"_$eq", Array(classOf[Boolean]): _*) - setMethod.invoke(fileManager, Array(java.lang.Boolean.valueOf(value)).asInstanceOf[Array[Object]]: _*) - } - - def setFileManagerStringProperty(name: String, value: String) { - log.debug("Setting partest property :"+name+" to :"+value) - val setMethod = - fileManager.getClass.getMethod(name+"_$eq", Array(classOf[String]): _*) - setMethod.invoke(fileManager, Array(value).asInstanceOf[Array[Object]]: _*) - } - - // System.setProperty("partest.srcdir", "files") - - setFileManagerBooleanProperty("showDiff", showDiff) - setFileManagerBooleanProperty("showLog", showLog) - setFileManagerBooleanProperty("failed", runFailed) - if (!javacmd.isEmpty) - setFileManagerStringProperty("JAVACMD", javacmd.get.getAbsolutePath) - if (!javaccmd.isEmpty) - setFileManagerStringProperty("JAVAC_CMD", "javac") - setFileManagerStringProperty("CLASSPATH", (config.classpath.map(_.absolutePath).mkString(File.pathSeparator))) - setFileManagerStringProperty("LATEST_LIB", config.library.absolutePath) - setFileManagerStringProperty("SCALAC_OPTS", scalacOpts getOrElse "") - - if (!timeout.isEmpty) - setFileManagerStringProperty("timeout", timeout.get) - - type TFSet = (Array[File], String, String) - - val testFileSets = config.tests - - def resultsToStatistics(results: Iterable[(_, Int)]): (Int, Int) = { - val (files, failures) = results map (_._2 == 0) partition (_ == true) - def count(i: Iterable[_]): Int ={ - var c = 0 - for (elem <-i) yield { - c = c+1 - } - c - } - (count(files), count(failures)) - } - - - def runSet(set: TestSet): (Int, Int, Iterable[String]) = { - val (files, name, msg) = (set.files, set.kind, set.description) - log.debug("["+name+"] "+ msg+files.mkString(", files :\n","\n","")) - if (files.isEmpty) { - log.debug("No files !") - (0, 0, List()) - } - else { - log.info(name +" : "+ msg) - val results: Iterable[(String, Int)] = runTestsForFiles(files, name) - val (succs, fails) = resultsToStatistics(results) - - val failed: Iterable[String] = results.filter( _._2!=0) map(_ match { - case (path, 1) => path + " [FAILED]" - case (path, 2) => path + " [TIMOUT]" - }) - - val r =(succs, fails, failed) - - config.junitReportDir match { - case Some(d) => { - val report = testReport(name, results, succs, fails) - scala.xml.XML.save(d/name+".xml", report) - } - case None => - } - - r - } - } - - val _results = testFileSets map runSet - val allSuccesses = _results.map (_._1).foldLeft(0)( _ + _ ) - val allFailures = _results.map (_._2).foldLeft(0)( _ + _ ) - val allFailedPaths = _results flatMap (_._3) - - def f(msg: String): Option[String] = - if (errorOnFailed && allFailures > 0) { - Some(msg) - } - else { - log.info(msg) - None - } - def s = if (allFailures > 1) "s" else "" - val msg = - if (allFailures > 0) "Test suite finished with %d case%s failing.\n".format(allFailures, s)+ allFailedPaths.mkString("\n") - else if (allSuccesses == 0) "There were no tests to run." - else "Test suite finished with no failures." - - f(msg) - - } - - private def oneResult(res: (String, Int)) = - <testcase name ={res._1}>{ - res._2 match { - case 0 => scala.xml.NodeSeq.Empty - case 1 => <failure message="Test failed"/> - case 2 => <failure message="Test timed out"/> - } - }</testcase> - - private def testReport(kind: String, results: Iterable[(String, Int)], succs: Int, fails: Int) = - <testsuite name ={kind} tests ={(succs + fails).toString} failures ={fails.toString}> - <properties/> - { - results.map(oneResult(_)) - } - </testsuite> - - -} |