scalatestCoreDotty/org.scalatest/Inspectors

Inspectors

object Inspectors extends Inspectors

Companion object that facilitates the importing of Inspectors members as an alternative to mixing it in. One use case is to import Inspectors's members so you can use them in the Scala interpreter.

Companion:
class
class Object
trait Matchable
class Any

Value members

Concrete methods

def forAllForJMapImpl[K, V, JMAP <: (Map), ASSERTION, RESULT](xs: JMAP[K, V], fun: Entry[K, V] => ASSERTION, collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forAllForMapImpl[K, V, MAP <: (Map), ASSERTION, RESULT](xs: MAP[K, V], fun: ((K, V)) => ASSERTION, collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forAllForStringImpl[ASSERTION, RESULT](xs: String, fun: Char => ASSERTION, collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forAllImpl[E, C[_], ASSERTION, RESULT](xs: C[E], fun: E => ASSERTION, collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forAtLeastForJMapImpl[K, V, JMAP <: (Map), ASSERTION, RESULT](min: Int, xs: JMAP[K, V], fun: Entry[K, V] => ASSERTION, collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forAtLeastForMapImpl[K, V, MAP <: (Map), ASSERTION, RESULT](min: Int, xs: MAP[K, V], fun: ((K, V)) => ASSERTION, collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forAtLeastForStringImpl[ASSERTION, RESULT](min: Int, xs: String, fun: Char => ASSERTION, collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forAtLeastImpl[E, C[_], ASSERTION, RESULT](min: Int, xs: C[E], fun: E => ASSERTION, collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forAtMostForJMapImpl[K, V, JMAP <: (Map), ASSERTION, RESULT](max: Int, xs: JMAP[K, V], fun: Entry[K, V] => ASSERTION, collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forAtMostForMapImpl[K, V, MAP <: (Map), ASSERTION, RESULT](max: Int, xs: MAP[K, V], fun: ((K, V)) => ASSERTION, collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forAtMostForStringImpl[ASSERTION, RESULT](max: Int, xs: String, fun: Char => ASSERTION, collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forAtMostImpl[E, C[_], ASSERTION, RESULT](max: Int, xs: C[E], fun: E => ASSERTION, collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forBetweenForJMapImpl[K, V, JMAP <: (Map), ASSERTION, RESULT](from: Int, upTo: Int, xs: JMAP[K, V], fun: Entry[K, V] => ASSERTION, collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forBetweenForMapImpl[K, V, MAP <: (Map), ASSERTION, RESULT](from: Int, upTo: Int, xs: MAP[K, V], fun: ((K, V)) => ASSERTION, collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forBetweenForStringImpl[ASSERTION, RESULT](from: Int, upTo: Int, xs: String, fun: Char => ASSERTION, collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forBetweenImpl[E, C[_], ASSERTION, RESULT](from: Int, upTo: Int, xs: C[E], fun: E => ASSERTION, collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forEveryForJMapImpl[K, V, JMAP <: (Map), ASSERTION, RESULT](xs: JMAP[K, V], fun: Entry[K, V] => ASSERTION, collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forEveryForMapImpl[K, V, MAP <: (Map), ASSERTION, RESULT](xs: MAP[K, V], fun: ((K, V)) => ASSERTION, collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forEveryForStringImpl[ASSERTION, RESULT](xs: String, fun: Char => ASSERTION, collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forEveryImpl[E, C[_], ASSERTION, RESULT](xs: C[E], fun: E => ASSERTION, collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forExactlyForJMapImpl[K, V, JMAP <: (Map), ASSERTION, RESULT](succeededCount: Int, xs: JMAP[K, V], fun: Entry[K, V] => ASSERTION, collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forExactlyForMapImpl[K, V, MAP <: (Map), ASSERTION, RESULT](succeededCount: Int, xs: MAP[K, V], fun: ((K, V)) => ASSERTION, collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forExactlyForStringImpl[ASSERTION, RESULT](succeededCount: Int, xs: String, fun: Char => ASSERTION, collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forExactlyImpl[E, C[_], ASSERTION, RESULT](succeededCount: Int, xs: C[E], fun: E => ASSERTION, collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forNoForJMapImpl[K, V, JMAP <: (Map), ASSERTION, RESULT](xs: JMAP[K, V], fun: Entry[K, V] => ASSERTION, collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forNoForMapImpl[K, V, MAP <: (Map), ASSERTION, RESULT](xs: MAP[K, V], fun: ((K, V)) => ASSERTION, collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forNoForStringImpl[ASSERTION, RESULT](xs: String, fun: Char => ASSERTION, collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT
def forNoImpl[E, C[_], ASSERTION, RESULT](xs: C[E], fun: E => ASSERTION, collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier, pos: Position): RESULT

Inherited methods

inline def forAll[ASSERTION, RESULT](xs: String)(fun: Char => ASSERTION)(implicit collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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).

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

xs

the String

Inherited from:
Inspectors
inline def forAll[K, V, JMAP <: (Map), ASSERTION, RESULT](xs: JMAP[K, V])(fun: Entry[K, V] => ASSERTION)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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).

Type parameters:
JMAP

subtype of java.util.Map

K

the type of key in the Java Map

V

the type of value in the Java Map

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

xs

the java.util.Map

Inherited from:
Inspectors
inline def forAll[K, V, MAP <: (Map), ASSERTION, RESULT](xs: MAP[K, V])(fun: ((K, V)) => ASSERTION)(implicit collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

Ensure that all elements in a given scala.collection.GenMap 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 scala.collection.GenMap 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 scala.collection.GenMap entries after the first failure (and report all failures).

Type parameters:
K

the type of key in the Map

MAP

subtype of java.util.Map

V

the type of value in the Map

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

xs

the java.util.Map

Inherited from:
Inspectors
inline def forAll[E, C[_], ASSERTION, RESULT](xs: C[E])(fun: E => ASSERTION)(implicit collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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).

Type parameters:
C

the type of collection

E

the type of element in the collection

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

xs

the collection of elements

Inherited from:
Inspectors
inline def forAtLeast[ASSERTION, RESULT](min: Int, xs: String)(fun: Char => ASSERTION)(implicit collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

min

the minimum number of characters in String that must pass the inspection function

xs

the String

Inherited from:
Inspectors
inline def forAtLeast[K, V, JMAP <: (Map), ASSERTION, RESULT](min: Int, xs: JMAP[K, V])(fun: Entry[K, V] => ASSERTION)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Type parameters:
JMAP

subtype of java.util.Map

K

the type of key in the java.util.Map

V

the type of value in the java.util.Map

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

min

the minimum number of elements that must pass the inspection function

xs

the java.util.Map

Inherited from:
Inspectors
inline def forAtLeast[K, V, MAP <: (Map), ASSERTION, RESULT](min: Int, xs: MAP[K, V])(fun: ((K, V)) => ASSERTION)(implicit collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

Ensure that at least min number of elements in a given scala.collection.GenMap pass the given inspection function.

Ensure that at least min number of elements in a given scala.collection.GenMap pass the given inspection function.

Type parameters:
K

the type of key in the scala.collection.GenMap

MAP

subtype of scala.collection.GenMap

V

the type of value in the scala.collection.GenMap

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

min

the minimum number of elements that must pass the inspection function

xs

the scala.collection.GenMap

Inherited from:
Inspectors
inline def forAtLeast[E, C[_], ASSERTION, RESULT](min: Int, xs: C[E])(fun: E => ASSERTION)(implicit collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Type parameters:
C

the type of collection

E

the type of element in the collection

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

min

the minimum number of elements that must pass the inspection function

xs

the collection of elements

Inherited from:
Inspectors
inline def forAtMost[ASSERTION, RESULT](max: Int, xs: String)(fun: Char => ASSERTION)(implicit collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

max

the maximum number of characters in String that must pass the inspection function

xs

the String

Inherited from:
Inspectors
inline def forAtMost[K, V, JMAP <: (Map), ASSERTION, RESULT](max: Int, xs: JMAP[K, V])(fun: Entry[K, V] => ASSERTION)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Type parameters:
JMAP

subtype of java.util.Map

K

the type of key in the java.util.Map

V

the type of value in the java.util.Map

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

max

the maximum number of elements in the java.util.Map that must pass the inspection function

xs

the java.util.Map

Inherited from:
Inspectors
inline def forAtMost[K, V, MAP <: (Map), ASSERTION, RESULT](max: Int, xs: MAP[K, V])(fun: ((K, V)) => ASSERTION)(implicit collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

Ensure that at most max number of elements in a given scala.collection.GenMap pass the given inspection function.

Ensure that at most max number of elements in a given scala.collection.GenMap pass the given inspection function.

Type parameters:
K

the type of key in the scala.collection.GenMap

MAP

subtype of scala.collection.GenMap

V

the type of value in the scala.collection.GenMap

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

max

the maximum number of elements in the scala.collection.GenMap that must pass the inspection function

xs

the scala.collection.GenMap

Inherited from:
Inspectors
inline def forAtMost[E, C[_], ASSERTION, RESULT](max: Int, xs: C[E])(fun: E => ASSERTION)(implicit collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Type parameters:
C

the type of collection

E

the type of element in the collection

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

max

the maximum number of elements that must pass the inspection function

xs

the collection of elements

Inherited from:
Inspectors
inline def forBetween[ASSERTION, RESULT](from: Int, upTo: Int, xs: String)(fun: Char => ASSERTION)(implicit collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

from

the minimum number of characters in the String that must pass the inspection number

fun

the inspection function

upTo

the maximum number of characters in the String that must pass the inspection number

xs

the String

Inherited from:
Inspectors
inline def forBetween[K, V, JMAP <: (Map), ASSERTION, RESULT](from: Int, upTo: Int, xs: JMAP[K, V])(fun: Entry[K, V] => ASSERTION)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Type parameters:
JMAP

subtype of java.util.Map

K

the type of key in the java.util.Map

V

the type of value in the java.util.Map

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

from

the minimum number of elements in the java.util.Map that must pass the inspection number

fun

the inspection function

upTo

the maximum number of elements in the java.util.Map that must pass the inspection number

xs

the java.util.Map

Inherited from:
Inspectors
inline def forBetween[K, V, MAP <: (Map), ASSERTION, RESULT](from: Int, upTo: Int, xs: MAP[K, V])(fun: ((K, V)) => ASSERTION)(implicit collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

Ensure the number of elements in a given scala.collection.GenMap that pass the given inspection function is between from and upTo.

Ensure the number of elements in a given scala.collection.GenMap that pass the given inspection function is between from and upTo.

Type parameters:
K

the type of key in the scala.collection.GenMap

MAP

subtype of scala.collection.GenMap

V

the type of value in the scala.collection.GenMap

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

from

the minimum number of elements in the scala.collection.GenMap that must pass the inspection number

fun

the inspection function

upTo

the maximum number of elements in the scala.collection.GenMap that must pass the inspection number

xs

the scala.collection.GenMap

Inherited from:
Inspectors
inline def forBetween[E, C[_], ASSERTION, RESULT](from: Int, upTo: Int, xs: C[E])(fun: E => ASSERTION)(implicit collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Type parameters:
C

the type of collection

E

the type of element in the collection

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

from

the minimum number of elements that must pass the inspection number

fun

the inspection function

upTo

the maximum number of elements that must pass the inspection number

xs

the collection of elements

Inherited from:
Inspectors
inline def forEvery[ASSERTION, RESULT](xs: String)(fun: Char => ASSERTION)(implicit collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

xs

the String

Inherited from:
Inspectors
inline def forEvery[K, V, JMAP <: (Map), ASSERTION, RESULT](xs: JMAP[K, V])(fun: Entry[K, V] => ASSERTION)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Type parameters:
JMAP

subtype of java.util.Map

K

the type of key in the java.util.Map

V

the type of value in the java.util.Map

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

xs

the java.util.Map

Inherited from:
Inspectors
inline def forEvery[K, V, MAP <: (Map), ASSERTION, RESULT](xs: MAP[K, V])(fun: ((K, V)) => ASSERTION)(implicit collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

Ensure that every element in a given scala.collection.GenMap 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 scala.collection.GenMap 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 entries in the scala.collection.GenMap after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

Type parameters:
K

the type of key in the scala.collection.GenMap

MAP

subtype of scala.collection.GenMap

V

the type of value in the scala.collection.GenMap

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

xs

the scala.collection.GenMap

Inherited from:
Inspectors
inline def forEvery[E, C[_], ASSERTION, RESULT](xs: C[E])(fun: E => ASSERTION)(implicit collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Type parameters:
C

the type of collection

E

the type of element in the collection

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

xs

the collection of elements

Inherited from:
Inspectors
inline def forExactly[ASSERTION, RESULT](succeededCount: Int, xs: String)(fun: Char => ASSERTION)(implicit collecting: Collecting[Char, String], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

succeededCount

the number of characters in the String that must pass the inspection function

xs

the String

Inherited from:
Inspectors
inline def forExactly[K, V, JMAP <: (Map), ASSERTION, RESULT](succeededCount: Int, xs: JMAP[K, V])(fun: Entry[K, V] => ASSERTION)(implicit collecting: Collecting[Entry[K, V], JMAP[K, V]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Type parameters:
JMAP

subtype of java.util.Map

K

the type of key in the java.util.Map

V

the type of value in the java.util.Map

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

succeededCount

the number of elements in the java.util.Map that must pass the inspection function

xs

the java.util.Map

Inherited from:
Inspectors
inline def forExactly[K, V, MAP <: (Map), ASSERTION, RESULT](succeededCount: Int, xs: MAP[K, V])(fun: ((K, V)) => ASSERTION)(implicit collecting: Collecting[(K, V), Iterable[(K, V)]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

Ensure that exactly succeededCount number of elements in a given scala.collection.GenMap pass the given inspection function.

Ensure that exactly succeededCount number of elements in a given scala.collection.GenMap pass the given inspection function.

Type parameters:
K

the type of key in the scala.collection.GenMap

MAP

subtype of scala.collection.GenMap

V

the type of value in the scala.collection.GenMap

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

succeededCount

the number of entries in the scala.collection.GenMap that must pass the inspection function

xs

the scala.collection.GenMap

Inherited from:
Inspectors
inline def forExactly[E, C[_], ASSERTION, RESULT](succeededCount: Int, xs: C[E])(fun: E => ASSERTION)(implicit collecting: Collecting[E, C[E]], asserting: InspectorAsserting[ASSERTION, RESULT], prettifier: Prettifier): RESULT

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.

Type parameters:
C

the type of collection

E

the type of element in the collection

Value parameters:
collecting

the implicit Collecting that can transform xs into a scala.collection.GenTraversable

fun

the inspection function

succeededCount

the number of elements that must pass the inspection function

xs

the collection of elements

Inherited from:
Inspectors