junit

Type Members

1. trait AssertionsForJUnit extends Assertions

   

   Trait that contains ScalaTest's basic assertion methods, suitable for use with JUnit.

   Trait that contains ScalaTest's basic assertion methods, suitable for use with JUnit.

   The assertion methods provided in this trait look and behave exactly like the ones in Assertions, except instead of throwing TestFailedException they throw JUnitTestFailedError, which extends junit.framework.AssertionFailedError.

   JUnit 3 (release 3.8 and earlier) distinguishes between failures and errors. If a test fails because of a failed assertion, that is considered a failure. If a test fails for any other reason, either the test code or the application being tested threw an unexpected exception, that is considered an error. The way JUnit 3 decides whether an exception represents a failure or error is that only thrown junit.framework.AssertionFailedErrors are considered failures. Any other exception type is considered an error. The exception type thrown by the JUnit 3 assertion methods declared in junit.framework.Assert (such as assertEquals, assertTrue, and fail) is, therefore, AssertionFailedError.

   In JUnit 4, AssertionFailedError was made to extend java.lang.AssertionError, and the distinction between failures and errors was essentially dropped. However, some tools that integrate with JUnit carry on this distinction, so even if you are using JUnit 4 you may want to use this AssertionsForJUnit trait instead of plain-old ScalaTest Assertions.

   To use this trait in a JUnit 3 TestCase, you can mix it into your TestCase class, like this:

   import junit.framework.TestCase
   import org.scalatest.junit.AssertionsForJUnit
   
   class MyTestCase extends TestCase with AssertionsForJUnit {
   
     def testSomething() {
       assert("hi".charAt(1) === 'i')
     }
   
     // ...
   }
   

   You can alternatively import the methods defined in this trait.

   import junit.framework.TestCase
   import org.scalatest.junit.AssertionsForJUnit._
   
   class MyTestCase extends TestCase {
   
     def testSomething() {
       assert("hi".charAt(1) === 'i')
     }
   
     // ...
   }
   

   For details on the importing approach, see the documentation for the AssertionsForJUnit companion object. For the details on the AssertionsForJUnit syntax, see the Scaladoc documentation for org.scalatest.Assertions

2. class JUnit3Suite extends TestCase with Suite with AssertionsForJUnit

   

   A Suite that is also a junit.framework.TestCase.

   A Suite that is also a junit.framework.TestCase.

   A JUnit3Suite may be run by either JUnit 3 (such as JUnit 3.8) or ScalaTest's runner. You write it the way you write a JUnit 3 TestCase. Tests are methods that start with test, take no parameters, and have a Unit return type. You manage fixtures with methods setUp and tearDown. Here's an example:

   import org.scalatest.junit.JUnit3Suite
   import scala.collection.mutable.ListBuffer
   
   class BlastFromThePastSuite extends JUnit3Suite {
   
     var sb: StringBuilder = _
     var lb: ListBuffer[String] = _
   
     override def setUp() {
       sb = new StringBuilder("ScalaTest is ")
       lb = new ListBuffer[String]
     }
   
     def testEasy() { // Uses JUnit-style assertions
       sb.append("easy!")
       assertEquals("ScalaTest is easy!", sb.toString)
       assertTrue(lb.isEmpty)
       lb += "sweet"
     }
   
     def testFun() { // Uses ScalaTest assertions
       sb.append("fun!")
       assert(sb.toString === "ScalaTest is fun!")
       assert(lb.isEmpty)
     }
   }
   

   You can use either JUnit's assertions, inherited from TestCase, or ScalaTest's, inherited from AssertionsForJUnit. You can also mix in ShouldMatchersForJUnit or MustMatchersForJUnit if you want to use ScalaTests's matchers DSL. Here's an example:

   import org.scalatest.junit.JUnit3Suite
   import org.scalatest.junit.MustMatchersForJUnit
   import scala.collection.mutable.ListBuffer
   
   class BlastFromThePastSuite extends JUnit3Suite with MustMatchersForJUnit {
   
     var stringBuilder: StringBuilder = _
     var listBuffer: ListBuffer[String] = _
   
     override def setUp() {
       stringBuilder = new StringBuilder("ScalaTest is ")
       listBuffer = new ListBuffer[String]
     }
   
     def testEasy() {
       stringBuilder.append("easy!")
       stringBuilder.toString must be ("ScalaTest is easy!")
       listBuffer must be ('empty)
       listBuffer += "sweet"
     }
   
     def testFun() {
       stringBuilder.append("fun!")
       stringBuilder.toString must be ("ScalaTest is fun!")
       listBuffer must be ('empty)
     }
   }
   

   The reason you would ordinarily want to mix in MustMatchersForJUnit or ShouldMatchersForJUnit rather than MustMatchers or ShouldMatchers is that MustMatchersForJUnit and ShouldMatchersForJUnit throw junit.framework.AssertionFailedErrors, which JUnit 3 will report as failures, not errors. When writing JUnit 3 tests in Scala, you should keep in mind that JUnit 3 will not run tests that have a return type other than Unit. Thus it is best to leave off the equals sign before the curly braces of the body of the test, like this:

   def testGoodIdea() { // result type will be Unit
     // ...
   }
   

   Instead of this:

   def testBadIdea() = { // result type will be inferred
     // ...
   }
   

   If the testBadIdea method ends in an expression that has a result type other than Unit, the Scala compiler will infer a result type to the testBadIdea method to be the same non-Unit type. As a "result," JUnit 3 will not discover or run the testBadIdea method at all.

3. final class JUnitRunner extends Runner

   

   A JUnit Runner that knows how to run any ScalaTest Suite.

   A JUnit Runner that knows how to run any ScalaTest Suite. This enables you to provide a JUnit RunWith annotation on any ScalaTest Suite. Here's an example:

   import org.junit.runner.RunWith
   import org.scalatest.junit.JUnitRunner
   import org.scalatest.FunSuite
   
   @RunWith(classOf[JUnitRunner])
   class MySuite extends FunSuite {
     // ...
   }
   

   This RunWith annotation will enable the MySuite class to be run by JUnit 4.

4. class JUnitSuite extends JUnitSuiteLike

   

   A suite of tests that can be run with either JUnit or ScalaTest.

   A suite of tests that can be run with either JUnit or ScalaTest. This class allows you to write JUnit 4 tests with ScalaTest's more concise assertion syntax as well as JUnit's assertions (assertEquals, etc.). You create tests by defining methods that are annotated with Test, and can create fixtures with methods annotated with Before and After. For example:

   import org.scalatest.junit.JUnitSuite
   import scala.collection.mutable.ListBuffer
   import _root_.org.junit.Test
   import _root_.org.junit.Before
   
   class TwoSuite extends JUnitSuite {
   
     var sb: StringBuilder = _
     var lb: ListBuffer[String] = _
   
     @Before def initialize() {
       sb = new StringBuilder("ScalaTest is ")
       lb = new ListBuffer[String]
     }
   
     @Test def verifyEasy() {
       sb.append("easy!")
       assert(sb.toString === "ScalaTest is easy!")
       assert(lb.isEmpty)
       lb += "sweet"
     }
   
     @Test def verifyFun() {
       sb.append("fun!")
       assert(sb.toString === "ScalaTest is fun!")
       assert(lb.isEmpty)
     }
   }
   

   To execute JUnitSuites with ScalaTest's Runner, you must include JUnit's jar file on the class path or runpath. This version of JUnitSuite was tested with JUnit version 4.10. Instances of this class are not thread safe.

5. trait JUnitSuiteLike extends Suite with AssertionsForJUnit

   

   Implementation trait for class JUnitSuite, which represents a suite of tests that can be run with either JUnit or ScalaTest.

   Implementation trait for class JUnitSuite, which represents a suite of tests that can be run with either JUnit or ScalaTest.

   JUnitSuite is a class, not a trait, to minimize compile time given there is a slight compiler overhead to mixing in traits compared to extending classes. If you need to mix the behavior of JUnitSuite into some other class, you can use this trait instead, because class JUnitSuite does nothing more than extend this trait.

   See the documentation of the class for a detailed overview of JUnitSuite.

6. class JUnitTestFailedError extends AssertionFailedError with exceptions.StackDepth with exceptions.ModifiableMessage[JUnitTestFailedError] with PayloadField with ModifiablePayload[JUnitTestFailedError]

   

   Exception that indicates a test failed.

   Exception that indicates a test failed.

   The purpose of this exception is to encapsulate the same stack depth information provided by TestFailedException, which is used when running with ScalaTest, but be reported as a failure not an error when running with JUnit. The stack depth information indicates which line of test code failed, so that when running with ScalaTest information can be presented to the user that makes it quick to find the failing line of test code. (In other words, when running with ScalaTest the user need not scan through the stack trace to find the correct filename and line number of the failing test.)

   JUnit distinguishes between failures and errors. If a test fails because of a failed assertion, that is considered a failure in JUnit. If a test fails for any other reason, either the test code or the application being tested threw an unexpected exception, that is considered an error in JUnit. This class differs from TestFailedException in that it extends junit.framework.AssertionFailedError. Instances of this class are thrown by the assertions provided by AssertionsForJUnit, and matcher expressions provided by ShouldMatchersForJUnit, and MustMatchersForJUnit.

   The way JUnit 3 (JUnit 3.8 and earlier releases) decided whether an exception represented a failure or error is that only thrown junit.framework.AssertionFailedErrors were considered failures. Any other exception type was considered an error. The exception type thrown by the JUnit 3 assertion methods declared in junit.framework.Assert (such as assertEquals, assertTrue, and fail) was, therefore, AssertionFailedError. In JUnit 4, AssertionFailedError was made to extend java.lang.AssertionError, and the distinction between failures and errors was essentially dropped. However, some tools that integrate with JUnit carry on this distinction, so even if you are using JUnit 4 you may want to use the "ForJUnit" of ScalaTest assertions and matchers.

   Exceptions thrown

   NullPointerException

   if either message or cause is null, or Some(null).

7. class JUnitWrapperSuite extends Suite

   

   A wrapper to allow JUnit tests to be run by the ScalaTest runner.

   A wrapper to allow JUnit tests to be run by the ScalaTest runner.

   Instances of this trait are not thread safe.

8. trait MustMatchersForJUnit extends MustMatchers with AssertionsForJUnit

   

   Trait that makes ScalaTest's ShouldMatchers DSL syntax available for use with JUnit.

   Trait that makes ScalaTest's ShouldMatchers DSL syntax available for use with JUnit.

   The assertion methods provided in this trait look and behave exactly like the ones in ShouldMatchers, except instead of throwing TestFailedException they throw JUnitTestFailedError, which extends junit.framework.AssertionFailedError.

   JUnit 3 (release 3.8 and earlier) distinguishes between failures and errors. If a test fails because of a failed assertion, that is considered a failure. If a test fails for any other reason, either the test code or the application being tested threw an unexpected exception, that is considered an error. The way JUnit 3 decides whether an exception represents a failure or error is that only thrown junit.framework.AssertionFailedErrors are considered failures. Any other exception type is considered an error. The exception type thrown by the JUnit 3 assertion methods declared in junit.framework.Assert (such as assertEquals, assertTrue, and fail) is, therefore, AssertionFailedError.

   In JUnit 4, AssertionFailedError was made to extend java.lang.AssertionError, and the distinction between failures and errors was essentially dropped. However, some tools that integrate with JUnit carry on this distinction, so even if you are using JUnit 4 you may want to use this ShouldMatchersForJUnit trait instead of plain-old ScalaTest ShouldMatchers.

   To use this trait in a JUnit 3 TestCase, you can mix it into your TestCase class, like this:

   import junit.framework.TestCase
   import org.scalatest.junit.ShouldMatchersForJUnit
   
   class MyTestCase extends TestCase with ShouldMatchersForJUnit {
   
     def testSomething() {
       "hello, world!" should startWith ("hello")
     }
   
     // ...
   }
   

   You can alternatively import the methods defined in this trait.

   import junit.framework.TestCase
   import org.scalatest.junit.ShouldMatchersForJUnit._
   
   class MyTestCase extends TestCase {
   
     def testSomething() {
       "hello, world!" should startWith ("hello")
     }
   
     // ...
   }
   

   For details on the importing approach, see the documentation for the ShouldMatchersForJUnit companion object. For the details on the ShouldMatchersForJUnit syntax, see the Scaladoc documentation for org.scalatest.matchers.ShouldMatchers

   Annotations

   @deprecated

   Deprecated

   Please use org.scalatest.MustMatchers with AssertionsForJUnit instead.

9. trait ShouldMatchersForJUnit extends Matchers with AssertionsForJUnit

   

   Trait that makes ScalaTest's ShouldMatchers DSL syntax available for use with JUnit.

   Trait that makes ScalaTest's ShouldMatchers DSL syntax available for use with JUnit.

   The assertion methods provided in this trait look and behave exactly like the ones in ShouldMatchers, except instead of throwing TestFailedException they throw JUnitTestFailedError, which extends junit.framework.AssertionFailedError.

   JUnit 3 (release 3.8 and earlier) distinguishes between failures and errors. If a test fails because of a failed assertion, that is considered a failure. If a test fails for any other reason, either the test code or the application being tested threw an unexpected exception, that is considered an error. The way JUnit 3 decides whether an exception represents a failure or error is that only thrown junit.framework.AssertionFailedErrors are considered failures. Any other exception type is considered an error. The exception type thrown by the JUnit 3 assertion methods declared in junit.framework.Assert (such as assertEquals, assertTrue, and fail) is, therefore, AssertionFailedError.

   In JUnit 4, AssertionFailedError was made to extend java.lang.AssertionError, and the distinction between failures and errors was essentially dropped. However, some tools that integrate with JUnit carry on this distinction, so even if you are using JUnit 4 you may want to use this ShouldMatchersForJUnit trait instead of plain-old ScalaTest ShouldMatchers.

   To use this trait in a JUnit 3 TestCase, you can mix it into your TestCase class, like this:

   import junit.framework.TestCase
   import org.scalatest.junit.ShouldMatchersForJUnit
   
   class MyTestCase extends TestCase with ShouldMatchersForJUnit {
   
     def testSomething() {
       "hello, world!" should startWith ("hello")
     }
   
     // ...
   }
   

   You can alternatively import the methods defined in this trait.

   import junit.framework.TestCase
   import org.scalatest.junit.ShouldMatchersForJUnit._
   
   class MyTestCase extends TestCase {
   
     def testSomething() {
       "hello, world!" should startWith ("hello")
     }
   
     // ...
   }
   

   For details on the importing approach, see the documentation for the ShouldMatchersForJUnit companion object. For the details on the ShouldMatchersForJUnit syntax, see the Scaladoc documentation for org.scalatest.matchers.ShouldMatchers

   Annotations

   @deprecated

   Deprecated

   Please use org.scalatest.Matchers with AssertionsForJUnit instead.