org.scalautils.NormMethods.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of scalatest_2.11.0-M5 Show documentation
ScalaTest is a free, open-source testing toolkit for Scala and Java programmers.
The newest version!
/*
 * Copyright 2001-2013 Artima, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.scalautils

/**
 * Defines a custom way to determine equality for a type.
 *
 * 
 * For example, here's how you could define equality between Doubles such that
 * a tolerance of ± 0.01 is allowed:
 * 
 *
 *  * class TolerantDoubleEquality extends Equality[Double] {
 *
 *   private val Tol = 0.01
 *
 *   def areEqual(a: Double, b: Any): Boolean = {
 *     b match {
 *       case bDouble: Double => (a <= bDouble + Tol) && (a >= bDouble - Tol)
 *       case _ => false
 *     }
 *   }
 * }
 * 
 *
 * 
 * If an implicit instance of TolerantDoubleEquality is in scope, it will be
 * used by ScalaTest's === operators and its should equal and should === matcher
 * syntax. Here's an example:
 * 
 *
 *  * $ scala -cp target/jar_contents/
 * Welcome to Scala version 2.10.0 (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_33).
 * Type in expressions to have them evaluated.
 * Type :help for more information.

 * scala> import org.scalautils._
 * import org.scalautils._

 * scala> class TolerantDoubleEquality extends Equality[Double] {
 *      | 
 *      |   private val Tol = 0.01
 *      | 
 *      |   def areEqual(a: Double, b: Any): Boolean = {
 *      |     b match {
 *      |       case bDouble: Double => (a >= bDouble + Tol) && (a >= bDouble - Tol)
 *      |       case _ => false
 *      |     }
 *      |   }
 *      | }
 * defined class TolerantDoubleEquality
 *
 * scala> import TripleEquals._
 * import TripleEquals._
 *
 * scala> 2.0 === 2.001
 * res0: Boolean = false
 *
 * scala> implicit val tolerantDoubleEquality = new TolerantDoubleEquality
 * tolerantDoubleEquality: TolerantDoubleEquality = TolerantDoubleEquality@70c13c17
 *
 * scala> 2.0 === 2.001
 * res1: Boolean = true
 * 
 *
 * 
 * Note: The Equality type class was inspired in part by the Equal type class of the 
 * scalaz project.
 * 
 *
 * @tparam A the type whose equality is being customized
 */
trait NormMethods {

  final class Normalizer[T](o: T)(implicit normalization: Normalization[T]) {
    def norm: T = normalization.normalized(o)
  }

  /**
   * Indicates whether the objects passed as a and b are equal.
   *
   * @param a a left-hand-side object being compared with another (right-hand-side one) for equality (e.g., a == b)
   * @param b a right-hand-side object being compared with another (left-hand-side one) for equality (e.g., a == b)
   * @return true if the passed objects are "equal," as defined by this Equality instance
   */
  implicit def convertToNormalizer[T](o: T)(implicit normalization: Normalization[T]): Normalizer[T] = new Normalizer[T](o)
} 

object NormMethods extends NormMethods