p

org

scalactic

package scalactic

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

Package Members

  1. package anyvals
  2. package exceptions
  3. package source

Type Members

  1. trait AbstractStringUniformity extends Uniformity[String]

    Convenience base trait for string Uniformitys.

    Convenience base trait for string Uniformitys.

    This trait defines a normalizedCanHandle method that returns true if the passed Any is a String and a normalizedOrSame method that normalizes any passed Strings via the normalized method, which is left abstract for subclasses to fill in.

    Here's an example in which AbstractStringUniformity is used to normalize strings by ensuring the first character, if any, is capitalized:

    val capitalized: Uniformity[String] =
      new AbstractStringUniformity {
        def normalized(s: String): String =
          if (s.isEmpty) "" else s.charAt(0).toUpper + s.substring(1)
      }
    

    Here's an example of using the capitalized Uniformity with a Matcher expression:

    scala> import org.scalatest._
    import org.scalatest._
    
    scala> import Matchers._
    import Matchers._
    
    scala> import org.scalactic._
    import org.scalactic._
    
    scala> val capitalized: Uniformity[String] =
         |   new AbstractStringUniformity {
         |     def normalized(s: String): String =
         |       if (s.isEmpty) "" else s.charAt(0).toUpper + s.substring(1)
         |   }
    capitalized: org.scalactic.Uniformity[String] = [email protected]
    
    scala> "Hello" should equal ("hello") (after being capitalized)
    

  2. trait Accumulation extends AccumulationLowPriorityImplicits

    Provides mechanisms that enable errors to be accumulated in “accumulating Ors,” Ors whose Bad type is an Every.

    Provides mechanisms that enable errors to be accumulated in “accumulating Ors,” Ors whose Bad type is an Every.

    The mechanisms are:

    • Passing accumulating Ors to withGood methods
    • Invoking combined on a container of accumulating Ors
    • Invoking validatedBy on a container of any type, passing in a function from that type to an accumulating Or
    • Invoking zip on an accumulating Or
    • Invoking when on an accumulating Or

    For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.

  3. trait AccumulationLowPriorityImplicits extends AnyRef
  4. trait Bool extends AnyRef

    A trait that represent a rich-featured boolean value, which includes the following members:

    A trait that represent a rich-featured boolean value, which includes the following members:

    • a boolean value
    • methods useful for failure messages construction
    • logical expression methods that makes Bool composable

    Bool is used by code generated from BooleanMacro (which AssertionsMacro and RequirementsMacro uses), it needs to be public so that the generated code can be compiled. It is expected that ScalaTest users would ever need to use Bool directly.

  5. abstract class CanEqual[A, B] extends AnyRef

    Abstract class used to enforce type constraints for equality checks.

    Abstract class used to enforce type constraints for equality checks.

    For more information on how this class is used, see the documentation of TripleEqualsSupport.

    Annotations
    @implicitNotFound("types ${A} and ${B} do not adhere to the type constraint selected for the === and !== operators; the missing implicit parameter is of type org.scalactic.CanEqual[${A},${B}]")
  6. class Catcher extends AnyRef

    Convenience class for extractors that match and return Throwables based on a type and Boolean condition.

    Convenience class for extractors that match and return Throwables based on a type and Boolean condition.

    Class Catcher was motivated by the need to catch and handle exceptions based on more than just the exception's type as a strategy for dealing with "flickering" tests—tests that usually pass, but occasionally fail. The best strategy for dealing with flickers is to fix the test such that they stop flickering, but sometimes that is not practical. In such cases allowing the test to continue flickering can distract the team by requiring them to spend time inspecting failures to determine whether or not they are flickers or real failures that need attention. Worse, with enough flickers, team members can stop checking all failures and not notice real ones.

    One strategy for dealing with flickers you can't practically fix is to catch exceptions that are causing individual flickers and cancel the test when you detect them. Often this means you will need to insert a catch clause in a particular spot, or a pattern match if in a withFixture, looking for a particular exception with a particular message or other identifying attribute. If the same problem is causing flickers in many places, it is handy to create an extractor to detect the problem. This Catcher class provides a factory method that takes a partial function from Throwable to Boolean and produces such an extractor. Here's an example:

    val InternalServerError =
      Catcher { case e: DBAccessException =>
        e.getMessage == "500:Internal Server Error"
      }
    

    Using this Catcher in a ScalaTest withFixture method would look like:

    override def withFixture(test: NoArgTest) = {
      super.withFixture(test) match {
         case Failed(InternalServerError(ex)) =>
           Canceled("Canceled because likely a flicker caused by intermittently flaky DB", ex)
         case other => other
      }
    }
    

  7. trait Equality[A] extends Equivalence[A]

    Defines a custom way to determine equality for a type when compared with another value of type Any.

    Defines a custom way to determine equality for a type when compared with another value of type Any.

    Equality enables you to define alternate notions of equality for types that can be used with ScalaUtil's === and !== syntax and ScalaTest's matcher syntax.

    For example, say you have a case class that includes a Double value:

    scala> case class Person(name: String, age: Double)
    defined class Person
    

    Imagine you are calculating the age values in such as way that occasionally tests are failing because of rounding differences that you actually don't care about. For example, you expect an age of 29.0, but you're sometimes seeing 29.0001:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TripleEquals._
    import TripleEquals._
    
    scala> Person("Joe", 29.0001) === Person("Joe", 29.0)
    res0: Boolean = false
    

    The === operator looks for an implicit Equality[L], where L is the left-hand type: in this case, Person. Because you didn't specifically provide an implicit Equality[Person], === will fall back on default equality, which will call Person's equals method. That equals method, provided by the Scala compiler because Person is a case class, will declare these two objects unequal because 29.001 does not exactly equal 29.0.

    To make the equality check more forgiving, you could define an implicit Equality[Person] that compares the age Doubles with a tolerance, like this:

    scala> import Tolerance._
    import Tolerance._
    
    scala> implicit val personEq =
         |   new Equality[Person] {
         |     def areEqual(a: Person, b: Any): Boolean =
         |       b match {
         |         case p: Person => a.name == p.name && a.age === p.age +- 0.0002
         |         case _ => false
         |       }
         |   }
    personEq: org.scalactic.Equality[Person] = [email protected]
    

    Now the === operator will use your more forgiving Equality[Person] for the equality check instead of default equality:

    scala> Person("Joe", 29.0001) === Person("Joe", 29.0)
    res1: Boolean = true
    

    Default equality

    Scalactic defines a default Equality[T] for all types T whose areEqual method works by first calling .deep on any passed array, then calling == on the left-hand object, passing in the right-hand object. You can obtain a default equality via the default method of the Equality companion object, or from the defaultEquality method defined in TripleEqualsSupport.

    About equality and equivalence

    The Equality trait represents the Java Platform's native notion of equality, as expressed in the signature and contract of the equals method of java.lang.Object. Essentially, trait Equality enables you to write alternate equals method implementations for a type outside its defining class.

    In an equals method, the left-hand type is known to be the type of this, but the right-hand type is Any. As a result, you would normally perform a runtime type test to determine whether the right-hand object is of an appropriate type for equality, and if so, compare it structurally for equality with the left-hand (this) object. An an illustration, here's a possible equals implementation for the Person case class shown in the earlier example:

    override def equals(other: Any): Boolean =
      other match {
        case p: Person => name = p.name && age = p.age
        case _ => false
      }
    

    The areEquals method of Equality[T] is similar. The left-hand type is known to be T, but the right-hand type is Any, so normally you'd need to do a runtime type test in your areEqual implementation. Here's the areEqual method implementation from the earlier Equality[Person] example:

    def areEqual(a: Person, b: Any): Boolean =
      b match {
        case p: Person => a.name == p.name && a.age === p.age +- 0.0002
        case _ => false
      }
    

    Equality is used by TripleEquals, which enforces no type constraint between the left and right values, and the equal, be, and contain syntax of ScalaTest Matchers.

    By contrast, TypeCheckedTripleEquals and ConversionCheckedTripleEquals use an Equivalence. Equivalence differs from Equality in that both the left and right values are of the same type. Equivalence works for TypeCheckedTripleEquals because the type constraint enforces that the left type is a subtype or supertype of (or the same type as) the right type, and it widens the subtype to the supertype. So ultimately, both left and right sides are of the supertype type. Similarly, Equivalence works for ConversionCheckedTripleEquals because the type constraint enforces that an implicit conversion exists from either the left type to the right type, or the right type to the left type, and it always converts one type to the other using the implicit conversion. (If both types are the same type, the identity implicit conversion from Predef is used.) Because of the conversion, both left and right sides are ultimately of the converted-to type. Here's an example of how writing an Equivalence's areEquivalent method might look:

    def areEquivalent(a: Person, b: Person): Boolean =
         a.name == b.name && a.age === b.age +- 0.0002
    

    Scalactic provides both Equality and Equivalence because the Any in Equality can sometimes make things painful. For example, in trait TolerantNumerics, a single generic factory method can produce Equivalences for any Numeric type, but because of the Any, a separate factory method must be defined to produce an Equality for each Numeric type.

    If you just want to customize the notion of equality for === used in Boolean expressions, you can work with Equivalences instead of Equalitys. If you do chose to write the more general Equalitys, they can be used wherever an Equivalence is required, because Equality extends Equivalence, defining a final implementation of areEquivalent that invokes areEqual.

    Note: The Equality type class was inspired in part by the Equal type class of the scalaz project.

    A

    the type whose equality is being customized

  8. trait Equivalence[T] extends AnyRef

    Defines a custom way to determine equality for a type when compared with another value of the same type.

    Defines a custom way to determine equality for a type when compared with another value of the same type.

    Equivalence enables you to define alternate notions of equality for types that can be used with ScalaUtil's TypeCheckedTripleEquals and ConversionCheckedTripleEquals traits. These traits can be used to perform equality comparisons with type constraints enforced at compile time using ScalaUtil's === and !== syntax and ScalaTest's should === syntax of Matchers trait.

    Because Equality extends Equivalence, you automatically define an Equivalence[T] when you define an Equality[T]. Most often you will usually want to define custom Equalitys, because they will be more generally useful: they are also used by Scalactic's TripleEquals trait and ScalaTest's equal, be, and contain matcher syntax. However, if you really want just an Equivalence, and writing an Equality is inconvenient, you can write an Equivalence directly for a type.

    For example, say you have a case class that includes a Double value:

    scala> case class Person(name: String, age: Double)
    defined class Person
    

    Imagine you are calculating the age values in such as way that occasionally tests are failing because of rounding differences that you actually don't care about. For example, you expect an age of 29.0, but you're sometimes seeing 29.0001:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TypeCheckedTripleEquals._
    import TypeCheckedTripleEquals._
    
    scala> Person("Joe", 29.0001) === Person("Joe", 29.0)
    res0: Boolean = false
    

    The === operator of TypeCheckedTripleEquals looks for an implicit Equivalence[SUPER], where SUPER is either the left-hand or right-hand type, whichever one is a supertype of the other. In this case, both sides are Person (which is considered a supertype of itself), so the compiler will look for an Equivalence[Person]. Because you didn't specifically provide an implicit Equivalence[Person], === will fall back on default equality, because an Equality[Person] is-an Equivalence[Person]. The default Equality[Person] will call Person's equals method. That equals method, provided by the Scala compiler because Person is a case class, will declare these two objects unequal because 29.001 does not exactly equal 29.0.

    To make the equality check more forgiving, you could define an implicit Equivalence[Person] that compares the age Doubles with a tolerance, like this:

    scala> import Tolerance._
    import Tolerance._
    
    scala> implicit val personEq =
         |   new Equivalence[Person] {
         |     def areEquivalent(a: Person, b: Person): Boolean =
         |       a.name == b.name && a.age === b.age +- 0.0002
         |   }
    personEq: org.scalactic.Equivalence[Person] = [email protected]
    

    Now the === operator will use your more forgiving Equivalence[Person] for the equality check instead of default equality:

    scala> Person("Joe", 29.0001) === Person("Joe", 29.0)
    res1: Boolean = true
    

  9. type ErrorMessage = String

    Type alias for String.

  10. trait Explicitly extends AnyRef

    Provides ScalaTest's “explicitly DSL,” which facilitates the explicit specification of an Equality[T] or a Uniformity[T] where Equality[T] is taken implicitly.

    Provides ScalaTest's “explicitly DSL,” which facilitates the explicit specification of an Equality[T] or a Uniformity[T] where Equality[T] is taken implicitly.

    The Explicitly DSL can be used with the === and !== operators of Scalactic as well as the should equal, be, contain, and === syntax of ScalaTest matchers.

    If you want to customize equality for a type in general, you would likely want to place an implicit Equality[T] for that type in scope (or in T's companion object). That implicit equality definition will then be picked up and used when that type is compared for equality with the equal, be, and contain matchers in ScalaTest tests and with === in both tests and production code. If you just want to use a custom equality for a single comparison, however, you may prefer to pass it explicitly. For example, if you have an implicit Equality[String] in scope, you can force a comparison to use the default equality with this syntax:

    // In production code:
    if ((result === "hello")(decided by defaultEquality)) true else false
    
    // In tests:
    result should equal ("hello") (decided by defaultEquality)
    

    The explicitly DSL also provides support for specifying a one-off equality that is based on a normalization. For example, Scalactic offers a StringNormalizations trait that provides methods such as trimmed and lowerCased that return Normalization[String] instances that normalize by trimming and lower-casing, respectively. If you bring those into scope by mixing in or importing the members of StringNormalizations, you could use the explicitly DSL like this:

    // In production code:
    if ((result === "hello")(after being lowerCased)) true else false
    
    // In tests:
    result should equal ("hello") (after being lowerCased and trimmed)
    

    If you prefer not to use English-like DSLs in your production code, you can alternatively not use the Explicitly trait and instead write:

    // To explicitly specify an Equality instance, just specify it:
    if ((result === "hello")(Equality.default)) true else false
    
    // To base an Equality instance on a Uniformity, just
    // call toEquality on it:
    if ((result === "hello")(lowerCased.toEquality)) true else false
    

  11. trait FutureSugar extends AnyRef

    Trait providing an implicit class that adds a validating method to Future, which takes one or more validation functions and returns either the same Future if either the Future had already failed or its value passes all the functions, or ValidationFailedException containing an error message describing the first validation that failed.

    Trait providing an implicit class that adds a validating method to Future, which takes one or more validation functions and returns either the same Future if either the Future had already failed or its value passes all the functions, or ValidationFailedException containing an error message describing the first validation that failed.

    Here's an example validation method, which passes if the given Int is evenly divisible by 10 (i.e., the result will be Pass). If the value does not pass this test, the result is a Fail containing a helpful error message string.

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import FutureSugar._
    import org.scalactic.FutureSugar._
    
    scala> import scala.concurrent.Future
    import scala.concurrent.Future
    
    scala> import scala.concurrent.ExecutionContext.Implicits.global
    import scala.concurrent.ExecutionContext.Implicits.global
    
    scala> def isRound(i: Int): Validation[ErrorMessage] =
         |   if (i % 10 == 0) Pass else Fail(i + " was not a round number")
    isRound: (i: Int)org.scalactic.Validation[org.scalactic.ErrorMessage]
    

    Validation will be attempted on a successful Try. If the validation succeeds, the resulting Future will be the same successful Future with the same value. (A "validation" only transforms the Future if the validation fails, otherwise it is the same Future. The only difference is its value has now been proven valid.) In the following example, a successful Future[Int] with the value 100 passes the validation (which checks whether 100 is evenly divisible by 10), therefore the result of the validating call is the same successful Future with the same value.

    scala> val fut100 = Future(100)
    fut100: scala.concurrent.Future[Int] = [email protected]
    
    scala> fut100.value
    res0: Option[scala.util.Try[Int]] = Some(Success(100))
    
    scala> val round100 = fut100.validating(isRound)
    round100: scala.concurrent.Future[Int] = [email protected]
    
    scala> round100.value
    res1: Option[scala.util.Try[Int]] = Some(Success(100))
    

    If validation fails, the successful Future will be transformed into a failed one, with a ValidationFailedException that contains the error message returned by the validation function. In the following example, 42 fails the validation because it is not evenly divisible by 10:

    scala> val fut42 = Future(42)
    fut42: scala.concurrent.Future[Int] = [email protected]
    
    scala> fut42.value
    res2: Option[scala.util.Try[Int]] = Some(Success(42))
    
    scala> val round42 = fut42.validating(isRound)
    round42: scala.concurrent.Future[Int] = [email protected]
    
    scala> round42.value
    res3: Option[scala.util.Try[Int]] = Some(Failure(org.scalactic.exceptions.ValidationFailedException: 42 was not a round number))
    

    If validating is called on a failed Future, it just returns the same failed Future:

    scala> val futEx = Future[Int] { throw new Exception("oops!") }
    futEx: scala.concurrent.Future[Int] = [email protected]
    
    scala> futEx.value
    res4: Option[scala.util.Try[Int]] = Some(Failure(java.lang.Exception: oops!))
    
    scala> val roundEx = futEx.validating(isRound)
    roundEx: scala.concurrent.Future[Int] = [email protected]
    
    scala> roundEx.value
    res5: Option[scala.util.Try[Int]] = Some(Failure(java.lang.Exception: oops!))
    

    The validating method accepts one or more validation functions. If you pass more than one, they will be tried in order up until the first failure, whose error message will appear in the ValidationFailedException. In other words, validating will short circuit at the first error and return that. It will not accumulate errors. For example, the following validation will short circuit after the isDivBy3 function fails:

    scala> def isDivBy3(i: Int): Validation[ErrorMessage] =
         |   if (i % 3 == 0) Pass else Fail(i + " was not divisible by 3")
    isDivBy3: (i: Int)org.scalactic.Validation[org.scalactic.ErrorMessage]
    
    scala> def isAnswerToLifeTheUniverseAndEverything(i: Int): Validation[ErrorMessage] =
         |   if (i == 42) Pass else Fail(i + " did not equal 42")
    isAnswerToLifeTheUniverseAndEverything: (i: Int)org.scalactic.Validation[org.scalactic.ErrorMessage]
    
    scala> val futShort = fut100.validating(isRound, isDivBy3, isAnswerToLifeTheUniverseAndEverything)
    futShort: scala.concurrent.Future[Int] = [email protected]
    
    scala> futShort.value
    res11: Option[scala.util.Try[Int]] = Some(Failure(org.scalactic.exceptions.ValidationFailedException: 100 was not divisible by 3))
    

  12. trait LowPriorityTypeCheckedConstraint extends TripleEqualsSupport

    Provides an implicit conversion that will be applied only if a higher-priority implicit conversion declared a subtrait is not applicable.

    Provides an implicit conversion that will be applied only if a higher-priority implicit conversion declared a subtrait is not applicable.

    The purpose of this trait is to make the === operator symetric. In other words, a === invocation will be allowed if subtype relationship exists in either direction. For example, in the following expression, the left hand side is a subtype of the right hand side:

    List(1, 2, 3) === Seq(1, 2, 3)
    

    But in the next expression, it the right hand side is a subtype of the left hand side

    Seq(1, 2, 3) === List(1, 2, 3)
    

    The first expression above is enabled by the implicit conversion typeCheckedConstraint in trait TypeCheckedTripleEquals. The second expression above is enabled by the implicit conversion lowPriorityTypeCheckedConstraint in this trait.

    The reason these two implicit methods aren't both declared in the subtraits is that if the subtype relationship existed in both directions, they would conflict. This can happen when the exact same type is on both the left and right hand sides, because a type is a subtype of itself. By placing one of them in this supertrait, the higher priority conversion will be selected.

  13. trait MapEqualityConstraints extends AnyRef

    Provides an implicit method that loosens the equality constraint defined by TypeCheckedTripleEquals or ConversionCheckedTripleEquals for Scala Maps to one that more closely matches Scala's approach to Map equality.

    Provides an implicit method that loosens the equality constraint defined by TypeCheckedTripleEquals or ConversionCheckedTripleEquals for Scala Maps to one that more closely matches Scala's approach to Map equality.

    Scala's approach to Map equality is that if both objects being compared are Maps, the elements are compared to determine equality. This means you could compare an immutable TreeMap and a mutable HashMap for equality, for instance, and get true so long as the two maps contained the same key-value mappings. Here's an example:

    scala> import scala.collection.immutable.TreeMap
    import scala.collection.immutable.TreeMap
    
    scala> import scala.collection.mutable.HashMap
    import scala.collection.mutable.HashMap
    
    scala> TreeMap("one" -> 1, "two" -> 2) == HashMap("one" -> 1, "two" -> 2)
    res0: Boolean = true
    

    Such a comparison would not, however, compile if you used === under either TypeCheckedTripleEquals or ConversionCheckedTripleEquals, because TreeMap and HashMap are not in a subtype/supertype relationship, nor does an implicit conversion by default exist between them:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TypeCheckedTripleEquals._
    import TypeCheckedTripleEquals._
    
    scala> TreeMap("one" -> 1, "two" -> 2) === HashMap("one" -> 1, "two" -> 2)
    <console>:16: error: types scala.collection.immutable.TreeMap[String,Int] and
      scala.collection.mutable.HashMap[String,Int] do not adhere to the equality constraint selected for
      the === and !== operators; the missing implicit parameter is of type
      org.scalactic.EqualityConstraint[scala.collection.immutable.TreeMap[String,Int],
      scala.collection.mutable.HashMap[String,Int]]
                  TreeMap("one" -> 1, "two" -> 2) === HashMap("one" -> 1, "two" -> 2)
                                                  ^
    

    If you mix or import the implicit conversion provided by MapEqualityConstraint, however, the comparison will be allowed:

    scala> import MapEqualityConstraints._
    import MapEqualityConstraints._
    
    scala> TreeMap("one" -> 1, "two" -> 2) === HashMap("one" -> 1, "two" -> 2)
    res2: Boolean = true
    

    The equality constraint provided by this trait requires that both left and right sides are subclasses of scala.collection.GenMap and that an EqualityConstraint can be found for both key types and both value types. In the example above, both the TreeMap and HashMap are subclasses of scala.collection.GenMap, and the regular TypeCheckedTripleEquals provides equality constraints for the key types, both of which are String, and value types, both of which are Int. By contrast, this trait would not allow a TreeMap[String, Int] to be compared against a HashMap[String, java.util.Date], because no equality constraint will exist between the value types Int and Date:

    scala> import java.util.Date
    import java.util.Date
    
    scala> TreeMap("one" -> 1, "two" -> 2) === HashMap("one" -> new Date, "two" -> new Date)
    <console>:20: error: types scala.collection.immutable.TreeMap[String,Int] and
      scala.collection.mutable.HashMap[String,java.util.Date] do not adhere to the equality constraint selected for
      the === and !== operators; the missing implicit parameter is of type
      org.scalactic.EqualityConstraint[scala.collection.immutable.TreeMap[String,Int],
      scala.collection.mutable.HashMap[String,java.util.Date]]
                  TreeMap("one" -> 1, "two" -> 2) === HashMap("one" -> new Date, "two" -> new Date)
                                                  ^
    

  14. trait NormMethods extends AnyRef

    Provides an implicit conversion that allows norm to be invoked on any value of type T for which an implicit Normalization[T] exists.

    Provides an implicit conversion that allows norm to be invoked on any value of type T for which an implicit Normalization[T] exists.

    Here's an example:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import StringNormalizations._
    import StringNormalizations._
    
    scala> implicit val stringNormalization = lowerCased and trimmed
    stringNormalization: org.scalactic.Uniformity[String] = [email protected]
    
    scala> import NormMethods._
    import NormMethods._
    
    scala> val s = " There "
    s: String = " There "
    
    scala> "Hey " + s + "!"
    res5: String = Hey  There !
    
    scala> "Hey " + s.norm + "!"
    res6: String = Hey there!
    

  15. trait Normalization[A] extends AnyRef

    Defines a custom way to normalize instances of a type.

    Defines a custom way to normalize instances of a type.

    For example, to normalize Doubles by truncating off any decimal part, you might write:

    import org.scalactic._
    
    val truncated =
      new Normalization[Double] {
       def normalized(d: Double) = d.floor
     }
    

    Given this definition you could use it with the Explicitly DSL like this:

    import org.scalatest._
    import Matchers._
    import TypeCheckedTripleEquals._
    
    (2.1 should === (2.0)) (after being truncated)
    

    Note that to use a Normalization with the Explicitly DSL, you'll need to use TypeCheckedTripleEquals. If you're just using plain-old TripleEquals, you'll need a Uniformity, a Normalization subclass.

    If you make the truncated val implicit and import or mix in the members of NormMethods, you can access the behavior by invoking .norm on Doubles.

    implicit val doubleNormalization = truncated
    import NormMethods._
    
    val d = 2.1
    d.norm // returns 2.0
    

    A

    the type whose normalization is being defined

  16. trait NormalizingEquality[A] extends Equality[A]

    An Equality[A] implementation that determines the equality of two objects by normalizing one or both objects, then comparing the results using an “after normalization” equality referenced from the afterNormalizationEquality member.

    An Equality[A] implementation that determines the equality of two objects by normalizing one or both objects, then comparing the results using an “after normalization” equality referenced from the afterNormalizationEquality member. By default, the afterNormalizationEquality is an instance of Equality.default[A].

    NormalizingEquality is returned by the Explicitly DSL's “after being” syntax, using for the afterNormalizationEquality the implicit Equality in scope for the type of Uniformity passed to being. Here's an example:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import Explicitly._
    import Explicitly._
    
    scala> import StringNormalizations._
    import StringNormalizations._
    
    scala> after being lowerCased
    res0: org.scalactic.NormalizingEquality[String] = ComposedNormalizingEquality(Equality.default,lowerCased)
    

  17. trait NormalizingEquivalence[A] extends Equivalence[A]

    An Equivalence[A] implementation that determines the equality of two objects by normalizing one or both objects, then comparing the results using an “after normalization” Equivalence referenced from the afterNormalizationEquivalence member.

    An Equivalence[A] implementation that determines the equality of two objects by normalizing one or both objects, then comparing the results using an “after normalization” Equivalence referenced from the afterNormalizationEquivalence member. By default, the afterNormalizationEquivalence is an instance of Equivalence.default[A].

    NormalizingEquivalence is returned by the Explicitly DSL's “after being” syntax, using for the afterNormalizationEquivalence the implicit Equivalence in scope for the type of Normalization passed to being. Here's an example:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import Explicitly._
    import Explicitly._
    
    scala> val lowerCased: Normalization[String] = StringNormalizations.lowerCased
    lowerCased: org.scalactic.Normalization[String] = lowerCased
    
    scala> after being lowerCased
    res0: org.scalactic.NormalizingEquivalence[String] = ComposedNormalizingEquivalence(Equality.default,lowerCased)
    

  18. trait OptionSugar extends AnyRef

    Trait providing an implicit class that adds a toOr method to Option, which converts Some to Good, None to Bad.

    Trait providing an implicit class that adds a toOr method to Option, which converts Some to Good, None to Bad.

    You can use the toOr method to record information about why a processing of nested Options resulted in None. For example, the following for expression results in None if either the passed optional Person is None or else if the contained optional age is None:

    scala> case class Person(name: String, age: Option[Int])
    defined class Person
    
    scala> def ageOf(person: Option[Person]) =
         |   for {
         |     per <- person
         |     age <- per.age
         |   } yield age
    ageOf: (person: Option[Person])Option[Int]
    
    scala> ageOf(Some(Person("Ralph", Some(32))))
    res0: Option[Int] = Some(32)
    
    scala> ageOf(Some(Person("Curt", None)))
    res3: Option[Int] = None
    
    scala> ageOf(None)
    res2: Option[Int] = None
    

    If you instead populate the for expression with Ors, supplying an error message or other "bad" value to the toOr method in case of None, you'll get an indication of which part failed if a None is encountered:

    scala> import OptionSugar._
    import OptionSugar._
    
    scala> def ageOf(person: Option[Person]) =
         |   for {
         |     per <- person toOr "no person here"
         |     age <- per.age toOr "ageless person"
         |   } yield age
    ageOf: (person: Option[Person])org.scalactic.Or[Int,String]
    
    scala> ageOf(Some(Person("Ralph", Some(32))))
    res1: org.scalactic.Or[Int,String] = Good(32)
    
    scala> ageOf(Some(Person("Curt", None)))
    res2: org.scalactic.Or[Int,String] = Bad(ageless person)
    
    scala> ageOf(None)
    res3: org.scalactic.Or[Int,String] = Bad(no person here)
    

  19. final class Present[A] extends AnyVal

    A wrapper class to allow any value to be used with for

    A wrapper class to allow any value to be used with for

    A

    the type of the underlying value

  20. trait Prettifier extends Serializable

    A function that given any object will produce a “pretty” string representation of that object, where “pretty” is in the eye of the implementer.

    A function that given any object will produce a “pretty” string representation of that object, where “pretty” is in the eye of the implementer.

    Scala's Any type declares a toString that will convert any object to a String representation. This String representation is primarily intended for programmers, and is usually sufficient. However, sometimes it can be helpful to provide an alternative implementation of toString for certain types. For example, the toString implementation on String prints out the value of the String:

    scala> "1".toString
    res0: String = 1
    

    If the error message that resulted from comparing Int 1 with String "1" in a ScalaTest assertion used toString, therefore, the error message would be:

    1 did not equal 1
    

    To make it quicker to figure out why the assertion failed, ScalaTest prettifies the objects involved in the error message. The default Prettifier will place double quotes on either side of a Strings toString result:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> Prettifier.default("1")
    res1: String = "1"
    

    Thus the error message resulting from comparing Int 1 with String "1", in a ScalaTest assertion is:

    1 did not equal "1"
    

    If you wish to prettify an object in production code, for example, to issue a profoundly clear debug message, you can use PrettyMethods and invoke pretty. Here's an example:

    scala> import PrettyMethods._
    import PrettyMethods._
    
    scala> 1.pretty
    res2: String = 1
    
    scala> "1".pretty
    res3: String = "1"
    

    For example, the default Prettifier, `Prettifier.default`, transforms:

    • Null to: null
    • Unit to: <() the Unit value>
    • String to: "string" (the toString result surrounded by double quotes)
    • Char to: 'c' (the toString result surrounded by single quotes)
    • Array to: Array("1", "2", "3")
    • scala.Some to: Some("3")
    • scala.util.Left to: Left("3")
    • scala.util.Right to: Right("3")
    • scala.util.Success to: Success("3")
    • org.scalactic.Good to: Good("3")
    • org.scalactic.Bad to: Bad("3")
    • org.scalactic.One to: One("3")
    • org.scalactic.Many to: Many("1", "2", "3")
    • scala.collection.GenTraversable to: List("1", "2", "3")
    • java.util.Collection to: ["1", "2", "3"]
    • java.util.Map to: {1="one", 2="two", 3="three"}

    For anything else, the default Prettifier returns the result of invoking toString.

    Note: Prettifier is not parameterized (i.e., Prettifier[T], where T is the type to prettify) because assertions (including matcher expressions) in ScalaTest would then need to look up Prettifiers implicitly by type. This would slow compilation even though most (let's guess 99.9%) of the time in practice assertions do not fail, and thus 99.9% of the time no error messages need to be generated. If no error messages are needed 99.9% of the time, no prettification is needed 99.9% of the time, so the slow down in compile time for the implicit look ups is unlikely to be worth the benefit. Only a few types in practice usually need prettification for testing error message purposes, and those will be covered by the default Prettifier. A future version of ScalaTest will provide a simple mechanism to replace the default Prettifier with a custom one when a test actually fails.

  21. trait PrettyMethods extends AnyRef

    Provides an implicit conversion that enables pretty to be invoked on any object, to transform that object into a String representation.

  22. case class PrettyPair(left: String, right: String, analysis: Option[String]) extends Product with Serializable
  23. trait Requirements extends AnyRef

    Trait that contains require, and requireState, and requireNonNull methods for checking pre-conditions that give descriptive error messages extracted via a macro.

    Trait that contains require, and requireState, and requireNonNull methods for checking pre-conditions that give descriptive error messages extracted via a macro.

    These methods of trait Requirements aim to improve error messages provided when a pre-condition check fails at runtime in production code. Although it is recommended practice to supply helpful error messages when doing pre-condition checks, often people don't. Instead of this:

    scala> val length = 5
    length: Int = 5
    
    scala> val idx = 6
    idx: Int = 6
    
    scala> require(idx >= 0 && idx <= length, "index, " + idx + ", was less than zero or greater than or equal to length, " + length)
    java.lang.IllegalArgumentException: requirement failed: index, 6, was less than zero or greater than or equal to length, 5
    	at scala.Predef$.require(Predef.scala:233)
    	...
    

    People write simply:

    scala> require(idx >= 0 && idx <= length)
    java.lang.IllegalArgumentException: requirement failed
    	at scala.Predef$.require(Predef.scala:221)
    	...
    

    Note that the detail message of the IllegalArgumentException thrown by the previous line of code is simply, "requirement failed". Such messages often end up in a log file or bug report, where a better error message can save time in debugging the problem. By importing the members of Requirements (or mixing in its companion trait), you'll get a more helpful error message extracted by a macro, whether or not a clue message is provided:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import Requirements._
    import Requirements._
    
    scala> require(idx >= 0 && idx <= length)
    java.lang.IllegalArgumentException: 6 was greater than or equal to 0, but 6 was not less than or equal to 5
    	at org.scalactic.Requirements$RequirementsHelper.macroRequire(Requirements.scala:56)
    	...
    
    scala> require(idx >= 0 && idx <= length, "(hopefully that helps)")
    java.lang.IllegalArgumentException: 6 was greater than or equal to 0, but 6 was not less than or equal to 5 (hopefully that helps)
    	at org.scalactic.Requirements$RequirementsHelper.macroRequire(Requirements.scala:56)
    	...
    

    The requireState method provides identical error messages to require, but throws IllegalStateException instead of IllegalArgumentException:

    scala> val connectionOpen = false
    connectionOpen: Boolean = false
    
    scala> requireState(connectionOpen)
    java.lang.IllegalStateException: connectionOpen was false
    	at org.scalactic.Requirements$RequirementsHelper.macroRequireState(Requirements.scala:71)
    	...
    

    Thus, whereas the require methods throw the Java platform's standard exception indicating a passed argument violated a precondition, IllegalArgumentException, the requireState methods throw the standard exception indicating an object's method was invoked when the object was in an inappropriate state for that method, IllegalStateException.

    The requireNonNull method takes one or more variables as arguments and throws NullArgumentException with an error messages that includes the variable names if any are null. Here's an example:

    scala> val e: String = null
    e: String = null
    
    scala> val f: java.util.Date = null
    f: java.util.Date = null
    
    scala> requireNonNull(a, b, c, d, e, f)
    org.scalactic.exceptions.NullArgumentException: e and f were null
    	at org.scalactic.Requirements$RequirementsHelper.macroRequireNonNull(Requirements.scala:101)
    	...
    

    Although trait Requirements can help you debug problems that occur in production, bear in mind that a much better alternative is to make it impossible for such events to occur at all. Use the type system to ensure that all pre-conditions are met so that the compiler can find broken pre-conditions and point them out with compiler error messages. When this is not possible or practical, however, trait Requirements is helpful.

  24. trait SeqEqualityConstraints extends AnyRef

    Provides an implicit method that loosens the equality constraint defined by TypeCheckedTripleEquals or ConversionCheckedTripleEquals for Scala Seqs to one that more closely matches Scala's approach to Seq equality.

    Provides an implicit method that loosens the equality constraint defined by TypeCheckedTripleEquals or ConversionCheckedTripleEquals for Scala Seqs to one that more closely matches Scala's approach to Seq equality.

    Scala's approach to Seq equality is that if both objects being compared are Seqs, the elements are compared to determine equality. This means you could compare an immutable Vector and a mutable ListBuffer for equality, for instance, and get true so long as the two Seqs contained the same elements in the same order. Here's an example:

    scala> import scala.collection.mutable.ListBuffer
    import scala.collection.mutable.ListBuffer
    
    scala> Vector(1, 2) == ListBuffer(1, 2)
    res0: Boolean = true
    

    Such a comparison would not, however, compile if you used === under either TypeCheckedTripleEquals or ConversionCheckedTripleEquals, because Vector and ListBuffer are not in a subtype/supertype relationship, nor does an implicit conversion by default exist between them:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TypeCheckedTripleEquals._
    import TypeCheckedTripleEquals._
    
    scala> Vector(1, 2) === ListBuffer(1, 2)
    <console>:16: error: types scala.collection.immutable.Vector[Int] and
      scala.collection.mutable.ListBuffer[Int] do not adhere to the equality constraint selected for
      the === and !== operators; the missing implicit parameter is of type
      org.scalactic.EqualityConstraint[scala.collection.immutable.Vector[Int],
      scala.collection.mutable.ListBuffer[Int]]
                  Vector(1, 2) === ListBuffer(1, 2)
                               ^
    

    If you mix or import the implicit conversion provided by SeqEqualityConstraint, however, the comparison will be allowed:

    scala> import SeqEqualityConstraints._
    import SeqEqualityConstraints._
    
    scala> Vector(1, 2) === ListBuffer(1, 2)
    res2: Boolean = true
    

    The equality constraint provided by this trait requires that both left and right sides are subclasses of scala.collection.GenSeq and that an EqualityConstraint can be found for the element types. In the example above, both the Vector and ListBuffer are subclasses of scala.collection.GenSeq, and the regular TypeCheckedTripleEquals provides equality constraints for the element types, both of which are Int. By contrast, this trait would not allow a Vector[Int] to be compared against a ListBuffer[java.util.Date], because no equality constraint will exist between the element types Int and Date:

    scala> import java.util.Date
    import java.util.Date
    
    scala> Vector(1, 2) === ListBuffer(new Date, new Date)
    <console>:20: error: types scala.collection.immutable.Vector[Int] and
      scala.collection.mutable.ListBuffer[java.util.Date] do not adhere to the equality constraint selected for
      the === and !== operators; the missing implicit parameter is of type
      org.scalactic.EqualityConstraint[scala.collection.immutable.Vector[Int],
      scala.collection.mutable.ListBuffer[java.util.Date]]
                  Vector(1, 2) === ListBuffer(new Date, new Date)
                               ^
    

  25. trait SetEqualityConstraints extends AnyRef

    Provides an implicit method that loosens the equality constraint defined by TypeCheckedTripleEquals or ConversionCheckedTripleEquals for Scala Sets to one that more closely matches Scala's approach to Set equality.

    Provides an implicit method that loosens the equality constraint defined by TypeCheckedTripleEquals or ConversionCheckedTripleEquals for Scala Sets to one that more closely matches Scala's approach to Set equality.

    Scala's approach to Set equality is that if both objects being compared are Sets, the elements are compared to determine equality. This means you could compare an immutable TreeSet and a mutable HashSet for equality, for instance, and get true so long as the two Sets contained the same elements in the same order. Here's an example:

    scala> import scala.collection.immutable.TreeSet
    import scala.collection.immutable.TreeSet
    
    scala> import scala.collection.mutable.HashSet
    import scala.collection.mutable.HashSet
    
    scala> TreeSet(1, 2) == HashSet(1, 2)
    res0: Boolean = true
    

    Such a comparison would not, however, compile if you used === under either TypeCheckedTripleEquals or ConversionCheckedTripleEquals, because TreeSet and HashSet are not in a subtype/supertype relationship, nor does an implicit conversion by default exist between them:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TypeCheckedTripleEquals._
    import TypeCheckedTripleEquals._
    
    scala> TreeSet(1, 2) === HashSet(1, 2)
    <console>:16: error: types scala.collection.immutable.TreeSet[Int] and
      scala.collection.mutable.HashSet[Int] do not adhere to the equality constraint selected for
      the === and !== operators; the missing implicit parameter is of type
      org.scalactic.EqualityConstraint[scala.collection.immutable.TreeSet[Int],
      scala.collection.mutable.HashSet[Int]]
                  TreeSet(1, 2) === HashSet(1, 2)
                                ^
    

    If you mix or import the implicit conversion provided by SetEqualityConstraint, however, the comparison will be allowed:

    scala> import SetEqualityConstraints._
    import SetEqualityConstraints._
    
    scala> TreeSet(1, 2) === HashSet(1, 2)
    res2: Boolean = true
    

    The equality constraint provided by this trait requires that both left and right sides are subclasses of scala.collection.GenSet and that an EqualityConstraint can be found for the element types. In the example above, both the TreeSet and HashSet are subclasses of scala.collection.GenSet, and the regular TypeCheckedTripleEquals provides equality constraints for the element types, both of which are Int. By contrast, this trait would not allow a TreeSet[Int] to be compared against a HashSet[java.util.Date], because no equality constraint will exist between the element types Int and Date:

    scala> import java.util.Date
    import java.util.Date
    
    scala> TreeSet(1, 2) === HashSet(new Date, new Date)
    <console>:20: error: types scala.collection.immutable.TreeSet[Int] and
      scala.collection.mutable.HashSet[java.util.Date] do not adhere to the equality constraint selected for
      the === and !== operators; the missing implicit parameter is of type
      org.scalactic.EqualityConstraint[scala.collection.immutable.TreeSet[Int],
      scala.collection.mutable.HashSet[java.util.Date]]
                  TreeSet(1, 2) === HashSet(new Date, new Date)
                                ^
    

  26. final case class Snapshot(name: String, value: Any) extends Product with Serializable

    Case class that stores the name and value of a variable or expression.

    Case class that stores the name and value of a variable or expression.

    See the main documentation for trait Snapshots for more information and examples.

    name

    the name of the expression

    value

    the value of the expression

  27. final class SnapshotSeq extends IndexedSeq[Snapshot]

    An IndexedSeq[Snapshot] providing toString and lines methods that can be useful for debug and log messages about program state.

    An IndexedSeq[Snapshot] providing toString and lines methods that can be useful for debug and log messages about program state.

    See the main documentation for trait Snapshots for more information and examples.

  28. trait Snapshots extends AnyRef

    Trait that provides a snap method that takes one or more arguments and results in a SnapshotSeq, whose toString lists the names and values of each argument.

    Trait that provides a snap method that takes one or more arguments and results in a SnapshotSeq, whose toString lists the names and values of each argument.

    The intended use case of this trait is to help you write debug and log messages that give a "snapshot" of program state. Here's an example:

    scala> import Snapshots._
    import Snapshots._
    
    scala> snap(a, b, c, d, e, f)
    res3: org.scalactic.SnapshotSeq = a was 1, b was 2, c was 3, d was 4, e was null, f was null
    

    SnapshotSeq offers a lines method that places each variable name/value pair on its own line:

    scala> snap(a, b, c, d, e, f).lines
    res4: String =
    a was 1
    b was 2
    c was 3
    d was 4
    e was null
    f was null
    

    Or, because a SnapshotSeq is a IndexedSeq[Snapshot], you can process it just like any other Seq, for example:

    scala> snap(a, b, c, d, e, f).mkString("Wow! ", ", and ", ". That's so awesome!")
    res6: String = Wow! a was 1, and b was 2, and c was 3, and d was 4, and e was null, and f was null. That's so awesome!
    

  29. trait StringNormalizations extends AnyRef

    Provides methods that produce Uniformity[String] instances for various ways to normalize strings for equality comparisons.

  30. trait TimesOnInt extends AnyRef

    Trait providing an implicit conversion that adds a times method to Ints that will repeat a given side-effecting operation multiple times.

    Trait providing an implicit conversion that adds a times method to Ints that will repeat a given side-effecting operation multiple times.

    Here's an example in which a friendly greeting is printed three times:

    3 times println("Hello again, world!")
    

    Running the above code would yield this output:

    Hello again, world!
    Hello again, world!
    Hello again, world!
    

    If you need to repeat a block of statements multiple times, just enclose them in parentheses, like this:

    2 times {
     print("Hello ")
     print("again, ")
     println("world!")
    }
    

    Running the above code would yield:

    Hello again, world!
    Hello again, world!
    

    This trait enables times to be invoked on 0 and any positive integer, but attempting to invoke times on a negative integer will result in an IllegalArgumentException.

  31. trait Tolerance extends AnyRef

    Trait containing an implicit conversion that adds a +- method to Numeric types, which enables spreads to be expressed in terms of a pivot and tolerance.

    Trait containing an implicit conversion that adds a +- method to Numeric types, which enables spreads to be expressed in terms of a pivot and tolerance.

    For example, the TripleEquals trait (and its type-checking siblings TypeCheckedTripleEquals and ConversionCheckedTripleEquals) enable you to write:

    a === (1.0 +- 0.1)
    

  32. trait TolerantNumerics extends AnyRef

    Provides Equality and Equivalence instances for Numeric types that compare for equality with a given tolerance.

    Provides Equality and Equivalence instances for Numeric types that compare for equality with a given tolerance.

    Here's an example:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TripleEquals._
    import TripleEquals._
    
    scala> 2.001 === 2.0
    res0: Boolean = false
    
    scala> implicit val doubleEquality = TolerantNumerics.tolerantDoubleEquality(0.01)
    doubleEquality: org.scalactic.Equality[Double] = [email protected]
    
    scala> 2.001 === 2.0
    res1: Boolean = true
    

  33. trait TraversableEqualityConstraints extends SeqEqualityConstraints with SetEqualityConstraints with MapEqualityConstraints

    Provides three implicit methods that loosen the equality constraint defined by TypeCheckedTripleEquals for Scala Traversables to one that more closely matches Scala's approach to Traversable equality.

    Provides three implicit methods that loosen the equality constraint defined by TypeCheckedTripleEquals for Scala Traversables to one that more closely matches Scala's approach to Traversable equality.

    Scala's approach to Traversable equality is that if the objects being compared are ether both Seqs, both Sets, or both Maps, the elements are compared to determine equality. This means you could compare an immutable Vector and a mutable ListBuffer for equality, for instance, and get true so long as the two Seqs contained the same elements in the same order. Here's an example:

    scala> import scala.collection.mutable.ListBuffer
    import scala.collection.mutable.ListBuffer
    
    scala> Vector(1, 2) == ListBuffer(1, 2)
    res0: Boolean = true
    

    Such a comparison would not, however, compile if you used === under TypeCheckedTripleEquals, because Vector and ListBuffer are not in a subtype/supertype relationship:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TypeCheckedTripleEquals._
    import TypeCheckedTripleEquals._
    
    scala> Vector(1, 2) === ListBuffer(1, 2)
    <console>:16: error: types scala.collection.immutable.Vector[Int] and
      scala.collection.mutable.ListBuffer[Int] do not adhere to the equality constraint selected for
      the === and !== operators; the missing implicit parameter is of type
      org.scalactic.CanEqual[scala.collection.immutable.Vector[Int],
      scala.collection.mutable.ListBuffer[Int]]
                  Vector(1, 2) === ListBuffer(1, 2)
                               ^
    

    If you mix or import the implicit conversion provided by TraversableEqualityConstraint, however, the comparison will be allowed:

    scala> import TraversableEqualityConstraints._
    import TraversableEqualityConstraints._
    
    scala> Vector(1, 2) === ListBuffer(1, 2)
    res2: Boolean = true
    

    The equality constraints provided by this trait require that left and right sides are both subclasses of either scala.collection.GenSeq, scala.collection.GenSet, or scala.collection.GenMap, and that an CanEqual can be found for the element types for Seq and Set, or the key and value types for Maps. In the example above, both the Vector and ListBuffer are subclasses of scala.collection.GenSeq, and the regular TypeCheckedTripleEquals provides equality constraints for the element types, both of which are Int. By contrast, this trait would not allow a Vector[Int] to be compared against a ListBuffer[java.util.Date], because no equality constraint will exist between the element types Int and Date:

    scala> import java.util.Date
    import java.util.Date
    
    scala> Vector(1, 2) === ListBuffer(new Date, new Date)
    <console>:20: error: types scala.collection.immutable.Vector[Int] and
      scala.collection.mutable.ListBuffer[java.util.Date] do not adhere to the equality constraint selected for
      the === and !== operators; the missing implicit parameter is of type
      org.scalactic.CanEqual[scala.collection.immutable.Vector[Int],
      scala.collection.mutable.ListBuffer[java.util.Date]]
                  Vector(1, 2) === ListBuffer(new Date, new Date)
                               ^
    

    This trait simply mixes together SeqEqualityConstraints, SetEqualityConstraints, and MapEqualityConstraints.

  34. trait TripleEquals extends TripleEqualsSupport

    Provides === and !== operators that return Boolean, delegate the equality determination to an Equality type class, and require no relationship between the types of the two values compared.

    Provides === and !== operators that return Boolean, delegate the equality determination to an Equality type class, and require no relationship between the types of the two values compared.

    Recommended Usage: Trait TripleEquals is useful (in both production and test code) when you need determine equality for a type of object differently than its equals method: either you can't change the equals method, or the equals method is sensible generally, but you are in a special situation where you need something else. You can use the SuperSafe Community Edition compiler plugin to get a compile-time safety check of types being compared with ===. In situations where you need a stricter type check, you can use TypeCheckedTripleEquals.

    This trait will override or hide implicit methods defined by its sibling traits, ConversionCheckedTripleEquals or TypeCheckedTripleEquals, and can therefore be used to temporarily turn of type checking in a limited scope. Here's an example, in which TypeCheckedTripleEquals will cause a compiler error:

    import org.scalactic._
    import TypeCheckedTripleEquals._
    
    object Example {
    
      def cmp(a: Int, b: Long): Int = {
        if (a === b) 0       // This line won't compile
        else if (a < b) -1
        else 1
      }
    
     def cmp(s: String, t: String): Int = {
       if (s === t) 0
       else if (s < t) -1
       else 1
     }
    }
    

    Because Int and Long are not in a subtype/supertype relationship, comparing 1 and 1L in the context of TypeCheckedTripleEquals will generate a compiler error:

    Example.scala:9: error: types Int and Long do not adhere to the equality constraint selected for
    the === and !== operators; they must either be in a subtype/supertype relationship, or, if
    ConversionCheckedTripleEquals is in force, implicitly convertible in one direction or the other;
    the missing implicit parameter is of type org.scalactic.Constraint[Int,Long]
        if (a === b) 0      // This line won't compile
              ^
    one error found
    

    You can “turn off” the type checking locally by importing the members of TripleEquals in a limited scope:

    package org.scalactic.examples.tripleequals
    
    import org.scalactic._
    import TypeCheckedTripleEquals._
    
    object Example {
    
      def cmp(a: Int, b: Long): Int = {
        import TripleEquals._
        if (a === b) 0
        else if (a < b) -1
        else 1
      }
    
     def cmp(s: String, t: String): Int = {
       if (s === t) 0
       else if (s < t) -1
       else 1
     }
    }
    

    With the above change, the Example.scala file compiles fine. Type checking is turned off only inside the first cmp method that takes an Int and a Long. TypeCheckedTripleEquals is still enforcing its type constraint, for example, for the s === t expression in the other overloaded cmp method that takes strings.

    Because the methods in TripleEquals (and its siblings)override all the methods defined in supertype TripleEqualsSupport, you can achieve the same kind of nested tuning of equality constraints whether you mix in traits, import from companion objects, or use some combination of both.

    In short, you should be able to select a primary constraint level via either a mixin or import, then change that in nested scopes however you want, again either through a mixin or import, without getting any implicit conversion ambiguity. The innermost constraint level in scope will always be in force.

  35. trait TripleEqualsSupport extends AnyRef

    Trait that defines abstract methods used to enforce compile-time type constraints for equality comparisons, and defines === and !== operators used by matchers.

    Trait that defines abstract methods used to enforce compile-time type constraints for equality comparisons, and defines === and !== operators used by matchers.

    The abstract methods of this trait are selectively implemented as implicit by subclasses to enable a spectrum of type constraints for the === and !== operators. As an illustration, if in the expression, a === b, the type of a is A and b is B, the following three levels of compile-time checking can be obtained from TripleEqualsSupport subtraits:

    Unchecked - A and B can be any two types. This constraint level is available from subtrait TripleEquals.

    Statically-checked - A must be a subtype of B, or vice versa, or must cooperate such that the equality laws stated in the equals contract are preserved. This (intermediate) constraint level is available by using subtrait TripleEquals and installing the SuperSafe Community Edition Scala compiler plugin.

    Type-checked - A must be a subtype of B, or vice versa. (Both A and B can be the same type, because a type is considered a subtype of itself.) This (strongest) constraint level is available from subtrait TypeCheckedTripleEquals.

    This trait defines all methods that need to be defined implicitly by the subtraits so that if multiple subtraits are used together, the inner-most subtrait in scope can not only enable the implicits it needs by overriding or hiding those methods (currently-in-scope as regular, non-implicit methods) and making them implicit, it can also disable any implicits enabled by its sibling subtraits in enclosing scopes. For example, if your test class mixes in TypeCheckedTripleEquals, inside your test class the following methods will be implicit:

    • convertToCheckingEqualizer
    • typeCheckedConstraint
    • lowPriorityTypeCheckedConstraint
    • convertEquivalenceToAToBConstraint
    • convertEquivalenceToBToAConstraint

    If in the body of a test you want to turn off the type checking, you can import the members of TripleEquals in the body of that test. This will not only hide non-implicit methods convertToEqualizer unconstrainedEquality of TypeCheckedTripleEquals, replacing those with implicit ones defined in TripleEquals, it will also hide the three methods made implicit in TypeCheckedTripleEquals (and listed above), replacing them by non-implicit ones.

    In short, you should be able to select a primary constraint level via either a mixin or import, then change that in nested scopes however you want, again either through a mixin or import, without getting any implicit conversion ambiguity. The innermost constraint level in scope will always be in force.

  36. trait TrySugar extends AnyRef

    Trait providing an implicit class that adds a toOr method to Try, which converts Success to Good, and Failure to Bad, as well as a validating method, which takes one or more validation functions and returns either the same Try if either the Try had already failed or its value passes all the functions, or ValidationFailedException containing an error message describing the first validation that failed.

    Trait providing an implicit class that adds a toOr method to Try, which converts Success to Good, and Failure to Bad, as well as a validating method, which takes one or more validation functions and returns either the same Try if either the Try had already failed or its value passes all the functions, or ValidationFailedException containing an error message describing the first validation that failed.

    Here's an example validation method, which passes if the given Int is evenly divisible by 10 (i.e., the result will be Pass). If the value does not pass this test, the result is a Fail containing a helpful error message string.

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TrySugar._
    import TrySugar._
    
    scala> import scala.util.Try
    import scala.util.Try
    
    scala> def isRound(i: Int): Validation[ErrorMessage] =
         |   if (i % 10 == 0) Pass else Fail(i + " was not a round number")
    isRound: (i: Int)org.scalactic.Validation[org.scalactic.ErrorMessage]
    

    Validation will be attempted on a successful Try. If the validation succeeds, the resulting Try will be the same successful Try with the same value. (A "validation" only transforms the Try if the validation fails, otherwise it is the same Try. The only difference is its value has now been proven valid.) In the following example, a successful Try[Int] with the value 100 passes the validation (which checks whether 100 is evenly divisible by 10), therefore the result of the validating call is the same successful Try with the same value.

    scala> val try100 = Try(100)
    try100: scala.util.Try[Int] = Success(100)
    
    scala> val round100 = try100.validating(isRound)
    round100: scala.util.Try[Int] = Success(100)
    

    If validation fails, the successful Try will be transformed into a failed one, with a ValidationFailedException that contains the error message returned by the validation function. In the following example, 42 fails the validation because it is not evenly divisible by 10:

    scala> val try42 = Try(42)
    try42: scala.util.Try[Int] = Success(42)
    
    scala> val round42 = try42.validating(isRound)
    round42: scala.util.Try[Int] = Failure(org.scalactic.exceptions.ValidationFailedException: 42 was not a round number)
    

    If validating is called on a failed Try, it just returns the same failed Try:

    scala> val tryEx = Try[Int] { throw new Exception("oops!") }
    tryEx: scala.util.Try[Int] = Failure(java.lang.Exception: oops!)
    
    scala> val roundEx = tryEx.validating(isRound)
    roundEx: scala.util.Try[Int] = Failure(java.lang.Exception: oops!)
    

    The validating method accepts one or more validation functions. If you pass more than one, they will be tried in order up until the first failure, whose error message will appear in the ValidationFailedException. In other words, validating will short circuit at the first error and return that. It will not accumulate errors. For example, the following validation will short circuit after the isDivBy3 function fails:

    scala> def isDivBy3(i: Int): Validation[ErrorMessage] =
         |   if (i % 3 == 0) Pass else Fail(i + " was not divisible by 3")
    isDivBy3: (i: Int)org.scalactic.Validation[org.scalactic.ErrorMessage]
    
    scala> def isAnswerToLifeTheUniverseAndEverything(i: Int): Validation[ErrorMessage] =
         |   if (i == 42) Pass else Fail(i + " did not equal 42")
    isAnswerToLifeTheUniverseAndEverything: (i: Int)org.scalactic.Validation[org.scalactic.ErrorMessage]
    
    scala> try100.validating(isRound, isDivBy3, isAnswerToLifeTheUniverseAndEverything)
    res0: scala.util.Try[Int] = Failure(org.scalactic.exceptions.ValidationFailedException: 100 was not divisible by 3)
    

    Here are some examples of the toOr method:

    scala> try100.toOr
    res1: org.scalactic.Or[Int,Throwable] = Good(100)
    
    scala> tryEx.toOr
    res2: org.scalactic.Or[Int,Throwable] = Bad(java.lang.Exception: oops!)
    

  37. trait TypeCheckedTripleEquals extends LowPriorityTypeCheckedConstraint

    Provides === and !== operators that return Boolean, delegate the equality determination to an Equality type class, and require the types of the two values compared to be in a subtype/supertype relationship.

    Provides === and !== operators that return Boolean, delegate the equality determination to an Equality type class, and require the types of the two values compared to be in a subtype/supertype relationship.

    Recommended Usage: Trait TypeCheckedTripleEquals is useful (in both production and test code) when you need a stricter type check than is provided by the SuperSafe Community Edition compiler plugin for TripleEquals. For example, if you are developing a library that uses advanced features of Scala's type system, you may want to enforce in your tests that the types appearing in equality comparisons match exactly.

    By default under TripleEquals, any use of === will compile, just like the == operator:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TripleEquals._
    import TripleEquals._
    
    scala> 1L === 1 // A Long can equal an Int
    res0: Boolean = true
    
    scala> List(1, 2, 3) === Vector(1, 2, 3) // A List can equal a Vector
    res1: Boolean = true
    
    scala> "hi" === 1 // Likely a bug, because a String can never equal an Int
    res2: Boolean = false
    

    With SuperSafe Community Edition installed, the first two expressions above will be allowed to compile, but the third (which represents a likely bug) will not:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TripleEquals._
    import TripleEquals._
    
    scala> 1L === 1
    res0: Boolean = true
    
    scala> List(1, 2, 3) === Vector(1, 2, 3)
    res1: Boolean = true
    
    scala> "hi" === 1 // SuperSafe catches the bug at compile time
    <console>:17: error: [Artima SuperSafe] Values of type String and Int may not be compared with
    the === operator. If you really want to compare them for equality, configure Artima SuperSafe to allow
    those types to be compared for equality.  For more information on this kind of error, see:
    http://www.artima.com/supersafe_user_guide.html#safer-equality
           "hi" === 1
                ^
    

    By contrast, TypeCheckedTripleEquals will prevent any of the above three expressions from compiling:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TypeCheckedTripleEquals._
    import TypeCheckedTripleEquals._
    
    scala> 1L === 1
    <console>:17: error: types Long and Int do not adhere to the type constraint selected for
        the === and !== operators; the missing implicit parameter is of type org.scalactic.CanEqual[Long,Int]
           1L === 1
              ^
    
    scala> List(1, 2, 3) === Vector(1, 2, 3)
    <console>:17: error: types List[Int] and scala.collection.immutable.Vector[Int] do not adhere
        to the type constraint selected for the === and !== operators; the missing implicit parameter is
        of type org.scalactic.CanEqual[List[Int],scala.collection.immutable.Vector[Int]]
           List(1, 2, 3) === Vector(1, 2, 3)
                         ^
    
    scala> "hi" === 1
    <console>:17: error: types String and Int do not adhere to the type constraint selected for
        the === and !== operators; the missing implicit parameter is of type org.scalactic.CanEqual[String,Int]
           "hi" === 1
                ^
    

    Trait TypeCheckedTripleEquals rejects comparisons of types Int and Long, List[Int] and Vector[Int], and String and Int, because none have a direct subtype/supertype relationship. To compare two types that are unrelated by inheritance under TypeCheckedTripleEquals, you could convert one of them to the other type (because a type is both a subtype and supertype of itself). Here's an example:

    scala> 1L === 1.toLong // Now both sides are Long
    res0: Boolean = true
    
    scala> List(1, 2, 3) === Vector(1, 2, 3).toList // Now both sides are List[Int]
    res1: Boolean = true
    

    Nevertheless, a better (and the recommended) way to deal with this situation is to use a widening type ascription. A type ascription is simply a colon and a type placed next to a variable, usually surrounded by parentheses. For example, because AnyVal is a common supertype of Int and Long, you could solve the type error by widening the type of one side or the other to AnyVal. Because AnyVal is a supertype of both Int and Long, the type constraint will be satisfied:

    scala> 1 === (1L: AnyVal)
    res2: Boolean = true
    
    scala> (1: AnyVal) === 1L
    res3: Boolean = true
    

    Similarly, since Seq[Int] is a common supertype of both Vector[Int] and List[Int], the type constraint can be satisfied by widening either to their common supertype, Seq[Int]:

    scala> List(1, 2, 3) === (Vector(1, 2, 3): Seq[Int])
    res4: Boolean = true
    
    scala> (List(1, 2, 3): Seq[Int]) === Vector(1, 2, 3)
    res5: Boolean = true
    

    The primary intended use case for TypeCheckedTripleEquals is to enable tests to be very strict about which types can compared for equality, but it can also be used with production code where this level of strictness is desired.

    Forcing implicit conversions before equality checks

    You can also use a type ascription to force an implicit conversion before a value participates in an equality comparison. For example, although JavaConversions provides an implicit conversion between java.util.Set and scala.collection.mutable.Set, under TypeCheckedTripleEquals an equality comparison between those two types will not be allowed:

    scala> import collection.JavaConversions._
    import collection.JavaConversions._
    
    scala> import collection.mutable
    import collection.mutable
    
    scala> import TypeCheckedTripleEquals._
    import TypeCheckedTripleEquals._
    
    scala> mutable.Set.empty[String] === new java.util.HashSet[String]
    <console>:36: error: types scala.collection.mutable.Set[String] and java.util.HashSet[String] do not
        adhere to the type constraint selected for the === and !== operators; the missing implicit parameter
        is of type org.scalactic.CanEqual[scala.collection.mutable.Set[String],java.util.HashSet[String]]
           mutable.Set.empty[String] === new java.util.HashSet[String]
                                     ^
    

    To force an implicit conversion of the Java HashSet to a Scala mutable.Set, after which the type constraint will be satisfied, you can use a type ascription:

    scala> mutable.Set.empty[String] === (new java.util.HashSet[String]: mutable.Set[String])
    res0: Boolean = true
    

    Scoping equality policies

    This trait will override or hide implicit methods defined by TripleEquals and can therefore be used to temporarily turn on or off type checking in a limited scope. Here's an example, in which TypeCheckedTripleEquals will cause a compiler error:

    import org.scalactic._
    import TypeCheckedTripleEquals._
    
    object Example {
    
      def cmp(a: Int, b: Long): Int = {
        if (a === b) 0       // This line won't compile
        else if (a < b) -1
        else 1
      }
    
     def cmp(s: String, t: String): Int = {
       if (s === t) 0
       else if (s < t) -1
       else 1
     }
    }
    

    Because Int and Long are not in a subtype/supertype relationship, comparing 1 and 1L in the context of TypeCheckedTripleEquals will generate a compiler error:

    Example.scala:9: error: types Int and Long do not adhere to the type constraint selected
      for the === and !== operators; the missing implicit parameter is of
      type org.scalactic.CanEqual[Int,Long]
            if (a === b) 0       // This line won't compile
                  ^
    one error found
    

    You can “relax” the type checking locally by importing the members of TripleEquals in a limited scope:

    package org.scalactic.examples.conversioncheckedtripleequals
    
    import org.scalactic._
    import TypeCheckedTripleEquals._
    
    object Example {
    
      def cmp(a: Int, b: Long): Int = {
        import TripleEquals._
        if (a === b) 0
        else if (a < b) -1
        else 1
      }
    
     def cmp(s: String, t: String): Int = {
       if (s === t) 0
       else if (s < t) -1
       else 1
     }
    }
    

    With the above change, the Example.scala file compiles fine. The strict checking is disabled only inside the first cmp method that takes an Int and a Long. TypeCheckedTripleEquals is still enforcing its type constraint, for example, for the s === t expression in the other overloaded cmp method that takes strings.

    Because the methods TripleEquals and TypeCheckedTripleEquals override all the methods defined in supertype TripleEqualsSupport, you can achieve the same kind of nested tuning of equality constraints whether you mix in traits, import from companion objects, or use some combination of both.

    In short, you should be able to select a primary constraint level via either a mixin or import, then change that in nested scopes however you want, again either through a mixin or import, without getting any implicit conversion ambiguity. The innermost constraint level in scope will always be in force.

  38. trait Uniformity[A] extends Normalization[A]

    Defines a custom way to normalize instances of a type that can also handle normalization of that type when passed as Any.

    Defines a custom way to normalize instances of a type that can also handle normalization of that type when passed as Any.

    For example, to normalize Doubles by truncating off any decimal part, you might write:

    import org.scalactic._
    
    val truncated =
      new Uniformity[Double] {
       def normalized(d: Double) = d.floor
       def normalizedCanHandle(o: Any) = o.isInstanceOf[Double]
       def normalizedOrSame(o: Any): Any =
         o match {
           case d: Double => normalized(d)
           case _ => o
         }
     }
    

    Given this definition you could use it with the Explicitly DSL like this:

    import org.scalatest._
    import Matchers._
    
    2.1 should equal (2.0) (after being truncated)
    

    If you make the truncated val implicit and import or mix in the members of NormMethods, you can access the behavior by invoking .norm on Doubles.

    implicit val doubleUniformity = truncated
    import NormMethods._
    
    val d = 2.1
    d.norm // returns 2.0
    

    Note that by creating a Uniformity rather than just an instance of its supertype, Normalization, it can be used more generally. For example, Uniformitys allow you to the Explicitly DSL with TripleEquals, whereas Normalizations require TypeCheckedTripleEquals. Uniformitys also enable you to use the Explicitly DSL with ScalaTest's should ===, equal, and contain matcher syntax, whereas a plain Normalization can only be used with should ===, and only under TypeCheckedTripleEquals.

    A

    the type whose uniformity is being defined

Deprecated Type Members

  1. type Chain[+T] = NonEmptyList[T]
    Annotations
    @deprecated
    Deprecated

    Chain has been deprecated and will be removed in a future version of Scalactic. Please use org.scalactic.anyvals.NonEmptyList instead.

  2. type Constraint[A, B] = CanEqual[A, B]
    Annotations
    @deprecated
    Deprecated

    Constraint has been deprecated and will be removed in a future version of Scalactic. Please use its new name, CanEqual, instead.

  3. trait ConversionCheckedTripleEquals extends LowPriorityConversionCheckedConstraint

    Trait ConversionCheckedTripleEquals has been deprecated and will be removed in a future version of Scalactic. Please use TypeCheckedTripleEquals with a type annotation instead.

    Trait ConversionCheckedTripleEquals has been deprecated and will be removed in a future version of Scalactic. Please use TypeCheckedTripleEquals with a type annotation instead.

    Trait ConversionCheckedTripleEquals has been deprecated because code that uses it can break if you change the equality policy to TripleEquals. For example, because JavaConversions provides an implicit conversion between java.util.Set and scala.collection.mutable.Set, an equality comparison under ConversionCheckedTripleEquals can yield true:

    scala> import collection.JavaConversions._
    import collection.JavaConversions._
    
    scala> import collection.mutable
    import collection.mutable
    
    scala> import ConversionCheckedTripleEquals._
    import ConversionCheckedTripleEquals._
    
    scala> mutable.Set.empty[String] === new java.util.HashSet[String]
    res0: Boolean = true
    

    If code written under ConversionCheckedTripleEquals is left unchanged, but the policy is changed to TripleEquals, the equality comparison will now yield false:

    scala>  import TripleEquals._
    import TripleEquals._
    
    scala> mutable.Set.empty[String] === (new java.util.HashSet[String])
    res1: Boolean = false
    

    The above change from true to false happens without any warning or complaint from the compiler. Thus it is quite error prone. A better way to achieve equality comparisons after an implicit conversion is to do so explicitly, by forcing the implicit conversion via a type annotation (following an expression with a colon and the desired type). Here's an example:

    scala> mutable.Set.empty[String] === (new java.util.HashSet[String]: mutable.Set[String])
    res3: Boolean = true
    

    To get rid of the deprecation warning, you can use TypeCheckedTripleEquals instead of ConversionCheckedTripleEquals, and add explicit type annotations where needed:

    scala>  import TypeCheckedTripleEquals._
    import TypeCheckedTripleEquals._
    
    scala> mutable.Set.empty[String] === new java.util.HashSet[String]
    <console>:27: error: types scala.collection.mutable.Set[String] and java.util.HashSet[String] do not adhere to the type constraint selected for the === and !== operators; the missing implicit parameter is of type org.scalactic.CanEqual[scala.collection.mutable.Set[String],java.util.HashSet[String]]
           mutable.Set.empty[String] === (new java.util.HashSet[String])
                                     ^
    
    scala> mutable.Set.empty[String] === (new java.util.HashSet[String]: mutable.Set[String])
    res4: Boolean = true
    

    Annotations
    @deprecated
    Deprecated

    ConversionCheckedTripleEquals has been deprecated and will be removed in a future version of Scalactic. Please use TypeCheckedTripleEquals with a type annotation instead

  4. trait DeprecatedPrettyMethods extends AnyRef

    This trait is the 2.2.6 PrettyMethods trait renamed to DeprecatedPrettyMethods. It is a quick way to get old code working again that defined an implicit PrettifierConfig, but before the deprecation cycle is over please change the implicit PrettifierConfig to an implicit Prettifier. Provides an implicit conversion that enables pretty to be invoked on any object, to transform that object into a String representation.

    This trait is the 2.2.6 PrettyMethods trait renamed to DeprecatedPrettyMethods. It is a quick way to get old code working again that defined an implicit PrettifierConfig, but before the deprecation cycle is over please change the implicit PrettifierConfig to an implicit Prettifier. Provides an implicit conversion that enables pretty to be invoked on any object, to transform that object into a String representation.

    Annotations
    @deprecated
    Deprecated

    Please use PrettyMethods instead.

  5. trait LowPriorityConversionCheckedConstraint extends TripleEqualsSupport

    Provides an implicit conversion that will be applied only if a higher-priority implicit conversion declared a subtrait is not applicable.

    Provides an implicit conversion that will be applied only if a higher-priority implicit conversion declared a subtrait is not applicable.

    This trait, which supports ConversionCheckedTripleEquals, will no longer be necessary once the deprecation cycle for ConversionCheckedTripleEquals has completed. At that time it will be removed.

    The purpose of this trait is to make the === operator symetric. In other words, a === invocation will be allowed if an implicit conversion exists in either direction. For example, the implicit widening conversion from Int to Long will be applied on the left hand side in this expression:

    1 === 1L
    

    But in the next expression, it will be applied on the right hand side:

    1L === 1
    

    The first expression above is enabled by the implicit conversion conversionCheckedConstraint in trait ConversionCheckedTripleEquals. The second expression above is enabled by the implicit conversion lowPriorityConversionCheckedConstraint in this trait.

    The reason these two implicit methods aren't both declared in the subtraits is that if implicit conversions were available in both directions, they would conflict. By placing one of them in this supertrait, the higher priority conversion will be selected.

    Annotations
    @deprecated
    Deprecated

    Trait LowPriorityConversionCheckedConstraint is deprecated and will be removed after the deprecation period of ConversionCheckedTripleEquals has completed.

Value Members

  1. val ScalacticVersion: String

    The version number of Scalactic.

    The version number of Scalactic.

    returns

    the Scalactic version number.

  2. def attempt[R](f: => R): Or[R, Throwable]

    Returns the result of evaluating the given block f, wrapped in a Good, or if an exception is thrown, the Throwable, wrapped in a Bad.

    Returns the result of evaluating the given block f, wrapped in a Good, or if an exception is thrown, the Throwable, wrapped in a Bad.

    Here are some examples:

    scala> import org.scalactic._
    import org.scalactic._
    
    scala> attempt { 2 / 1 }
    res0: org.scalactic.Or[Int,Throwable] = Good(2)
    
    scala> attempt { 2 / 0 }
    res1: org.scalactic.Or[Int,Throwable] = Bad(java.lang.ArithmeticException: / by zero)
    

    f

    the block to attempt to evaluate

    returns

    the result of evaluating the block, wrapped in a Good, or the thrown exception, wrapped in a Bad

  3. object Accumulation extends Accumulation

    Companion object to trait Accumulation that allows Accumulation's members to be imported rather than mixed in, and also contains nested traits used by implicit conversions declared in trait Accumulations.

    Companion object to trait Accumulation that allows Accumulation's members to be imported rather than mixed in, and also contains nested traits used by implicit conversions declared in trait Accumulations.

    For more information and examples, see the Accumulating errors with Or section of the main documentation for class Or.

  4. object Bool

    Bool companion object that provides factory methods to create different sub types of Bool

    Bool companion object that provides factory methods to create different sub types of Bool

    Bool is used by code generated from BooleanMacro (which AssertionsMacro and RequirementsMacro uses), it needs to be public so that the generated code can be compiled. It is expected that ScalaTest users would ever need to use Bool directly.

  5. object Catcher

    Companion object for Catcher that provides a factory method for creating Throwable extractors.

  6. object DefaultEquality
  7. object Equality

    Companion object for trait Equality that provides factory methods for producing Equality instances.

  8. object Equivalence

    Companion object for trait Equivalence that provides a factory method for producing default Equivalence instances.

  9. object Explicitly extends Explicitly

    Companion object for Explicitly, which enables the Scalactic explicitly DSL to be imported rather than mixed in, like this:

    Companion object for Explicitly, which enables the Scalactic explicitly DSL to be imported rather than mixed in, like this:

    import org.scalactic._
    import Explicitly._
    
    // Use the explicitly DSL...
    

  10. object FutureSugar extends FutureSugar

    Companion object for FutureSugar enabling its members to be imported as an alternative to mixing them in.

  11. object MapEqualityConstraints extends MapEqualityConstraints

    Companion object that facilitates the importing of MapEqualityConstraints members as an alternative to mixing it in.

    Companion object that facilitates the importing of MapEqualityConstraints members as an alternative to mixing it in. One use case is to import MapEqualityConstraints members so you can use them in the Scala interpreter.

  12. object NormMethods extends NormMethods

    Companion object for NormMethods enabling its members to be imported as an alternative to mixing them in.

  13. object OptionSugar extends OptionSugar

    Companion object for OptionSugar enabling its members to be imported as an alternative to mixing them in.

  14. object Present
  15. object Prettifier extends Serializable

    Companion object for Prettifier that provides a default Prettifier implementation.

  16. object PrettyMethods extends PrettyMethods

    Companion object for trait PrettyMethods enabling its members to be imported as an alternative to mixing them in.

  17. object Requirements extends Requirements

    Companion object that facilitates the importing of Requirements members as an alternative to mixing it in.

    Companion object that facilitates the importing of Requirements members as an alternative to mixing it in. One use case is to import Requirements members so you can use them in the Scala interpreter:

    $scala -classpath scalatest.jar
    Welcome to Scala version 2.10.3.final (Java HotSpot(TM) Client VM, Java xxxxxx).
    Type in expressions to have them evaluated.
    Type :help for more information.
     
    scala> import org.scalactic.Requirements._
    import org.scalactic.Requirements._
     
    scala> val a = 1
    a: Int = 1
     
    scala> require(a == 2)
    java.lang.IllegalArgumentException: 1 did not equal 2
         at org.scalactic.Requirements$RequirementsHelper.macroRequire(Requirements.scala:56)
         at .<init>(<console>:20)
         at .<clinit>(<console>)
         at .<init>(<console>:7)
         at .<clinit>(<console>)
         at $print(<console>)
         at sun.reflect.NativeMethodAccessorImpl.invoke...
    

  18. object SeqEqualityConstraints extends SeqEqualityConstraints

    Companion object that facilitates the importing of SeqEqualityConstraints members as an alternative to mixing it in.

    Companion object that facilitates the importing of SeqEqualityConstraints members as an alternative to mixing it in. One use case is to import SeqEqualityConstraints members so you can use them in the Scala interpreter.

  19. object SetEqualityConstraints extends SetEqualityConstraints

    Companion object that facilitates the importing of SetEqualityConstraints members as an alternative to mixing it in.

    Companion object that facilitates the importing of SetEqualityConstraints members as an alternative to mixing it in. One use case is to import SetEqualityConstraints members so you can use them in the Scala interpreter.

  20. object SnapshotSeq
  21. object Snapshots extends Snapshots

    Companion object that facilitates the importing of Snapshots members as an alternative to mixing it in.

    Companion object that facilitates the importing of Snapshots members as an alternative to mixing it in. One use case is to import Snapshots members so you can use them in the Scala interpreter:

    $scala -classpath scalatest.jar
    Welcome to Scala version 2.10.3.final (Java HotSpot(TM) Client VM, Java xxxxxx).
    Type in expressions to have them evaluated.
    Type :help for more information.
     
    scala> import org.scalactic.Snapshots._
    import org.scalatest.Snapshots._
     
    scala> val a = 8
    a: Int = 8
     
    scala> snap(a)
    res0: scala.collection.immutable.Vector[org.scalactic.Snapshot] = Vector(a = 8)
    

  22. object StringNormalizations extends StringNormalizations

    Companion object to trait StringNormalizations that provides an alternative to mixing it in.

  23. object TimesOnInt extends TimesOnInt

    Companion object that facilitates the importing of TimesOnInt members as an alternative to mixing it in.

    Companion object that facilitates the importing of TimesOnInt members as an alternative to mixing it in.

    One use case of this companion object is to import TimesOnInt members so you can use them in the Scala interpreter. Here's an example:

    scala> import org.scalatest.TimesOnInt._
    import org.scalatest.TimesOnInt._
    
    scala> 3 times println("Hello again, world!")
    Hello again, world!
    Hello again, world!
    Hello again, world!
    

  24. object Tolerance extends Tolerance

    Companion object to trait Tolerance that facilitates the importing of Tolerance members as an alternative to mixing it in.

    Companion object to trait Tolerance that facilitates the importing of Tolerance members as an alternative to mixing it in. One use case is to import Tolerance members so you can use them in the Scala interpreter:

    $ scala -classpath scalactic.jar
    Welcome to Scala version 2.10.0
    Type in expressions to have them evaluated.
    Type :help for more information.
    
    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import Tolerance._
    import Tolerance._
    
    scala> 1.0 +- 0.1
    res0: org.scalactic.TripleEqualsSupport.Spread[Double] = Spread(1.0,0.1)
    

  25. object TolerantNumerics extends TolerantNumerics

    Companion object for TolerantNumerics that enables its members to be imported as an alternative to mixing them in.

  26. object TraversableEqualityConstraints extends TraversableEqualityConstraints

    Companion object that facilitates the importing of TraversableEqualityConstraints members as an alternative to mixing it in.

    Companion object that facilitates the importing of TraversableEqualityConstraints members as an alternative to mixing it in. One use case is to import TraversableEqualityConstraints members so you can use them in the Scala interpreter.

  27. object TripleEquals extends TripleEquals

    Companion object to trait TripleEquals that facilitates the importing of TripleEquals members as an alternative to mixing it in.

    Companion object to trait TripleEquals that facilitates the importing of TripleEquals members as an alternative to mixing it in. One use case is to import TripleEquals members so you can use them in the Scala interpreter:

    $ scala -classpath scalatest.jar
    Welcome to Scala version 2.10.0
    Type in expressions to have them evaluated.
    Type :help for more information.
    
    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TripleEquals._
    import TripleEquals._
    
    scala> 1 + 1 === 2
    res0: Boolean = true
    

  28. object TripleEqualsSupport
  29. object TrySugar extends TrySugar

    Companion object for TrySugar enabling its members to be imported as an alternative to mixing them in.

  30. object TypeCheckedTripleEquals extends TypeCheckedTripleEquals

    Companion object to trait TypeCheckedTripleEquals that facilitates the importing of TypeCheckedTripleEquals members as an alternative to mixing it in.

    Companion object to trait TypeCheckedTripleEquals that facilitates the importing of TypeCheckedTripleEquals members as an alternative to mixing it in. One use case is to import TypeCheckedTripleEquals members so you can use them in the Scala interpreter:

    $ scala -classpath scalatest.jar
    Welcome to Scala version 2.10.0
    Type in expressions to have them evaluated.
    Type :help for more information.
    
    scala> import org.scalactic._
    import org.scalactic._
    
    scala> import TypeCheckedTripleEquals._
    import TypeCheckedTripleEquals._
    
    scala> 1 + 1 === 2
    res0: Boolean = true
    

Deprecated Value Members

  1. val Chain: NonEmptyList.type
    Annotations
    @deprecated
    Deprecated

    Chain has been deprecated and will be removed in a future version of Scalactic. Please use org.scalactic.anyvals.NonEmptyList instead.

  2. val End: scalactic.anyvals.End.type
    Annotations
    @deprecated
    Deprecated

    End has been deprecated and will be removed in a future version of Scalactic. Please use org.scalactic.anyvals.End instead.

  3. object ConversionCheckedTripleEquals extends ConversionCheckedTripleEquals

    Object ConversionCheckedTripleEquals has been deprecated and will be removed in a future version of Scalactic. Please use TypeCheckedTripleEquals with a type annotation instead.

    Object ConversionCheckedTripleEquals has been deprecated and will be removed in a future version of Scalactic. Please use TypeCheckedTripleEquals with a type annotation instead.

    For more information and examples, please see the documentation for the ConversionCheckedTripleEqals companion trait.

    Annotations
    @deprecated
    Deprecated

    ConversionCheckedTripleEquals has been deprecated and will be removed in a future version of Scalactic. Please use TypeCheckedTripleEquals with a type annotation instead

  4. object DeprecatedPrettyMethods extends DeprecatedPrettyMethods

    This object is the 2.2.6 PrettyMethods object renamed to DeprecatedPrettyMethods. Please change DeprecatedPrettyMethods to PrettyMethods, as DeprecatedPrettyMethods is deprecated and will be removed in a future version of ScalaTest.

    This object is the 2.2.6 PrettyMethods object renamed to DeprecatedPrettyMethods. Please change DeprecatedPrettyMethods to PrettyMethods, as DeprecatedPrettyMethods is deprecated and will be removed in a future version of ScalaTest.

    Annotations
    @deprecated
    Deprecated

    Please use PrettyMethods instead.

Inherited from AnyRef

Inherited from Any

Ungrouped