specification

Type Members

1. case class Action (action: LazyParameter[Result]) extends Fragment with Executable with Product with Serializable

   An Action is similar to a Step but can be executed concurrently with other examples.

2. trait After extends Context

   The After trait can be inherited by classes representing a context where an action must be executing after the main executable action

3. trait AfterContextExample [C <: After] extends ExamplesFactory

   For each created example use a given After context

4. trait AfterEach extends After with Apply

   apply an After context to each Example

5. trait AfterExample extends AfterContextExample[After]

   For each created example use a given after method

6. trait Analysis extends DependencyMatchers

   This trait provides integrated analysis method for a scala project

7. trait Apply extends Context

   Apply a Context to a sequence of fragments containing examples.

8. trait Around extends Context

   The Around trait can be inherited by classes which will execute some code inside the around method provided by the context.

9. trait AroundContextExample [C <: Around] extends ExamplesFactory

   For each created example use a given Around context

10. trait AroundEach extends Around with Apply

    apply an Around context to each Example

11. trait AroundExample extends AroundContextExample[Around]

    For each created example use a given around method

12. trait AroundOutside [T] extends Outside[T]

    The AroundOutside trait can be inherited by classes which will execute some code inside a given context, with a function using that context and actions before and after if necessary.

13. trait BaseSpecification extends SpecificationStructure with FragmentsBuilder with SpecificationInclusion

    A Base specification contains the minimum elements for a Specification

14. trait Before extends Context

    The Before trait can be inherited by classes representing a context where an action must be executing before the main executable action

15. trait BeforeAfter extends Before with After

    The BeforeAfter trait allows to declare before and after actions to execute before and after an Example

16. trait BeforeAfterAround extends Before with After with Around

    The BeforeAfter trait allows to declare before, around and after actions

17. trait BeforeAfterAroundContextExample [C <: BeforeAfterAround] extends ExamplesFactory

    For each created example use a given BeforeAfterAround context

18. trait BeforeAfterAroundEach extends BeforeAfterAround with Apply

    apply a BeforeAfterAround context to each Example

19. trait BeforeAfterAroundExample extends BeforeAfterAroundContextExample[BeforeAfterAround]

    For each created example use a given before/after method

20. trait BeforeAfterContextExample [C <: BeforeAfter] extends ExamplesFactory

    For each created example use a given BeforeAfter context

21. trait BeforeAfterEach extends BeforeAfter with Apply

    apply a BeforeAfter context to each Example

22. trait BeforeAfterExample extends BeforeAfterContextExample[BeforeAfter]

    For each created example use a given before/after method

23. trait BeforeContextExample [C <: Before] extends ExamplesFactory

    For each created example use a given Before context

24. trait BeforeEach extends Before with Apply

    apply a Before context to each Example

25. trait BeforeExample extends BeforeContextExample[Before]

    For each created example use a given after method

26. trait Context extends Scope

    generic trait for Before, After, Around

27. trait Contexts extends AnyRef

    This trait is only used when we wish to write after actions in unit specifications like this

28. case class Example (desc: MarkupString, body: () ⇒ Result) extends Fragment with Executable with Product with Serializable

    A Example is:

29. trait ExamplesFactory extends AnyRef

30. case class ExecutedBacktab (n: Int, location: Location) extends ExecutedStandardFragment with Product with Serializable

31. case class ExecutedBr (location: Location) extends ExecutedStandardFragment with Product with Serializable

32. case class ExecutedEnd (location: Location) extends ExecutedStandardFragment with Product with Serializable

33. trait ExecutedFragment extends AnyRef

    The Executed Fragments represent pieces of a Specification which have already been executed to provide a Result

34. case class ExecutedNoText (isAction: Boolean, timer: SimpleTimer, location: Location) extends ExecutedFragment with Product with Serializable

    This executed Fragment is used when no text must be displayed (for the successful execution of an Action for example)

35. case class ExecutedResult (s: MarkupString, result: Result, timer: SimpleTimer, location: Location, statistics: Stats) extends ExecutedFragment with Product with Serializable

36. case class ExecutedSpecEnd (end: SpecEnd, location: Location, stats: Stats) extends ExecutedFragment with Product with Serializable

37. case class ExecutedSpecStart (start: SpecStart, location: Location, stats: Stats) extends ExecutedFragment with Product with Serializable

38. case class ExecutedSpecification (name: SpecName, fs: Seq[ExecutedFragment]) extends Product with Serializable

    A specification with a name and all of its fragments already executed

39. trait ExecutedStandardFragment extends ExecutedFragment

40. case class ExecutedTab (n: Int, location: Location) extends ExecutedStandardFragment with Product with Serializable

41. case class ExecutedText (text: String, location: Location) extends ExecutedFragment with Product with Serializable

42. trait ExecutingFragment extends AnyRef

    The Executing Fragment trait represent a Fragment being executed.

43. case class ExecutingSpecification (name: SpecName, fs: Seq[ExecutingFragment], executor: ExecutorService) extends Product with Serializable

    a specification with a name and a sequence of fragments being executed

44. case class FinishedExecutingFragment (f: ExecutedFragment) extends ExecutingFragment with Product with Serializable

    embed an already executed Fragment

45. class FormMarkup extends MarkupString

    The FormMarkup embeds the description of a form as text or as Xml

46. trait FormattingFragments extends AnyRef

    Set of fragments which can be used for formatting

47. trait Forms extends FormsBuilder with DecoratedProperties

    Allow a Form to be inserted among Fragments as a Text Fragment Allow a Form to be used as an example body and return a Result automatically

48. trait Fragment extends AnyRef

    A Fragment is a piece of a specification.

49. trait FragmentExecution extends AnyRef

    This trait executes Fragments

50. case class Fragments (title: Option[SpecName], middle: Seq[Fragment], arguments: Arguments, link: Option[HtmlLink], seeOnly: Boolean) extends Product with Serializable

    A Fragments object is a list of fragments with a SpecStart and a SpecEnd

51. class Given [T] extends RegexStep[Unit, T]

    This step can start a sequence of Given / When / Then.

52. class GivenThen extends RegexStep[String, Result]

    Attributes

    abstract

53. class GivenThenFunction [R] extends GivenThen

54. class HtmlLink extends AnyRef

    The HtmlLink class represents a link in a specification with an identifier (either a spec name, or a string) and link elements.

55. case class LazyExecutingFragment (f: () ⇒ ExecutedFragment) extends ExecutingFragment with Product with Serializable

    embed an executing Fragment into a function to execute it on demand

56. trait Outside [T] extends AnyRef

    The Outside trait can be inherited by classes which will execute some code inside the outside method provided by the context.

57. case class PromisedExecutingFragment (promised: Promise[ExecutedFragment]) extends ExecutingFragment with Product with Serializable

    embed an executed Fragment into a promise

58. class RegexStep [P, T] extends AnyRef

    A Regular expression step which takes a text and extracts meaningful values according to a regular expression:

59. trait RegexSteps extends AnyRef

    This trait provides building blocks to create steps and examples from regular expression.

60. trait Scope extends AnyRef

    Marker trait that is used to create a new scope with variables and implicitly converted to a Success in a mutable Specification

61. case class SpecEnd (specName: SpecName) extends Fragment with Product with Serializable

    End of a specification.

62. case class SpecHtmlLink (name: SpecName, beforeText: String, linkText: String, afterText: String, tip: String) extends HtmlLink with Product with Serializable

63. case class SpecStart (specName: SpecName, arguments: Arguments, link: Option[HtmlLink], seeOnly: Boolean) extends Fragment with Product with Serializable

    Start of a specification.

64. trait SpecificationInclusion extends AnyRef

    additional methods to include other specifications or Fragments

65. trait SpecificationStructure extends AnyRef

    The structure of a Specification is simply defined as a sequence of fragments

66. case class Stats (examples: Int, successes: Int, expectations: Int, failures: Int, errors: Int, pending: Int, skipped: Int, trend: Option[Stats], timer: SimpleTimer) extends Product with Serializable

    The Stats class store results for the number of: - successes - expectations - failures - errors - pending - skipped

67. case class Step (step: LazyParameter[Result]) extends Fragment with Executable with Product with Serializable

    An Step creates a fragment that will either return an Error Result if there is an exception or a Success.

68. trait Tags extends AnyRef

    The tags trait allows the creation of Tags fragments in a Specification

69. case class Text (t: String) extends Fragment with Product with Serializable

    Free text, describing the system to specify

70. class Then [T] extends RegexStep[Either[Result, T], (T, Result)]

    This step define checks in a sequence of Given / When / Then.

71. case class UrlHtmlLink (url: String, beforeText: String, linkText: String, afterText: String, tip: String) extends HtmlLink with Product with Serializable

72. class When [P, T] extends RegexStep[P, T]

    This step define conditions in a sequence of Given / When / Then.