From c985d9cdc075c31b9314ee80c96fb6c076cab270 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Tue, 24 Jan 2017 21:13:58 -0500 Subject: [PATCH] Switch Scripted tests to used ManagedLogger --- .../sbt/internal/scripted/ScriptedTests.scala | 50 +++++++++++-------- 1 file changed, 29 insertions(+), 21 deletions(-) diff --git a/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptedTests.scala b/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptedTests.scala index 197a58403..81a04721a 100644 --- a/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptedTests.scala +++ b/internal/util-scripted/src/main/scala/sbt/internal/scripted/ScriptedTests.scala @@ -3,18 +3,18 @@ package internal package scripted import java.io.File -import sbt.util.Logger -import sbt.internal.util.{ ConsoleLogger, BufferedLogger, FullLogger } +import sbt.util.{ Logger, LogExchange, Level } +import sbt.internal.util.{ ManagedLogger, ConsoleOut, MainAppender, ConsoleAppender, BufferedAppender } import sbt.io.IO.wrapNull import sbt.io.{ DirectoryFilter, HiddenFileFilter } import sbt.io.syntax._ import sbt.internal.io.Resources +import java.util.concurrent.atomic.AtomicInteger object ScriptedRunnerImpl { def run(resourceBaseDirectory: File, bufferLog: Boolean, tests: Array[String], handlersProvider: HandlersProvider): Unit = { val runner = new ScriptedTests(resourceBaseDirectory, bufferLog, handlersProvider) - val logger = ConsoleLogger() - logger.setLevel(sbt.util.Level.Debug) + val logger = newLogger val allTests = get(tests, resourceBaseDirectory, logger) flatMap { case ScriptedTest(group, name) => runner.scriptedTest(group, name, logger) @@ -26,29 +26,36 @@ object ScriptedRunnerImpl { if (errors.nonEmpty) sys.error(errors.mkString("Failed tests:\n\t", "\n\t", "\n")) } - def get(tests: Seq[String], baseDirectory: File, log: Logger): Seq[ScriptedTest] = + def get(tests: Seq[String], baseDirectory: File, log: ManagedLogger): Seq[ScriptedTest] = if (tests.isEmpty) listTests(baseDirectory, log) else parseTests(tests) - def listTests(baseDirectory: File, log: Logger): Seq[ScriptedTest] = + def listTests(baseDirectory: File, log: ManagedLogger): Seq[ScriptedTest] = (new ListTests(baseDirectory, _ => true, log)).listTests def parseTests(in: Seq[String]): Seq[ScriptedTest] = for (testString <- in) yield { val Array(group, name) = testString.split("/").map(_.trim) ScriptedTest(group, name) } + private[sbt] val generateId: AtomicInteger = new AtomicInteger + private[sbt] def newLogger: ManagedLogger = + { + val loggerName = "scripted-" + generateId.incrementAndGet + val x = LogExchange.logger(loggerName) + x + } } final class ScriptedTests(resourceBaseDirectory: File, bufferLog: Boolean, handlersProvider: HandlersProvider) { - // import ScriptedTests._ private val testResources = new Resources(resourceBaseDirectory) + private val consoleAppender: ConsoleAppender = ConsoleAppender() val ScriptFilename = "test" val PendingScriptFilename = "pending" def scriptedTest(group: String, name: String, log: xsbti.Logger): Seq[() => Option[String]] = scriptedTest(group, name, Logger.xlog2Log(log)) - def scriptedTest(group: String, name: String, log: Logger): Seq[() => Option[String]] = + def scriptedTest(group: String, name: String, log: ManagedLogger): Seq[() => Option[String]] = scriptedTest(group, name, { _ => () }, log) - def scriptedTest(group: String, name: String, prescripted: File => Unit, log: Logger): Seq[() => Option[String]] = { + def scriptedTest(group: String, name: String, prescripted: File => Unit, log: ManagedLogger): Seq[() => Option[String]] = { for (groupDir <- (resourceBaseDirectory * group).get; nme <- (groupDir * name).get) yield { val g = groupDir.getName val n = nme.getName @@ -69,19 +76,20 @@ final class ScriptedTests(resourceBaseDirectory: File, bufferLog: Boolean, handl } } - private def scriptedTest(label: String, testDirectory: File, prescripted: File => Unit, log: Logger): Unit = + private def scriptedTest(label: String, testDirectory: File, prescripted: File => Unit, log: ManagedLogger): Unit = { - val buffered = new BufferedLogger(new FullLogger(log)) - buffered.setLevel(sbt.util.Level.Debug) - if (bufferLog) + val buffered = BufferedAppender(consoleAppender) + LogExchange.unbindLoggerAppenders(log.name) + LogExchange.bindLoggerAppenders(log.name, (buffered -> Level.Debug) :: Nil) + if (bufferLog) { buffered.record() - + } def createParser() = { // val fileHandler = new FileCommands(testDirectory) // // val sbtHandler = new SbtHandler(testDirectory, launcher, buffered, launchOpts) // new TestScriptParser(Map('$' -> fileHandler, /* '>' -> sbtHandler, */ '#' -> CommentHandler)) - val scriptConfig = new ScriptConfig(label, testDirectory, buffered) + val scriptConfig = new ScriptConfig(label, testDirectory, log) new TestScriptParser(handlersProvider getHandlers scriptConfig) } val (file, pending) = { @@ -98,31 +106,31 @@ final class ScriptedTests(resourceBaseDirectory: File, bufferLog: Boolean, handl run(parser.parse(file)) } def testFailed(): Unit = { - if (pending) buffered.clear() else buffered.stop() - buffered.error("x " + label + pendingString) + if (pending) buffered.clearBuffer() else buffered.stopBuffer() + log.error("x " + label + pendingString) } try { prescripted(testDirectory) runTest() - buffered.info("+ " + label + pendingString) + log.info("+ " + label + pendingString) if (pending) throw new PendingTestSuccessException(label) } catch { case e: TestException => testFailed() e.getCause match { - case null | _: java.net.SocketException => buffered.error(" " + e.getMessage) + case null | _: java.net.SocketException => log.error(" " + e.getMessage) case _ => if (!pending) e.printStackTrace } if (!pending) throw e case e: PendingTestSuccessException => testFailed() - buffered.error(" Mark as passing to remove this failure.") + log.error(" Mark as passing to remove this failure.") throw e case e: Exception => testFailed() if (!pending) throw e - } finally { buffered.clear() } + } finally { buffered.clearBuffer() } } }