scalatestCoreDottyJS/org.scalatest.enablers/Sequencing

Sequencing

object Sequencing

Companion object for Sequencing that provides implicit implementations for the following types:

  • scala.collection.GenSeq

  • scala.collection.SortedSet

  • scala.collection.SortedMap

  • Array

  • java.util.List

  • java.util.SortedSet

  • java.util.SortedMap

  • String

Companion:
class
class Object
trait Matchable
class Any

Implicits

Implicits

implicit def convertEqualityToArraySequencing[E](equality: Equality[E]): Sequencing[Array[E]]

Implicit conversion that converts an Equality of type E into Sequencing 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 Sequencing of type Array[E]. This is required to support the explicit Equality syntax, for example:

(Array("hi", "he") should contain inOrderOnly ("HI", "HE")) (after being lowerCased)

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

Type parameters:
E

type of elements in the Array

Value parameters:
equality

Equality of type E

Returns:

Sequencing of type Array[E]

implicit def convertEqualityToEverySequencing[E](equality: Equality[E]): Sequencing[Every[E]]

Implicit conversion that converts an Equality of type E into Sequencing 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 Sequencing of type Every[E]. This is required to support the explicit Equality syntax, for example:

(Every("hi", "he") should contain inOrderOnly ("HI", "HE")) (after being lowerCased)

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

Type parameters:
E

type of elements in the Every

Value parameters:
equality

Equality of type E

Returns:

Sequencing of type Every[E]

implicit def convertEqualityToGenSeqSequencing[E, SEQ <: (Seq)](equality: Equality[E]): Sequencing[SEQ[E]]

Implicit conversion that converts an Equality of type E into Sequencing of type SEQ[E], where SEQ is a subtype of scala.collection.GenSeq. This is required to support the explicit Equality syntax, for example:

Implicit conversion that converts an Equality of type E into Sequencing of type SEQ[E], where SEQ is a subtype of scala.collection.GenSeq. This is required to support the explicit Equality syntax, for example:

(List("hi", "he") should contain inOrderOnly ("HI", "HE")) (after being lowerCased)

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

Type parameters:
E

type of elements in the scala.collection.GenSeq

SEQ

subtype of scala.collection.GenSeq

Value parameters:
equality

Equality of type E

Returns:

Sequencing of type SEQ[E]

implicit def convertEqualityToJavaListSequencing[E, JLIST <: (List)](equality: Equality[E]): Sequencing[JLIST[E]]

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

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

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

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

Type parameters:
E

type of elements in the java.util.List

JLIST

subtype of java.util.List

Value parameters:
equality

Equality of type E

Returns:

Sequencing of type JLIST[E]

implicit def convertEqualityToJavaSortedMapSequencing[K, V, JMAP <: (SortedMap)](equality: Equality[Entry[K, V]]): Sequencing[JMAP[K, V]]

Implicit conversion that converts an Equality of type java.util.Map.Entry[K, V] into Sequencing of type JMAP[K, V], where JMAP is a subtype of java.util.SortedMap. 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 Sequencing of type JMAP[K, V], where JMAP is a subtype of java.util.SortedMap. This is required to support the explicit Equality syntax, for example:

val javaMap = new java.util.TreeMap[Int, String]()
javaMap.put(1, "one")
// lowerCased needs to be implemented as Normalization[java.util.Map.Entry[K, V]]
(javaMap should contain inOrderOnly (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.TreeMap[Int, String]].

Type parameters:
JMAP

subtype of java.util.SortedMap

K

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

V

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

Value parameters:
equality

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

Returns:

Sequencing of type JMAP[K, V]

implicit def convertEqualityToJavaSortedSetSequencing[E, JSET <: (SortedSet)](equality: Equality[E]): Sequencing[JSET[E]]

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

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

val javaSet = new java.util.TreeSet[String]()
javaSet.add("hi", "he")
(javaSet should contain inOrderOnly ("HI", "HE")) (after being lowerCased)

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

Type parameters:
E

type of elements in the java.util.List

JSET

subtype of java.util.List

Value parameters:
equality

Equality of type E

Returns:

Sequencing of type JLIST[E]

implicit def convertEqualityToSortedMapSequencing[K, V, MAP <: (SortedMap)](equality: Equality[(K, V)]): Sequencing[MAP[K, V]]

Implicit conversion that converts an Equality of type (K, V) into Sequencing of type MAP[K, V], where MAP is a subtype of scala.collection.SortedMap. This is required to support the explicit Equality syntax, for example:

Implicit conversion that converts an Equality of type (K, V) into Sequencing of type MAP[K, V], where MAP is a subtype of scala.collection.SortedMap. This is required to support the explicit Equality syntax, for example:

// lowerCased needs to be implemented as Normalization[(K, V)]
(SortedMap("hi" -> "hi", "he" -> "he") should contain inOrderOnly ("HI" -> "HI", "HE" -> "HE")) (after being lowerCased)

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

Type parameters:
K

the type of the key in the scala.collection.SortedMap

MAP

subtype of scala.collection.SortedMap

V

the type of the value in the scala.collection.SortedMap

Value parameters:
equality

Equality of type (K, V)

Returns:

Sequencing of type MAP[K, V]

implicit def convertEqualityToSortedSetSequencing[E, SET <: (SortedSet)](equality: Equality[E]): Sequencing[SET[E]]

Implicit conversion that converts an Equality of type E into Sequencing of type SET[E], where SET is a subtype of scala.collection.SortedSet. This is required to support the explicit Equality syntax, for example:

Implicit conversion that converts an Equality of type E into Sequencing of type SET[E], where SET is a subtype of scala.collection.SortedSet. This is required to support the explicit Equality syntax, for example:

(SortedSet("hi", "he") should contain inOrderOnly ("HI", "HE")) (after being lowerCased)

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

Type parameters:
E

type of elements in the scala.collection.SortedSet

SET

subtype of scala.collection.SortedSet

Value parameters:
equality

Equality of type E

Returns:

Sequencing of type SET[E]

implicit def convertEqualityToStringSequencing(equality: Equality[Char]): Sequencing[String]

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

Implicit conversion that converts an Equality of type Char into Sequencing 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 inOrderOnly ('E')) (after being lowerCased)

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

Value parameters:
equality

Equality of type Char

Returns:

Sequencing of type String

implicit def sequencingNatureOfArray[E](implicit equality: Equality[E]): Sequencing[Array[E]]

Implicit to support Sequencing nature of Array.

Implicit to support Sequencing 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:

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

implicit def sequencingNatureOfEvery[E](implicit equality: Equality[E]): Sequencing[Every[E]]

Implicit to support Sequencing nature of Every.

Implicit to support Sequencing 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:

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

implicit def sequencingNatureOfGenSeq[E, SEQ <: (Seq)](implicit equality: Equality[E]): Sequencing[SEQ[E]]

Implicit to support Sequencing nature of scala.collection.GenSeq.

Implicit to support Sequencing nature of scala.collection.GenSeq.

Type parameters:
E

the type of the element in the scala.collection.GenSeq

SEQ

any subtype of scala.collection.GenSeq

Value parameters:
equality

Equality type class that is used to check equality of element in the scala.collection.GenSeq

Returns:

Sequencing[SEQ[E]] that supports scala.collection.GenSeq in relevant contain syntax

implicit def sequencingNatureOfJavaList[E, JLIST <: (List)](implicit equality: Equality[E]): Sequencing[JLIST[E]]

Implicit to support Sequencing nature of java.util.List.

Implicit to support Sequencing nature of java.util.List.

Type parameters:
E

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

JLIST

any subtype of java.util.List

Value parameters:
equality

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

Returns:

Sequencing[JLIST[E]] that supports java.util.List in relevant contain syntax

implicit def sequencingNatureOfJavaSortedMap[K, V, JMAP <: (SortedMap)](implicit equality: Equality[Entry[K, V]]): Sequencing[JMAP[K, V]]

Implicit to support Sequencing nature of java.util.SortedMap.

Implicit to support Sequencing nature of java.util.SortedMap.

Type parameters:
JMAP

any subtype of java.util.SortedMap

K

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

V

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

Value parameters:
equality

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

Returns:

Sequencing[JMAP[K, V]] that supports java.util.SortedMap in relevant contain syntax

implicit def sequencingNatureOfJavaSortedSet[E, JSET <: (SortedSet)](implicit equality: Equality[E]): Sequencing[JSET[E]]

Implicit to support Sequencing nature of java.util.SortedSet.

Implicit to support Sequencing nature of java.util.SortedSet.

Type parameters:
E

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

JSET

any subtype of java.util.SortedSet

Value parameters:
equality

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

Returns:

Sequencing[JSET[E]] that supports java.util.SortedSet in relevant contain syntax

implicit def sequencingNatureOfSortedMap[K, V, MAP <: (SortedMap)](implicit equality: Equality[(K, V)]): Sequencing[MAP[K, V]]

Implicit to support Sequencing nature of scala.collection.SortedMap.

Implicit to support Sequencing nature of scala.collection.SortedMap.

Type parameters:
K

the type of the key in the scala.collection.SortedMap

MAP

any subtype of scala.collection.SortedMap

V

the type of the value in the scala.collection.SortedMap

Value parameters:
equality

Equality type class that is used to check equality of element in the scala.collection.SortedMap

Returns:

Sequencing[MAP[K, V]] that supports scala.collection.SortedMap in relevant contain syntax

implicit def sequencingNatureOfSortedSet[E, SET <: (SortedSet)](implicit equality: Equality[E]): Sequencing[SET[E]]

Implicit to support Sequencing nature of scala.collection.SortedSet.

Implicit to support Sequencing nature of scala.collection.SortedSet.

Type parameters:
E

the type of the element in the scala.collection.SortedSet

SET

any subtype of scala.collection.SortedSet

Value parameters:
equality

Equality type class that is used to check equality of element in the scala.collection.SortedSet

Returns:

Sequencing[SET[E]] that supports scala.collection.SortedSet in relevant contain syntax

implicit def sequencingNatureOfString(implicit equality: Equality[Char]): Sequencing[String]

Implicit to support Sequencing nature of String.

Implicit to support Sequencing nature of String.

Value parameters:
equality

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

Returns:

Sequencing[String] that supports String in relevant contain syntax