org.scalautils.CheckingEqualizer.scala Maven / Gradle / Ivy
Show all versions of scalatest_2.9.0 Show documentation
/*
* Copyright 2001-2008 Artima, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.scalautils
/**
* Class used via an implicit conversion to enable any two objects to be compared with
* === in assertions in tests. For example:
*
*
* assert(a === b)
*
*
*
* The benefit of using assert(a === b) rather than assert(a == b) is
* that a TestFailedException produced by the former will include the values of a and b
* in its detail message.
* The implicit method that performs the conversion from Any to Equalizer is
* convertToEqualizer in trait Assertions.
*
*
*
* In case you're not familiar with how implicit conversions work in Scala, here's a quick explanation.
* The convertToEqualizer method in Assertions is defined as an "implicit" method that takes an
* Any, which means you can pass in any object, and it will convert it to an Equalizer.
* The Equalizer has === defined. Most objects don't have === defined as a method
* on them. Take two Strings, for example:
*
*
*
* assert("hello" === "world")
*
*
*
* Given this code, the Scala compiler looks for an === method on class String, because that's the class of
* "hello". String doesn't define ===, so the compiler looks for an implicit conversion from
* String to something that does have an === method, and it finds the convertToEqualizer method. It
* then rewrites the code to this:
*
*
*
* assert(convertToEqualizer("hello").===("world"))
*
*
*
* So inside a Suite (which mixes in Assertions, === will work on anything. The only
* situation in which the implicit conversion wouldn't
* happen is on types that have an === method already defined.
*
*
*
* The primary constructor takes one object, left, whose type is being converted to Equalizer. The left
* value may be a null reference, because this is allowed by Scala's == operator.
*
*
* @param left An object to convert to Equalizer, which represents the left value
* of an assertion.
*
* @author Bill Venners
*/
class CheckingEqualizer[L](left: L) {
def ===[R](right: R)(implicit constraint: EqualityConstraint[L, R]): Boolean = constraint.areEqual(left, right)
def !==[R](right: R)(implicit constraint: EqualityConstraint[L, R]): Boolean = !constraint.areEqual(left, right)
def ===(interval: Interval[L]): Boolean = if (interval != null) interval.isWithin(left) else left == interval
def !==(interval: Interval[L]): Boolean = if (interval != null) !interval.isWithin(left) else left != interval
}