org.scalatest.concurrent.AbstractPatienceConfiguration.scala Maven / Gradle / Ivy
/*
* Copyright 2001-2013 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.concurrent
import org.scalatest.time.{Span, Millis}
/**
* Trait that defines an abstract patienceConfig method that is implemented in PatienceConfiguration and can
* be overriden in stackable modification traits such as IntegrationPatience.
*
*
* The main purpose of AbstractPatienceConfiguration is to differentiate core PatienceConfiguration
* traits, such as Eventually and Waiters, from stackable
* modification traits for PatienceConfigurations such as IntegrationPatience.
* Because these stackable traits extend AbstractPatienceConfiguration
* instead of Suite, you can't simply mix in a stackable trait:
*
*
*
* class ExampleSpec extends FunSpec with IntegrationPatience // Won't compile
*
*
*
* The previous code is undesirable because IntegrationPatience would have no affect on the class. Instead, you need to mix
* in a core PatienceConfiguration trait and mix the stackable IntegrationPatience trait
* into that, like this:
*
*
*
* class ExampleSpec extends FunSpec with Eventually with IntegrationPatience // Compiles fine
*
*
*
* The previous code is better because IntegrationPatience does have an effect: it modifies the behavior
* of Eventually.
*
*
* @author Bill Venners
*/
trait AbstractPatienceConfiguration extends ScaledTimeSpans {
/**
* Configuration object for asynchronous constructs, such as those provided by traits Eventually and
* Waiters.
*
*
* The default values for the parameters are:
*
*
*
* Configuration Parameter Default Value
*
* timeout
*
*
* scaled(150 milliseconds)
*
*
*
*
* interval
*
*
* scaled(15 milliseconds)
*
*
*
*
* @param timeout the maximum amount of time to wait for an asynchronous operation to complete before giving up and throwing
* TestFailedException.
* @param interval the amount of time to sleep between each check of the status of an asynchronous operation when polling
*
* @author Bill Venners
* @author Chua Chee Seng
*/
final case class PatienceConfig(timeout: Span = scaled(Span(150, Millis)), interval: Span = scaled(Span(15, Millis))) {
/**
* PatienceConfig is an inner class. For some reason (like using SocketReporter and having
* a ScalaFutures test that fails), instance of this class will be serialized. But as an inner class,
* scala will add an extra $outer field that references actual outer class: an instance that you don't
* want make serializable.
* To avoid errors like java.io.NotSerializableException: org.scalatest.verbs.BehaveWord, this function
* delegates serialization to a non inner class.
*/
private def writeReplace(): Any = new AbstractPatienceConfiguration.PatienceConfigProxy(timeout, interval)
}
/**
* Returns a PatienceConfig value providing default configuration values if implemented and made implicit in subtraits.
*/
def patienceConfig: PatienceConfig
}
private object AbstractPatienceConfiguration extends AbstractPatienceConfiguration {
override def patienceConfig: PatienceConfig = PatienceConfig()
private final class PatienceConfigProxy(timeout: Span, interval: Span) extends Serializable {
private def readResolve(): Any = PatienceConfig(timeout, interval)
}
}