/* sbt -- Simple Build Tool
 * Copyright 2008, 2009  Steven Blundy, Mark Harrah
 */
package sbt

import scala.xml.{Elem, Group}

object object sbt.ResultResult extends EnumerationEnumeration
{
	val sbt.Result.ValueError, sbt.Result.ValuePassed, sbt.Result.ValueFailed = => sbt.Result.ValueValue
}
object object sbt.ClassTypeClassType extends EnumerationEnumeration
{
	val sbt.ClassType.ValueModule, sbt.ClassType.ValueClass = => sbt.ClassType.ValueValue
}

trait trait TestFramework extends java.lang.Object with NotNullTestFramework extends NotNullNotNull
{
	def => Stringname: StringString
	def => StringtestSuperClassName: StringString
	def => sbt.ClassType.ValuetestSubClassType: ClassType.sbt.ClassType.ValueValue
	
	def (java.lang.ClassLoader,Iterable[sbt.TestReportListener],sbt.Logger)sbt.TestRunnertestRunner(java.lang.ClassLoaderclassLoader: java.lang.ClassLoaderClassLoader, Iterable[sbt.TestReportListener]listeners: Iterable[sbt.TestReportListener]Iterable[TestReportListener], sbt.Loggerlog: sbt.LoggerLogger): sbt.TestRunnerTestRunner
}
trait trait TestRunner extends java.lang.Object with NotNullTestRunner extends NotNullNotNull
{
	def (String)sbt.Result.Valuerun(StringtestClassName: StringString): Result.sbt.Result.ValueValue
}

trait trait TestReportListener extends java.lang.ObjectTestReportListener
{
	/** called for each class or equivalent grouping */
  def (String)UnitstartGroup(Stringname: StringString)
	/** called for each test method or equivalent */
  def (sbt.TestEvent)UnittestEvent(sbt.TestEventevent: sbt.TestEventTestEvent)
	/** called if there was an error during test */
  def (String,Throwable)UnitendGroup(Stringname: StringString, Throwablet: ThrowableThrowable)
	/** called if test completed */
  def (String,sbt.Result.Value)UnitendGroup(Stringname: StringString, sbt.Result.Valueresult: Result.sbt.Result.ValueValue)
}

trait trait TestsListener extends java.lang.Object with sbt.TestReportListenerTestsListener extends sbt.TestReportListenerTestReportListener
{
	/** called once, at beginning. */
  def => UnitdoInit
	/** called once, at end. */
  def (sbt.Result.Value)UnitdoComplete(sbt.Result.ValuefinalResult: Result.sbt.Result.ValueValue)
	/** called once, at end, if the test framework throws an exception. */
  def (Throwable)UnitdoComplete(Throwablet: ThrowableThrowable)
}

abstract class class WriterReportListener extends java.lang.Object with sbt.TestsListener with ScalaObjectWriterReportListener(val sbt.Loggerlog: sbt.LoggerLogger) extends sbt.TestsListenerTestsListener
{
	import java.io.{IOException, PrintWriter, Writer}
	import scala.collection.mutable.{Buffer, ListBuffer}

	protected case class class Summary extends java.lang.Object with NotNull with ScalaObject with ProductSummary(Intcount: IntInt, Intfailures: IntInt, Interrors: IntInt, Intskipped: IntInt, Option[String]message: Option[String]Option[String]) extends NotNullNotNull
	private var Option[java.io.PrintWriter]out: Option[java.io.PrintWriter]Option[PrintWriter] = object NoneNone
	private var IntgroupCount: IntInt = Int(0)0
	private var IntgroupFailures: IntInt = Int(0)0
	private var IntgroupErrors: IntInt = Int(0)0
	private var IntgroupSkipped: IntInt = Int(0)0
	private var Seq[String]groupMessages: Seq[String]Seq[String] = object NilNil

	protected val (sbt.TestEvent) => WriterReportListener.this.SummarypassedEventHandler: TestEvent => Summary = (sbt.TestEventevent: sbt.TestEventTestEvent) => sbt.TestEventevent WriterReportListener.this.Summarymatch
		{
			WriterReportListener.this.Summarycase SpecificationReportEvent(Intsuccesses, Intfailures, Interrors, Intskipped, Stringdesc, Seq[sbt.SystemReportEvent]systems, Seq[sbt.SpecificationReportEvent]subSpecs) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Intsuccesses, Intfailures, Interrors, Intskipped, object NoneNone)
			WriterReportListener.this.Summarycase IgnoredEvent(Stringname, Some(scala.xml.Elemmessage)) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(0)0, Int(0)0, Int(1)1, (String)Some[String]Some(scala.xml.Elemmessage.=> Stringtext))
			WriterReportListener.this.Summarycase IgnoredEvent(Stringname, object NoneNone) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(0)0, Int(0)0, Int(1)1, object NoneNone)
			WriterReportListener.this.Summarycase _ => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(0)0, Int(0)0, Int(0)0, object NoneNone)
		}
	protected val (sbt.TestEvent) => WriterReportListener.this.SummaryfailedEventHandler: TestEvent => Summary = (sbt.TestEventevent: sbt.TestEventTestEvent) => sbt.TestEventevent WriterReportListener.this.Summarymatch
		{
			WriterReportListener.this.Summarycase FailedEvent(Stringname, scala.xml.Elemmsg) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(1)1, Int(0)0, Int(0)0, (java.lang.String)Some[java.lang.String]Some(java.lang.String("! ")"! " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ scala.xml.Elemmsg.=> Stringtext))
			WriterReportListener.this.Summarycase TypedErrorEvent(Stringname, Stringevent, Some(scala.xml.Elemmsg)) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(1)1, Int(0)0, Int(0)0, (java.lang.String)Some[java.lang.String]Some(Stringevent (Any)java.lang.String+ java.lang.String(" - ")" - " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ scala.xml.Elemmsg.=> Stringtext))
			WriterReportListener.this.Summarycase TypedErrorEvent(Stringname, Stringevent, object NoneNone) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(1)1, Int(0)0, Int(0)0, (java.lang.String)Some[java.lang.String]Some(Stringevent (Any)java.lang.String+ java.lang.String(" - ")" - " (Any)java.lang.String+ Stringname))
			WriterReportListener.this.Summarycase ErrorEvent(scala.xml.Elemmsg) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(1)1, Int(0)0, Int(0)0, (String)Some[String]Some(scala.xml.Elemmsg.=> Stringtext))
			WriterReportListener.this.Summarycase SpecificationReportEvent(Intsuccesses, Intfailures, Interrors, Intskipped, Stringdesc, Seq[sbt.SystemReportEvent]systems, Seq[sbt.SpecificationReportEvent]subSpecs) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Intsuccesses (Int)Int+ Intfailures (Int)Int+ Interrors (Int)Int+ Intskipped, Intfailures, Interrors, Intskipped, (String)Some[String]Some(Stringdesc))
			WriterReportListener.this.Summarycase _ => {=> sbt.Loggerlog.(=> String)Unitwarn(java.lang.String("Unrecognized failure: ")"Unrecognized failure: " (Any)java.lang.String+ sbt.TestEventevent); (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(1)1, Int(0)0, Int(0)0, object NoneNone)}
		}
	protected val (sbt.TestEvent) => WriterReportListener.this.SummaryerrorEventHandler: TestEvent => Summary = (sbt.TestEventevent: sbt.TestEventTestEvent) => sbt.TestEventevent WriterReportListener.this.Summarymatch
		{
			WriterReportListener.this.Summarycase FailedEvent(Stringname, scala.xml.Elemmsg) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(0)0, Int(1)1, Int(0)0, (java.lang.String)Some[java.lang.String]Some(java.lang.String("! ")"! " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ scala.xml.Elemmsg.=> Stringtext))
			WriterReportListener.this.Summarycase TypedErrorEvent(Stringname, Stringevent, Some(scala.xml.Elemmsg)) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(0)0, Int(1)1, Int(0)0, (java.lang.String)Some[java.lang.String]Some(Stringevent (Any)java.lang.String+ java.lang.String(" - ")" - " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ scala.xml.Elemmsg.=> Stringtext))
			WriterReportListener.this.Summarycase TypedErrorEvent(Stringname, Stringevent, object NoneNone) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(0)0, Int(1)1, Int(0)0, (java.lang.String)Some[java.lang.String]Some(Stringevent (Any)java.lang.String+ java.lang.String(" - ")" - " (Any)java.lang.String+ Stringname))
			WriterReportListener.this.Summarycase ErrorEvent(scala.xml.Elemmsg) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(0)0, Int(1)1, Int(0)0, (String)Some[String]Some(scala.xml.Elemmsg.=> Stringtext))
			WriterReportListener.this.Summarycase SpecificationReportEvent(Intsuccesses, Intfailures, Interrors, Intskipped, Stringdesc, Seq[sbt.SystemReportEvent]systems, Seq[sbt.SpecificationReportEvent]subSpecs) => (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Intsuccesses (Int)Int+ Intfailures (Int)Int+ Interrors (Int)Int+ Intskipped, Intfailures, Interrors, Intskipped, (String)Some[String]Some(Stringdesc))
			WriterReportListener.this.Summarycase _ => {=> sbt.Loggerlog.(=> String)Unitwarn(java.lang.String("Unrecognized error: ")"Unrecognized error: " (Any)java.lang.String+ sbt.TestEventevent); (Int,Int,Int,Int,Option[String])WriterReportListener.this.SummarySummary(Int(1)1, Int(0)0, Int(1)1, Int(0)0, object NoneNone)}
		}
	protected def => java.io.Writeropen: java.io.WriterWriter
	protected def => Unitclose =
	{
		((java.io.PrintWriter) => Unit)UnitonOut(java.io.PrintWriter_.()Unitclose())
		(Option[java.io.PrintWriter])Unitout = object NoneNone
	}
	def => UnitdoInit = object sbt.ControlControl.(sbt.Logger)(=> Unit)UnittrapAndLog(=> sbt.Loggerlog){ (Option[java.io.PrintWriter])Unitout = (java.io.PrintWriter)Some[java.io.PrintWriter]Some(java.io.PrintWriternew java.io.PrintWriterPrintWriter(=> java.io.Writeropen)) }
	def (sbt.Result.Value)UnitdoComplete(sbt.Result.ValuefinalResult: Result.sbt.Result.ValueValue) =
	{
		sbt.Result.ValuefinalResult Unitmatch
		{
			Unitcase object sbt.ResultResult.=> sbt.Result.ValueError => (String)Unitprintln(java.lang.String("Error during Tests")"Error during Tests")
			Unitcase object sbt.ResultResult.=> sbt.Result.ValuePassed => (String)Unitprintln(java.lang.String("All Tests Passed")"All Tests Passed")
			Unitcase object sbt.ResultResult.=> sbt.Result.ValueFailed => (String)Unitprintln(java.lang.String("Tests Failed")"Tests Failed")
		}
		=> Unitclose
	}
	def (Throwable)UnitdoComplete(Throwablet: ThrowableThrowable) =
	{
		(String)Unitprintln(java.lang.String("Exception in Test Framework")"Exception in Test Framework")
		((java.io.PrintWriter) => Unit)UnitonOut(Throwablet.(java.io.PrintWriter)UnitprintStackTrace(java.io.PrintWriter_))
		=> Unitclose
	}
	def (String)UnitstartGroup(Stringname: StringString) =
	{
		(Int)UnitgroupCount = Int(0)0
		(Int)UnitgroupFailures = Int(0)0
		(Int)UnitgroupErrors = Int(0)0
		(Int)UnitgroupSkipped = Int(0)0
		(Seq[String])UnitgroupMessages = object NilNil
	}
	def (sbt.TestEvent)UnittestEvent(sbt.TestEventevent: sbt.TestEventTestEvent) = sbt.TestEventevent.=> Option[sbt.Result.Value]result Unitmatch
		{
			Unitcase Some(sbt.Result.Valueresult) =>
			{
				val (Int, Int, Int, Int, Option[String])Summary(Intcount, Intfailures, Interrors, Intskipped, Option[String]msg) = sbt.Result.Valueresult WriterReportListener.this.Summarymatch
				{
					WriterReportListener.this.Summarycase object sbt.ResultResult.=> sbt.Result.ValuePassed => (sbt.TestEvent)WriterReportListener.this.SummarypassedEventHandler(sbt.TestEventevent)
					WriterReportListener.this.Summarycase object sbt.ResultResult.=> sbt.Result.ValueFailed => (sbt.TestEvent)WriterReportListener.this.SummaryfailedEventHandler(sbt.TestEventevent)
					WriterReportListener.this.Summarycase object sbt.ResultResult.=> sbt.Result.ValueError => (sbt.TestEvent)WriterReportListener.this.SummaryerrorEventHandler(sbt.TestEventevent)
				}
				(Int)UnitgroupCount (Int)Int+= Intcount
				(Int)UnitgroupFailures (Int)Int+= Intfailures
				(Int)UnitgroupErrors (Int)Int+= Interrors
				(Int)UnitgroupSkipped (Int)Int+= Intskipped
				(Seq[String])UnitgroupMessages (Iterable[String])Seq[String]++= Option[String]msg.=> List[String]toList
			}
			Unitcase object NoneNone => Unit{}
		}
	def (String,Throwable)UnitendGroup(Stringname: StringString, Throwablet: ThrowableThrowable) =
	{
		(Seq[String])UnitgroupMessages = object NilNil
		(String)Unitprintln(java.lang.String("Exception in ")"Exception in " (Any)java.lang.String+ Stringname)
		((java.io.PrintWriter) => Unit)UnitonOut(Throwablet.(java.io.PrintWriter)UnitprintStackTrace(java.io.PrintWriter_))
	}
	def (String,sbt.Result.Value)UnitendGroup(Stringname: StringString, sbt.Result.Valueresult: Result.sbt.Result.ValueValue) =
	{
		sbt.Result.Valueresult Unitmatch
		{
			Unitcase object sbt.ResultResult.=> sbt.Result.ValueError => (String)Unitprintln(java.lang.String("Error: ")"Error: " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(" - Count ")" - Count " (Any)java.lang.String+ => IntgroupCount (Any)java.lang.String+ java.lang.String(", Failed ")", Failed " (Any)java.lang.String+ => IntgroupFailures (Any)java.lang.String+ java.lang.String(", Errors ")", Errors " (Any)java.lang.String+ => IntgroupErrors)
			Unitcase object sbt.ResultResult.=> sbt.Result.ValuePassed => (String)Unitprintln(java.lang.String("Passed: ")"Passed: " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(" - Count ")" - Count " (Any)java.lang.String+ => IntgroupCount (Any)java.lang.String+ java.lang.String(", Failed ")", Failed " (Any)java.lang.String+ => IntgroupFailures (Any)java.lang.String+ java.lang.String(", Errors ")", Errors " (Any)java.lang.String+ => IntgroupErrors)
			Unitcase object sbt.ResultResult.=> sbt.Result.ValueFailed => (String)Unitprintln(java.lang.String("Failed: ")"Failed: " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(" - Count ")" - Count " (Any)java.lang.String+ => IntgroupCount (Any)java.lang.String+ java.lang.String(", Failed ")", Failed " (Any)java.lang.String+ => IntgroupFailures (Any)java.lang.String+ java.lang.String(", Errors ")", Errors " (Any)java.lang.String+ => IntgroupErrors)
		}
		Unitif(=> Boolean!=> Seq[String]groupMessages.=> BooleanisEmpty)
		{
			=> Seq[String]groupMessages.((String) => Unit)Unitforeach((String)Unitprintln(String_))
			(Seq[String])UnitgroupMessages = object NilNil
			(String)Unitprintln(java.lang.String("")"")
		}
	}
	protected def ((java.io.PrintWriter) => Unit)UnitonOut((java.io.PrintWriter) => Unitf: PrintWriter => Unit) = object sbt.ControlControl.(sbt.Logger)(=> Unit)UnittrapAndLog(=> sbt.Loggerlog){
			=> Option[java.io.PrintWriter]out Unitmatch
			{
				Unitcase Some(java.io.PrintWriterpw) => (java.io.PrintWriter)Unitf(java.io.PrintWriterpw)
				Unitcase object NoneNone => => sbt.Loggerlog.(=> String)Unitwarn(java.lang.String("Method called when output was not open")"Method called when output was not open")
			}
		}
	protected def (String)Unitprintln(Strings: StringString) = ((java.io.PrintWriter) => Unit)UnitonOut(java.io.PrintWriter_.(java.lang.String)Unitprintln(Strings))
}

class class FileReportListener extends sbt.WriterReportListener with ScalaObjectFileReportListener(val sbt.Pathfile: sbt.PathPath, sbt.Loggerlog: sbt.LoggerLogger) extends sbt.WriterReportListenerWriterReportListener(sbt.Loggerlog)
{
	def => java.io.FileWriteropen = (java.io.File)java.io.FileWriternew java.io.java.io.FileWriterFileWriter(=> sbt.Pathfile.=> java.io.FileasFile)
}

abstract class class TestEvent extends java.lang.Object with NotNull with ScalaObjectTestEvent extends NotNullNotNull
{
	def => Option[sbt.Result.Value]result: Option[sbt.Result.Value]Option[Result.Value]
}

sealed abstract class class ScalaCheckEvent extends sbt.TestEvent with ScalaObjectScalaCheckEvent extends sbt.TestEventTestEvent
final case class class PassedEvent extends sbt.ScalaCheckEvent with ScalaObject with ProductPassedEvent(Stringname: StringString, scala.xml.Elemmsg: scala.xml.ElemElem) extends sbt.ScalaCheckEventScalaCheckEvent { def => Some[sbt.Result.Value]result = (sbt.Result.Value)Some[sbt.Result.Value]Some(object sbt.ResultResult.=> sbt.Result.ValuePassed) }
final case class class FailedEvent extends sbt.ScalaCheckEvent with ScalaObject with ProductFailedEvent(Stringname: StringString, scala.xml.Elemmsg: scala.xml.ElemElem) extends sbt.ScalaCheckEventScalaCheckEvent { def => Some[sbt.Result.Value]result = (sbt.Result.Value)Some[sbt.Result.Value]Some(object sbt.ResultResult.=> sbt.Result.ValueFailed) }

sealed abstract class class ScalaTestEvent extends sbt.TestEvent with ScalaObjectScalaTestEvent(val Option[sbt.Result.Value]result: Option[sbt.Result.Value]Option[Result.Value]) extends sbt.TestEventTestEvent
final case class class TypedEvent extends sbt.ScalaTestEvent with ScalaObject with ProductTypedEvent(Stringname: StringString, String`type`: StringString, Option[scala.xml.Elem]msg: Option[scala.xml.Elem]Option[Elem])(Option[sbt.Result.Value]result: Option[sbt.Result.Value]Option[Result.Value]) extends sbt.ScalaTestEventScalaTestEvent(Option[sbt.Result.Value]result)
final case class class TypedErrorEvent extends sbt.ScalaTestEvent with ScalaObject with ProductTypedErrorEvent(Stringname: StringString, String`type`: StringString, Option[scala.xml.Elem]msg: Option[scala.xml.Elem]Option[Elem])(Option[sbt.Result.Value]result: Option[sbt.Result.Value]Option[Result.Value]) extends sbt.ScalaTestEventScalaTestEvent(Option[sbt.Result.Value]result)
final case class class MessageEvent extends sbt.ScalaTestEvent with ScalaObject with ProductMessageEvent(scala.xml.Elemmsg: scala.xml.ElemElem) extends sbt.ScalaTestEventScalaTestEvent(object NoneNone)
final case class class ErrorEvent extends sbt.ScalaTestEvent with ScalaObject with ProductErrorEvent(scala.xml.Elemmsg: scala.xml.ElemElem) extends sbt.ScalaTestEventScalaTestEvent(object NoneNone)
final case class class IgnoredEvent extends sbt.ScalaTestEvent with ScalaObject with ProductIgnoredEvent(Stringname: StringString, Option[scala.xml.Elem]msg: Option[scala.xml.Elem]Option[Elem]) extends sbt.ScalaTestEventScalaTestEvent((sbt.Result.Value)Some[sbt.Result.Value]Some(object sbt.ResultResult.=> sbt.Result.ValuePassed))

sealed abstract class class SpecsEvent extends sbt.TestEvent with ScalaObjectSpecsEvent extends sbt.TestEventTestEvent
final case class class SpecificationReportEvent extends sbt.SpecsEvent with ScalaObject with ProductSpecificationReportEvent(Intsuccesses: IntInt, Intfailures: IntInt, Interrors: IntInt, Intskipped: IntInt, Stringpretty: StringString, Seq[sbt.SystemReportEvent]systems: Seq[sbt.SystemReportEvent]Seq[SystemReportEvent], Seq[sbt.SpecificationReportEvent]subSpecs: Seq[sbt.SpecificationReportEvent]Seq[SpecificationReportEvent]) extends sbt.SpecsEventSpecsEvent
{
	def => Option[sbt.Result.Value]result = Option[sbt.Result.Value]if(=> Interrors (Int)Boolean> Int(0)0) (sbt.Result.Value)Some[sbt.Result.Value]Some(object sbt.ResultResult.=> sbt.Result.ValueError) else Option[sbt.Result.Value]if(=> Intfailures (Int)Boolean> Int(0)0) (sbt.Result.Value)Some[sbt.Result.Value]Some(object sbt.ResultResult.=> sbt.Result.ValueFailed) else (sbt.Result.Value)Some[sbt.Result.Value]Some(object sbt.ResultResult.=> sbt.Result.ValuePassed)
}
final case class class SystemReportEvent extends sbt.SpecsEvent with ScalaObject with ProductSystemReportEvent(Stringdescription: StringString, Stringverb: StringString, Option[Throwable]skippedSus:Option[Throwable]Option[Throwable], Option[scala.xml.Group]literateDescription: Option[scala.xml.Group]Option[Group], Seq[sbt.ExampleReportEvent]examples: Seq[sbt.ExampleReportEvent]Seq[ExampleReportEvent]) extends sbt.SpecsEventSpecsEvent { def => object Noneresult = object NoneNone }
final case class class ExampleReportEvent extends sbt.SpecsEvent with ScalaObject with ProductExampleReportEvent(Stringdescription: StringString, Seq[Throwable]errors: Seq[Throwable]Seq[Throwable], Seq[RuntimeException]failures: Seq[RuntimeException]Seq[RuntimeException], Seq[RuntimeException]skipped: Seq[RuntimeException]Seq[RuntimeException], Seq[sbt.ExampleReportEvent]subExamples: Seq[sbt.ExampleReportEvent]Seq[ExampleReportEvent]) extends sbt.SpecsEventSpecsEvent { def => object Noneresult = object NoneNone }

trait trait EventOutput[E <: sbt.TestEvent] extends java.lang.ObjectEventOutput[>: Nothing <: sbt.TestEventE <: TestEvent]
{
	def (E)Unitoutput(Ee: EE): UnitUnit
}

sealed abstract class class LazyEventOutput[E <: sbt.TestEvent] extends java.lang.Object with sbt.EventOutput[E] with ScalaObjectLazyEventOutput[>: Nothing <: sbt.TestEventE <: TestEvent](val sbt.Loggerlog: sbt.LoggerLogger) extends sbt.EventOutput[E]EventOutput[E]

final class class ScalaCheckOutput extends sbt.LazyEventOutput[sbt.ScalaCheckEvent] with ScalaObjectScalaCheckOutput(sbt.Loggerlog: sbt.LoggerLogger) extends sbt.LazyEventOutput[sbt.ScalaCheckEvent]LazyEventOutput[ScalaCheckEvent](sbt.Loggerlog)
{
	def (sbt.ScalaCheckEvent)Unitoutput(sbt.ScalaCheckEventevent: sbt.ScalaCheckEventScalaCheckEvent) = sbt.ScalaCheckEventevent Unitmatch
		{
			Unitcase PassedEvent(Stringname, scala.xml.Elemmsg) => => sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("+ ")"+ " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ scala.xml.Elemmsg.=> Stringtext)
			Unitcase FailedEvent(Stringname, scala.xml.Elemmsg) => => sbt.Loggerlog.(=> String)Uniterror(java.lang.String("! ")"! " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ scala.xml.Elemmsg.=> Stringtext)
		}
}

final class class ScalaTestOutput extends sbt.LazyEventOutput[sbt.ScalaTestEvent] with ScalaObjectScalaTestOutput(sbt.Loggerlog: sbt.LoggerLogger) extends sbt.LazyEventOutput[sbt.ScalaTestEvent]LazyEventOutput[ScalaTestEvent](sbt.Loggerlog)
{
	def (sbt.ScalaTestEvent)Unitoutput(sbt.ScalaTestEventevent: sbt.ScalaTestEventScalaTestEvent) = sbt.ScalaTestEventevent Unitmatch
		{
			Unitcase TypedEvent(Stringname, Stringevent, Some(scala.xml.Elemmsg)) => => sbt.Loggerlog.(=> String)Unitinfo(Stringevent (Any)java.lang.String+ java.lang.String(" - ")" - " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ scala.xml.Elemmsg.=> Stringtext)
			Unitcase TypedEvent(Stringname, Stringevent, object NoneNone) => => sbt.Loggerlog.(=> String)Unitinfo(Stringevent (Any)java.lang.String+ java.lang.String(" - ")" - " (Any)java.lang.String+ Stringname)
			Unitcase TypedErrorEvent(Stringname, Stringevent, Some(scala.xml.Elemmsg)) => => sbt.Loggerlog.(=> String)Uniterror(Stringevent (Any)java.lang.String+ java.lang.String(" - ")" - " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ scala.xml.Elemmsg.=> Stringtext)
			Unitcase TypedErrorEvent(Stringname, Stringevent, object NoneNone) => => sbt.Loggerlog.(=> String)Uniterror(Stringevent (Any)java.lang.String+ java.lang.String(" - ")" - " (Any)java.lang.String+ Stringname)
			Unitcase MessageEvent(scala.xml.Elemmsg) => => sbt.Loggerlog.(=> String)Unitinfo(scala.xml.Elemmsg.=> Stringtext)
			Unitcase ErrorEvent(scala.xml.Elemmsg) => => sbt.Loggerlog.(=> String)Uniterror(scala.xml.Elemmsg.=> Stringtext)
			Unitcase IgnoredEvent(Stringname, Some(scala.xml.Elemmsg)) => => sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("Test ignored - ")"Test ignored - " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ scala.xml.Elemmsg.=> Stringtext)
			Unitcase IgnoredEvent(Stringname, object NoneNone) => => sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("Test ignored - ")"Test ignored - " (Any)java.lang.String+ Stringname)
		}
}

final class class SpecsOutput extends sbt.LazyEventOutput[sbt.SpecsEvent] with ScalaObjectSpecsOutput(sbt.Loggerlog: sbt.LoggerLogger) extends sbt.LazyEventOutput[sbt.SpecsEvent]LazyEventOutput[SpecsEvent](sbt.Loggerlog)
{
		private val java.lang.StringIndent = java.lang.String("  ")"  "

	def (sbt.SpecsEvent)Unitoutput(sbt.SpecsEventevent: sbt.SpecsEventSpecsEvent) = sbt.SpecsEventevent Unitmatch
		{
			Unitcase sbt.SpecificationReportEventsre: sbt.SpecificationReportEventSpecificationReportEvent => (sbt.SpecificationReportEvent,String)UnitreportSpecification(sbt.SpecificationReportEventsre, java.lang.String("")"")
			Unitcase sbt.SystemReportEventsre: sbt.SystemReportEventSystemReportEvent => (sbt.SystemReportEvent,String)UnitreportSystem(sbt.SystemReportEventsre, java.lang.String("")"")
			Unitcase sbt.ExampleReportEventere: sbt.ExampleReportEventExampleReportEvent => (sbt.ExampleReportEvent,String)UnitreportExample(sbt.ExampleReportEventere, java.lang.String("")"")
		}

	/* The following is closely based on org.specs.runner.OutputReporter,
	* part of specs, which is Copyright 2007-2008 Eric Torreborre.
	* */

	private def (sbt.SpecificationReportEvent,String)UnitreportSpecification(sbt.SpecificationReportEventspecification: sbt.SpecificationReportEventSpecificationReportEvent, Stringpadding: StringString)
	{
		val java.lang.StringnewIndent = Stringpadding (Any)java.lang.String+ => java.lang.StringIndent
		(Iterable[sbt.SpecificationReportEvent],String)UnitreportSpecifications(sbt.SpecificationReportEventspecification.=> Seq[sbt.SpecificationReportEvent]subSpecs, java.lang.StringnewIndent)
		(Iterable[sbt.SystemReportEvent],String)UnitreportSystems(sbt.SpecificationReportEventspecification.=> Seq[sbt.SystemReportEvent]systems, java.lang.StringnewIndent)
	}
	private def (Iterable[sbt.SpecificationReportEvent],String)UnitreportSpecifications(Iterable[sbt.SpecificationReportEvent]specifications: Iterable[sbt.SpecificationReportEvent]Iterable[SpecificationReportEvent], Stringpadding: StringString)
	{
		for(((sbt.SpecificationReportEvent) => Unit)Unitspecification <- Iterable[sbt.SpecificationReportEvent]specifications)
			(sbt.SpecificationReportEvent,String)UnitreportSpecification(sbt.SpecificationReportEventspecification, Stringpadding)
	}
	private def (Iterable[sbt.SystemReportEvent],String)UnitreportSystems(Iterable[sbt.SystemReportEvent]systems: Iterable[sbt.SystemReportEvent]Iterable[SystemReportEvent], Stringpadding: StringString)
	{
		for(((sbt.SystemReportEvent) => Unit)Unitsystem <- Iterable[sbt.SystemReportEvent]systems)
			(sbt.SystemReportEvent,String)UnitreportSystem(sbt.SystemReportEventsystem, Stringpadding)
	}
	private def (sbt.SystemReportEvent,String)UnitreportSystem(sbt.SystemReportEventsus: sbt.SystemReportEventSystemReportEvent, Stringpadding: StringString)
	{
		=> sbt.Loggerlog.(=> String)Unitinfo(Stringpadding (Any)java.lang.String+ sbt.SystemReportEventsus.=> Stringdescription (Any)java.lang.String+ java.lang.String(" ")" " (Any)java.lang.String+ sbt.SystemReportEventsus.=> Stringverb (Any)java.lang.String+ sbt.SystemReportEventsus.=> Option[Throwable]skippedSus.((Throwable) => java.lang.String)Option[java.lang.String]map(java.lang.String(" (skipped: ")" (skipped: " (Any)java.lang.String+ Throwable_.()java.lang.StringgetMessage (Any)java.lang.String+ java.lang.String(")")")").(=> java.lang.String)java.lang.StringgetOrElse(java.lang.String("")""))
		for(((scala.xml.Group) => Unit)Unitdescription <- sbt.SystemReportEventsus.=> Option[scala.xml.Group]literateDescription)
			=> sbt.Loggerlog.(=> String)Unitinfo(Stringpadding (Any)java.lang.String+ scala.xml.Groupdescription.=> Stringtext)
		(Iterable[sbt.ExampleReportEvent],String)UnitreportExamples(sbt.SystemReportEventsus.=> Seq[sbt.ExampleReportEvent]examples, Stringpadding)
		=> sbt.Loggerlog.(=> String)Unitinfo(java.lang.String(" ")" ")
	}
	private def (Iterable[sbt.ExampleReportEvent],String)UnitreportExamples(Iterable[sbt.ExampleReportEvent]examples: Iterable[sbt.ExampleReportEvent]Iterable[ExampleReportEvent], Stringpadding: StringString)
	{
		for(((sbt.ExampleReportEvent) => Unit)Unitexample <- Iterable[sbt.ExampleReportEvent]examples)
		{
			(sbt.ExampleReportEvent,String)UnitreportExample(sbt.ExampleReportEventexample, Stringpadding)
			(Iterable[sbt.ExampleReportEvent],String)UnitreportExamples(sbt.ExampleReportEventexample.=> Seq[sbt.ExampleReportEvent]subExamples, Stringpadding (Any)java.lang.String+ => java.lang.StringIndent)
		}
	}
	private def (sbt.ExampleReportEvent)java.lang.Stringstatus(sbt.ExampleReportEventexample: sbt.ExampleReportEventExampleReportEvent) =
	{
		java.lang.Stringif (sbt.ExampleReportEventexample.=> Seq[Throwable]errors.=> Intsize (Int)Int+ sbt.ExampleReportEventexample.=> Seq[RuntimeException]failures.=> Intsize (Int)Boolean> Int(0)0)
			java.lang.String("x ")"x "
		else java.lang.Stringif (sbt.ExampleReportEventexample.=> Seq[RuntimeException]skipped.=> Intsize (Int)Boolean> Int(0)0)
			java.lang.String("o ")"o "
		else
			java.lang.String("+ ")"+ "
	}
	private def (sbt.ExampleReportEvent,String)UnitreportExample(sbt.ExampleReportEventexample: sbt.ExampleReportEventExampleReportEvent, Stringpadding: StringString)
	{
		=> sbt.Loggerlog.(=> String)Unitinfo(Stringpadding (Any)java.lang.String+ (sbt.ExampleReportEvent)java.lang.Stringstatus(sbt.ExampleReportEventexample) (Any)java.lang.String+ sbt.ExampleReportEventexample.=> Stringdescription)
		for(((RuntimeException) => Unit)Unitskip <- sbt.ExampleReportEventexample.=> Seq[RuntimeException]skipped)
		{
			=> sbt.Loggerlog.(=> Throwable)Unittrace(RuntimeExceptionskip)
			=> sbt.Loggerlog.(=> String)Unitwarn(Stringpadding (Any)java.lang.String+ RuntimeExceptionskip.()java.lang.StringtoString)
		}
		for(((Throwable) => Unit)Unite <- sbt.ExampleReportEventexample.=> Seq[RuntimeException]failures (Iterable[Throwable])Seq[Throwable]++ sbt.ExampleReportEventexample.=> Seq[Throwable]errors)
		{
			=> sbt.Loggerlog.(=> Throwable)Unittrace(Throwablee)
			=> sbt.Loggerlog.(=> String)Uniterror(Stringpadding (Any)java.lang.String+ Throwablee.()java.lang.StringtoString)
		}
	}
}
abstract class class BasicTestRunner extends java.lang.Object with sbt.TestRunner with ScalaObjectBasicTestRunner extends sbt.TestRunnerTestRunner
{
	protected def => sbt.Loggerlog: sbt.LoggerLogger
	protected def => Seq[sbt.TestReportListener]listeners: Seq[sbt.TestReportListener]Seq[TestReportListener]

	final def (String)sbt.Result.Valuerun(StringtestClass: StringString): Result.sbt.Result.ValueValue =
	{
		((sbt.TestReportListener) => Unit)UnitsafeListenersCall(sbt.TestReportListener_.(String)UnitstartGroup(StringtestClass))
		try
		{
			val sbt.Result.Valueresult = (String)sbt.Result.ValuerunTest(StringtestClass)
			((sbt.TestReportListener) => Unit)UnitsafeListenersCall(sbt.TestReportListener_.(String,sbt.Result.Value)UnitendGroup(StringtestClass, sbt.Result.Valueresult))
			sbt.Result.Valueresult
		}
		catch
		{
			sbt.Result.Valuecase java.lang.Throwablee =>
			{
				((sbt.TestReportListener) => Unit)UnitsafeListenersCall(sbt.TestReportListener_.(String,Throwable)UnitendGroup(StringtestClass, java.lang.Throwablee))
				object sbt.ResultResult.=> sbt.Result.ValueError
			}
		}
	}
	def (String)sbt.Result.ValuerunTest(StringtestClass: StringString): Result.sbt.Result.ValueValue

	protected def (sbt.TestEvent)Unitfire(sbt.TestEventevent: sbt.TestEventTestEvent) = ((sbt.TestReportListener) => Unit)UnitsafeListenersCall(sbt.TestReportListener_.(sbt.TestEvent)UnittestEvent(sbt.TestEventevent))
	protected def ((sbt.TestReportListener) => Unit)UnitsafeListenersCall((sbt.TestReportListener) => Unitcall: (TestReportListener) => Unit) = => Seq[sbt.TestReportListener]listeners.((sbt.TestReportListener) => Unit)Unitforeach(sbt.TestReportListenerl => object sbt.ControlControl.(sbt.Logger)(=> Unit)UnittrapAndLog(=> sbt.Loggerlog){(sbt.TestReportListener)Unitcall(sbt.TestReportListenerl)})
}

object object sbt.TestFrameworkTestFramework
{
	import scala.collection.{Map, Set}
	def (Iterable[sbt.TestFramework],Iterable[sbt.Path],Iterable[sbt.TestDefinition],sbt.Logger,Iterable[sbt.TestReportListener])Option[String]runTests(Iterable[sbt.TestFramework]frameworks: Iterable[sbt.TestFramework]Iterable[TestFramework], Iterable[sbt.Path]classpath: Iterable[sbt.Path]Iterable[Path], Iterable[sbt.TestDefinition]tests: Iterable[sbt.TestDefinition]Iterable[TestDefinition], sbt.Loggerlog: sbt.LoggerLogger, Iterable[sbt.TestReportListener]listeners: Iterable[sbt.TestReportListener]Iterable[TestReportListener]): Option[String]Option[String] =
	{
		val scala.collection.Map[sbt.TestFramework,scala.collection.Set[String]]mappedTests = (Iterable[sbt.TestFramework],Iterable[sbt.TestDefinition])scala.collection.Map[sbt.TestFramework,scala.collection.Set[String]]testMap(Iterable[sbt.TestFramework]frameworks, Iterable[sbt.TestDefinition]tests)
		Option[String]if(scala.collection.Map[sbt.TestFramework,scala.collection.Set[String]]mappedTests.=> BooleanisEmpty)
		{
			sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("No tests to run.")"No tests to run.")
			object NoneNone
		}
		else
			object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])Option[String]trapUnit(java.lang.String("")"", sbt.Loggerlog) { (Iterable[sbt.Path],scala.collection.Map[sbt.TestFramework,scala.collection.Set[String]],sbt.Logger,Iterable[sbt.TestReportListener])Option[String]doRunTests(Iterable[sbt.Path]classpath, scala.collection.Map[sbt.TestFramework,scala.collection.Set[String]]mappedTests, sbt.Loggerlog, Iterable[sbt.TestReportListener]listeners) }
	}
	private def (Iterable[sbt.TestFramework],Iterable[sbt.TestDefinition])scala.collection.Map[sbt.TestFramework,scala.collection.Set[String]]testMap(Iterable[sbt.TestFramework]frameworks: Iterable[sbt.TestFramework]Iterable[TestFramework], Iterable[sbt.TestDefinition]tests: Iterable[sbt.TestDefinition]Iterable[TestDefinition]): scala.collection.Map[sbt.TestFramework,scala.collection.Set[String]]Map[TestFramework, Set[String]] =
	{
		import scala.collection.mutable.{HashMap, HashSet, Set}
		val scala.collection.mutable.HashMap[sbt.TestFramework,scala.collection.mutable.Set[String]]map = scala.collection.mutable.HashMap[sbt.TestFramework,scala.collection.mutable.Set[String]]new scala.collection.mutable.HashMap[sbt.TestFramework,scala.collection.mutable.Set[String]]HashMap[TestFramework, Set[String]]
		Unitif(=> Boolean!Iterable[sbt.TestFramework]frameworks.=> BooleanisEmpty)
		{
			for(((sbt.TestDefinition) => Unit)Unittest <- Iterable[sbt.TestDefinition]tests)
			{
				def (sbt.TestFramework)BooleanisTestForFramework(sbt.TestFrameworkframework: sbt.TestFrameworkTestFramework) =
					(sbt.TestFrameworkframework.=> sbt.ClassType.ValuetestSubClassType (AnyRef)Boolean== object sbt.ClassTypeClassType.=> sbt.ClassType.ValueModule) (Boolean)Boolean== sbt.TestDefinitiontest.=> BooleanisModule (Boolean)Boolean&&
					sbt.TestFrameworkframework.=> StringtestSuperClassName (AnyRef)Boolean== sbt.TestDefinitiontest.=> StringsuperClassName
				
				for(((sbt.TestFramework) => Unit)Unitframework <- Iterable[sbt.TestFramework]frameworks.((sbt.TestFramework) => Boolean)Option[sbt.TestFramework]find((sbt.TestFramework)BooleanisTestForFramework))
					scala.collection.mutable.HashMap[sbt.TestFramework,scala.collection.mutable.Set[String]]map.(sbt.TestFramework,=> scala.collection.mutable.Set[String])scala.collection.mutable.Set[String]getOrElseUpdate(sbt.TestFrameworkframework, scala.collection.mutable.HashSet[String]new scala.collection.mutable.HashSet[String]HashSet[String]) (String)Unit+= sbt.TestDefinitiontest.=> StringtestClassName
			}
		}
		scala.collection.mutable.HashMap[sbt.TestFramework,scala.collection.mutable.Set[String]]map.=> scala.collection.Map[sbt.TestFramework,scala.collection.mutable.Set[String]]readOnly
	}
	private def (Iterable[sbt.Path],scala.collection.Map[sbt.TestFramework,scala.collection.Set[String]],sbt.Logger,Iterable[sbt.TestReportListener])Option[String]doRunTests(Iterable[sbt.Path]classpath: Iterable[sbt.Path]Iterable[Path], scala.collection.Map[sbt.TestFramework,scala.collection.Set[String]]tests: scala.collection.Map[sbt.TestFramework,scala.collection.Set[String]]Map[TestFramework, Set[String]], sbt.Loggerlog: sbt.LoggerLogger, Iterable[sbt.TestReportListener]listeners: Iterable[sbt.TestReportListener]Iterable[TestReportListener]): Option[String]Option[String] =
	{
		val java.lang.ClassLoaderloader: java.lang.ClassLoaderClassLoader = sbt.IntermediateLoadernew sbt.IntermediateLoaderIntermediateLoader(Iterable[sbt.Path]classpath.((sbt.Path) => java.net.URL)Iterable[java.net.URL]map(sbt.Path_.=> java.net.URLasURL).=> Seq[java.net.URL]toSeq.Array[java.net.URL]toArray, ()java.lang.Class[_ <: java.lang.Object]getClass.()java.lang.ClassLoadergetClassLoader)
		val java.lang.ClassLoaderoldLoader = object java.lang.ThreadThread.()java.lang.ThreadcurrentThread.()java.lang.ClassLoadergetContextClassLoader
		object java.lang.ThreadThread.()java.lang.ThreadcurrentThread.(java.lang.ClassLoader)UnitsetContextClassLoader(java.lang.ClassLoaderloader)
		val Iterable[sbt.TestsListener]testsListeners = Iterable[sbt.TestReportListener]listeners.((sbt.TestReportListener) => Boolean)Iterable[sbt.TestReportListener]filter(sbt.TestReportListener_.BooleanisInstanceOf[sbt.TestsListenerTestsListener]).((sbt.TestReportListener) => sbt.TestsListener)Iterable[sbt.TestsListener]map(sbt.TestReportListener_.sbt.TestsListenerasInstanceOf[sbt.TestsListenerTestsListener])
		import Result._
		var sbt.Result.Valueresult: sbt.Result.ValueValue = => sbt.Result.ValuePassed
		Iterable[sbt.TestsListener]testsListeners.((sbt.TestsListener) => Unit)Unitforeach(sbt.TestsListenerl => object sbt.ControlControl.(sbt.Logger)(=> Unit)UnittrapAndLog(sbt.Loggerlog){ sbt.TestsListenerl.=> UnitdoInit })
		try {
			for((((sbt.TestFramework, scala.collection.Set[String])) => Unit)Unit(sbt.TestFrameworkframework, scala.collection.Set[String]testClassNames) <- scala.collection.Map[sbt.TestFramework,scala.collection.Set[String]]tests)
			{
				Unitif(scala.collection.Set[String]testClassNames.=> BooleanisEmpty)
					sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("No tests to run for framework ")"No tests to run for framework " (Any)java.lang.String+ sbt.TestFrameworkframework.=> Stringname (Any)java.lang.String+ java.lang.String(".")".")
				else
				{
					sbt.Loggerlog.(=> String)Unitinfo(java.lang.String(" ")" ")
					sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("Running ")"Running " (Any)java.lang.String+ sbt.TestFrameworkframework.=> Stringname (Any)java.lang.String+ java.lang.String(" tests...")" tests...")
					val sbt.TestRunnerrunner = sbt.TestFrameworkframework.(java.lang.ClassLoader,Iterable[sbt.TestReportListener],sbt.Logger)sbt.TestRunnertestRunner(java.lang.ClassLoaderloader, Iterable[sbt.TestReportListener]listeners, sbt.Loggerlog)
					for(((String) => Unit)UnittestClassName <- scala.collection.Set[String]testClassNames)
					{
						sbt.TestRunnerrunner.(String)sbt.Result.Valuerun(StringtestClassName) Unitmatch
						{
							Unitcase => sbt.Result.ValueError => sbt.Result.Valueresult = => sbt.Result.ValueError
							Unitcase => sbt.Result.ValueFailed => Unitif(sbt.Result.Valueresult (AnyRef)Boolean!= => sbt.Result.ValueError) sbt.Result.Valueresult = => sbt.Result.ValueFailed
							Unitcase _ => Unit()
						}
					}
				}
			}
			Iterable[sbt.TestsListener]testsListeners.((sbt.TestsListener) => Unit)Unitforeach(sbt.TestsListenerl => object sbt.ControlControl.(sbt.Logger)(=> Unit)UnittrapAndLog(sbt.Loggerlog){ sbt.TestsListenerl.(sbt.Result.Value)UnitdoComplete(sbt.Result.Valueresult) })
		}
		catch
		{
			Nothingcase java.lang.Throwablet =>
			{
				Iterable[sbt.TestsListener]testsListeners.((sbt.TestsListener) => Unit)Unitforeach(sbt.TestsListenerl => object sbt.ControlControl.(sbt.Logger)(=> Unit)UnittrapAndLog(sbt.Loggerlog){ sbt.TestsListenerl.(Throwable)UnitdoComplete(java.lang.Throwablet) })
				Nothingthrow java.lang.Throwablet
			}
		}
		finally {
			object java.lang.ThreadThread.()java.lang.ThreadcurrentThread.(java.lang.ClassLoader)UnitsetContextClassLoader(java.lang.ClassLoaderloader)
		}
		sbt.Result.Valueresult Option[String]match
		{
			Some[java.lang.String]case => sbt.Result.ValueError => (java.lang.String)Some[java.lang.String]Some(java.lang.String("ERROR occurred during testing.")"ERROR occurred during testing.")
			Some[java.lang.String]case => sbt.Result.ValueFailed => (java.lang.String)Some[java.lang.String]Some(java.lang.String("One or more tests FAILED.")"One or more tests FAILED.")
			None.typecase => sbt.Result.ValuePassed =>
			{
				sbt.Loggerlog.(=> String)Unitinfo(java.lang.String(" ")" ")
				sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("All tests PASSED.")"All tests PASSED.")
				object NoneNone
			}
		}
	}
}
sealed abstract class class LazyTestFramework extends java.lang.Object with sbt.TestFramework with ScalaObjectLazyTestFramework extends sbt.TestFrameworkTestFramework
{
	/** The class name of the the test runner that executes
	* tests for this framework.*/
	protected def => StringtestRunnerClassName: StringString
	
	/** Creates an instance of the runner given by 'testRunnerClassName'.*/
	final def (java.lang.ClassLoader,Iterable[sbt.TestReportListener],sbt.Logger)sbt.TestRunnertestRunner(java.lang.ClassLoaderprojectLoader: java.lang.ClassLoaderClassLoader, Iterable[sbt.TestReportListener]listeners: Iterable[sbt.TestReportListener]Iterable[TestReportListener], sbt.Loggerlog: sbt.LoggerLogger): sbt.TestRunnerTestRunner =
	{
		val StringrunnerClassName = => StringtestRunnerClassName
		val sbt.LazyFrameworkLoaderlazyLoader = sbt.LazyFrameworkLoadernew sbt.LazyFrameworkLoaderLazyFrameworkLoader(StringrunnerClassName, (java.net.URL*)Array[java.net.URL]Array(object sbt.FileUtilitiesFileUtilities.=> java.io.FilesbtJar.()java.net.URItoURI.()java.net.URLtoURL), java.lang.ClassLoaderprojectLoader, ()java.lang.Class[_ <: java.lang.Object]getClass.()java.lang.ClassLoadergetClassLoader)
		val java.lang.Class[_ <: sbt.TestRunner]runnerClass = object java.lang.ClassClass.(java.lang.String,Boolean,java.lang.ClassLoader)java.lang.Class[_]forName(StringrunnerClassName, Boolean(true)true, sbt.LazyFrameworkLoaderlazyLoader).(java.lang.Class[sbt.TestRunner])java.lang.Class[_ <: sbt.TestRunner]asSubclass(java.lang.Class[sbt.TestRunner]classOf[TestRunner])

		java.lang.Class[_ <: sbt.TestRunner]runnerClass.((java.lang.Class[_]*)java.lang.reflect.Constructor[?0]) forSome { type ?0 <: sbt.TestRunner }getConstructor(java.lang.Class[sbt.Logger]classOf[Logger], java.lang.Class[Seq[sbt.TestReportListener]]classOf[Seq[TestReportListener]], java.lang.Class[java.lang.ClassLoader]classOf[ClassLoader]).(java.lang.Object*)?0newInstance(sbt.Loggerlog, (LazyTestFramework.this.LogTestReportListener*)Seq[LazyTestFramework.this.LogTestReportListener]Seq(LazyTestFramework.this.LogTestReportListenernew LazyTestFramework.this.LogTestReportListenerLogTestReportListener(sbt.Loggerlog, sbt.LazyFrameworkLoaderlazyLoader)) (Iterable[sbt.TestReportListener])Seq[sbt.TestReportListener]++ Iterable[sbt.TestReportListener]listeners, java.lang.ClassLoaderprojectLoader)
	}

	private class class LogTestReportListener extends java.lang.Object with sbt.TestReportListener with ScalaObjectLogTestReportListener(val sbt.Loggerlog: sbt.LoggerLogger, val java.lang.ClassLoadertestLoader: java.lang.ClassLoaderClassLoader) extends sbt.TestReportListenerTestReportListener
	{
		import LazyTestFramework._
		private lazy val sbt.EventOutput[sbt.ScalaCheckEvent]scalaCheckOutput: sbt.EventOutput[sbt.ScalaCheckEvent]EventOutput[ScalaCheckEvent] = (String)sbt.LazyEventOutput[sbt.ScalaCheckEvent]load(=> java.lang.StringScalaCheckOutputClass)
		private lazy val sbt.EventOutput[sbt.ScalaTestEvent]scalaTestOutput: sbt.EventOutput[sbt.ScalaTestEvent]EventOutput[ScalaTestEvent] = (String)sbt.LazyEventOutput[sbt.ScalaTestEvent]load(=> java.lang.StringScalaTestOutputClass)
		private lazy val sbt.EventOutput[sbt.SpecsEvent]specsOutput: sbt.EventOutput[sbt.SpecsEvent]EventOutput[SpecsEvent] = (String)sbt.LazyEventOutput[sbt.SpecsEvent]load(=> java.lang.StringSpecsOutputClass)

		def (String)UnitstartGroup(Stringname: StringString)
		{
			=> sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("")"")
			=> sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("Testing ")"Testing " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(" ...")" ...")
		}
		def (sbt.TestEvent)UnittestEvent(sbt.TestEventevent: sbt.TestEventTestEvent) =
		{
			=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("in testEvent:")"in testEvent:" (Any)java.lang.String+ sbt.TestEventevent)
			sbt.TestEventevent Unitmatch
			{
				Unitcase sbt.ScalaCheckEventsce: sbt.ScalaCheckEventScalaCheckEvent => => sbt.EventOutput[sbt.ScalaCheckEvent]scalaCheckOutput.(sbt.ScalaCheckEvent)Unitoutput(sbt.ScalaCheckEventsce)
				Unitcase sbt.ScalaTestEventste: sbt.ScalaTestEventScalaTestEvent => => sbt.EventOutput[sbt.ScalaTestEvent]scalaTestOutput.(sbt.ScalaTestEvent)Unitoutput(sbt.ScalaTestEventste)
				Unitcase sbt.SpecsEventse: sbt.SpecsEventSpecsEvent => => sbt.EventOutput[sbt.SpecsEvent]specsOutput.(sbt.SpecsEvent)Unitoutput(sbt.SpecsEventse)
				Unitcase sbt.TestEvente => => sbt.Loggerlog.(=> String)Uniterror(java.lang.String("Event not supported: ")"Event not supported: " (Any)java.lang.String+ sbt.TestEvente)
			}
		}
		def (String,Throwable)UnitendGroup(Stringname: StringString, Throwablet: ThrowableThrowable)
		{
			=> sbt.Loggerlog.(=> String)Uniterror(java.lang.String("Could not run test ")"Could not run test " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ Throwablet.()java.lang.StringtoString)
			=> sbt.Loggerlog.(=> Throwable)Unittrace(Throwablet)
		}
		def (String,sbt.Result.Value)UnitendGroup(Stringname: StringString, sbt.Result.Valueresult: Result.sbt.Result.ValueValue) = { => sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("in endGroup:")"in endGroup:" (Any)java.lang.String+ sbt.Result.Valueresult) }

		private def [E <: sbt.TestEvent](String)sbt.LazyEventOutput[E]load[>: Nothing <: sbt.TestEventE <: TestEvent](StringclassName: StringString): sbt.LazyEventOutput[E]LazyEventOutput[E] =
		{
			val sbt.LazyFrameworkLoaderlazyLoader = sbt.LazyFrameworkLoadernew sbt.LazyFrameworkLoaderLazyFrameworkLoader(StringclassName, (java.net.URL*)Array[java.net.URL]Array(object sbt.FileUtilitiesFileUtilities.=> java.io.FilesbtJar.()java.net.URItoURI.()java.net.URLtoURL), => java.lang.ClassLoadertestLoader, ()java.lang.Class[_ <: java.lang.Object]getClass.()java.lang.ClassLoadergetClassLoader)
			val java.lang.Class[_ <: sbt.LazyEventOutput[E]]formatterClass = object java.lang.ClassClass.(java.lang.String,Boolean,java.lang.ClassLoader)java.lang.Class[_]forName(StringclassName, Boolean(true)true, sbt.LazyFrameworkLoaderlazyLoader).(java.lang.Class[sbt.LazyEventOutput[E]])java.lang.Class[_ <: sbt.LazyEventOutput[E]]asSubclass(java.lang.Class[sbt.LazyEventOutput[E]]classOf[LazyEventOutput[E]])
			java.lang.Class[_ <: sbt.LazyEventOutput[E]]formatterClass.((java.lang.Class[_]*)java.lang.reflect.Constructor[?0]) forSome { type ?0 <: sbt.LazyEventOutput[E] }getConstructor(java.lang.Class[sbt.Logger]classOf[Logger]).(java.lang.Object*)?0newInstance(=> sbt.Loggerlog)
		}
	}
}

object object sbt.LazyTestFrameworkLazyTestFramework
{
	private val java.lang.StringScalaCheckOutputClass = java.lang.String("sbt.ScalaCheckOutput")"sbt.ScalaCheckOutput"
	private val java.lang.StringScalaTestOutputClass = java.lang.String("sbt.ScalaTestOutput")"sbt.ScalaTestOutput"
	private val java.lang.StringSpecsOutputClass = java.lang.String("sbt.SpecsOutput")"sbt.SpecsOutput"
}

/** The test framework definition for ScalaTest.*/
object object sbt.ScalaTestFrameworkScalaTestFramework extends sbt.LazyTestFrameworkLazyTestFramework
{
	val java.lang.Stringname = java.lang.String("ScalaTest")"ScalaTest"
	val java.lang.StringSuiteClassName = java.lang.String("org.scalatest.Suite")"org.scalatest.Suite"
	
	def => java.lang.StringtestSuperClassName = => java.lang.StringSuiteClassName
	def => sbt.ClassType.ValuetestSubClassType = object sbt.ClassTypeClassType.=> sbt.ClassType.ValueClass
	
	def => java.lang.StringtestRunnerClassName = java.lang.String("sbt.ScalaTestRunner")"sbt.ScalaTestRunner"
}
/** The test framework definition for ScalaCheck.*/
object object sbt.ScalaCheckFrameworkScalaCheckFramework extends sbt.LazyTestFrameworkLazyTestFramework
{
	val java.lang.Stringname = java.lang.String("ScalaCheck")"ScalaCheck"
	val java.lang.StringPropertiesClassName = java.lang.String("org.scalacheck.Properties")"org.scalacheck.Properties"
	
	def => java.lang.StringtestSuperClassName = => java.lang.StringPropertiesClassName
	def => sbt.ClassType.ValuetestSubClassType = object sbt.ClassTypeClassType.=> sbt.ClassType.ValueModule
	
	def => java.lang.StringtestRunnerClassName = java.lang.String("sbt.ScalaCheckRunner")"sbt.ScalaCheckRunner"
}
/** The test framework definition for specs.*/
object object sbt.SpecsFrameworkSpecsFramework extends sbt.LazyTestFrameworkLazyTestFramework
{
	val java.lang.Stringname = java.lang.String("specs")"specs"
	val java.lang.StringSpecificationClassName = java.lang.String("org.specs.Specification")"org.specs.Specification"
	
	def => java.lang.StringtestSuperClassName = => java.lang.StringSpecificationClassName
	def => sbt.ClassType.ValuetestSubClassType = object sbt.ClassTypeClassType.=> sbt.ClassType.ValueModule
	
	def => java.lang.StringtestRunnerClassName = java.lang.String("sbt.SpecsRunner")"sbt.SpecsRunner"
}
/* The following classes run tests for their associated test framework.
* NOTE #1: DO NOT actively use these classes.  Only specify their names to LazyTestFramework
*  for reflective loading.  This allows using the test libraries provided on the
*  project classpath instead of requiring global versions.
* NOTE #2: Keep all active uses of these test frameworks inside these classes so that sbt
*  runs without error when a framework is not available at runtime and no tests for that
*  framework are defined.*/

/** The test runner for ScalaCheck tests. */
private class class ScalaCheckRunner extends sbt.BasicTestRunner with ScalaObjectScalaCheckRunner(val sbt.Loggerlog: sbt.LoggerLogger, val Seq[sbt.TestReportListener]listeners: Seq[sbt.TestReportListener]Seq[TestReportListener], val java.lang.ClassLoadertestLoader: java.lang.ClassLoaderClassLoader) extends sbt.BasicTestRunnerBasicTestRunner
{
	import org.scalacheck.{Pretty, Properties, Test}
	def (String)sbt.Result.ValuerunTest(StringtestClassName: StringString): Result.sbt.Result.ValueValue =
	{
		val org.scalacheck.Propertiestest = object sbt.ModuleUtilitiesModuleUtilities.(String,java.lang.ClassLoader)java.lang.ObjectgetObject(StringtestClassName, => java.lang.ClassLoadertestLoader).org.scalacheck.PropertiesasInstanceOf[org.scalacheck.PropertiesProperties]
		sbt.Result.Valueif(object org.scalacheck.TestTest.(org.scalacheck.Properties,org.scalacheck.Test.Params,(String, Int, Int) => Unit,(String, org.scalacheck.Test.Result) => Unit)Seq[(String, org.scalacheck.Test.Result)]checkProperties(org.scalacheck.Propertiestest, object org.scalacheck.TestTest.=> org.scalacheck.Test.ParamsdefaultParams, (String,Int,Int)UnitpropReport, (String,org.scalacheck.Test.Result)UnittestReport).(((String, org.scalacheck.Test.Result)) => Boolean)Option[(String, org.scalacheck.Test.Result)]find(=> Boolean!(String, org.scalacheck.Test.Result)_.=> org.scalacheck.Test.Result_2.=> Booleanpassed).=> BooleanisEmpty)
			object sbt.ResultResult.=> sbt.Result.ValuePassed
		else
			object sbt.ResultResult.=> sbt.Result.ValueFailed
	}
	private def (String,Int,Int)UnitpropReport(StringpName: StringString, Ints: IntInt, Intd: IntInt) Unit{}
	private def (String,org.scalacheck.Test.Result)UnittestReport(StringpName: StringString, org.scalacheck.Test.Resultres: Test.org.scalacheck.Test.ResultResult) =
	{
		Unitif(org.scalacheck.Test.Resultres.=> Booleanpassed)
			(sbt.TestEvent)Unitfire((String,scala.xml.Elem)sbt.PassedEventPassedEvent(StringpName, <message>{object org.scalacheck.PrettyPretty.(org.scalacheck.Test.Result)(implicit org.scalacheck.Pretty[org.scalacheck.Test.Result])Stringpretty(org.scalacheck.Test.Resultres)}</message>))
		else
			(sbt.TestEvent)Unitfire((String,scala.xml.Elem)sbt.FailedEventFailedEvent(StringpName, <message>{object org.scalacheck.PrettyPretty.(org.scalacheck.Test.Result)(implicit org.scalacheck.Pretty[org.scalacheck.Test.Result])Stringpretty(org.scalacheck.Test.Resultres)}</message>))
	}
}
/** The test runner for ScalaTest suites. */
private class class ScalaTestRunner extends sbt.BasicTestRunner with ScalaObjectScalaTestRunner(val sbt.Loggerlog: sbt.LoggerLogger, val Seq[sbt.TestReportListener]listeners: Seq[sbt.TestReportListener]Seq[TestReportListener], val java.lang.ClassLoadertestLoader: java.lang.ClassLoaderClassLoader) extends sbt.BasicTestRunnerBasicTestRunner
{
	def (String)sbt.Result.ValuerunTest(StringtestClassName: StringString): Result.sbt.Result.ValueValue =
	{
		import org.scalatest.{Stopper, Suite}
		val java.lang.Class[_ <: org.scalatest.Suite]testClass = object java.lang.ClassClass.(java.lang.String,Boolean,java.lang.ClassLoader)java.lang.Class[_]forName(StringtestClassName, Boolean(true)true, => java.lang.ClassLoadertestLoader).(java.lang.Class[org.scalatest.Suite])java.lang.Class[_ <: org.scalatest.Suite]asSubclass(java.lang.Class[org.scalatest.Suite]classOf[Suite])
		val org.scalatest.Suitetest = java.lang.Class[_ <: org.scalatest.Suite]testClass.()org.scalatest.SuitenewInstance
		val ScalaTestRunner.this.ScalaTestReporterreporter = ScalaTestRunner.this.ScalaTestReporternew ScalaTestRunner.this.ScalaTestReporterScalaTestReporter
		val <refinement> extends java.lang.Object with org.scalatest.Stopperstopper = template $anon extends java.lang.Object with org.scalatest.Stoppernew org.scalatest.StopperStopper { override def => BooleanstopRequested = Boolean(false)false }
		org.scalatest.Suitetest.(Option[String],org.scalatest.Reporter,org.scalatest.Stopper,Set[String],Set[String],Map[String,Any],Option[org.scalatest.Distributor])Unitexecute(object NoneNone, ScalaTestRunner.this.ScalaTestReporterreporter, <refinement> extends java.lang.Object with org.scalatest.Stopperstopper, => collection.immutable.Set.typeSet.scala.collection.immutable.Set[String]empty, => collection.immutable.Set.typeSet.scala.collection.immutable.Set[String]empty, => collection.immutable.Map.typeMap.scala.collection.immutable.Map[String,Nothing]empty, object NoneNone)
		sbt.Result.Valueif(ScalaTestRunner.this.ScalaTestReporterreporter.=> Booleansucceeded)
			object sbt.ResultResult.=> sbt.Result.ValuePassed
		else
			object sbt.ResultResult.=> sbt.Result.ValueFailed
	}
	
	/** An implementation of Reporter for ScalaTest. */
	private class class ScalaTestReporter extends java.lang.Object with org.scalatest.Reporter with NotNull with ScalaObjectScalaTestReporter extends org.scalatest.org.scalatest.ReporterReporter with NotNullNotNull
	{
		import org.scalatest.Report
		override def (org.scalatest.Report)UnittestIgnored(org.scalatest.Reportreport: org.scalatest.ReportReport) =
		{
			Unitif(org.scalatest.Reportreport.=> Stringmessage.implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringtrim.=> BooleanisEmpty) (sbt.TestEvent)Unitfire((String,Option[scala.xml.Elem])sbt.IgnoredEventIgnoredEvent(org.scalatest.Reportreport.=> Stringname, object NoneNone))
			else (sbt.TestEvent)Unitfire((String,Option[scala.xml.Elem])sbt.IgnoredEventIgnoredEvent(org.scalatest.Reportreport.=> Stringname, (scala.xml.Elem)Some[scala.xml.Elem]Some(<message>scala.xml.Textreport.message.trim</message>)))
		}
		override def (org.scalatest.Report)UnittestStarting(org.scalatest.Reportreport: org.scalatest.ReportReport) { (org.scalatest.Report,String,Option[sbt.Result.Value])Unitinfo(org.scalatest.Reportreport, java.lang.String("Test starting")"Test starting", object NoneNone) }
		override def (org.scalatest.Report)UnittestSucceeded(org.scalatest.Reportreport: org.scalatest.ReportReport) { (org.scalatest.Report,String,Option[sbt.Result.Value])Unitinfo(org.scalatest.Reportreport, java.lang.String("Test succeeded")"Test succeeded", (sbt.Result.Value)Some[sbt.Result.Value]Some(object sbt.ResultResult.=> sbt.Result.ValuePassed)) }
		override def (org.scalatest.Report)UnittestFailed(org.scalatest.Reportreport: org.scalatest.ReportReport)
		{
			(Boolean)Unitsucceeded = Boolean(false)false
			(org.scalatest.Report,String,Option[sbt.Result.Value])Uniterror(org.scalatest.Reportreport, java.lang.String("Test failed")"Test failed", (sbt.Result.Value)Some[sbt.Result.Value]Some(object sbt.ResultResult.=> sbt.Result.ValueFailed))
		}
		
		override def (org.scalatest.Report)UnitinfoProvided(org.scalatest.Reportreport : org.scalatest.ReportReport) { (org.scalatest.Report,String,Option[sbt.Result.Value])Unitinfo(org.scalatest.Reportreport, java.lang.String("")"", object NoneNone) }
		
		override def (org.scalatest.Report)UnitsuiteStarting(org.scalatest.Reportreport: org.scalatest.ReportReport) { (org.scalatest.Report,String,Option[sbt.Result.Value])Unitinfo(org.scalatest.Reportreport, java.lang.String("Suite starting")"Suite starting", object NoneNone) }
		override def (org.scalatest.Report)UnitsuiteCompleted(org.scalatest.Reportreport: org.scalatest.ReportReport) { (org.scalatest.Report,String,Option[sbt.Result.Value])Unitinfo(org.scalatest.Reportreport, java.lang.String("Suite completed")"Suite completed", object NoneNone) }
		override def (org.scalatest.Report)UnitsuiteAborted(org.scalatest.Reportreport: org.scalatest.ReportReport) { (org.scalatest.Report,String,Option[sbt.Result.Value])Uniterror(org.scalatest.Reportreport, java.lang.String("Suite aborted")"Suite aborted", object NoneNone) }
		
		override def (Int)UnitrunStarting(InttestCount: IntInt) { (sbt.TestEvent)Unitfire((scala.xml.Elem)sbt.MessageEventMessageEvent(<message>scala.xml.TextRun starting</message>)) }
		override def ()UnitrunStopped()
		{
			(Boolean)Unitsucceeded = Boolean(false)false
			(sbt.TestEvent)Unitfire((scala.xml.Elem)sbt.ErrorEventErrorEvent(<message>scala.xml.TextRun stopped</message>))
		}
		override def (org.scalatest.Report)UnitrunAborted(org.scalatest.Reportreport: org.scalatest.ReportReport)
		{
			(Boolean)Unitsucceeded = Boolean(false)false
			(org.scalatest.Report,String,Option[sbt.Result.Value])Uniterror(org.scalatest.Reportreport, java.lang.String("Run aborted")"Run aborted", object NoneNone)
		}
		override def ()UnitrunCompleted() { => sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("Run completed.")"Run completed.") }
		
		private def (org.scalatest.Report,String,Option[sbt.Result.Value])Uniterror(org.scalatest.Reportreport: org.scalatest.ReportReport, Stringevent: StringString, Option[sbt.Result.Value]result: Option[sbt.Result.Value]Option[Result.Value]) { (org.scalatest.Report,String,Option[sbt.Result.Value],sbt.Level.Value)UnitlogReport(org.scalatest.Reportreport, Stringevent, Option[sbt.Result.Value]result, object sbt.LevelLevel.=> sbt.Level.ValueError) }
		private def (org.scalatest.Report,String,Option[sbt.Result.Value])Unitinfo(org.scalatest.Reportreport: org.scalatest.ReportReport, Stringevent: StringString, Option[sbt.Result.Value]result: Option[sbt.Result.Value]Option[Result.Value]) { (org.scalatest.Report,String,Option[sbt.Result.Value],sbt.Level.Value)UnitlogReport(org.scalatest.Reportreport, Stringevent, Option[sbt.Result.Value]result, object sbt.LevelLevel.=> sbt.Level.ValueInfo) }
		private def (org.scalatest.Report,String,Option[sbt.Result.Value],sbt.Level.Value)UnitlogReport(org.scalatest.Reportreport: org.scalatest.ReportReport, Stringevent: StringString, Option[sbt.Result.Value]result: Option[sbt.Result.Value]Option[Result.Value], sbt.Level.Valuelevel: Level.sbt.Level.ValueValue)
		{
			sbt.Level.Valuelevel Unitmatch
			{
				Unitcase object sbt.LevelLevel.=> sbt.Level.ValueError =>
					Unitif(org.scalatest.Reportreport.=> Stringmessage.implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringtrim.=> BooleanisEmpty)
						(sbt.TestEvent)Unitfire((String,String,Option[scala.xml.Elem])(Option[sbt.Result.Value])sbt.TypedErrorEventTypedErrorEvent(org.scalatest.Reportreport.=> Stringname, Stringevent, object NoneNone)(Option[sbt.Result.Value]result))
					else
						(sbt.TestEvent)Unitfire((String,String,Option[scala.xml.Elem])(Option[sbt.Result.Value])sbt.TypedErrorEventTypedErrorEvent(org.scalatest.Reportreport.=> Stringname, Stringevent, (scala.xml.Elem)Some[scala.xml.Elem]Some(<message>{org.scalatest.Reportreport.=> Stringmessage.()java.lang.Stringtrim}</message>))(Option[sbt.Result.Value]result))
				Unitcase object sbt.LevelLevel.=> sbt.Level.ValueInfo =>
					Unitif(org.scalatest.Reportreport.=> Stringmessage.implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringtrim.=> BooleanisEmpty)
						(sbt.TestEvent)Unitfire((String,String,Option[scala.xml.Elem])(Option[sbt.Result.Value])sbt.TypedEventTypedEvent(org.scalatest.Reportreport.=> Stringname, Stringevent, object NoneNone)(Option[sbt.Result.Value]result))
					else
						(sbt.TestEvent)Unitfire((String,String,Option[scala.xml.Elem])(Option[sbt.Result.Value])sbt.TypedEventTypedEvent(org.scalatest.Reportreport.=> Stringname, Stringevent, (scala.xml.Elem)Some[scala.xml.Elem]Some(<message>{org.scalatest.Reportreport.=> Stringmessage.()java.lang.Stringtrim}</message>))(Option[sbt.Result.Value]result))
				Unitcase sbt.Level.Valuel => => sbt.Loggerlog.(=> String)Unitwarn(java.lang.String("Level not prepared for:")"Level not prepared for:" (Any)java.lang.String+ sbt.Level.Valuel)
			}
		}
		
		var Booleansucceeded = Boolean(true)true
	}
}
/** The test runner for specs tests. */
private class class SpecsRunner extends sbt.BasicTestRunner with ScalaObjectSpecsRunner(val sbt.Loggerlog: sbt.LoggerLogger, val Seq[sbt.TestReportListener]listeners: Seq[sbt.TestReportListener]Seq[TestReportListener], val java.lang.ClassLoadertestLoader: java.lang.ClassLoaderClassLoader) extends sbt.BasicTestRunnerBasicTestRunner
{
	import org.specs.Specification
	import org.specs.runner.TextFormatter
	import org.specs.specification.{Example, Sus}

	def (String)sbt.Result.ValuerunTest(StringtestClassName: StringString): Result.sbt.Result.ValueValue =
	{
		val org.specs.Specificationtest = object sbt.ModuleUtilitiesModuleUtilities.(String,java.lang.ClassLoader)java.lang.ObjectgetObject(StringtestClassName, => java.lang.ClassLoadertestLoader).org.specs.SpecificationasInstanceOf[org.specs.SpecificationSpecification]
		val sbt.SpecificationReportEventevent = (org.specs.Specification)sbt.SpecificationReportEventreportSpecification(org.specs.Specificationtest)
		(sbt.TestEvent)Unitfire(sbt.SpecificationReportEventevent)
		sbt.Result.Valueif(org.specs.Specificationtest.=> BooleanisFailing)
			object sbt.ResultResult.=> sbt.Result.ValueFailed
		else
			object sbt.ResultResult.=> sbt.Result.ValuePassed
	}
	
	/* The following is closely based on org.specs.runner.OutputReporter,
	* part of specs, which is Copyright 2007-2008 Eric Torreborre.
	* */
	
	private def (org.specs.Specification)sbt.SpecificationReportEventreportSpecification(org.specs.Specificationspec: org.specs.SpecificationSpecification): sbt.SpecificationReportEventSpecificationReportEvent =
	{
		Nothingreturn (Int,Int,Int,Int,String,Seq[sbt.SystemReportEvent],Seq[sbt.SpecificationReportEvent])sbt.SpecificationReportEventSpecificationReportEvent(org.specs.Specificationspec.=> List[org.specs.specification.Example]successes.=> Intsize, org.specs.Specificationspec.=> List[org.specs.specification.FailureException]failures.=> Intsize, org.specs.Specificationspec.=> List[Throwable]errors.=> Intsize, org.specs.Specificationspec.=> List[org.specs.specification.SkippedException]skipped.=> Intsize, org.specs.Specificationspec.=> java.lang.Stringpretty, (Seq[org.specs.specification.Sus])Seq[sbt.SystemReportEvent]reportSystems(org.specs.Specificationspec.=> List[org.specs.specification.Sus]systems), (Seq[org.specs.Specification])Seq[sbt.SpecificationReportEvent]reportSpecifications(org.specs.Specificationspec.=> List[org.specs.Specification]subSpecifications))
	}
	private def (Seq[org.specs.Specification])Seq[sbt.SpecificationReportEvent]reportSpecifications(Seq[org.specs.Specification]specifications: Seq[org.specs.Specification]Seq[Specification]): Seq[sbt.SpecificationReportEvent]Seq[SpecificationReportEvent] =
	{
		for(((org.specs.Specification) => sbt.SpecificationReportEvent)Seq[sbt.SpecificationReportEvent]specification <- Seq[org.specs.Specification]specifications) yield
			(org.specs.Specification)sbt.SpecificationReportEventreportSpecification(org.specs.Specificationspecification)
	}
	private def (Seq[org.specs.specification.Sus])Seq[sbt.SystemReportEvent]reportSystems(Seq[org.specs.specification.Sus]systems: Seq[org.specs.specification.Sus]Seq[Sus]): Seq[sbt.SystemReportEvent]Seq[SystemReportEvent] =
	{
		for(((org.specs.specification.Sus) => sbt.SystemReportEvent)Seq[sbt.SystemReportEvent]system <- Seq[org.specs.specification.Sus]systems) yield
			(org.specs.specification.Sus)sbt.SystemReportEventreportSystem(org.specs.specification.Sussystem)
	}
	private def (org.specs.specification.Sus)sbt.SystemReportEventreportSystem(org.specs.specification.Sussus: org.specs.specification.SusSus): sbt.SystemReportEventSystemReportEvent =
	{
		def (Option[scala.xml.Elem])Option[scala.xml.Group]format(Option[scala.xml.Elem]description: Option[scala.xml.Elem]Option[Elem]): Option[scala.xml.Group]Option[Group] = Option[scala.xml.Elem]description Option[scala.xml.Group]match
			{
				None.typecase object NoneNone => object NoneNone
				Some[scala.xml.Group]case Some(scala.xml.Elemelem) => (scala.xml.Group)Some[scala.xml.Group]Some(org.specs.runner.TextFormatternew org.specs.runner.TextFormatterTextFormatter().(scala.xml.Elem,Iterable[org.specs.specification.Example])scala.xml.Groupformat(scala.xml.Elemelem, org.specs.specification.Sussus.=> scala.collection.mutable.Queue[org.specs.specification.Example]examples))
			}

		(String,String,Option[Throwable],Option[scala.xml.Group],Seq[sbt.ExampleReportEvent])sbt.SystemReportEventSystemReportEvent(org.specs.specification.Sussus.=> Stringdescription, org.specs.specification.Sussus.=> java.lang.Stringverb, org.specs.specification.Sussus.=> Option[Throwable]skippedSus, (Option[scala.xml.Elem])Option[scala.xml.Group]format(org.specs.specification.Sussus.=> Option[scala.xml.Elem]literateDescription), (Seq[org.specs.specification.Example])Seq[sbt.ExampleReportEvent]reportExamples(org.specs.specification.Sussus.=> scala.collection.mutable.Queue[org.specs.specification.Example]examples))
	}
	private def (Seq[org.specs.specification.Example])Seq[sbt.ExampleReportEvent]reportExamples(Seq[org.specs.specification.Example]examples: Seq[org.specs.specification.Example]Seq[Example]): Seq[sbt.ExampleReportEvent]Seq[ExampleReportEvent] =
	{
		for(((org.specs.specification.Example) => sbt.ExampleReportEvent)Seq[sbt.ExampleReportEvent]example <- Seq[org.specs.specification.Example]examples) yield
			(org.specs.specification.Example)sbt.ExampleReportEventreportExample(org.specs.specification.Exampleexample)
	}
	private def (org.specs.specification.Example)sbt.ExampleReportEventreportExample(org.specs.specification.Exampleexample: org.specs.specification.ExampleExample): sbt.ExampleReportEventExampleReportEvent =
	{
		(String,Seq[Throwable],Seq[RuntimeException],Seq[RuntimeException],Seq[sbt.ExampleReportEvent])sbt.ExampleReportEventExampleReportEvent(org.specs.specification.Exampleexample.=> Stringdescription, org.specs.specification.Exampleexample.=> Seq[Throwable]errors, org.specs.specification.Exampleexample.=> Seq[org.specs.specification.FailureException]failures, org.specs.specification.Exampleexample.=> Seq[org.specs.specification.SkippedException]skipped, (Seq[org.specs.specification.Example])Seq[sbt.ExampleReportEvent]reportExamples(org.specs.specification.Exampleexample.=> scala.collection.mutable.Queue[org.specs.specification.Example]subExamples))
	}
}