Packages

•  package root

  Definition Classes

  root

•  package org

  Definition Classes

  root

•  package scalatest

  ScalaTest's main traits, classes, and other members, including members supporting ScalaTest's DSL for the Scala interpreter.

  ScalaTest's main traits, classes, and other members, including members supporting ScalaTest's DSL for the Scala interpreter.

  Definition Classes

  org

•  trait TestSuite extends Suite

  The base trait of ScalaTest's synchronous testing styles, which defines a withFixture lifecycle method that accepts as its parameter a test function that returns an Outcome.

  The base trait of ScalaTest's synchronous testing styles, which defines a withFixture lifecycle method that accepts as its parameter a test function that returns an Outcome.

  The withFixture method add by this trait has the following signature and implementation:

  def withFixture(test: NoArgTest): Outcome = {
    test()
  }
  

  The apply method of test function interface, NoArgTest, also returns Outcome:

  // In trait NoArgTest:
  def apply(): Outcome
  

  Because the result of a test is an Outcome, when the test function returns, the test body must have determined an outcome already. It will already be one of Succeeded, Failed, Canceled, or Pending. This is also true when withFixture(NoArgTest) returns: because the result type of withFixture(NoArgTest) is Outcome, the test has by definition already finished execution.

  The recommended way to ensure cleanup is performed after a test body finishes execution is to use a try-finally clause. Using try-finally will ensure that cleanup will occur whether the test function completes abruptly by throwing a suite-aborting exception, or returns normally yielding an Outcome. Note that the only situation in which a test function will complete abruptly with an exception is if the test body throws a suite-aborting exception. Any other exception will be caught and reported as either a Failed, Canceled, or Pending.

  The withFixture method is designed to be stacked, and to enable this, you should always call the super implementation of withFixture, and let it invoke the test function rather than invoking the test function directly. In other words, instead of writing “test()”, you should write “super.withFixture(test)”. Thus, the recommended structure of a withFixture implementation that performs cleanup looks like this:

  // Your implementation
  override def withFixture(test: NoArgTest) = {
    // Perform setup here
    try {
      super.withFixture(test) // Invoke the test function
    } finally {
      // Perform cleanup here
    }
  }
  

  If you have no cleanup to perform, you can write withFixture like this instead:

  // Your implementation
  override def withFixture(test: NoArgTest) = {
    // Perform setup here
    super.withFixture(test) // Invoke the test function
  }
  

  If you want to perform an action only for certain outcomes, you can use a pattern match. For example, if you want to perform an action if a test fails, you'd match on Failed, like this:

  // Your implementation
  override def withFixture(test: NoArgTest) = {
  
    // Perform setup here
  
    val outcome = super.withFixture(test) // Invoke the test function
  
    outcome match {
      case failed: Failed =>
        // perform action that you want to occur
        // only if a test fails here
        failed
      case other => other
    }
  }
  

  If you want to change the outcome in some way in withFixture, you can also use a pattern match. For example, if a particular exception intermittently causes a test to fail, and can transform those failures into cancelations, like this:

  // Your implementation
  override def withFixture(test: NoArgTest) = {
  
    super.withFixture(test) match {
      case Failed(ex: ParticularException) =>
        Canceled("Muting flicker", ex)
      case other => other
    }
  }
  

  Definition Classes

  scalatest

• CheckingEqualizer
• Equalizer
• NoArgTest

org.scalatest.TestSuite

NoArgTest