org.scalactic.DefaultEquality.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of scalatest-app_3 Show documentation
scalatest-app
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.scalactic

import org.scalactic.anyvals.NonEmptyArray

/**
 * A default Equality type class implementation (which can be used for any type) whose
 * areEqual method compares the passed objects with ==, calling .deep
 * first on any passed object that is an array.
 * 
 */
private[scalactic] final class DefaultEquality[A] extends Equality[A] {

  /**
   * Indicates whether the objects passed as a and b are equal by invoking == on a
   * passing in b, treating arrays specially by invoking .deep on a and/or b if they
   * are arrays, and using the result or results of invoking .deep in the equality check.
   *
   * @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)
   */
  def areEqual(a: A, b: Any): Boolean = {
    DefaultEquality.areEqualComparingArraysStructurally(a, b)
  }

  override def toString: String = "Equality.default"
}

object DefaultEquality {

  import ArrayHelper.deep

  private[org] def areEqualComparingArraysStructurally(left: Any, right: Any): Boolean = {
    // Prior to 2.0 this only called .deep if both sides were arrays. Loosened it
    // when nearing 2.0.M6 to call .deep if either left or right side is an array.
    // TODO: this is the same algo as in scalactic.DefaultEquality. Put that one in
    // a singleton and use it in both places.
    left match {
      case leftArray: Array[_] =>
        right match {
          case rightArray: Array[_] => deep(leftArray) == deep(rightArray)
          case rightNonEmptyArray: NonEmptyArray[_] => deep(leftArray) == deep(rightNonEmptyArray.toArray)
          case _ => deep(leftArray) == right
        }
      case leftNonEmptyArray: NonEmptyArray[_] =>
        right match {
          case rightArray: Array[_] => deep(leftNonEmptyArray.toArray) == deep(rightArray)
          case rightNonEmptyArray: NonEmptyArray[_] => deep(leftNonEmptyArray.toArray) == deep(rightNonEmptyArray.toArray)
          case _ => deep(leftNonEmptyArray.toArray) == right
        }

      case other => {
        right match {
          case rightArray: Array[_] => left == deep(rightArray)
          case rightNonEmptyArray: NonEmptyArray[_] => left == deep(rightNonEmptyArray.toArray)
          case _ => left == right
        }
      }
    }
  }

}