TestNGSuite

The groups methods has been deprecated and will be removed in a future version of ScalaTest. Please call (and override) tags instead.

Returns a hash code value for the object.

The default hashing algorithm is platform dependent.

Note that it is allowed for two objects to have identical hash codes (o1.hashCode.equals(o2.hashCode)) yet not be equal (o1.equals(o2) returns false). A degenerate implementation could always return 0. However, it is required that if two objects are equal (o1.equals(o2) returns true) that they have identical hash codes (o1.hashCode.equals(o2.hashCode)). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the equals method.

Intercept and return an exception that's expected to be thrown by the passed function value. The thrown exception must be an instance of the type specified by the type parameter of this method. This method invokes the passed function. If the function throws an exception that's an instance of the specified type, this method returns that exception. Else, whether the passed function returns normally or completes abruptly with a different exception, this method throws TestFailedException.

Note that the type specified as this method's type parameter may represent any subtype ofAnyRef, not just Throwable or one of its subclasses. In Scala, exceptions can be caught based on traits they implement, so it may at times make sense to specify a trait that the intercepted exception's class must mix in. If a class instance is passed for a type that could not possibly be used to catch an exception (such as String, for example), this method will complete abruptly with a TestFailedException.

This method is used to test whether the dynamic type of the receiver object is T0.

Note that the test result of the test is modulo Scala's erasure semantics. Therefore the expression1.isInstanceOf[String] will return false, while the expression List(1).isInstanceOf[List[String]] will return true. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested typed.

o.ne(arg0) is the same as !(o.eq(arg0)).

A List of this Suite object's nested Suites. If this Suite contains no nested Suites, this method returns an empty List. This trait's implementation of this method returns an empty List.

Wakes up a single thread that is waiting on the receiver object's monitor.

Wakes up all threads that are waiting on the receiver object's monitor.

Throws TestPendingException to indicate a test is pending.

A pending test is one that has been given a name but is not yet implemented. The purpose of pending tests is to facilitate a style of testing in which documentation of behavior is sketched out before tests are written to verify that behavior (and often, the before the behavior of the system being tested is itself implemented). Such sketches form a kind of specification of what tests and functionality to implement later.

To support this style of testing, a test can be given a name that specifies one bit of behavior required by the system being tested. The test can also include some code that sends more information about the behavior to the reporter when the tests run. At the end of the test, it can call method pending, which will cause it to complete abruptly with TestPendingException. Because tests in ScalaTest can be designated as pending with TestPendingException, both the test name and any information sent to the reporter when running the test can appear in the report of a test run. (In other words, the code of a pending test is executed just like any other test.) However, because the test completes abruptly with TestPendingException, the test will be reported as pending, to indicate the actual test, and possibly the functionality it is intended to test, has not yet been implemented.

Note: This method always completes abruptly with a TestPendingException. Thus it always has a side effect. Methods with side effects are usually invoked with parentheses, as in pending(). This method is defined as a parameterless method, in flagrant contradiction to recommended Scala style, because it forms a kind of DSL for pending tests. It enables tests in suites such as FunSuite or Specto be denoted by placing "(pending)" after the test name, as in:

test("that style rules are not laws") (pending)

Readers of the code see "pending" in parentheses, which looks like a little note attached to the test name to indicate it is pending. Whereas "(pending()) looks more like a method call, "(pending)" lets readers stay at a higher level, forgetting how it is implemented and just focusing on the intent of the programmer who wrote the code.

Execute the passed block of code, and if it completes abruptly, throw TestPendingException, else throw TestFailedException.

This method can be used to temporarily change a failing test into a pending test in such a way that it will automatically turn back into a failing test once the problem originally causing the test to fail has been fixed. At that point, you need only remove the pendingUntilFixed call. In other words, apendingUntilFixed surrounding a block of code that isn't broken is treated as a test failure. The motivation for this behavior is to encourage people to remove pendingUntilFixed calls when there are no longer needed.

This method facilitates a style of testing in which tests are written before the code they test. Sometimes you may encounter a test failure that requires more functionality than you want to tackle without writing more tests. In this case you can mark the bit of test code causing the failure with pendingUntilFixed. You can then write more tests and functionality that eventually will get your production code to a point where the original test won't fail anymore. At this point the code block marked with pendingUntilFixed will no longer throw an exception (because the problem has been fixed). This will in turn cause pendingUntilFixed to throw TestFailedExceptionwith a detail message explaining you need to go back and remove the pendingUntilFixed call as the problem orginally causing your test code to fail has been fixed.

Execute this TestNGSuite.

Throws UnsupportedOperationException, because this method is unused by this trait, given this trait's run method delegates to TestNG to run its tests.

The main purpose of this method implementation is to render a compiler error an attempt to mix in a trait that overrides runNestedSuites. Because this trait does not actually use runNestedSuites, the attempt to mix in behavior would very likely not work.

Throws UnsupportedOperationException, because this method is unused by this trait, given this trait's run method delegates to TestNG to run its tests.

The main purpose of this method implementation is to render a compiler error an attempt to mix in a trait that overrides runTest. Because this trait does not actually use runTest, the attempt to mix in behavior would very likely not work.

Throws UnsupportedOperationException, because this method is unused by this trait, given this trait's run method delegates to TestNG to run its tests.

The main purpose of this method implementation is to render a compiler error an attempt to mix in a trait that overrides runTests. Because this trait does not actually use runTests, the attempt to mix in behavior would very likely not work.

A user-friendly suite name for this Suite.

This trait's implementation of this method returns the simple name of this object's class. This trait's implementation of runNestedSuites calls this method to obtain a name for Reports to pass to the suiteStarting, suiteCompleted, and suiteAborted methods of the Reporter.

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.

This trait's implementation of this method uses Java reflection to discover any Java annotations attached to its test methods. The fully qualified name of each unique annotation that extends TagAnnotation is considered a tag. This trait's implementation of this method, therefore, places one key/value pair into to theMap for each unique tag annotation name discovered through reflection. The mapped value for each tag name key will contain the test method name, as provided via the testNames method.

Subclasses may override 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.

Note, the TagAnnotation annotation was introduced in ScalaTest 1.0, when "groups" were renamed to "tags." In 1.0 and 1.1, the TagAnnotation will continue to not be required by an annotation on a Suitemethod. Any annotation on a Suite method will be considered a tag until 1.2, to give users time to addTagAnnotations on any tag annotations they made prior to the 1.0 release. From 1.2 onward, only annotations themselves annotated by TagAnnotation will be considered tag annotations.

An Set of test names. If this Suite contains no tests, this method returns an empty Set.

This trait's implementation of this method uses Java reflection to discover all public methods whose name starts with "test", which take either nothing or a single Informer as parameters. For each discovered test method, it assigns a test name comprised of just the method name if the method takes no parameters, or the method name plus (Informer) if the method takes a Informer. Here are a few method signatures and the names that this trait's implementation assigns them:

def testCat() {}         // test name: "testCat"
def testCat(Informer) {} // test name: "testCat(Informer)"
def testDog() {}         // test name: "testDog"
def testDog(Informer) {} // test name: "testDog(Informer)"
def test() {}            // test name: "test"
def test(Informer) {}    // test name: "test(Informer)"

This trait's implementation of this method returns an immutable Set of all such names, excluding the nametestNames. The iterator obtained by invoking elements on this returned Set will produce the test names in their natural order, as determined by String'scompareTo method.

This trait's implementation of runTests invokes this method and calls runTest for each test name in the order they appear in the returned Set's iterator. Although this trait's implementation of this method returns a Set whose iterator produces Stringtest names in a well-defined order, the contract of this method does not required a defined order. Subclasses are free to override this method and return test names in an undefined order, or in a defined order that's different from String's natural order.

Subclasses may override this method to produce test names in a custom manner. One potential reason to override testNames is to run tests in a different order, for example, to ensure that tests that depend on other tests are run after those other tests. Another potential reason to override is allow tests to be defined in a different manner, such as methods annotated @Test annotations (as is done in JUnitSuite and TestNGSuite) or test functions registered during construction (as is done in FunSuite and Spec).

Returns a string representation of the object.

The default representation is platform dependent.

Executes the block of code passed as the second parameter, and, if it completes abruptly with a ModifiableMessage exception, prepends the "clue" string passed as the first parameter to the beginning of the detail message of that thrown exception, then rethrows it. If clue does not end in a white space character, one space will be added between it and the existing detail message (unless the detail message is not defined).

This method allows you to add more information about what went wrong that will be reported when a test fails. Here's an example:

withClue("(Employee's name was: " + employee.name + ")") {
  intercept[IllegalArgumentException] {
    employee.getTask(-1)
  }
}

If an invocation of intercept completed abruptly with an exception, the resulting message would be something like:

(Employee's name was Bob Jones) Expected IllegalArgumentException to be thrown, but no exception was thrown

Throws UnsupportedOperationException, because this method is unused by this class, given this class's run method delegates to JUnit to run its tests.

The main purpose of this method implementation is to render a compiler error an attempt to mix in a trait that overrides withFixture. Because this trait does not actually use withFixture, the attempt to mix in behavior would very likely not work.