specification

Type Members

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

2. case class Action(action: LazyParameter[Result] = ...) 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. sealed trait CreationPath extends AnyRef

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

    A Example is:

32. trait ExamplesFactory extends AnyRef

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

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

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

36. sealed trait ExecutedFragment extends AnyRef

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

37. 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)

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

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

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

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

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

42. trait ExecutedStandardFragment extends ExecutedFragment

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

44. case class ExecutedText(text: String, location: Location = new io.Location()) extends ExecutedFragment with Product with Serializable

45. sealed trait ExecutingFragment extends AnyRef

    The Executing Fragment trait represent a Fragment being executed.

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

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

    embed an already executed Fragment

48. class FormMarkup extends MarkupString

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

49. trait FormattingFragments extends AnyRef

    Set of fragments which can be used for formatting

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

51. sealed trait Fragment extends AnyRef

    A Fragment is a piece of a specification.

52. trait FragmentExecution extends AnyRef

    This trait executes Fragments

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

54. trait FragmentsBuilder extends RegexSteps with ExamplesFactory

    This trait provides function to create specification Fragments:

55. class FragmentsFragment extends AnyRef

    Fragments can be chained with the ^ method

56. abstract class Given[T] extends RegexStep[Unit, T]

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

57. abstract class GivenThen extends RegexStep[String, Result]

58. class GivenThenFunction[R] extends GivenThen

59. case class Group(name: String = "") extends BeforeAfterAround with Product with Serializable

60. trait Grouped extends AnyRef

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

61. trait Groups extends AnyRef

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

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

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

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

    encapsulation of the linking behaviour

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

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

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

67. trait NoBangExamples extends FragmentsBuilder

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

68. trait NoBooleanAutoExamples extends AutoExamples

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

69. trait NoContexts extends Contexts

    Use this trait to deactivate the Contexts implicits

70. trait NoDataTableAutoExamples extends AutoExamples

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

71. trait NoFragmentsBuilder extends FragmentsBuilder

    This trait can be used to deactivate implicits for building fragments

72. trait NoMatchResultAutoExamples extends AutoExamples

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

73. trait NoResultAutoExamples extends AutoExamples

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

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

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

    embed an executed Fragment into a promise

76. trait RegexFragment extends AnyRef

77. abstract class RegexStep[P, T] extends AnyRef

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

78. trait RegexSteps extends RegexStepsFactory with TuplesToSeq

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

79. trait RegexStepsFactory extends ImplicitParameters

80. class ResultsContext extends StoredResultsContext

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

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

82. case class SpecEnd(specName: SpecName, isSeeOnlyLink: Boolean = false) extends Fragment with Product with Serializable

    End of a specification.

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

84. trait SpecIdentification extends AnyRef

    Identification information for a specification

85. sealed trait SpecName extends SpecIdentification

    Name declaration for a specification

86. case class SpecStart(specName: SpecName, arguments: Arguments = main.Arguments.apply(), linked: Linked = ...) extends Fragment with Product with Serializable

    Start of a specification.

87. trait SpecificationInclusion extends AnyRef

    additional methods to include other specifications or Fragments

88. trait SpecificationNavigation extends AnyRef

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

89. trait SpecificationStructure extends AnyRef

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

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

91. case class Step(step: LazyParameter[Result], stopOnFail: Boolean = false) 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.

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

93. trait StoredResultsContext extends Context

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

94. trait Tags extends AnyRef

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

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

    Free text, describing the system to specify

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

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

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

98. abstract class When[P, T] extends RegexStep[P, T]

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