org.specs2.control

Asynchronous action with:

• an optional list of "finalization" actions to be executed when this action is done whether it has timed-out or thrown an exception. This allows resources to be safely disposed of

This exception class is used when an Action is transformed to a Task to avoid losing information

Logger implementation directing messages to the console

This trait provides simple a way to print out any object to the console:

"this string".pp must ===("this string")

will print 'this string' and pass it to the rest of the expectation

default filter for specs2 runs

This trait provides methods to catch exceptions and transform them into values which can be passed to further computations.

It uses the facilities found in the scala.util.control.Exception object while providing a more concise api on some use cases.

Execute external commands

This trait is used primarily to change the junit behavior depending on the execution environment

Delayed action

This trait provides utility methods for functions

This trait describes something which has a stackTrace with:

• a list of stacktrace element

This is used to provide a common interface to execute.Failure and execute.Error

This trait is used to abuse method overloading and allow some of the methods in specs2 DSL to be applicable to various parameters.

For example in a mutable specification, the >> method is overloaded for lots of different arguments:

• result
• function of the Environment
• function of the Command line
• ...

Implementation of the StackTraceFilter trait with a list of include/exclude patterns

Factory object to build a stack trace filter from include/exclude expressions:

.*specs2 ==> include .*specs2 traces .specs2/scala. ==> include .specs2 traces, exclude scala. traces .*specs2,eclipse ==> include .*specs2,scala traces and eclipse traces

class holding a value to be evaluated lazily

These functions can be used to allow some function to be called with varargs, with values being evaluated lazily:

 def method[T](values: Lazy[T]*) = {
   values.to(LazyList) // use the toStream method to consume the values lazily
 }
 // usage
 method(exp1, exp2, exp3)

Note that the values are really evaluated once, unlike a by-name parameter.

This class simply encapsulates a lazy value which will be only evaluated once

specs2 logger support

This factory creates named threads which can be prefixed by "specs2" to track the threads used by specs2 for the specification execution

Contributed by @jedws

Use this trait to disable the pp method on objects

This filter doesn't do anything

Syntactic sugar to execute an action a given number of times

Synchronous action with:

• an optional list of "finalization" actions to be executed when this action is done if it throws an exception. This allows resources to be safely disposed of

It is essentially the same as an Action without the asynchronicity

This class represents values which are evaluated lazily and which may even be missing.

It has Option-like function and can be also converted to an Either object

Companion object to create properties with possibly no initial value

class holding an optional mutable value

Typeclass for "safe" actions which are actions which can be attempted or finalized

This trait filters an Exception stacktrace

Utility methods to determine the origin of the execution of the current code

This trait adds some utility methods to Throwable objects.

Utility object to show a parameter as used In particular this is useful to avoid warnings with ImplicitParameters

This exception class is used to notify the user of instantiation errors