Inspectors

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def forAll(xs: String)(fun: (Char) ⇒ Assertion)(implicit collecting: Collecting[Char, String]): Assertion

Ensure that all characters in a given String pass the given inspection function, where "pass" means returning normally from the function (i.e., without throwing an exception).
Ensure that all characters in a given String pass the given inspection function, where "pass" means returning normally from the function (i.e., without throwing an exception).
The difference between forAll and forEvery is that forAll will stop on the first failure, while forEvery will continue to inspect all characters in the String after the first failure (and report all failures).
xs
the String
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forAll[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(fun: (Entry[K, V]) ⇒ Assertion)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): Assertion

Ensure that all elements in a given java.util.Map pass the given inspection function, where "pass" means returning normally from the function (i.e., without throwing an exception).
Ensure that all elements in a given java.util.Map pass the given inspection function, where "pass" means returning normally from the function (i.e., without throwing an exception).
The difference between forAll and forEvery is that forAll will stop on the first failure, while forEvery will continue to inspect all java.util.Map elements after the first failure (and report all failures).
K
the type of key in the Java Map
V
the type of value in the Java Map
JMAP
subtype of java.util.Map
xs
the java.util.Map
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forAll[E, C[_]](xs: C[E])(fun: (E) ⇒ Assertion)(implicit collecting: Collecting[E, C[E]]): Assertion

Ensure that all elements in a given collection pass the given inspection function, where "pass" means returning normally from the function (i.e., without throwing an exception).
Ensure that all elements in a given collection pass the given inspection function, where "pass" means returning normally from the function (i.e., without throwing an exception).
The difference between forAll and forEvery is that forAll will stop on the first failure, while forEvery will continue to inspect all elements after the first failure (and report all failures).
E
the type of element in the collection
C
the type of collection
xs
the collection of elements
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forAtLeast(min: Int, xs: String)(fun: (Char) ⇒ Assertion)(implicit collecting: Collecting[Char, String]): Assertion

Ensure that at least min number of characters in a given String pass the given inspection function.
Ensure that at least min number of characters in a given String pass the given inspection function.
min
the minimum number of characters in String that must pass the inspection function
xs
the String
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forAtLeast[K, V, JMAP[k, v] <: Map[k, v]](min: Int, xs: JMAP[K, V])(fun: (Entry[K, V]) ⇒ Assertion)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): Assertion

Ensure that at least min number of elements in a given java.util.Map pass the given inspection function.
Ensure that at least min number of elements in a given java.util.Map pass the given inspection function.
K
the type of key in the java.util.Map
V
the type of value in the java.util.Map
JMAP
subtype of java.util.Map
min
the minimum number of elements that must pass the inspection function
xs
the java.util.Map
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forAtLeast[E, C[_]](min: Int, xs: C[E])(fun: (E) ⇒ Assertion)(implicit collecting: Collecting[E, C[E]]): Assertion

Ensure that at least min number of elements of a given collection pass the given inspection function.
Ensure that at least min number of elements of a given collection pass the given inspection function.
E
the type of element in the collection
C
the type of collection
min
the minimum number of elements that must pass the inspection function
xs
the collection of elements
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forAtMost(max: Int, xs: String)(fun: (Char) ⇒ Assertion)(implicit collecting: Collecting[Char, String]): Assertion

Ensure that at most max number of characters in a given String pass the given inspection function.
Ensure that at most max number of characters in a given String pass the given inspection function.
max
the maximum number of characters in String that must pass the inspection function
xs
the String
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forAtMost[K, V, JMAP[k, v] <: Map[k, v]](max: Int, xs: JMAP[K, V])(fun: (Entry[K, V]) ⇒ Assertion)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): Assertion

Ensure that at most max number of elements in a given java.util.Map pass the given inspection function.
Ensure that at most max number of elements in a given java.util.Map pass the given inspection function.
K
the type of key in the java.util.Map
V
the type of value in the java.util.Map
JMAP
subtype of java.util.Map
max
the maximum number of elements in the java.util.Map that must pass the inspection function
xs
the java.util.Map
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forAtMost[E, C[_]](max: Int, xs: C[E])(fun: (E) ⇒ Assertion)(implicit collecting: Collecting[E, C[E]]): Assertion

Ensure that at most max number of elements of a given collection pass the given inspection function.
Ensure that at most max number of elements of a given collection pass the given inspection function.
E
the type of element in the collection
C
the type of collection
max
the maximum number of elements that must pass the inspection function
xs
the collection of elements
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forBetween(from: Int, upTo: Int, xs: String)(fun: (Char) ⇒ Assertion)(implicit collecting: Collecting[Char, String]): Assertion

Ensure the number of characters of a given String that pass the given inspection function is between from and upTo.
Ensure the number of characters of a given String that pass the given inspection function is between from and upTo.
from
the minimum number of characters in the String that must pass the inspection number
upTo
the maximum number of characters in the String that must pass the inspection number
xs
the String
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forBetween[K, V, JMAP[k, v] <: Map[k, v]](from: Int, upTo: Int, xs: JMAP[K, V])(fun: (Entry[K, V]) ⇒ Assertion)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): Assertion

Ensure the number of elements in a given java.util.Map that pass the given inspection function is between from and upTo.
Ensure the number of elements in a given java.util.Map that pass the given inspection function is between from and upTo.
K
the type of key in the java.util.Map
V
the type of value in the java.util.Map
JMAP
subtype of java.util.Map
from
the minimum number of elements in the java.util.Map that must pass the inspection number
upTo
the maximum number of elements in the java.util.Map that must pass the inspection number
xs
the java.util.Map
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forBetween[E, C[_]](from: Int, upTo: Int, xs: C[E])(fun: (E) ⇒ Assertion)(implicit collecting: Collecting[E, C[E]]): Assertion

Ensure the number of elements of a given collection that pass the given inspection function is between from and upTo.
Ensure the number of elements of a given collection that pass the given inspection function is between from and upTo.
E
the type of element in the collection
C
the type of collection
from
the minimum number of elements that must pass the inspection number
upTo
the maximum number of elements that must pass the inspection number
xs
the collection of elements
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forEvery(xs: String)(fun: (Char) ⇒ Assertion)(implicit collecting: Collecting[Char, String]): Assertion

Ensure that every character in a given String passes the given inspection function, where "pass" means returning normally from the function (i.e., without throwing an exception).
Ensure that every character in a given String passes the given inspection function, where "pass" means returning normally from the function (i.e., without throwing an exception).
The difference between forEvery and forAll is that forEvery will continue to inspect all characters in the String after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.
xs
the String
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forEvery[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(fun: (Entry[K, V]) ⇒ Assertion)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): Assertion

Ensure that every element in a given java.util.Map passes the given inspection function, where "pass" means returning normally from the function (i.e., without throwing an exception).
Ensure that every element in a given java.util.Map passes the given inspection function, where "pass" means returning normally from the function (i.e., without throwing an exception).
The difference between forEvery and forAll is that forEvery will continue to inspect all elements in the java.util.Map after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.
K
the type of key in the java.util.Map
V
the type of value in the java.util.Map
JMAP
subtype of java.util.Map
xs
the java.util.Map
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forEvery[E, C[_]](xs: C[E])(fun: (E) ⇒ Assertion)(implicit collecting: Collecting[E, C[E]]): Assertion

Ensure that every element in a given collection passes the given inspection function, where "pass" means returning normally from the function (i.e., without throwing an exception).
Ensure that every element in a given collection passes the given inspection function, where "pass" means returning normally from the function (i.e., without throwing an exception).
The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.
E
the type of element in the collection
C
the type of collection
xs
the collection of elements
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forExactly(succeededCount: Int, xs: String)(fun: (Char) ⇒ Assertion)(implicit collecting: Collecting[Char, String]): Assertion

Ensure that exactly succeededCount number of characters in a given String pass the given inspection function.
Ensure that exactly succeededCount number of characters in a given String pass the given inspection function.
succeededCount
the number of characters in the String that must pass the inspection function
xs
the String
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forExactly[K, V, JMAP[k, v] <: Map[k, v]](succeededCount: Int, xs: JMAP[K, V])(fun: (Entry[K, V]) ⇒ Assertion)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): Assertion

Ensure that exactly succeededCount number of elements in a given java.util.Map pass the given inspection function.
Ensure that exactly succeededCount number of elements in a given java.util.Map pass the given inspection function.
K
the type of key in the java.util.Map
V
the type of value in the java.util.Map
JMAP
subtype of java.util.Map
succeededCount
the number of elements in the java.util.Map that must pass the inspection function
xs
the java.util.Map
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
def forExactly[E, C[_]](succeededCount: Int, xs: C[E])(fun: (E) ⇒ Assertion)(implicit collecting: Collecting[E, C[E]]): Assertion

Ensure that exactly succeededCount number of elements of a given collection pass the given inspection function.
Ensure that exactly succeededCount number of elements of a given collection pass the given inspection function.
E
the type of element in the collection
C
the type of collection
succeededCount
the number of elements that must pass the inspection function
xs
the collection of elements
fun
the inspection function
collecting
the implicit Collecting that can transform xs into a scala.collection.GenTraversable

Definition Classes
Inspectors
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val stackDepthAdjustment: Int

Definition Classes
Inspectors
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: trait Inspectors | package scalatest

object Inspectors extends Inspectors

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def forAll(xs: String)(fun: (Char) ⇒ Assertion)(implicit collecting: Collecting[Char, String]): Assertion

def forAll[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(fun: (Entry[K, V]) ⇒ Assertion)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): Assertion

def forAll[E, C[_]](xs: C[E])(fun: (E) ⇒ Assertion)(implicit collecting: Collecting[E, C[E]]): Assertion

def forAtLeast(min: Int, xs: String)(fun: (Char) ⇒ Assertion)(implicit collecting: Collecting[Char, String]): Assertion

def forAtLeast[K, V, JMAP[k, v] <: Map[k, v]](min: Int, xs: JMAP[K, V])(fun: (Entry[K, V]) ⇒ Assertion)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): Assertion

def forAtLeast[E, C[_]](min: Int, xs: C[E])(fun: (E) ⇒ Assertion)(implicit collecting: Collecting[E, C[E]]): Assertion

def forAtMost(max: Int, xs: String)(fun: (Char) ⇒ Assertion)(implicit collecting: Collecting[Char, String]): Assertion

def forAtMost[K, V, JMAP[k, v] <: Map[k, v]](max: Int, xs: JMAP[K, V])(fun: (Entry[K, V]) ⇒ Assertion)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): Assertion

def forAtMost[E, C[_]](max: Int, xs: C[E])(fun: (E) ⇒ Assertion)(implicit collecting: Collecting[E, C[E]]): Assertion

def forBetween(from: Int, upTo: Int, xs: String)(fun: (Char) ⇒ Assertion)(implicit collecting: Collecting[Char, String]): Assertion

def forBetween[K, V, JMAP[k, v] <: Map[k, v]](from: Int, upTo: Int, xs: JMAP[K, V])(fun: (Entry[K, V]) ⇒ Assertion)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): Assertion

def forBetween[E, C[_]](from: Int, upTo: Int, xs: C[E])(fun: (E) ⇒ Assertion)(implicit collecting: Collecting[E, C[E]]): Assertion

def forEvery(xs: String)(fun: (Char) ⇒ Assertion)(implicit collecting: Collecting[Char, String]): Assertion

def forEvery[K, V, JMAP[k, v] <: Map[k, v]](xs: JMAP[K, V])(fun: (Entry[K, V]) ⇒ Assertion)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): Assertion

def forEvery[E, C[_]](xs: C[E])(fun: (E) ⇒ Assertion)(implicit collecting: Collecting[E, C[E]]): Assertion

def forExactly(succeededCount: Int, xs: String)(fun: (Char) ⇒ Assertion)(implicit collecting: Collecting[Char, String]): Assertion

def forExactly[K, V, JMAP[k, v] <: Map[k, v]](succeededCount: Int, xs: JMAP[K, V])(fun: (Entry[K, V]) ⇒ Assertion)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]]): Assertion

def forExactly[E, C[_]](succeededCount: Int, xs: C[E])(fun: (E) ⇒ Assertion)(implicit collecting: Collecting[E, C[E]]): Assertion

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val stackDepthAdjustment: Int

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from Inspectors

Inherited from AnyRef

Inherited from Any

Ungrouped