org.scalatest.enablers.Length.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-RC2 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.scalatest.enablers

/**
 * Supertrait for Length typeclasses.
 *
 * 
 * Trait Length is a typeclass trait for objects that can be queried for length.
 * Objects of type T for which an implicit Length[T] is available can be used
 * with the should have length syntax.
 * In other words, this trait enables you to use the length checking
 * syntax with arbitrary objects. As an example, consider
 * java.net.DatagramPacket, which has a getLength method. By default, this
 * can't be used with ScalaTest's have length syntax. 
 * 
 *
 *  * scala> import java.net.DatagramPacket
 * import java.net.DatagramPacket
 * 
 * scala> import org.scalatest.Matchers._
 * import org.scalatest.Matchers._
 *
 * scala> val dp = new DatagramPacket(Array(0x0, 0x1, 0x2, 0x3), 4)
 * dp: java.net.DatagramPacket = java.net.DatagramPacket@54906181
 * 
 * scala> dp.getLength
 * res0: Int = 4
 *
 * scala> dp should have length 4
 * :13: error: could not find implicit value for parameter ev: org.scalatest.matchers.ShouldMatchers.Extent[java.net.DatagramPacket]
 *          dp should have length 4
 *             ^
 *
 * scala> implicit val lengthOfDatagramPacket =
 *     |   new Length[DatagramPacket] {
 *     |     def lengthOf(dp: DatagramPacket): Long = dp.getLength
 *     |   }
 * lengthOfDatagramPacket: java.lang.Object with org.scalatest.matchers.ShouldMatchers.Length[java.net.DatagramPacket] = $anon$1@550c6b37
 *
 * scala> dp should have length 4
 *
 * scala> dp should have length 3
 * org.scalatest.exceptions.TestFailedException:  java.net.DatagramPacket@54906181 had length 4, not length 3
 * 
 *
 * @author Bill Venners
 */
trait Length[T] {

  /**
   * Returns the length of the passed object.
   *
   * @param obj the object whose length to return
   * @return the length of the passed object
   */
  def lengthOf(obj: T): Long
}

/**
 * Companion object for Length that provides implicit implementations for the following types:
 *
 * 
 * scala.collection.GenSeq
 * String
 * Array
 * java.util.Collection
 * arbitary object with a length() method that returns Int
 * arbitary object with a parameterless length method that returns Int
 * arbitary object with a getLength() method that returns Int
 * arbitary object with a parameterless getLength method that returns Int
 * arbitary object with a length() method that returns Long
 * arbitary object with a parameterless length method that returns Long
 * arbitary object with a getLength() method that returns Long
 * arbitary object with a parameterless getLength method that returns Long
 * 
 */
object Length {

  /**
   * Enable Length implementation for java.util.List
   *
   * @tparam JLIST any subtype of java.util.List
   * @return Length[JLIST] that supports java.util.List in have length syntax
   */
  implicit def lengthOfJavaList[JLIST <: java.util.List[_]]: Length[JLIST] = 
    new Length[JLIST] {
      def lengthOf(javaList: JLIST): Long = javaList.size
    }

  /**
   * Enable Length implementation for scala.collection.GenSeq
   *
   * @tparam SEQ any subtype of scala.collection.GenSeq
   * @return Length[SEQ] that supports scala.collection.GenSeq in have length syntax
   */
  implicit def lengthOfGenSeq[SEQ <: scala.collection.GenSeq[_]]: Length[SEQ] = 
    new Length[SEQ] {
      def lengthOf(seq: SEQ): Long = seq.length
    }

  /**
   * Enable Length implementation for Array
   *
   * @tparam E the type of the element in the Array
   * @return Length[Array[E]] that supports Array in have length syntax
   */
  implicit def lengthOfArray[E]: Length[Array[E]] = 
    new Length[Array[E]] {
      def lengthOf(arr: Array[E]): Long = arr.length
    }

  /**
   * Enable Length implementation for String
   *
   * @return Length[String] that supports String in have length syntax
   */
  implicit val lengthOfString: Length[String] = 
    new Length[String] {
      def lengthOf(str: String): Long = str.length
    }

  import scala.language.reflectiveCalls

  /**
   * Enable Length implementation for arbitary object with length() method that returns Int.
   *
   * @tparam T any type with length() method that returns Int
   * @return Length[T] that supports T in have length syntax
   */
  implicit def lengthOfAnyRefWithLengthMethodForInt[T <: AnyRef { def length(): Int}]: Length[T] = 
    new Length[T] {
      def lengthOf(obj: T): Long = obj.length
    }

  /**
   * Enable Length implementation for arbitary object with parameterless length method that returns Int.
   *
   * @tparam T any type with parameterless length method that returns Int
   * @return Length[T] that supports T in have length syntax
   */
  implicit def lengthOfAnyRefWithParameterlessLengthMethodForInt[T <: AnyRef { def length: Int}]: Length[T] = 
    new Length[T] {
      def lengthOf(obj: T): Long = obj.length
    }

  /**
   * Enable Length implementation for arbitary object with getLength() method that returns Int.
   *
   * @tparam T any type with getLength() method that returns Int
   * @return Length[T] that supports T in have length syntax
   */
  implicit def lengthOfAnyRefWithGetLengthMethodForInt[T <: AnyRef { def getLength(): Int}]: Length[T] = 
    new Length[T] {
      def lengthOf(obj: T): Long = obj.getLength
    }

  /**
   * Enable Length implementation for arbitary object with parameterless getLength method that returns Int.
   *
   * @tparam T any type with parameterless getLength method that returns Int
   * @return Length[T] that supports T in have length syntax
   */
  implicit def lengthOfAnyRefWithParameterlessGetLengthMethodForInt[T <: AnyRef { def getLength: Int}]: Length[T] = 
    new Length[T] {
      def lengthOf(obj: T): Long = obj.getLength
    }

  /**
   * Enable Length implementation for arbitary object with length() method that returns Long.
   *
   * @tparam T any type with length() method that returns Long
   * @return Length[T] that supports T in have length syntax
   */
  implicit def lengthOfAnyRefWithLengthMethodForLong[T <: AnyRef { def length(): Long}]: Length[T] = 
    new Length[T] {
      def lengthOf(obj: T): Long = obj.length
    }

  /**
   * Enable Length implementation for arbitary object with parameterless length method that returns Long.
   *
   * @tparam T any type with parameterless length method that returns Long
   * @return Length[T] that supports T in have length syntax
   */
  implicit def lengthOfAnyRefWithParameterlessLengthMethodForLong[T <: AnyRef { def length: Long}]: Length[T] = 
    new Length[T] {
      def lengthOf(obj: T): Long = obj.length
    }

  /**
   * Enable Length implementation for arbitary object with getLength() method that returns Long.
   *
   * @tparam T any type with getLength() method that returns Long
   * @return Length[T] that supports T in have length syntax
   */
  implicit def lengthOfAnyRefWithGetLengthMethodForLong[T <: AnyRef { def getLength(): Long}]: Length[T] = 
    new Length[T] {
      def lengthOf(obj: T): Long = obj.getLength
    }

  /**
   * Enable Length implementation for arbitary object with parameterless getLength method that returns Long.
   *
   * @tparam T any type with parameterless getLength method that returns Long
   * @return Length[T] that supports T in have length syntax
   */
  implicit def lengthOfAnyRefWithParameterlessGetLengthMethodForLong[T <: AnyRef { def getLength: Long}]: Length[T] = 
    new Length[T] {
      def lengthOf(obj: T): Long = obj.getLength
    }
}