Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.specs2.matcher.MapMatchers.scala Maven / Gradle / Ivy
package org.specs2
package matcher
import text.Quote._
import text.Plural._
import MatchResult._
import scalaz._
import Scalaz._
/**
* Matchers for Maps
*/
trait MapMatchers extends MapBaseMatchers with MapBeHaveMatchers
object MapMatchers extends MapMatchers
private[specs2]
trait MapBaseMatchers {
/** matches if map.contains(k) */
def haveKey[K](k: K) = haveKeys(k)
/** matches if map.contains(k) forall key k */
def haveKeys[K](keys: K*) = new Matcher[Iterable[(K, Any)]] {
def apply[S <: Iterable[(K, Any)]](map: Expectable[S]) = {
lazy val missing = keys.filterNot(map.value.map(_._1).toSeq.contains)
result(missing.isEmpty,
map.description+s" has the ${"key".plural(keys)} "+q(keys.mkString(", ")),
map.description+s" doesn't have the ${"key".plural(missing)} "+q(missing.mkString(", ")),
map)
}
override def not = new Matcher[Iterable[(K, Any)]] {
def apply[S <: Iterable[(K, Any)]](map: Expectable[S]) = {
lazy val existing = map.value.map(_._1).filter(keys.contains)
result(existing.isEmpty,
map.description+s" doesn't have the ${"key".plural(keys)}"+q(keys),
map.description+s" has the ${"key".plural(existing)} "+q(existing.mkString(", ")),
map)
}
}
}
/** matches if map contains a pair (key, value) with value == v */
def haveValue[V](v: V) = haveValues(v)
/** matches if map contains a pair (key, value) with value == v for all value v*/
def haveValues[V](values: V*) = new Matcher[Iterable[(Any, V)]] {
def apply[S <: Iterable[(Any, V)]](map: Expectable[S]) = {
lazy val missing = values.filterNot(map.value.map(_._2).toSeq.contains)
result(missing.isEmpty,
map.description+s" has the ${"value".plural(values)} "+q(values.mkString(", ")),
map.description+s" doesn't have the ${"value".plural(missing)} "+q(missing.mkString(", ")),
map)
}
override def not = new Matcher[Iterable[(Any, V)]] {
def apply[S <: Iterable[(Any, V)]](map: Expectable[S]) = {
lazy val existing = map.value.map(_._2).filter(values.contains)
result(existing.isEmpty,
map.description+s" doesn't have the ${"value".plural(values)} "+q(values.mkString(", ")),
map.description+s" has the ${"value".plural(existing)} "+q(existing.mkString(", ")),
map)
}
}
}
/** matches if map contains a pair (key, value) == (k, v) */
def havePair[K, V](p: (K, V)) = havePairs(p)
/** matches if map contains all the specified pairs */
def havePairs[K, V](pairs: (K, V)*) = new Matcher[Iterable[(K, V)]] {
def apply[S <: Iterable[(K, V)]](map: Expectable[S]) = {
lazy val missing = pairs.filterNot(map.value.toSeq.contains)
result(missing.isEmpty,
map.description+s" has the ${"pair".plural(pairs)} "+q(pairs.mkString(", ")),
map.description+s" doesn't have the ${"pair".plural(missing)} "+q(missing.mkString(", ")),
map)
}
override def not = new Matcher[Iterable[(K, V)]] {
def apply[S <: Iterable[(K, V)]](map: Expectable[S]) = {
lazy val existing = map.value.filter(pairs.contains)
result(existing.isEmpty,
map.description+s" doesn't have the ${"pair".plural(pairs)} "+q(pairs.mkString(", ")),
map.description+s" has the ${"pair".plural(existing)} "+q(existing.mkString(", ")),
map)
}
}
}
/** matches if the partial function is defined at those values */
def beDefinedAt[K](values: K*) = new Matcher[PartialFunction[K, Any]] {
def apply[S <: PartialFunction[K, Any]](f: Expectable[S]) = {
val isDefined = values.map(v => (v, f.value.isDefinedAt(v)))
val undefined = isDefined.filter(!_._2).map(_._1)
result(isDefined.map(_._2).forall(_ == true),
f.optionalDescription.getOrElse("the function") + noun(" is defined for the value").plural(values.size) +
" " + q(values.mkString(", ")),
f.optionalDescription.getOrElse("the function") +
noun(" is not defined for the value").plural(undefined.size) + " " +
q(undefined.mkString(", ")), f)
}
}
/** matches if the partial function is defined at those values and return expected values */
def beDefinedBy[K, V](values: (K, V)*) = new Matcher[PartialFunction[K, V]] {
def apply[S <: PartialFunction[K, V]](f: Expectable[S]) = {
val isDefined = values.map(v => (v, f.value.isDefinedAt(v._1) && f.value(v._1) == v._2))
val undefined = isDefined.filter(!_._2).map(_._1)
result(isDefined.map(_._2).forall(_ == true),
f.optionalDescription.getOrElse("the function") + noun(" is defined by the value").plural(values.size) + " " + q(values.mkString(", ")),
f.optionalDescription.getOrElse("the function") + noun(" is not defined by the value").plural(undefined.size) + " " + q(undefined.mkString(", ")),
f)
}
}
}
private[specs2]
trait MapBeHaveMatchers { outer: MapBaseMatchers =>
implicit def toMapKeyResultMatcher[K](result: MatchResult[Iterable[(K, Any)]]) = new MapKeyResultMatcher(result)
class MapKeyResultMatcher[K](result: MatchResult[Iterable[(K, Any)]]) {
def key(k: K) = result(outer.haveKey(k))
def keys(ks: K*) = result(outer.haveKeys(ks:_*))
def haveKey(k: K) = result(outer.haveKey(k))
def haveKeys(ks: K*) = result(outer.haveKeys(ks:_*))
}
implicit def toMapValueResultMatcher[V](result: MatchResult[Iterable[(Any, V)]]) = new MapValueResultMatcher(result)
class MapValueResultMatcher[V](result: MatchResult[Iterable[(Any, V)]]) {
def value(v: V) = result(outer.haveValue(v))
def values(vs: V*) = result(outer.haveValues(vs:_*))
def haveValue(v: V) = result(outer.haveValue(v))
def haveValues(vs: V*) = result(outer.haveValues(vs:_*))
}
implicit def toMapResultMatcher[K, V](result: MatchResult[Iterable[(K, V)]]) = new MapResultMatcher(result)
class MapResultMatcher[K, V](result: MatchResult[Iterable[(K, V)]]) {
def pair(p: (K, V)) = result(outer.havePair(p))
def pairs(pairs: (K, V)*) = result(outer.havePairs(pairs:_*))
def havePair(p: (K, V)) = result(outer.havePair(p))
def havePairs(pairs: (K, V)*) = result(outer.havePairs(pairs:_*))
}
implicit def toPartialFunctionResultMatcher[K, V](result: MatchResult[PartialFunction[K, V]]) = new PartialFunctionResultMatcher(result)
class PartialFunctionResultMatcher[K, V](result: MatchResult[PartialFunction[K, V]]) {
def definedAt(values: K*) = result(outer.beDefinedAt(values:_*))
def beDefinedAt(values: K*) = result(outer.beDefinedAt(values:_*))
def definedBy(values: (K, V)*) = result(outer.beDefinedBy(values:_*))
def beDefinedBy(values: (K, V)*) = result(outer.beDefinedBy(values:_*))
}
def key[K](k: K) = haveKey(k)
def keys[K](ks: K*) = haveKeys(ks:_*)
def value[V](v: V) = haveValue(v)
def values[V](vs: V*) = haveValues(vs:_*)
def pair[K, V](p: (K, V)) = havePair(p)
def pairs[K, V](pairs: (K, V)*) = havePairs(pairs:_*)
def definedAt[K](values: K*) = beDefinedAt(values:_*)
def definedBy[K, V](values: (K, V)*) = beDefinedBy(values:_*)
}
