scalatestCoreDotty/org.scalatest.enablers/AggregatingStandardImplicits

AggregatingStandardImplicits

trait AggregatingStandardImplicits extends AggregatingJavaImplicits
class Object
trait Matchable
class Any
object Aggregating.type

Implicits

Implicits

implicit def aggregatingNatureOfArray[E](implicit equality: Equality[E]): Aggregating[Array[E]]

Implicit to support Aggregating nature of Array.

Implicit to support Aggregating nature of Array.

Type parameters:
E

the type of the element in the Array

Value parameters:
equality

Equality type class that is used to check equality of element in the Array

Returns:

Aggregating[Array[E]] that supports Array in relevant contain syntax

implicit def aggregatingNatureOfEvery[E](implicit equality: Equality[E]): Aggregating[Every[E]]

Implicit to support Aggregating nature of Every.

Implicit to support Aggregating nature of Every.

Type parameters:
E

the type of the element in the Every

Value parameters:
equality

Equality type class that is used to check equality of element in the Every

Returns:

Aggregating[Every[E]] that supports Every in relevant contain syntax

implicit def aggregatingNatureOfGenTraversable[E, TRAV <: (Iterable)](implicit equality: Equality[E]): Aggregating[TRAV[E]]

Implicit to support Aggregating nature of GenTraversable.

Implicit to support Aggregating nature of GenTraversable.

Type parameters:
E

the type of the element in the GenTraversable

TRAV

any subtype of GenTraversable

Value parameters:
equality

Equality type class that is used to check equality of element in the GenTraversable

Returns:

Aggregating[TRAV[E]] that supports GenTraversable in relevant contain syntax

implicit def aggregatingNatureOfString(implicit equality: Equality[Char]): Aggregating[String]

Implicit to support Aggregating nature of String.

Implicit to support Aggregating nature of String.

Value parameters:
equality

Equality type class that is used to check equality of Char in the String

Returns:

Aggregating[String] that supports String in relevant contain syntax

implicit def convertEqualityToArrayAggregating[E](equality: Equality[E]): Aggregating[Array[E]]

Implicit conversion that converts an Equality of type E into Aggregating of type Array[E]. This is required to support the explicit Equality syntax, for example:

Implicit conversion that converts an Equality of type E into Aggregating of type Array[E]. This is required to support the explicit Equality syntax, for example:

(Array("hi") should contain ("HI")) (after being lowerCased)

(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Aggregating[Array[String]].

Type parameters:
E

type of elements in the Array

Value parameters:
equality

Equality of type E

Returns:

Aggregating of type Array[E]

implicit def convertEqualityToEveryAggregating[E](equality: Equality[E]): Aggregating[Every[E]]

Implicit conversion that converts an Equality of type E into Aggregating of type Every[E]. This is required to support the explicit Equality syntax, for example:

Implicit conversion that converts an Equality of type E into Aggregating of type Every[E]. This is required to support the explicit Equality syntax, for example:

(Every("hi") should contain ("HI")) (after being lowerCased)

(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Aggregating[Every[String]].

Type parameters:
E

type of elements in the Every

Value parameters:
equality

Equality of type E

Returns:

Aggregating of type Every[E]

implicit def convertEqualityToGenTraversableAggregating[E, TRAV <: (Iterable)](equality: Equality[E]): Aggregating[TRAV[E]]

Implicit conversion that converts an Equality of type E into Aggregating of type TRAV[E], where TRAV is a subtype of GenTraversable. This is required to support the explicit Equality syntax, for example:

Implicit conversion that converts an Equality of type E into Aggregating of type TRAV[E], where TRAV is a subtype of GenTraversable. This is required to support the explicit Equality syntax, for example:

(List("hi") should contain ("HI")) (after being lowerCased)

(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Aggregating[List[String]].

Type parameters:
E

type of elements in the GenTraversable

TRAV

subtype of GenTraversable

Value parameters:
equality

Equality of type E

Returns:

Aggregating of type TRAV[E]

implicit def convertEqualityToStringAggregating(equality: Equality[Char]): Aggregating[String]

Implicit conversion that converts an Equality of type Char into Aggregating of type String. This is required to support the explicit Equality syntax, for example:

Implicit conversion that converts an Equality of type Char into Aggregating of type String. This is required to support the explicit Equality syntax, for example:

// lowerCased needs to be implemented as Normalization[Char]
("hi hello" should contain ('E')) (after being lowerCased)

(after being lowerCased) will returns an Equality[Char] and this implicit conversion will convert it into Aggregating[String].

Value parameters:
equality

Equality of type Char

Returns:

Aggregating of type String

Inherited implicits

implicit def aggregatingNatureOfJavaCollection[E, JCOL <: (Collection)](implicit equality: Equality[E]): Aggregating[JCOL[E]]

Implicit to support Aggregating nature of java.util.Collection.

Implicit to support Aggregating nature of java.util.Collection.

Type parameters:
E

the type of the element in the java.util.Collection

JCOL

any subtype of java.util.Collection

Value parameters:
equality

Equality type class that is used to check equality of element in the java.util.Collection

Returns:

Aggregating[JCOL[E]] that supports java.util.Collection in relevant contain syntax

Inherited from:
AggregatingJavaImplicits
implicit def aggregatingNatureOfJavaMap[K, V, JMAP <: (Map)](implicit equality: Equality[Entry[K, V]]): Aggregating[JMAP[K, V]]

Implicit to support Aggregating nature of java.util.Map.

Implicit to support Aggregating nature of java.util.Map.

Type parameters:
JMAP

any subtype of java.util.Map

K

the type of the key in the java.util.Map

V

the type of the value in the java.util.Map

Value parameters:
equality

Equality type class that is used to check equality of entry in the java.util.Map

Returns:

Aggregating[JMAP[K, V]] that supports java.util.Map in relevant contain syntax

Inherited from:
AggregatingJavaImplicits
implicit def convertEqualityToJavaCollectionAggregating[E, JCOL <: (Collection)](equality: Equality[E]): Aggregating[JCOL[E]]

Implicit conversion that converts an Equality of type E into Aggregating of type JCOL[E], where JCOL is a subtype of java.util.Collection. This is required to support the explicit Equality syntax, for example:

Implicit conversion that converts an Equality of type E into Aggregating of type JCOL[E], where JCOL is a subtype of java.util.Collection. This is required to support the explicit Equality syntax, for example:

val javaList = new java.util.ArrayList[String]()
javaList.add("hi")
(javaList should contain ("HI")) (after being lowerCased)

(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Aggregating[java.util.ArrayList[String]].

Type parameters:
E

type of elements in the java.util.Collection

JCOL

subtype of java.util.Collection

Value parameters:
equality

Equality of type E

Returns:

Aggregating of type JCOL[E]

Inherited from:
AggregatingJavaImplicits
implicit def convertEqualityToJavaMapAggregating[K, V, JMAP <: (Map)](equality: Equality[Entry[K, V]]): Aggregating[JMAP[K, V]]

Implicit conversion that converts an Equality of type java.util.Map.Entry[K, V] into Aggregating of type JMAP[K, V], where JMAP is a subtype of java.util.Map. This is required to support the explicit Equality syntax, for example:

Implicit conversion that converts an Equality of type java.util.Map.Entry[K, V] into Aggregating of type JMAP[K, V], where JMAP is a subtype of java.util.Map. This is required to support the explicit Equality syntax, for example:

val javaMap = new java.util.HashMap[Int, String]()
javaMap.put(1, "one")
// lowerCased needs to be implemented as Normalization[java.util.Map.Entry[K, V]]
(javaMap should contain (Entry(1, "ONE"))) (after being lowerCased)

(after being lowerCased) will returns an java.util.Map.Entry[Int, String] and this implicit conversion will convert it into Aggregating[java.util.HashMap[Int, String]].

Type parameters:
JMAP

any subtype of java.util.Map

K

the type of the key in the java.util.Map

V

the type of the value in the java.util.Map

Value parameters:
equality

Equality of type java.util.Map.Entry[K, V]

Returns:

Aggregating of type JMAP[K, V]

Inherited from:
AggregatingJavaImplicits