specification

Type Members

1. case class AcceptanceCreationPath(path: Seq[Int]) extends CreationPath with Product with Serializable

2. case class Action(action: LazyParameter[Result] = ..., location: Location = new io.Location(), isolable: Boolean = true, creationPath: Option[CreationPath] = scala.None) extends Fragment with Executable with Isolable with Product with Serializable

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

3. 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

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

   For each created example use a given After context

5. trait AfterEach extends After with Apply

   apply an After context to each Example

6. trait AfterExample extends AfterContextExample[After]

   For each created example use a given after method

7. trait AllExpectations extends StoredExpectations with ExamplesFactory with SpecificationStructure with ArgumentsArgs

   This trait can be mixed-in a specification to allow examples to have all of their expectations being evaluated (unless the example body throws an exception of course).

8. trait Analysis extends DependencyMatchers

   This trait provides integrated analysis method for a scala project

9. trait Apply extends Context

   Apply a Context to a sequence of fragments containing examples.

10. 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.

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

    For each created example use a given Around context

12. trait AroundEach extends Around with Apply

    apply an Around context to each Example

13. trait AroundExample extends AroundContextExample[Around]

    For each created example use a given around method

14. trait AroundOutside[+T] extends Around with 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.

15. trait BaseSpecification extends SpecificationStructure with FragmentsBuilder with SpecificationInclusion

    A Base specification contains the minimum elements for a Specification

16. 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

17. trait BeforeAfter extends Before with After

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

18. trait BeforeAfterAround extends Before with After with Around

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

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

    For each created example use a given BeforeAfterAround context

20. trait BeforeAfterAroundEach extends BeforeAfterAround with Apply

    apply a BeforeAfterAround context to each Example

21. trait BeforeAfterAroundExample extends BeforeAfterAroundContextExample[BeforeAfterAround]

    For each created example use a given before/after method

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

    For each created example use a given BeforeAfter context

23. trait BeforeAfterEach extends BeforeAfter with Apply

    apply a BeforeAfter context to each Example

24. trait BeforeAfterExample extends BeforeAfterContextExample[BeforeAfter]

    For each created example use a given before/after method

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

    For each created example use a given Before context

26. trait BeforeEach extends Before with Apply

    apply a Before context to each Example

27. trait BeforeExample extends BeforeContextExample[Before]

    For each created example use a given after method

28. trait Context extends Scope

    generic trait for Before, After, Around

29. trait Contexts extends AnyRef

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

30. trait ContextsInjection extends Contexts

31. sealed trait CreationPath extends AnyRef

32. class DecoratedExampleFactory extends ExampleFactory

    Decorated creation where the body of the example can be surrounded with a given context if necessary

33. class DefaultExampleFactory extends ExampleFactory

    Default implementation for the example factory trait just creating an Example object

34. trait DefaultFragmentsFormatting extends FragmentsFormatting with TagsAssociation

35. case class Example extends Fragment with Executable with Isolable with Product with Serializable

    A Example is:

36. trait ExampleFactory extends AnyRef

    This trait defines methods for creating Examples.

37. trait ExamplesFactory extends AnyRef

38. case class ExamplesGroup(name: String = "") extends Product with Serializable

39. case class ExecutedBacktab(n: Int = 1, location: Location = new io.Location()) extends ExecutedStandardFragment with Product with Serializable

40. case class ExecutedBr(location: Location = new io.Location()) extends ExecutedStandardFragment with Product with Serializable

41. case class ExecutedEnd(location: Location = new io.Location()) extends ExecutedStandardFragment with Product with Serializable

42. sealed trait ExecutedFragment extends AnyRef

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

43. case class ExecutedNoText(isAction: Boolean = false, timer: SimpleTimer = new time.SimpleTimer(), location: Location = new io.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)

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

45. case class ExecutedSpecEnd(end: SpecEnd, location: Location = new io.Location(), stats: Stats = ...) extends ExecutedFragment with Product with Serializable

46. case class ExecutedSpecStart(start: SpecStart, location: Location = new io.Location(), stats: Stats = ...) extends ExecutedFragment with Product with Serializable

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

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

48. trait ExecutedStandardFragment extends ExecutedFragment

49. case class ExecutedTab(n: Int = 1, location: Location = new io.Location()) extends ExecutedStandardFragment with Product with Serializable

50. case class ExecutedText(textFragment: Text, location: Location = new io.Location()) extends ExecutedFragment with Product with Serializable

51. sealed trait ExecutingFragment extends AnyRef

    The Executing Fragment trait represent a Fragment being executed.

52. case class ExecutingSpecification(name: SpecName, arguments: Arguments, fs: Seq[ExecutingFragment], executor: ExecutorService = ExecutingSpecification.newExecutor) extends Product with Serializable

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

53. case class FinishedExecutingFragment(f: ExecutedFragment, original: Fragment) extends ExecutingFragment with Product with Serializable

    embed an already executed Fragment

54. trait Fixture[T] extends AnyRef

    A Fixture can be implicitly passed to a set of examples taking a function as an input.

55. trait FixtureExample[T] extends AnyRef

    For each created example use a given after method

56. class FormFormattedString extends FormattedString

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

57. case class FormattedString(t: String = "", formatting: Formatting = ..., isEmpty: Boolean = false) extends Product with Serializable

58. case class Formatting(flow: Boolean = false, markdown: Boolean = true, verbatim: Boolean = true) extends Product with Serializable

    Formatting for Text fragments

59. trait FormattingFragments extends AnyRef

    Set of fragments which can be used for formatting

60. trait FormattingTags extends Tags

61. 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

62. sealed trait Fragment extends AnyRef

    A Fragment is a piece of a specification.

63. trait FragmentExecution extends AnyRef

    This trait executes Fragments

64. case class Fragments(specTitle: Option[SpecName] = scala.None, middle: Seq[Fragment] = ..., arguments: Arguments = main.Arguments.apply(), linked: Linked = ...) extends Product with Serializable

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

65. trait FragmentsBuilder extends ExamplesFactory with ImplicitParameters with FormattingTags

    This trait provides function to create specification Fragments:

66. trait FragmentsFormatting extends AnyRef

    This trait post-process fragments.

67. class FragmentsFragment extends AnyRef

    Fragments can be chained with the ^ method

68. abstract class Given[T] extends RegexExtractor[Unit, T]

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

69. abstract class GivenThen extends RegexExtractor[String, Result]

70. class GivenThenFunction[R] extends GivenThen

71. trait GivenWhenThen extends RegexStepsFactory with TuplesToSeq with FragmentsBuilder with SpecificationStringContext with ArgumentsArgs

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

72. trait Grouped extends GroupsLike

    This trait can be used to standardize names for groups of examples in an acceptance specification.

73. trait Groups extends GroupsLike

    This trait can be used to standardize names for groups of examples in an acceptance specification.

74. trait GroupsLike extends AnyRef

75. abstract 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.

76. case class LazyExecutingFragment(f: () ⇒ ExecutedFragment, original: Fragment) extends ExecutingFragment with Product with Serializable

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

77. case class Linked(link: Option[HtmlLink] = scala.None, seeOnly: Boolean = false, hidden: Boolean = false) extends Product with Serializable

    encapsulation of the linking behaviour

78. case class MutableCreationPath(path: Seq[Int]) extends CreationPath with Product with Serializable

79. trait NoAutoExamples extends NoBooleanAutoExamples with NoResultAutoExamples with NoMatchResultAutoExamples with NoDataTableAutoExamples

    This trait ca be used to deactivate all automatic conversions to examples

80. trait NoBangExamples extends FragmentsBuilder

    This trait deactivates the implicit on Strings which is used to create examples with !

81. trait NoBooleanAutoExamples extends AutoExamples

    This trait can be used to deactivate the Boolean conversions to fragments and examples

82. trait NoContexts extends Contexts

    Use this trait to deactivate the Contexts implicits

83. trait NoDataTableAutoExamples extends AutoExamples

    This trait can be used to deactivate the DataTable conversions to fragments and examples

84. trait NoFragmentsBuilder extends FragmentsBuilder

    This trait can be used to deactivate implicits for building fragments

85. trait NoMatchResultAutoExamples extends AutoExamples

    This trait can be used to deactivate the MatchResult conversions to fragments and examples

86. trait NoResultAutoExamples extends AutoExamples

    This trait can be used to deactivate the Result conversions to fragments and examples

87. 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.

88. case class PromisedExecutingFragment(promised: Promise[ExecutedFragment], f: Fragment) extends ExecutingFragment with Product with Serializable

    embed an executed Fragment into a promise

89. trait RegexFragment extends AnyRef

90. trait RegexStepsFactory extends ImplicitParameters

91. class ResultsContext extends StoredResultsContext

    This class is used to evaluate a Context as a sequence of results by side-effects.

92. 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

93. trait Snippets extends execute.Snippets

    Snippets of code can be extracted from interpolated specification strings.

94. case class SpecEnd(specName: SpecName, isSeeOnlyLink: Boolean = false, location: Location = new io.Location()) extends Fragment with Product with Serializable

    End of a specification.

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

96. trait SpecIdentification extends AnyRef

    Identification information for a specification

97. sealed trait SpecName extends SpecIdentification

    Name declaration for a specification

98. trait SpecPart extends AnyRef

99. case class SpecStart(specName: SpecName, arguments: Arguments = main.Arguments.apply(), linked: Linked = ..., location: Location = new io.Location()) extends Fragment with Product with Serializable

    Start of a specification.

100. trait SpecificationInclusion extends AnyRef

     additional methods to include other specifications or Fragments

101. trait SpecificationNavigation extends AnyRef

     This trait models "what happens" before a fragment is created in terms of side-effects.

102. trait SpecificationStringContext extends AnyRef

     Allow to use fragments inside interpolated strings starting with s2 in order to build the specification content

103. trait SpecificationStructure extends DefaultFragmentsFormatting

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

104. case class Stats(examples: Int = 0, successes: Int = 0, expectations: Int = 0, failures: Int = 0, errors: Int = 0, pending: Int = 0, skipped: Int = 0, trend: Option[Stats] = scala.None, timer: SimpleTimer = new org.specs2.time.SimpleTimer()) extends Product with Serializable

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

105. case class Step(step: LazyParameter[Result], stopOnFail: Boolean = false, location: Location = new io.Location(), isolable: Boolean = true) extends Fragment with Executable with Isolable with Product with Serializable

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

106. trait StoredExpectationsContext extends StoredExpectations with StoredResultsContext

     This trait can be used when it is not desirable to use the AllExpectations trait, that is, when the specification examples must be executed concurrently and not isolated.

107. trait StoredResultsContext extends Context

     This trait is a context which will use the results provided by the class inheriting that trait.

108. trait Tables extends DataTables with NoBangExamples

109. trait Tags extends AnyRef

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

110. trait TagsAssociation extends AnyRef

111. case class Text(text: FormattedString, location: Location = new io.Location()) extends Fragment with Product with Serializable

     Free text, describing the system to specify

112. abstract class Then[T] extends RegexExtractor[Either[Result, T], (T, Result)]

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

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

114. abstract class When[P, T] extends RegexExtractor[P, T]

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