BaseSpecification

abstract def is: Fragments

declaration of Fragments from the user

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

implicit def RegexFragmentToFragments(r: RegexFragment): Fragments

at any point in time a regex sequence can be transformed as a sequence of Fragments

implicit def argumentsFragment(a: Arguments): FragmentsFragment

Arguments creation

final def asInstanceOf[T0]: T0

def clone(): AnyRef

implicit def downcastGiven[X, Y <: X](gv: Given[Y]): Given[X] { def extract(s: String): Y }

implicit conversion to transform a Given[Y] to Given[X] when Y <: X

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit def exampleFactory: ExampleFactory

def finalize(): Unit

implicit def forExample(s: String): ExampleDesc

Example creation

implicit def fragmentFragments(f: ⇒ Fragment): FragmentsFragment

implicit def fragments(f: ⇒ Fragment): Fragments

implicit def fragmentsFragmentToFragments(fs: FragmentsFragment): Fragments

reverse conversion from a Fragment containing a Fragments object to the Fragments object

implicit def fragmentsFragments(fs: ⇒ Fragments): FragmentsFragment

final def getClass(): Class[_]

def hashCode(): Int

def identification: SpecIdentification

specName provides useful information identifying the specification: title, className, url.

implicit def identifySpecificationStructure(s: SpecificationStructure): SpecIdentification

automatically convert a specification to its identification

implicit def inScope(s: Scope): Success

transform a scope to a success to be able to create traits containing any variables and usable in any Examples

def include(args: Arguments, f: Fragments, fs: Fragments*): FragmentsFragment

def include(args: Arguments, f: Fragments): FragmentsFragment

def include(args: Arguments, s: SpecificationStructure, ss: SpecificationStructure*): FragmentsFragment

def include(args: Arguments, s: SpecificationStructure): FragmentsFragment

def include(s: SpecificationStructure, ss: SpecificationStructure*): FragmentsFragment

implicit def include(s: SpecificationStructure): FragmentsFragment

def include(f: Fragments, fs: Fragments*): FragmentsFragment

def include(f: Fragments): FragmentsFragment

final def isInstanceOf[T0]: Boolean

def link(htmlLink: HtmlLink, f: Fragments): Fragments

def link(htmlLink: HtmlLink, s: SpecificationStructure): Fragments

create a link directly on a specification, with a given link

def link(fss: Seq[Fragments]): Fragments

def link(fs: Fragments, fss: Fragments*): Fragments

def link(fs: Fragments): Fragments

def link(ss: Seq[SpecificationStructure], dummy: Int = 0): Fragments

def link(s: SpecificationStructure, ss: SpecificationStructure*): Fragments

def link(s: SpecificationStructure): Fragments

create a link directly on a specification

def map(fs: ⇒ Fragments): Fragments

this method can be overriden to map additional behavior in the user-defined fragments

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def see(htmlLink: HtmlLink, fs: Fragments): Fragments

def see(htmlLink: HtmlLink, s: SpecificationStructure): Fragments

create a see-only link directly on a specification, with a given link

def see(fss: Seq[Fragments]): Fragments

def see(fs: Fragments, fss: Fragments*): Fragments

def see(fs: Fragments): Fragments

def see(s: SpecificationStructure): Fragments

def see(ss: Seq[SpecificationStructure], dummy: Int = 0): Fragments

def see(s: SpecificationStructure, ss: SpecificationStructure*): Fragments

create a html link without including the other specification fragments

implicit def specIdentificationMarkdownLink(s: String): SpecIdentificationMarkdownLink

create markdown links from string + spec identification

implicit def specificationStructureToFragments(s: SpecificationStructure): AsFragments

this implicit allows to call some functions directly on a specification, like 'hide'

implicit def stringToHtmlLinkFragments(s: String): HtmlLinkFragments

Links to other specifications creation

implicit def stringToHtmlLinkFragments2(s: String): HtmlLinkFragments2

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

implicit def textFragment(s: String): FragmentsFragment

implicit def textStart(s: String): Fragments

implicit def title(s: String): SpecTitle

This method allows to add a title to the Specification.

def toString(): String

implicit def upcastThen[X, Y <: X](th: Then[X]): Then[Y]

implicit conversion to transform a Then[Y] to Then[X] when Y <: X

implicit def updowncastWhen[P, Q, R <: P, S >: Q](wh: When[P, Q]): When[R, S]

implicit conversion to transform a When[P, Q] to When[R, S] when R <: P and S >: Q

final def wait(): Unit

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

final def wait(arg0: Long): Unit