org.scalatest

# BeforeAndAfterAll

#### trait BeforeAndAfterAll extends AbstractSuite

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
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Hide All
2. Show all

1. BeforeAndAfterAll
2. AbstractSuite
3. AnyRef
4. Any

Visibility

1. Public
2. All

### Abstract Value Members

1. #### 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

2. #### def nestedSuites : List[Suite]

   A `List` of this `Suite` object's nested `Suite`s.

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

   Attributes
     abstract
   Definition Classes
     AbstractSuite

3. #### 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 `Suite`s to be run by another entity, such as concurrently by a pool of threads. If `None`, nested `Suite`s will be run sequentially.

   tracker

     a `Tracker` tracking `Ordinal`s being fired by the current thread.

   Attributes
     protected abstract
   Definition Classes
     AbstractSuite

4. #### 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 `Ordinal`s being fired by the current thread.

   Attributes
     protected abstract
   Definition Classes
     AbstractSuite

5. #### 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 `Ordinal`s being fired by the current thread.

   Attributes
     protected abstract
   Definition Classes
     AbstractSuite

6. #### 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

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

8. #### 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 `var`s in this `Suite` or initializing a globally accessible external database. If you want to avoid reassigning instance `var`s you can use FixtureSuite.

   test

     the no-arg test function to run with a fixture

   Attributes
     protected abstract
   Definition Classes
     AbstractSuite

### Concrete Value Members

1. #### def != (arg0: AnyRef): Boolean

   Attributes
     final
   Definition Classes
     AnyRef

2. #### def != (arg0: Any): Boolean

   Attributes
     final
   Definition Classes
     Any

3. #### def ## (): Int

   Attributes
     final
   Definition Classes
     AnyRef → Any

4. #### def == (arg0: AnyRef): Boolean

   Attributes
     final
   Definition Classes
     AnyRef

5. #### def == (arg0: Any): Boolean

   Attributes
     final
   Definition Classes
     Any

6. #### 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

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

8. #### def asInstanceOf [T0] : T0

   Attributes
     final
   Definition Classes
     Any

9. #### 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

10. #### 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

11. #### def clone (): AnyRef

    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws()

12. #### def eq (arg0: AnyRef): Boolean

    Attributes
      final
    Definition Classes
      AnyRef

13. #### def equals (arg0: Any): Boolean

    Definition Classes
      AnyRef → Any

14. #### def finalize (): Unit

    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws()

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

    Attributes
      final
    Definition Classes
      AnyRef

16. #### def hashCode (): Int

    Definition Classes
      AnyRef → Any

17. #### def isInstanceOf [T0] : Boolean

    Attributes
      final
    Definition Classes
      Any

18. #### def ne (arg0: AnyRef): Boolean

    Attributes
      final
    Definition Classes
      AnyRef

19. #### def notify (): Unit

    Attributes
      final
    Definition Classes
      AnyRef

20. #### def notifyAll (): Unit

    Attributes
      final
    Definition Classes
      AnyRef

21. #### 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 `Suite`s to be executed by another entity, such as concurrently by a pool of threads. If `None`, nested `Suite`s will be executed sequentially.

    tracker

      a `Tracker` tracking `Ordinal`s being fired by the current thread.

    Definition Classes
      BeforeAndAfterAll → AbstractSuite

22. #### def synchronized [T0] (arg0: ⇒ T0): T0

    Attributes
      final
    Definition Classes
      AnyRef

23. #### def toString (): String

    Definition Classes
      AnyRef → Any

24. #### def wait (): Unit

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

25. #### def wait (arg0: Long, arg1: Int): Unit

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

26. #### def wait (arg0: Long): Unit

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

### Inherited from AbstractSuite

### Inherited from AnyRef

### Inherited from Any