JUnitReporter

implicit abstract def args: Arguments

arguments for the specification

abstract def descriptions: Map[Fragment, Description]

map providing a description for each fragment

abstract def notifier: RunNotifier

the junit notifier to use

implicit abstract def properties: SystemProperties

system properties

abstract def selected: SpecificationStructure

the selected fragments to report

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val ExecutedStatisticsReducer: Reducer[ExecutedFragment, SpecsStatistics]

implicit def SpecStatsMonoid: Monoid[SpecStats] { val zero: JUnitReporter.this.SpecStats }

implicit def SpecsStatisticsMonoid: Monoid[SpecsStatistics] { val zero: JUnitReporter.this.SpecsStatistics }

val StatisticsReducer: Reducer[ExecutingFragment, SpecsStatistics]

val StatsReducer: Reducer[ExecutingFragment, SpecStats]

val StatsReducer2: Reducer[ExecutingFragment, Stats]

val allOptionalExporters: Seq[String]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def copyBody(name: SpecName, f: Fragment, body: ⇒ Result)(implicit arguments: Arguments): Result

def customExporter(arguments: Arguments): Option[Exporting]

def delegate(arguments: Arguments): Option[Executor]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def execute(implicit arguments: Arguments): (ExecutableSpecification) ⇒ ExecutingSpecification

def execute(f: Fragment)(implicit arguments: Arguments): Product with Serializable with ExecutedFragment

def executeBody(body: ⇒ Result)(implicit arguments: Arguments): Result

def executeConcurrently(fs: FragmentSeq, barrier: ⇒ Any, args: Arguments)(implicit strategy: Strategy): Seq[Product with Serializable with ExecutingFragment { def map(function: org.specs2.specification.ExecutedFragment => org.specs2.specification.ExecutedFragment): Product with Serializable with org.specs2.specification.ExecutingFragment }]

def executeFragment(implicit arguments: Arguments): Function[Fragment, ExecutedFragment]

def executeRandomly(fs: FragmentSeq, args: Arguments): Seq[FinishedExecutingFragment]

def executeSequence(fs: FragmentSeq, barrier: ⇒ Any)(implicit args: Arguments, strategy: Strategy): Seq[ExecutingFragment]

def executeSequentially(fs: FragmentSeq, args: Arguments): Seq[FinishedExecutingFragment]

def export(implicit args: Arguments): (ExecutingSpecification) ⇒ ExecutedSpecification

def exportAll(exporters: Seq[Exporting])(implicit arguments: Arguments): EE

def exportAll(args: Arguments, accept: (String) ⇒ Boolean): EE

def exportAll(arguments: Arguments): EE

def exportConsole(accept: (String) ⇒ Boolean)(implicit arguments: Arguments): Option[Exporting]

def exportCustom(accept: (String) ⇒ Boolean)(implicit arguments: Arguments): Option[Exporting]

def exportHtml(accept: (String) ⇒ Boolean)(implicit arguments: Arguments): Option[Exporting]

def exportJUnitxml(accept: (String) ⇒ Boolean)(implicit arguments: Arguments): Option[Exporting]

def exportMarkdown(accept: (String) ⇒ Boolean)(implicit arguments: Arguments): Option[Exporting]

def exportNotifier(accept: (String) ⇒ Boolean)(implicit arguments: Arguments): Option[Exporting]

def exporter(condition: Boolean)(e: ⇒ Exporting): Option[Exporting]

def exporters(accept: (String) ⇒ Boolean)(implicit arguments: Arguments): Seq[Exporting]

def exporters(implicit arguments: Arguments): Seq[Exporting]

def filter(implicit commandLineArgs: Arguments): (Seq[(Fragment, Arguments, SpecName)]) ⇒ Seq[Fragment]

def filterExamples(implicit commandLineArgs: Arguments): (Seq[(Fragment, Arguments, SpecName)]) ⇒ Seq[Fragment]

def filterPrevious(implicit commandLineArgs: Arguments): (Seq[(Fragment, Arguments, SpecName)]) ⇒ Seq[(Fragment, Arguments, SpecName)]

def filterTags(implicit commandLineArgs: Arguments): (Seq[(Fragment, Arguments, SpecName)]) ⇒ Seq[(Fragment, Arguments, SpecName)]

def finalize(): Unit

def foldAll(fs: Seq[ExecutingFragment]): SpecsStatistics

def fromSpecs2orScalaz: (String) ⇒ Boolean

final def getClass(): Class[_]

def hashCode(): Int

def includePrevious(specName: SpecName, e: Example, args: Arguments): Boolean

def isConsole(args: Arguments): Boolean

def isExecutedFrom(name: String, st: Seq[StackTraceElement]): Boolean

def isExecutedFrom(name: String): Boolean

lazy val isExecutedFromAnIDE: Boolean

lazy val isExecutedFromEclipse: Boolean

lazy val isExecutedFromGradle: Boolean

lazy val isExecutedFromIntellij: Boolean

lazy val isExecutedFromMaven: Boolean

lazy val isExecutedFromSBT: Boolean

def isFromClass(classNamePredicate: (String) ⇒ Boolean, st: Seq[StackTraceElement]): Boolean

def isFromClass(classNamePredicate: (String) ⇒ Boolean): Boolean

final def isInstanceOf[T0]: Boolean

def isSpecificationFromSpecs2orScalaz(st: Seq[StackTraceElement]): Boolean

def isolateExamples(implicit arguments: Arguments): (Seq[(Fragment, Arguments, SpecName)]) ⇒ Seq[Fragment]

def isolateSteps(fragments: Seq[Fragment])(implicit arguments: Arguments): Seq[FragmentSeq]

final def ne(arg0: AnyRef): Boolean

def notifierExporter(arguments: Arguments): Option[Exporting]

final def notify(): Unit

final def notifyAll(): Unit

def optionalExporter(condition: Boolean)(e: Option[Exporting]): Option[Exporting]

def report: ExecutedSpecification

run the suite by executing each fragment related to a description: - execute all fragments (including Steps which are reported as steps) - for each result, report the failure/error/skipped or pending message as a junit failure or ignored event on the RunNotifier

def report(spec: SpecificationStructure)(implicit arguments: Arguments): ExecutedSpecification

lazy val repository: StatisticsRepository

def select(implicit arguments: Arguments): (SpecificationStructure) ⇒ SpecificationStructure

def select(fragments: Seq[Fragment])(implicit arguments: Arguments): Seq[Fragment]

def sequence(implicit arguments: Arguments): (SpecificationStructure) ⇒ ExecutableSpecification

def sequence(specName: SpecName, fragments: Seq[Fragment])(implicit arguments: Arguments): Seq[FragmentSeq]

def setStatsOnSpecEndFragments(implicit args: Arguments): ((ExecutedFragment, Stats)) ⇒ ExecutedFragment

def store(implicit arguments: Arguments): (ExecutingSpecification) ⇒ ExecutingSpecification

def storeResults: ((SpecName, Seq[(SpecName, ExecutedResult)])) ⇒ repository.type

def storeStats: ((ExecutedFragment, SpecName)) ⇒ ExecutedFragment

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit