SpecificationCreation

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def action(a: ⇒ Any): Fragment

implicit def anyAsResultIsInterpolatedFragment(r: ⇒ Function0Result): InterpolatedFragment

implicit def anyToArgProperty[T](t: ⇒ T): ArgProperty[T]

def args(ex: ArgProperty[String], include: ArgProperty[String], exclude: ArgProperty[String], was: ArgProperty[String], plan: ArgProperty[Boolean], skipAll: ArgProperty[Boolean], stopOnFail: ArgProperty[Boolean], stopOnSkip: ArgProperty[Boolean], sequential: ArgProperty[Boolean], isolated: ArgProperty[Boolean], xonly: ArgProperty[Boolean], showOnly: ArgProperty[String], color: ArgProperty[Boolean]): Arguments

lazy val args: ArgumentsNamespace

implicit def argumentsFunctionIsInterpolatedFragment[R](f: (Arguments) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

final def asInstanceOf[T0]: T0

implicit def asResultIsInterpolatedFragment[R](r: ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

implicit def bangExample(d: String): BangExample

def br: Fragment

def bt(n: Int): Fragment

def bt: Fragment

def clone(): AnyRef

def colors(c: Colors): Arguments

implicit def commandLineFunctionIsInterpolatedFragment[R](f: (CommandLine) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

def createExample[T](expression: String, code: ⇒ T, asResult: AsResult[T]): Fragments

def createExecutionInterpolatedFragment(execution: Execution): InterpolatedFragment

implicit def descriptionToFragmentsIsInterpolatedFragment(fragments: (String) ⇒ Fragments): InterpolatedFragment

def diffs(show: Boolean, separators: String, triggerSize: Int, diffRatio: Int, shortenSize: Int, full: Boolean, seqTriggerSize: Int, seqMaxSize: Int): Arguments

implicit macro def eg[T](code: ⇒ T)(implicit arg0: AsResult[T]): Fragments

def end: Fragment

implicit def envFunctionIsInterpolatedFragment[R](f: (Env) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exclude(tags: String): Arguments

def excludeAlsoTrace(patterns: String*): IncludeExcludeStackTraceFilter

def excludeTrace(patterns: String*): IncludeExcludeStackTraceFilter

implicit def executionContextFunctionIsInterpolatedFragment[R](f: (ExecutionContext) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

implicit def executionIsInterpolatedFragment(execution: Execution): InterpolatedFragment

implicit def executorServiceFunctionIsInterpolatedFragment[R](f: (ExecutorService) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

def finalize(): Unit

implicit def fragmentAsSpecStructure(f: Fragment): SpecStructure

def fragmentFactory: FragmentFactory

implicit def fragmentIsInterpolatedFragment(f: ⇒ Fragment): InterpolatedFragment

implicit def fragmentToFragments(f: Fragment): Fragments

implicit def fragmentsAsSpecStructure(fs: ⇒ Fragments): SpecStructure

def fragmentsBlock(fragments: Seq[Fragment], offset: Int = 2): Fragments

create a block of new fragments where each of them is separated by a newline and there is a specific offset from the left margin

implicit def fragmentsIsInterpolatedFragment(fragments: Fragments): InterpolatedFragment

def fullStackTrace: Arguments

final def getClass(): Class[_]

def hashCode(): Int

def include(tags: String): Arguments

def includeAlsoTrace(patterns: String*): IncludeExcludeStackTraceFilter

def includeTrace(patterns: String*): IncludeExcludeStackTraceFilter

final def isInstanceOf[T0]: Boolean

def isolated: Arguments

def link(s: ⇒ SpecificationStructure): Fragment

def link(s: SpecStructure): Fragment

final def ne(arg0: AnyRef): Boolean

def nocolor: Arguments

final def notify(): Unit

final def notifyAll(): Unit

def only(examples: String): Arguments

def p: Fragments

def plan: Arguments

implicit def resultAsSpecStructure[R](r: ⇒ R)(implicit arg0: AsResult[R]): SpecStructure

def s2(content: String, Yrangepos: Boolean, texts: Seq[String], textsStartPositions: Seq[String], textsEndPositions: Seq[String], variables: Seq[InterpolatedFragment], rangeExpressions: Seq[String]): Fragments

based on the interpolated variables and the expressions captured with the macro, create the appropriate fragments

def section(tag: NamedTag): Fragment

def section(names: String*): Fragment

def see(s: ⇒ SpecificationStructure): Fragment

def see(s: SpecStructure): Fragment

def sequential: Arguments

def showOnly(s: String): Arguments

def skipAll: Arguments

def skipAllIf(condition: ⇒ Boolean): Arguments

def skipAllUnless(condition: ⇒ Boolean): Arguments

implicit def specHeaderAsStructure(header: SpecHeader): SpecStructure

implicit def specStructureAsFragments(spec: SpecStructure): Fragments

implicit def specStructureIsInterpolatedFragment(s: SpecStructure): InterpolatedFragment

implicit def specificationRefIsInterpolatedFragment(ref: SpecificationRef): InterpolatedFragment

implicit def specificationStructureIsInterpolatedFragment(s: SpecificationStructure): InterpolatedFragment

implicit def statsRepositoryFunctionIsInterpolatedFragment[R](f: (StatisticsRepository) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

def step(a: ⇒ Any, global: Boolean = false): Fragment

def step(a: ⇒ Any): Fragment

def stopOnFail: Arguments

def stopOnSkip: Arguments

implicit def stringAsSpecStructure(s: String): SpecStructure

implicit def stringFunctionIsInterpolatedFragment[R](f: (String) ⇒ R)(implicit arg0: AsResult[R]): InterpolatedFragment

implicit def stringIsInterpolatedFragment(s: ⇒ String): InterpolatedFragment

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

def t(n: Int): Fragment

def t: Fragment

def tag(tag: NamedTag): Fragment

def tag(names: String*): Fragment

implicit def title(s: String): TitleOps

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def was(s: String): Arguments

def xonly: Arguments

def Action(a: ⇒ Any): Fragment

def Step(a: ⇒ Any, global: Boolean = false): Fragment

def Step(a: ⇒ Any): Fragment