org.scalatest.exceptions.TestRegistrationClosedException.scala Maven / Gradle / Ivy
Show all versions of scalatest_2.11.0-M3 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.exceptions
/**
* Exception that indicates an action that is only allowed during a suite's test registration phase,
* such as registering a test to run or ignore, was attempted after registration had already closed.
*
*
* In suites that register tests as functions, such as FunSuite and FunSpec, tests
* are normally registered during construction. Although it is not the usual approach, tests can also
* be registered after construction by invoking methods that register tests on the already constructed suite so
* long as run has not been invoked on that suite.
* As soon as run is invoked for the first time, registration of tests is "closed," meaning
* that any further attempts to register a test will fail (and result in an instance of this exception class being thrown). This
* can happen, for example, if an attempt is made to nest tests, such as in a FunSuite:
*
*
*
* test("this test is fine") {
* test("but this nested test is not allowed") {
* }
* }
*
*
*
* This exception encapsulates information about the stack depth at which the line of code that made this attempt resides,
* so that information can be presented to the user that makes it quick to find the problem line of code. (In other words,
* the user need not scan through the stack trace to find the correct filename and line number of the offending code.)
*
*
* @param message the exception's detail message
* @param failedCodeStackDepth the depth in the stack trace of this exception at which the line of code that attempted
* to register the test after registration had been closed.
*
* @throws NullPointerException if either message or failedCodeStackDepthFun is null
*
* @author Bill Venners
*/
class TestRegistrationClosedException(message: String, failedCodeStackDepthFun: StackDepthException => Int)
extends StackDepthException(Some(message), None, failedCodeStackDepthFun) {
if (message == null) throw new NullPointerException("message was null")
if (failedCodeStackDepthFun == null) throw new NullPointerException("failedCodeStackDepthFun was null")
/**
* Constructs a TestRegistrationClosedException with a message and a pre-determined
* and failedCodeStackDepth. (This was the primary constructor form prior to ScalaTest 1.5.)
*
* @param message the exception's detail message
* @param failedCodeStackDepth the depth in the stack trace of this exception at which the line of test code that failed resides.
*
* @throws NullPointerException if message is null
*/
def this(message: String, failedCodeStackDepth: Int) = this(message, e => failedCodeStackDepth)
/**
* Returns an exception of class TestRegistrationClosedException with failedExceptionStackDepth set to 0 and
* all frames above this stack depth severed off. This can be useful when working with tools (such as IDEs) that do not
* directly support ScalaTest. (Tools that directly support ScalaTest can use the stack depth information delivered
* in the StackDepth exceptions.)
*/
def severedAtStackDepth: TestRegistrationClosedException = {
val truncated = getStackTrace.drop(failedCodeStackDepth)
val e = new TestRegistrationClosedException(message, 0)
e.setStackTrace(truncated)
e
}
/**
* Indicates whether this object can be equal to the passed object.
*/
override def canEqual(other: Any): Boolean = other.isInstanceOf[TestRegistrationClosedException]
/**
* Indicates whether this object is equal to the passed object. If the passed object is
* a TestRegistrationClosedException, equality requires equal message,
* cause, and failedCodeStackDepth fields, as well as equal
* return values of getStackTrace.
*/
override def equals(other: Any): Boolean =
other match {
case that: TestRegistrationClosedException => super.equals(that)
case _ => false
}
/**
* Returns a hash code value for this object.
*/
// Don't need to change it. Implementing it only so as to not freak out people who know
// that if you override equals you must override hashCode.
override def hashCode: Int = super.hashCode
}
// I pass in a message here so different situations can be described better in the
// error message, such as an it inside an it, an ignore inside an it, a describe inside an it, etc.