org.scalatest.junit.AssertionsForJUnit.scala Maven / Gradle / Ivy
Show all versions of scalatest_2.9.0 Show documentation
/*
* Copyright 2001-2008 Artima, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.scalatest.junit
import org.scalatest._
import _root_.junit.framework.AssertionFailedError
/**
* 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
*
*
* @author Bill Venners
*/
trait AssertionsForJUnit extends Assertions {
private[scalatest] override def newAssertionFailedException(optionalMessage: Option[Any], optionalCause: Option[Throwable], stackDepth: Int): Throwable =
(optionalMessage, optionalCause) match {
case (None, None) => new JUnitTestFailedError(stackDepth)
case (None, Some(cause)) => new JUnitTestFailedError(cause, stackDepth)
case (Some(message), None) => new JUnitTestFailedError(message.toString, stackDepth)
case (Some(message), Some(cause)) => new JUnitTestFailedError(message.toString, cause, stackDepth)
}
/*
private[scalatest] override def newAssertionFailedException(optionalMessage: Option[Any], optionalCause: Option[Throwable], stackDepth: Int): Throwable = {
val assertionFailedError =
optionalMessage match {
case None => new AssertionFailedError
case Some(message) => new AssertionFailedError(message.toString)
}
for (cause <- optionalCause)
assertionFailedError.initCause(cause)
assertionFailedError
} */
}
/**
* Companion object that facilitates the importing of AssertionsForJUnit members as
* an alternative to mixing it in. One use case is to import AssertionsForJUnit members so you can use
* them in the Scala interpreter:
*
*
* $ scala -cp junit3.8.2/junit.jar:../target/jar_contents
* Welcome to Scala version 2.7.5.final (Java HotSpot(TM) Client VM, Java 1.5.0_16).
* Type in expressions to have them evaluated.
* Type :help for more information.
*
* scala> import org.scalatest.junit.AssertionsForJUnit._
* import org.scalatest.junit.AssertionsForJUnit._
*
* scala> assert(1 === 2)
* junit.framework.AssertionFailedError: 1 did not equal 2
* at org.scalatest.junit.AssertionsForJUnit$class.assert(AssertionsForJUnit.scala:353)
* at org.scalatest.junit.AssertionsForJUnit$.assert(AssertionsForJUnit.scala:672)
* at .(:7)
* at .()
* at RequestResult$.(:3)
* at RequestResult$.()
* at RequestResult$result( expect(3) { 1 + 3 }
* junit.framework.AssertionFailedError: Expected 3, but got 4
* at org.scalatest.junit.AssertionsForJUnit$class.expect(AssertionsForJUnit.scala:563)
* at org.scalatest.junit.AssertionsForJUnit$.expect(AssertionsForJUnit.scala:672)
* at .(:7)
* at .()
* at RequestResult$.(:3)
* at RequestResult$.()
* at RequestResult$result( val caught = intercept[StringIndexOutOfBoundsException] { "hi".charAt(-1) }
* caught: StringIndexOutOfBoundsException = java.lang.StringIndexOutOfBoundsException: String index out of range: -1
*
*
* @author Bill Venners
*/
object AssertionsForJUnit extends AssertionsForJUnit