org.scalatest

# BeforeAndAfter

#### trait BeforeAndAfter extends AbstractSuite

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

1. Alphabetic
2. By inheritance

Inherited

1. Hide All
2. Show all

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

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

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

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

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

   Attributes
     final
   Definition Classes
     Any

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

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

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

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

    Attributes
      final
    Definition Classes
      AnyRef

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

    Definition Classes
      AnyRef → Any

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

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

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

    Attributes
      final
    Definition Classes
      AnyRef

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

    Definition Classes
      AnyRef → Any

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

    Attributes
      final
    Definition Classes
      Any

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

    Attributes
      final
    Definition Classes
      AnyRef

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

    Attributes
      final
    Definition Classes
      AnyRef

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

    Attributes
      final
    Definition Classes
      AnyRef

19. #### 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 `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
      BeforeAndAfter → AbstractSuite

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

    Attributes
      protected
    Definition Classes
      BeforeAndAfter → AbstractSuite

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

    Attributes
      final
    Definition Classes
      AnyRef

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

    Definition Classes
      AnyRef → Any

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

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

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

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

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

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

### Inherited from AbstractSuite

### Inherited from AnyRef

### Inherited from Any