org.specs2.execute

Type class to transform any value to a Result

Typeclass trait for anything that can be transformed to a Result

Use of the Hopcroft-Karp (https://en.wikipedia.org/wiki/Hopcroft%E2%80%93Karp_algorithm) algorithm for specs2, to the minimum set of mismatched elements, and corresponding failures

This result allows to embed additional data with a given result for further display

Is is used to provide a way to display properly the data tables in the HtmlExporter

this class allows to throw a result that's decorated with additional information in an Exception

Trait to model detailed information for failures so that smart differences can be computed

This class represents an exception occurring during an execution.

This object allows to create an Error from an exception

this class allows to throw an Error result in an Exception

This trait adds the possibility to retry a given value, convertible to a result, until it succeeds.

This was adapted from a contribution by @robey (http://robey.lag.net)

Trait for anything that can be executed to return a Result

This class represents the failure of an execution. It has a message and a stacktrace

this class allows to throw a failure result in an Exception

This class is used to delay the execution of a result

This trait models elements which can be executed in a brand new context with new local variables It is used to execute examples in a new specification when needed

Pending result

this class allows to throw a pending result in an Exception

The result of an execution, either:

• a success: the execution is ok
• a failure: an expectation is not met
• an error: an exception occurred
• a pending execution: the user has decided that execution must not be performed
• a skipped execution: based on dynamic conditions (a database not available for instance) the execution is not performed

A Result has:

• a message describing the outcome
• a message describing the expectation
• possibly a number of expectations when it is the outcome of several checks (this is used for the reporting of ScalaCheck properties).

This trait executes a Result and returns an appropriate value when a specs2 exception is thrown

This trait adds some implicits to easily fold sequences of results

This trait can be used for anything that can be converted to a Result.

It is used by the MatchResult class so it can be executed as any other kind of Result by the ResultExecution class without introducing a dependency between the execute and the matcher package

This trait provides logical combinators to Results: and, or, not

A Result expression can throw an exception which will be changed into a failure or an error before being used with and/or/not

The stacktrace for a Result

Implementation of a function to cut pieces of code by using some comments as markers

this class allows to throw a skipped result in an Exception

Skipped result

Captured snippet of code with: a value of type T, a string representing the expression, captured by a macro, some evaluation and display parameters

Evaluation and display parameters for a Snippet.

It is possible to change:

• the function that's trimming the expression from newlines or accolades
• the cutter function to remove part which must not be shown
• the asCode function to render the resulting text
• the prompt function to possibly display the evaluated result with a prompt
• the eval boolean indicating if a snippet must be evaluated
• the verify function checking the result

Snippets of code can be extracted from interpolated specification strings.

When you want to specify that a piece of code must be included in the specification output, you can use the snippet method to execute a this code and use the text in the output. If you just want to output part of the code you need to delimit it with some comments // 8<------- (with as many dashes >= 2 as you want)

Generally the value of a snippet will not be evaluated nor displayed but it is possible to show it using the eval method on a Snippet.

It is also possible to check that the result value is correct by using the check method.

This trait provides standard results which can be used in Fragments bodies

This class represents the success of an execution

Companion object to the Success class providing a method to set the expectations number