BeforeAndAfterAll

Trait that can be mixed into suites that need methods invoked before and after executing the suite. This trait allows code to be executed before and/or after all the tests and nested suites of a suite are run. This trait overrides run (the main run method that takes seven parameters, an optional test name, reporter, stopper, filter, configMap, optional distributor, and tracker) and calls the beforeAll method, then calls super.run. After the super.run invocation completes, whether it returns normally or completes abruptly with an exception, this trait's run method will invoke afterAll.

Trait BeforeAndAfterAll defines two overloaded variants each of beforeAll and afterAll, one that takes a configMap and another that takes no arguments. This traits implemention of the variant that takes the configMap simply invokes the variant that takes no parameters, which does nothing. Thus you can override whichever variant you want. If you need something from the configMap before all tests and nested suites are run, override beforeAll(Map[String, Any]). Otherwise, override beforeAll().

For example, the following MasterSuite mixes in BeforeAndAfterAll and in beforeAll, creates and writes to a temp file, taking the name of the temp file from the configMap. This same configMap is then passed to the run methods of the nested suites, OneSuite, TwoSuite, RedSuite, and BlueSuite, so those suites can access the filename and, therefore, the file's contents. After all of the nested suites have executed, afterAll is invoked, which again grabs the file name from the configMap and deletes the file:

import org.scalatest.SuperSuite
import org.scalatest.BeforeAndAfterAll
import java.io.FileReader
import java.io.FileWriter
import java.io.File

class MasterSuite extends Suite with BeforeAndAfterAll {

  private val FileNameKeyInGoodies = "tempFileName"

  // Set up the temp file needed by the test, taking
  // a file name from the configMap
  override def beforeAll(configMap: Map[String, Any]) {

    require(
      configMap.isDefinedAt(FileNameKeyInGoodies),
      "must place a temp file name in the configMap under the key: " + FileNameKeyInGoodies
    )

    val fileName = configMap(tempFileName)

    val writer = new FileWriter(fileName)
    try {
      writer.write("Hello, suite of tests!")
    }
    finally {
      writer.close()
    }
  }

  override def nestedSuites =
    List(new OneSuite, new TwoSuite, new RedSuite, new BlueSuite)

  // Delete the temp file
  override def afterAll(configMap: Map[String, Any]) {
    // No need to require that configMap contains the key again because it won't get
    // here if it didn't contain the key in beforeAll 
    val fileName = configMap(tempFileName))
    val file = new File(fileName)
    file.delete()
  }
}

Because the BeforeAndAfterAll trait invokes super.run to run the suite, you may need to mix this trait in last to get the desired behavior. For example, this won't work, because BeforeAndAfterAll is "super" to FunSuite:

class MySuite extends BeforeAndAfterAll with FunSuite

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

class MySuite extends FunSuite with BeforeAndAfterAll

Note: This trait does not currently ensure that the code in afterAll is executed after all the tests and nested suites are executed if a Distributor is passed. The plan is to do that eventually, but in the meantime, be aware that afterAll is guaranteed to be run after all the tests and nested suites only when they are run sequentially.

Self Type: BeforeAndAfterAll with Suite

Linear Supertypes

AbstractSuite, AnyRef, Any

Abstract Value Members

abstract 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

Definition Classes
AbstractSuite
abstract 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.

Definition Classes
AbstractSuite
abstract 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
Definition Classes
AbstractSuite
Exceptions thrown
NullPointerException
if any passed parameter is null.
abstract def runTest(testName: String, reporter: Reporter, stopper: Stopper, configMap: Map[String, Any], tracker: Tracker): Unit

Runs a test.
Runs a test.
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
AbstractSuite
Exceptions thrown
NullPointerException
if any of testName, reporter, stopper, configMap, or tracker is null.
abstract 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
Definition Classes
AbstractSuite
Exceptions thrown
NullPointerException
if any of testName, reporter, stopper, groupsToInclude, groupsToExclude, or configMap is null.
abstract val styleName: String

Suite style name.
Suite style name.

Definition Classes
AbstractSuite
abstract 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.

Definition Classes
AbstractSuite
abstract 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.

Definition Classes
AbstractSuite
abstract def withFixture(test: (BeforeAndAfterAll.this)#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
Definition Classes
AbstractSuite

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

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

Definition Classes
Any
final def ##(): Int

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

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

Definition Classes
Any
def afterAll(configMap: Map[String, Any]): Unit

Defines a method (that takes a configMap) to be run after all of this suite's tests and nested suites have been run.
Defines a method (that takes a configMap) to be run after all of this suite's tests and nested suites have been run.
This trait's implementation of run invokes this method after executing all tests and nested suites (passing in the configMap passed to it), thus this method can be used to tear down a test fixture needed by the entire suite. This trait's implementation of this method invokes the overloaded form of afterAll that takes no configMap.

Attributes
protected
def afterAll(): Unit

Defines a method to be run after all of this suite's tests and nested suites have been run.
Defines a method to be run after all of this suite's tests and nested suites have been run.
This trait's implementation of run invokes the overloaded form of this method that takes a configMap after executing all tests and nested suites. This trait's implementation of that afterAll(Map[String, Any]) method simply invokes this afterAll() method. Thus this method can be used to tear down a test fixture needed by the entire suite, when you don't need anything from the configMap. This trait's implementation of this method does nothing.

Attributes
protected
final def asInstanceOf[T0]: T0

Definition Classes
Any
def beforeAll(configMap: Map[String, Any]): Unit

Defines a method (that takes a configMap) to be run before any of this suite's tests or nested suites are run.
Defines a method (that takes a configMap) to be run before any of this suite's tests or nested suites are run.
This trait's implementation of run invokes this method before executing any tests or nested suites (passing in the configMap passed to it), thus this method can be used to set up a test fixture needed by the entire suite. This trait's implementation of this method invokes the overloaded form of beforeAll that takes no configMap.

Attributes
protected
def beforeAll(): Unit

Defines a method to be run before any of this suite's tests or nested suites are run.
Defines a method to be run before any of this suite's tests or nested suites are run.
This trait's implementation of run invokes the overloaded form of this method that takes a configMap before executing any tests or nested suites. This trait's implementation of that beforeAll(Map[String, Any]) method simply invokes this beforeAll() method. Thus this method can be used to set up a test fixture needed by the entire suite, when you don't need anything from the configMap. This trait's implementation of this method does nothing.

Attributes
protected
def clone(): AnyRef

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

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

Definition Classes
AnyRef → Any
def finalize(): Unit

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

Definition Classes
AnyRef → Any
def hashCode(): Int

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

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

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

Execute a suite surrounded by calls to beforeAll and afterAll.
Execute a suite surrounded by calls to beforeAll and afterAll.
This trait's implementation of this method ("this method") invokes beforeAll(Map[String, Any]) before executing any tests or nested suites and afterAll(Map[String, Any]) after executing all tests and nested suites. It runs the suite by invoking super.run, passing along the seven parameters passed to it.
If any invocation of beforeAll completes abruptly with an exception, this method will complete abruptly with the same exception. If any call to super.run completes abruptly with an exception, this method will complete abruptly with the same exception, however, before doing so, it will invoke afterAll. If <cod>afterAll also completes abruptly with an exception, this method will nevertheless complete abruptly with the exception previously thrown by super.run. If super.run returns normally, but afterAll completes abruptly with an exception, this method will complete abruptly with the same exception.
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
BeforeAndAfterAll → AbstractSuite
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws()

trait BeforeAndAfterAll extends AbstractSuite

Abstract Value Members

abstract def expectedTestCount(filter: Filter): Int

abstract def nestedSuites: List[Suite]

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

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

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

abstract val styleName: String

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

abstract def testNames: Set[String]

abstract def withFixture(test: (BeforeAndAfterAll.this)#NoArgTest): Unit

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def afterAll(configMap: Map[String, Any]): Unit

def afterAll(): Unit

final def asInstanceOf[T0]: T0

def beforeAll(configMap: Map[String, Any]): Unit

def beforeAll(): Unit

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AbstractSuite

Inherited from AnyRef

Inherited from Any

Ungrouped