DefaultReporter

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

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: DefaultReporter.this.SpecStats }

object SpecsStatistics extends Product with Serializable

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

val StatisticsReducer: Reducer[ExecutingFragment, SpecsStatistics]

val StatsReducer: Reducer[ExecutingFragment, SpecStats]

val StatsReducer2: Reducer[ExecutingFragment, Stats]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

execute sequences of Fragments.

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

execute a Fragment.

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

This method could be overriden to provide alternate behavior when executing an Example

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]

execute a Fragment.

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 filter(implicit commandLineArgs: Arguments): (Seq[(Fragment, Arguments, SpecName)]) ⇒ Seq[Fragment]

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

the filter method filters examples based on their description, keeping only the ones matching the ex attribute of the arguments object

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

final def getClass(): Class[_]

def hashCode(): Int

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

final def isInstanceOf[T0]: Boolean

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

This function "clones" the body of each example if the applicable arguments indicate that the specification should be isolated

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

report Fragments by:

lazy val repository: StatisticsRepository

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

select function returning a filtered seq of Fragments

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

select function returning a filtered seq of Fragments

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

sequence function returning an ordered seq of seq of Fragments

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

the sequence method returns sequences of fragments which can be executed concurrently.

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

set the statistics on SpecEndFragments after they've been computed by the StatisticsReducer Those statistics are updated from previously executed statistics to calculate trends

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

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

store the results by spec name

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

store the statistics: - for SpecEnd -> put the stats in the repository - for a SpecStart that's a link -> read the status of the previous execution

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