org.scalatest.BeforeAndAfter

Trait that can be mixed into suites that need code executed before and after running each test. This trait facilitates a style of testing in which mutable fixture objects held in instance variables are replaced or reinitialized before each test or suite. Here's an example:

import org.scalatest._
import scala.collection.mutable.ListBuffer

class MySuite extends FunSuite with BeforeAndAfter {

  // Fixtures as reassignable variables and mutable objects
  var sb: StringBuilder = _
  val lb = new ListBuffer[String]

  before {
    sb = new StringBuilder("ScalaTest is ")
    lb.clear()
  }

  def testEasy() {
    sb.append("easy!")
    assert(sb.toString === "ScalaTest is easy!")
    assert(lb.isEmpty)
    lb += "sweet"
  }

  def testFun() {
    sb.append("fun!")
    assert(sb.toString === "ScalaTest is fun!")
    assert(lb.isEmpty)
  }
}

Because this trait invokes super.runTest to run each test, you will need to mix it in after a core suite trait to get the desired behavior. For example, this won't compile, because BeforeAndAfter is "super" to FunSuite:

class MySuite extends BeforeAndAfter with FunSuite

You'd need to turn it around, so that FunSuite is "super" to BeforeAndAfter, like this:

class MySuite extends FunSuite with BeforeAndAfter

The before and after methods can each only be called once per Suite, and cannot be invoked after run has been invoked.

Note: The advantage this trait has over BeforeAndAfterEach is that its syntax is more concise. The main disadvantage is that it is not stackable, whereas BeforeAndAfterEach is. I.e., you can write several traits that extend BeforeAndAfterEach and provide beforeEach methods that include a call to super.beforeEach, and mix them together in various combinations. By contrast, only one call to the before registration function is allowed in a suite or spec that mixes in BeforeAndAfter. In addition, BeforeAndAfterEach allows you to access the config map in its beforeEach and afterEach methods, whereas BeforeAndAfter gives you no access to the config map.

Self Type: BeforeAndAfter with Suite

Linear Supertypes

AbstractSuite, AnyRef, Any

Ordering

Alphabetic
By inheritance

Inherited

Hide All
Show all

BeforeAndAfter
AbstractSuite
AnyRef
Any

Visibility

Public
All

Abstract Value Members

def expectedTestCount (filter: Filter): Int

The total number of tests that are expected to run when this Suite's run method is invoked.
The total number of tests that are expected to run when this Suite's run method is invoked.
filter
a Filter with which to filter tests to count based on their tags

Attributes
abstract
Definition Classes
AbstractSuite
def nestedSuites : List[Suite]

A List of this Suite object's nested Suites.
A List of this Suite object's nested Suites. If this Suite contains no nested Suites, this method returns an empty List.

Attributes
abstract
Definition Classes
AbstractSuite
def runNestedSuites (reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit

Runs zero to many of this suite's nested suites.
Runs zero to many of this suite's nested suites.
reporter
the Reporter to which results will be reported
stopper
the Stopper that will be consulted to determine whether to stop execution early.
filter
a Filter with which to filter tests based on their tags
configMap
a Map of key-value pairs that can be used by the executing Suite of tests.
distributor
an optional Distributor, into which to put nested Suites to be run by another entity, such as concurrently by a pool of threads. If None, nested Suites will be run sequentially.
tracker
a Tracker tracking Ordinals being fired by the current thread.

Attributes
protected abstract
Definition Classes
AbstractSuite
def runTests (testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit

Runs zero to many of this suite's tests.
Runs zero to many of this suite's tests.
testName
an optional name of one test to run. If None, all relevant tests should be run. I.e., None acts like a wildcard that means run all relevant tests in this Suite.
reporter
the Reporter to which results will be reported
stopper
the Stopper that will be consulted to determine whether to stop execution early.
filter
a Filter with which to filter tests based on their tags
configMap
a Map of key-value pairs that can be used by the executing Suite of tests.
distributor
an optional Distributor, into which instances of this Suite class that are responsible for executing individual tests contained in this Suite, or groups of this Suite's tests, may be placed so as to be run by another entity, such as concurrently by a pool of threads.
tracker
a Tracker tracking Ordinals being fired by the current thread.

Attributes
protected abstract
Definition Classes
AbstractSuite
val styleName : String

Suite style name.
Suite style name.

Attributes
abstract
Definition Classes
AbstractSuite
def tags : Map[String, Set[String]]

A Map whose keys are String tag names with which tests in this Suite are marked, and whose values are the Set of test names marked with each tag.
A Map whose keys are String tag names with which tests in this Suite are marked, and whose values are the Set of test names marked with each tag. If this Suite contains no tags, this method returns an empty Map.
Subclasses may implement this method to define and/or discover tags in a custom manner, but overriding method implementations should never return an empty Set as a value. If a tag has no tests, its name should not appear as a key in the returned Map.

Attributes
abstract
Definition Classes
AbstractSuite
def testNames : Set[String]

An Set of test names.
An Set of test names. If this Suite contains no tests, this method returns an empty Set.
Although subclass and subtrait implementations of this method may return a Set whose iterator produces String test names in a well-defined order, the contract of this method does not required a defined order. Subclasses are free to implement this method and return test names in either a defined or undefined order.

Attributes
abstract
Definition Classes
AbstractSuite
def withFixture (test: NoArgTest): Unit

Runs the passed test function with a fixture established by this method.
Runs the passed test function with a fixture established by this method.
This method should set up the fixture needed by the tests of the current suite, invoke the test function, and if needed, perform any clean up needed after the test completes. Because the NoArgTest function passed to this method takes no parameters, preparing the fixture will require side effects, such as reassigning instance vars in this Suite or initializing a globally accessible external database. If you want to avoid reassigning instance vars you can use fixture.Suite.
test
the no-arg test function to run with a fixture

Attributes
protected abstract
Definition Classes
AbstractSuite

Concrete Value Members

def != (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def != (arg0: Any): Boolean

Attributes
final
Definition Classes
Any
def ## (): Int

Attributes
final
Definition Classes
AnyRef → Any
def == (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def == (arg0: Any): Boolean

Attributes
final
Definition Classes
Any
def after (fun: ⇒ Any): Unit

Registers code to be executed after each of this suite's tests.
Registers code to be executed after each of this suite's tests.
This trait's implementation of runTest executes the code passed to this method after running each test. Thus the code passed to this method can be used to tear down a test fixture needed by each test.

Attributes
protected
def asInstanceOf [T0] : T0

Attributes
final
Definition Classes
Any
def before (fun: ⇒ Any): Unit

Registers code to be executed before each of this suite's tests.
Registers code to be executed before each of this suite's tests.
This trait's implementation of runTest executes the code passed to this method before running each test. Thus the code passed to this method can be used to set up a test fixture needed by each test.

Attributes
protected
def clone (): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def eq (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def equals (arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize (): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def getClass (): java.lang.Class[_]

Attributes
final
Definition Classes
AnyRef
def hashCode (): Int

Definition Classes
AnyRef → Any
def isInstanceOf [T0] : Boolean

Attributes
final
Definition Classes
Any
def ne (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def notify (): Unit

Attributes
final
Definition Classes
AnyRef
def notifyAll (): Unit

Attributes
final
Definition Classes
AnyRef
def run (testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit

This trait's implementation of run sets a flag indicating run has been invoked, after which any invocation to before or after will complete abruptly with a NotAllowedException.
This trait's implementation of run sets a flag indicating run has been invoked, after which any invocation to before or after will complete abruptly with a NotAllowedException.
testName
an optional name of one test to execute. If None, all relevant tests should be executed. I.e., None acts like a wildcard that means execute all relevant tests in this Suite.
reporter
the Reporter to which results will be reported
stopper
the Stopper that will be consulted to determine whether to stop execution early.
filter
a Filter with which to filter tests based on their tags
configMap
a Map of key-value pairs that can be used by the executing Suite of tests.
distributor
an optional Distributor, into which to put nested Suites to be executed by another entity, such as concurrently by a pool of threads. If None, nested Suites will be executed sequentially.
tracker
a Tracker tracking Ordinals being fired by the current thread.

Definition Classes
BeforeAndAfter → AbstractSuite
def runTest (testName: String, reporter: Reporter, stopper: Stopper, configMap: Map[String, Any], tracker: Tracker): Unit

Run a test surrounded by calls to the code passed to before and after, if any.
Run a test surrounded by calls to the code passed to before and after, if any.
This trait's implementation of this method ("this method") invokes the function registered with before, if any, before running each test and the function registered with after, if any, after running each test. It runs each test by invoking super.runTest, passing along the five parameters passed to it.
If any invocation of the function registered with before completes abruptly with an exception, this method will complete abruptly with the same exception. If any call to super.runTest completes abruptly with an exception, this method will complete abruptly with the same exception, however, before doing so, it will invoke the function registered with after, if any. If the function registered with after also completes abruptly with an exception, this method will nevertheless complete abruptly with the exception previously thrown by super.runTest. If super.runTest returns normally, but the function registered with after completes abruptly with an exception, this method will complete abruptly with the exception thrown by the function registered with after.
testName
the name of one test to execute.
reporter
the Reporter to which results will be reported
stopper
the Stopper that will be consulted to determine whether to stop execution early.
configMap
a Map of key-value pairs that can be used by the executing Suite of tests.
tracker
a Tracker tracking Ordinals being fired by the current thread.

Attributes
protected
Definition Classes
BeforeAndAfter → AbstractSuite
def synchronized [T0] (arg0: ⇒ T0): T0

Attributes
final
Definition Classes
AnyRef
def toString (): String

Definition Classes
AnyRef → Any
def wait (): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()
def wait (arg0: Long, arg1: Int): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()
def wait (arg0: Long): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()

BeforeAndAfter

trait BeforeAndAfter extends AbstractSuite

Abstract Value Members

def expectedTestCount (filter: Filter): Int

def nestedSuites : List[Suite]

def runNestedSuites (reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit

def runTests (testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit

val styleName : String

def tags : Map[String, Set[String]]

def testNames : Set[String]

def withFixture (test: NoArgTest): Unit

Concrete Value Members

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def after (fun: ⇒ Any): Unit

def asInstanceOf [T0] : T0

def before (fun: ⇒ Any): Unit

def clone (): AnyRef

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def finalize (): Unit

def getClass (): java.lang.Class[_]

def hashCode (): Int

def isInstanceOf [T0] : Boolean

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

def run (testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit

def runTest (testName: String, reporter: Reporter, stopper: Stopper, configMap: Map[String, Any], tracker: Tracker): Unit

def synchronized [T0] (arg0: ⇒ T0): T0

def toString (): String

def wait (): Unit

def wait (arg0: Long, arg1: Int): Unit

def wait (arg0: Long): Unit

Inherited from AbstractSuite

Inherited from AnyRef

Inherited from Any