org.scalatest

# OneInstancePerTest

#### trait OneInstancePerTest extends AbstractSuite

Trait that facilitates a style of testing in which each test is run in its own instance of the suite class to isolate each test from the side effects of the other tests in the suite.

If you mix this trait into a `Suite`, you can initialize shared reassignable fixture variables as well as shared mutable fixture objects in the constructor of the class. Because each test will run in its own instance of the class, each test will get a fresh copy of the instance variables. This is the approach to test isolation taken, for example, by the JUnit framework.

Here's an example of `OneInstancePerTest` being used in a `FunSuite`:

    import org.scalatest.FunSuite
    import org.scalatest.OneInstancePerTest
    import collection.mutable.ListBuffer

    class MySuite extends FunSuite with OneInstancePerTest {

      val builder = new StringBuilder("ScalaTest is ")
      val buffer = new ListBuffer[String]

      test("easy") {
        builder.append("easy!")
        assert(builder.toString === "ScalaTest is easy!")
        assert(buffer.isEmpty)
        buffer += "sweet"
      }

      test("fun") {
        builder.append("fun!")
        assert(builder.toString === "ScalaTest is fun!")
        assert(buffer.isEmpty)
      }
    }

Self Type
  OneInstancePerTest with Suite

Linear Supertypes
AbstractSuite, AnyRef, Any
Known Subclasses
ParallelTestExecution
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Hide All
2. Show all

1. OneInstancePerTest
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 run (testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit

   Runs this suite of tests.

   Runs this suite of tests.

   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.

   Attributes
     abstract
   Definition Classes
     AbstractSuite

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

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

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 asInstanceOf [T0] : T0

   Attributes
     final
   Definition Classes
     Any

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

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

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

   Attributes
     final
   Definition Classes
     AnyRef

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

   Definition Classes
     AnyRef → Any

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

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

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

    Attributes
      final
    Definition Classes
      AnyRef

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

    Definition Classes
      AnyRef → Any

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

    Attributes
      final
    Definition Classes
      Any

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

    Attributes
      final
    Definition Classes
      AnyRef

15. #### def newInstance : Suite

    Construct a new instance of this `Suite`.

    Construct a new instance of this `Suite`.

    This trait's implementation of `runTests` invokes this method to create a new instance of this `Suite` for each test. This trait's implementation of this method uses reflection to call `this.getClass.newInstance`. This approach will succeed only if this `Suite`'s class has a public, no-arg constructor. In most cases this is likely to be true, because to be instantiated by ScalaTest's `Runner` a `Suite` needs a public, no-arg constructor. However, this will not be true of any `Suite` defined as an inner class of another class or trait, because every constructor of an inner class type takes a reference to the enclosing instance. In such cases, and in cases where a `Suite` class is explicitly defined without a public, no-arg constructor, you will need to override this method to construct a new instance of the `Suite` in some other way.

    Here's an example of how you could override `newInstance` to construct a new instance of an inner class:

        import org.scalatest.Suite

        class Outer {
          class InnerSuite extends Suite with OneInstancePerTest {
            def testOne() {}
            def testTwo() {}
            override def newInstance = new InnerSuite
          }
        }

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

    Attributes
      final
    Definition Classes
      AnyRef

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

    Attributes
      final
    Definition Classes
      AnyRef

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

    Run this `Suite's` tests each in their own instance of this `Suite`'s class.

    Run this `Suite's` tests each in their own instance of this `Suite`'s class.

    If the passed `testName` is `None`, this trait's implementation of this method will for each test name returned by `testNames`, invoke `newInstance` to get a new instance of this `Suite`, and call `run` on it, passing in the test name wrapped in a `Some`. If the passed `testName` is defined, this trait's implementation of this method will simply forward all passed parameters to `super.run`. If the invocation of either `newInstance` on this `Suite` or `run` on a newly created instance of this `Suite` completes abruptly with an exception, then this `runTests` method will complete abruptly with the same exception.

    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 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
    Definition Classes
      OneInstancePerTest → AbstractSuite

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

    Attributes
      final
    Definition Classes
      AnyRef

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

    Definition Classes
      AnyRef → Any

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

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

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

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

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

    Attributes
      final
    Definition Classes
      AnyRef
    Annotations
      @throws()

### Inherited from AbstractSuite

### Inherited from AnyRef

### Inherited from Any