ParallelTestExecution

Trait that causes that the tests of any suite it is mixed into to be run in parallel if
a Distributor is passed to runTests.

ScalaTest's normal approach for running suites of tests in parallel is to run different suites in parallel,
but the tests of any one suite sequentially. This approach should provide sufficient distribution of the work load
in most cases, but some suites may encapsulate multiple long-running tests. Such suites may dominate the execution
time of the run. If so, mixing in this trait into just those suites will allow their long-running tests to run in parallel with each
other, thereby helping to reduce the total time required to run an entire run.

Because this trait extends OneInstancePerTest,
each test will be run its own instance of the suite's class. This trait overrides the
runTests method. If no Distributor is passed to runTests,
this trait's implementation simply invokes its supertrait OneInstancePerTest's implementation
of runTests, which will run each test in its own instance sequentially. If a Distributor
is passed, however, this traits' implementation of runTests will, for each test, wrap a new instance of the
suite in a special wrapper suite that will invoke just that one test, and passes the wrapper suites to the Distributor.
The thread or entity that takes a wrapper suite from the Distributor will invoke run
on the wrapper suite, which will run just one test. In this way, different tests of a suite that mixes in
ParallelTestExecution will run in parallel.

deftags: 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.

deftestNames: 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.

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.

defne(arg0: AnyRef): Boolean

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: