Trait/Object

org.scalatest.concurrent

Timeouts

Related Docs: object Timeouts | package concurrent

Permalink

trait Timeouts extends AnyRef

This trait has been deprecated and will be removed in a later version of ScalaTest. Please use trait TimeLimits instead.

TimeLimits differs from Timeouts in two ways. First, its behavior is driven by a Timed typeclass, so that it can treat Futures (and FutureOutcomes) differently than non-Futures. Second, where Timeouts failAfter and cancelAfter take an implicit Interruptor strategy, the corresponding methods in TimeLimits take an implicit Signaler strategy. Although the Signaler hierarchy corresponds exactly to the Interruptor hierarchy, the default is different. For Timeouts, the default is ThreadInterruptor; For Signaler, the default is DoNotSignal.

Trait that provides a failAfter and cancelAfter construct, which allows you to specify a time limit for an operation passed as a by-name parameter, as well as a way to interrupt it if the operation exceeds its time limit.

The time limit is passed as the first parameter, as a Span. The operation is passed as the second parameter. And an Interruptor, a strategy for interrupting the operation, is passed as an implicit third parameter. Here's a simple example of its use:

failAfter(Span(100, Millis)) {
  Thread.sleep(200)
}

The above code, after 100 milliseconds, will produce a TestFailedDueToTimeoutException with a message that indicates a timeout expired:

The code passed to failAfter did not complete within 100 milliseconds.

If you use cancelAfter in place of failAfter, a TestCanceledException with a message that indicates a timeout expired:

The code passed to cancelAfter did not complete within 100 milliseconds.

If you prefer you can mix in or import the members of SpanSugar and place a units value after the integer timeout. Here are some examples:

import org.scalatest.time.SpanSugar._

failAfter(100 millis) {
  Thread.sleep(200)
}

failAfter(1 second) {
  Thread.sleep(2000)
}

The code passed via the by-name parameter to failAfter or cancelAfter will be executed by the thread that invoked failAfter or cancelAfter, so that no synchronization is necessary to access variables declared outside the by-name.

var result = -1 // No need to make this volatile
failAfter(100 millis) {
  result = accessNetService()
}
result should be (99)

The failAfter or cancelAfter method will create a timer that runs on a different thread than the thread that invoked failAfter or cancelAfter, so that it can detect when the timeout has expired and attempt to interrupt the main thread. Because different operations can require different interruption strategies, the failAfter or cancelAfter method accepts an implicit third parameter of type Interruptor that is responsible for interrupting the main thread.

Configuring failAfter or cancelAfter with an Interruptor

This trait declares an implicit val named defaultInterruptor, initialized with a ThreadInterruptor, which attempts to interrupt the main thread by invoking Thread.interrupt. If you wish to use a different strategy, you can override this val (or hide it, for example if you imported the members of Timeouts rather than mixing it in). Here's an example in which the default interruption method is changed to DoNotInterrupt, which does not attempt to interrupt the main thread in any way:

override val defaultInterruptor = DoNotInterrupt
failAfter(100 millis) {
  Thread.sleep(500)
}

As with the default Interruptor, the above code will eventually produce a TestFailedDueToTimeoutException with a message that indicates a timeout expired. However, instead of throwing the exception after approximately 100 milliseconds, it will throw it after approximately 500 milliseconds.

This illustrates an important feature of failAfter and cancelAfter: it will throw a TestFailedDueToTimeoutException (or TestCanceledException in case of cancelAfter) if the code passed as the by-name parameter takes longer than the specified timeout to execute, even if it is allowed to run to completion beyond the specified timeout and returns normally.

ScalaTest provides the following Interruptor implementations:

Interruptor implementation Usage
ThreadInterruptor The default interruptor, invokes interrupt on the main test thread. This will set the interrupted status for the main test thread and, if the main thread is blocked, will in some cases cause the main thread to complete abruptly with an InterruptedException.
DoNotInterrupt Does not attempt to interrupt the main test thread in any way
SelectorInterruptor Invokes wakeup on the passed java.nio.channels.Selector, which will cause the main thread, if blocked in Selector.select, to complete abruptly with a ClosedSelectorException.
SocketInterruptor Invokes close on the java.io.Socket, which will cause the main thread, if blocked in a read or write of an java.io.InputStream or java.io.OutputStream that uses the Socket, to complete abruptly with a SocketException.

You may wish to create your own Interruptor in some situations. For example, if your operation is performing a loop and can check a volatile flag each pass through the loop. You could in that case write an Interruptor that sets that flag so that the next time around, the loop would exit.

Annotations
@deprecated
Deprecated

Please use org.scalatest.concurrent.TimeLimits instead

Source
Timeouts.scala
Linear Supertypes
AnyRef, Any
Known Subclasses
Timeouts
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Timeouts
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any

  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any

  3. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any

  4. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any

  5. def cancelAfter[T](timeout: Span)(f: ⇒ T)(implicit interruptor: Interruptor, pos: Position = implicitly[source.Position]): T

    Permalink

    Executes the passed function, enforcing the passed time limit by attempting to interrupt the function if the time limit is exceeded, and throwing TestCanceledException if the time limit has been exceeded after the function completes.

    Executes the passed function, enforcing the passed time limit by attempting to interrupt the function if the time limit is exceeded, and throwing TestCanceledException if the time limit has been exceeded after the function completes.

    If the function completes before the timeout expires:

    • If the function returns normally, this method will return normally.
    • If the function completes abruptly with an exception, this method will complete abruptly with that same exception.

    If the function completes after the timeout expires:

    • If the function returns normally, this method will complete abruptly with a TestCanceledException.
    • If the function completes abruptly with an exception, this method will complete abruptly with a TestCanceledException that includes the exception thrown by the function as its cause.

    If the interrupted status of the main test thread (the thread that invoked cancelAfter) was not invoked when cancelAfter was invoked, but is set after the operation times out, it is reset by this method before it completes abruptly with a TestCanceledException. The interrupted status will be set by ThreadInterruptor, the default Interruptor implementation.

    timeout

    the maximimum amount of time allowed for the passed operation

    f

    the operation on which to enforce the passed timeout

    interruptor

    a strategy for interrupting the passed operation

  6. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  7. implicit val defaultInterruptor: Interruptor

    Permalink

    Implicit Interruptor value defining a default interruption strategy for the failAfter and cancelAfter method.

    Implicit Interruptor value defining a default interruption strategy for the failAfter and cancelAfter method.

    To change the default Interruptor configuration, override or hide this val with another implicit Interruptor.

  8. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef

  9. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any

  10. def failAfter[T](timeout: Span)(fun: ⇒ T)(implicit interruptor: Interruptor, pos: Position = implicitly[source.Position]): T

    Permalink

    Executes the passed function, enforcing the passed time limit by attempting to interrupt the function if the time limit is exceeded, and throwing TestFailedDueToTimeoutException if the time limit has been exceeded after the function completes.

    Executes the passed function, enforcing the passed time limit by attempting to interrupt the function if the time limit is exceeded, and throwing TestFailedDueToTimeoutException if the time limit has been exceeded after the function completes.

    If the function completes before the timeout expires:

    • If the function returns normally, this method will return normally.
    • If the function completes abruptly with an exception, this method will complete abruptly with that same exception.

    If the function completes after the timeout expires:

    • If the function returns normally, this method will complete abruptly with a TestFailedDueToTimeoutException.
    • If the function completes abruptly with an exception, this method will complete abruptly with a TestFailedDueToTimeoutException that includes the exception thrown by the function as its cause.

    If the interrupted status of the main test thread (the thread that invoked failAfter) was not invoked when failAfter was invoked, but is set after the operation times out, it is reset by this method before it completes abruptly with a TestFailedDueToTimeoutException. The interrupted status will be set by ThreadInterruptor, the default Interruptor implementation.

    timeout

    the maximimum amount of time allowed for the passed operation

    fun

    the operation on which to enforce the passed timeout

    interruptor

    a strategy for interrupting the passed operation

  11. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

  12. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any

  13. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any

  14. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any

  15. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef

  16. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef

  17. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef

  18. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef

  19. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any

  20. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  21. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  22. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped