org.scalatest.prop

PropertyChecks

trait PropertyChecks extends TableDrivenPropertyChecks with GeneratorDrivenPropertyChecks

Trait that facilitates property checks on data supplied by tables and generators.

This trait extends both TableDrivenPropertyChecks and GeneratorDrivenPropertyChecks. Thus by mixing in this trait you can perform property checks on data supplied either by tables or generators. For the details of table- and generator-driven property checks, see the documentation for each by following the links above.

For a quick example of using both table and generator-driven property checks in the same suite of tests, however, imagine you want to test this Fraction class:

class Fraction(n: Int, d: Int) {

  require(d != 0)
  require(d != Integer.MIN_VALUE)
  require(n != Integer.MIN_VALUE)

  val numer = if (d < 0) -1 * n else n
  val denom = d.abs

  override def toString = numer + " / " + denom
}

If you mix in PropertyChecks, you could use a generator-driven property check to test that the passed values for numerator and denominator are properly normalized, like this:

forAll { (n: Int, d: Int) =>

  whenever (d != 0 && d != Integer.MIN_VALUE
      && n != Integer.MIN_VALUE) {

    val f = new Fraction(n, d)

    if (n < 0 && d < 0 || n > 0 && d > 0)
      f.numer should be > 0
    else if (n != 0)
      f.numer should be < 0
    else
      f.numer shouldEqual 0

    f.denom should be > 0
  }
}

And you could use a table-driven property check to test that all combinations of invalid values passed to the Fraction constructor produce the expected IllegalArgumentException, like this:

val invalidCombos =
  Table(
    ("n",               "d"),
    (Integer.MIN_VALUE, Integer.MIN_VALUE),
    (1,                 Integer.MIN_VALUE),
    (Integer.MIN_VALUE, 1),
    (Integer.MIN_VALUE, 0),
    (1,                 0)
  )

forAll (invalidCombos) { (n: Int, d: Int) =>
  an [IllegalArgumentException] should be thrownBy {
    new Fraction(n, d)
  }
}

Linear Supertypes
Known Subclasses
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. PropertyChecks
  2. GeneratorDrivenPropertyChecks
  3. Configuration
  4. CommonGenerators
  5. TableDrivenPropertyChecks
  6. Tables
  7. Whenever
  8. AnyRef
  9. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. class ConfiguredPropertyCheck extends AnyRef

    Performs a configured property checks by applying property check functions passed to its apply methods to arguments supplied by implicitly passed generators, modifying the values in the PropertyGenConfig object passed implicitly to its apply methods with parameter values passed to its constructor.

  2. case class MaxDiscardedFactor(value: PosZDouble) extends PropertyCheckConfigParam with Product with Serializable

    Definition Classes
    Configuration
  3. case class MinSize(value: PosZInt) extends PropertyCheckConfigParam with Product with Serializable

    A PropertyCheckConfigParam that specifies the minimum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).

  4. case class MinSuccessful(value: PosInt) extends PropertyCheckConfigParam with Product with Serializable

    A PropertyCheckConfigParam that specifies the minimum number of successful property evaluations required for the property to pass.

  5. sealed abstract class PropertyCheckConfigParam extends Product with Serializable

    Abstract class defining a family of configuration parameters for property checks.

  6. case class PropertyCheckConfiguration(minSuccessful: PosInt = PosInt.ensuringValid(10), maxDiscardedFactor: PosZDouble = PosZDouble.ensuringValid(5.0), minSize: PosZInt = Configuration.minSize.get(), sizeRange: PosZInt = Configuration.sizeRange.get(), workers: PosInt = PosInt.ensuringValid(1)) extends PropertyCheckConfigurable with Product with Serializable

    Definition Classes
    Configuration
  7. case class SizeRange(value: PosZInt) extends PropertyCheckConfigParam with Product with Serializable

    A PropertyCheckConfigParam that (with minSize) specifies the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).

  8. case class Workers(value: PosInt) extends PropertyCheckConfigParam with Product with Serializable

    A PropertyCheckConfigParam that specifies the number of worker threads to use when evaluating a property.

  9. case class MaxDiscarded(value: Int) extends PropertyCheckConfigParam with Product with Serializable

    A PropertyCheckConfigParam that specifies the maximum number of discarded property evaluations allowed during property evaluation.

  10. case class MaxSize(value: Int) extends PropertyCheckConfigParam with Product with Serializable

    A PropertyCheckConfigParam that specifies the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).

  11. case class PropertyCheckConfig(minSuccessful: Int = 10, maxDiscarded: Int = 500, minSize: Int = 0, maxSize: Int = 100, workers: Int = 1) extends PropertyCheckConfigurable with Product with Serializable

    Configuration object for property checks.

  12. trait PropertyCheckConfigurable extends AnyRef

    Definition Classes
    Configuration
    Annotations
    @deprecated
    Deprecated

    Use PropertyCheckConfiguration directly instead.

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

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

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

    Definition Classes
    Any
  6. implicit def PropertyCheckConfig2PropertyCheckConfiguration(p: PropertyCheckConfig): PropertyCheckConfiguration

    Implicitly converts PropertyCheckConfigs to PropertyCheckConfiguration, which enables a smoother upgrade path.

    Implicitly converts PropertyCheckConfigs to PropertyCheckConfiguration, which enables a smoother upgrade path.

    Definition Classes
    Configuration
  7. object PropertyCheckConfiguration extends Serializable

    Definition Classes
    Configuration
  8. object Table

    Object containing one apply factory method for each TableFor<n> class.

  9. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  10. val bytes: Generator[Byte]

    Definition Classes
    CommonGenerators
  11. def bytesBetween(from: Byte, to: Byte): Generator[Byte]

    Definition Classes
    CommonGenerators
  12. val chars: Generator[Char]

    Definition Classes
    CommonGenerators
  13. def charsBetween(from: Char, to: Char): Generator[Char]

    Definition Classes
    CommonGenerators
  14. def classify[A](count: PosInt, genOfA: Generator[A])(pf: PartialFunction[A, String]): Classification

    Definition Classes
    CommonGenerators
  15. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  16. val doubles: Generator[Double]

    Definition Classes
    CommonGenerators
  17. def doublesBetween(from: Double, to: Double): Generator[Double]

    Definition Classes
    CommonGenerators
  18. final def eq(arg0: AnyRef): Boolean

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

    Definition Classes
    AnyRef → Any
  20. def evenly[T](first: Generator[T], second: Generator[T], rest: Generator[T]*): Generator[T]

    Definition Classes
    CommonGenerators
  21. def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, ASSERTION](table: TableFor22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor22 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor22 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  22. def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, ASSERTION](table: TableFor21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor21 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor21 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  23. def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, ASSERTION](table: TableFor20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor20 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor20 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  24. def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, ASSERTION](table: TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor19 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor19 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  25. def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, ASSERTION](table: TableFor18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor18 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor18 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  26. def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, ASSERTION](table: TableFor17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor17 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor17 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  27. def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ASSERTION](table: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor16 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor16 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  28. def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ASSERTION](table: TableFor15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor15 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor15 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  29. def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, ASSERTION](table: TableFor14[A, B, C, D, E, F, G, H, I, J, K, L, M, N])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor14 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor14 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  30. def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, ASSERTION](table: TableFor13[A, B, C, D, E, F, G, H, I, J, K, L, M])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor13 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor13 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  31. def exists[A, B, C, D, E, F, G, H, I, J, K, L, ASSERTION](table: TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])(fun: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor12 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor12 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  32. def exists[A, B, C, D, E, F, G, H, I, J, K, ASSERTION](table: TableFor11[A, B, C, D, E, F, G, H, I, J, K])(fun: (A, B, C, D, E, F, G, H, I, J, K) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor11 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor11 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  33. def exists[A, B, C, D, E, F, G, H, I, J, ASSERTION](table: TableFor10[A, B, C, D, E, F, G, H, I, J])(fun: (A, B, C, D, E, F, G, H, I, J) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor10 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor10 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  34. def exists[A, B, C, D, E, F, G, H, I, ASSERTION](table: TableFor9[A, B, C, D, E, F, G, H, I])(fun: (A, B, C, D, E, F, G, H, I) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor9 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor9 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  35. def exists[A, B, C, D, E, F, G, H, ASSERTION](table: TableFor8[A, B, C, D, E, F, G, H])(fun: (A, B, C, D, E, F, G, H) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor8 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor8 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  36. def exists[A, B, C, D, E, F, G, ASSERTION](table: TableFor7[A, B, C, D, E, F, G])(fun: (A, B, C, D, E, F, G) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor7 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor7 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  37. def exists[A, B, C, D, E, F, ASSERTION](table: TableFor6[A, B, C, D, E, F])(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor6 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor6 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  38. def exists[A, B, C, D, E, ASSERTION](table: TableFor5[A, B, C, D, E])(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor5 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor5 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  39. def exists[A, B, C, D, ASSERTION](table: TableFor4[A, B, C, D])(fun: (A, B, C, D) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor4 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor4 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  40. def exists[A, B, C, ASSERTION](table: TableFor3[A, B, C])(fun: (A, B, C) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor3 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor3 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  41. def exists[A, B, ASSERTION](table: TableFor2[A, B])(fun: (A, B) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor2 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor2 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  42. def exists[A, ASSERTION](table: TableFor1[A])(fun: (A) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor1 and succeeding if at least one element satisfies the property check.

    Performs a property check by applying the specified property check function to each row of the specified TableFor1 and succeeding if at least one element satisfies the property check.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  43. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  44. val finiteDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators
  45. val finiteDoubles: Generator[FiniteDouble]

    Definition Classes
    CommonGenerators
  46. def finiteDoublesBetween(from: FiniteDouble, to: FiniteDouble): Generator[FiniteDouble]

    Definition Classes
    CommonGenerators
  47. val finiteFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators
  48. val finiteFloats: Generator[FiniteFloat]

    Definition Classes
    CommonGenerators
  49. def finiteFloatsBetween(from: FiniteFloat, to: FiniteFloat): Generator[FiniteFloat]

    Definition Classes
    CommonGenerators
  50. def first1000Primes: Generator[Int]

    Definition Classes
    CommonGenerators
  51. val floats: Generator[Float]

    Definition Classes
    CommonGenerators
  52. def floatsBetween(from: Float, to: Float): Generator[Float]

    Definition Classes
    CommonGenerators
  53. def forAll[A, B, C, D, E, F, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), genAndNameD: (Generator[D], String), genAndNameE: (Generator[E], String), genAndNameF: (Generator[F], String), configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  54. def forAll[A, B, C, D, E, F, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), genAndNameD: (Generator[D], String), genAndNameE: (Generator[E], String), genAndNameF: (Generator[F], String))(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  55. def forAll[A, B, C, D, E, F, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], genF: Generator[F], configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  56. def forAll[A, B, C, D, E, F, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], genF: Generator[F])(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  57. def forAll[A, B, C, D, E, F, ASSERTION](a: String, b: String, c: String, d: String, e: String, f: String, configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], genF: Generator[F], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  58. def forAll[A, B, C, D, E, F, ASSERTION](a: String, b: String, c: String, d: String, e: String, f: String)(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], genF: Generator[F], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  59. def forAll[A, B, C, D, E, F, ASSERTION](fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], genF: Generator[F], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  60. def forAll[A, B, C, D, E, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), genAndNameD: (Generator[D], String), genAndNameE: (Generator[E], String), configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  61. def forAll[A, B, C, D, E, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), genAndNameD: (Generator[D], String), genAndNameE: (Generator[E], String))(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  62. def forAll[A, B, C, D, E, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  63. def forAll[A, B, C, D, E, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E])(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  64. def forAll[A, B, C, D, E, ASSERTION](a: String, b: String, c: String, d: String, e: String, configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  65. def forAll[A, B, C, D, E, ASSERTION](a: String, b: String, c: String, d: String, e: String)(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  66. def forAll[A, B, C, D, E, ASSERTION](fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  67. def forAll[A, B, C, D, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), genAndNameD: (Generator[D], String), configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  68. def forAll[A, B, C, D, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), genAndNameD: (Generator[D], String))(fun: (A, B, C, D) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  69. def forAll[A, B, C, D, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  70. def forAll[A, B, C, D, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D])(fun: (A, B, C, D) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  71. def forAll[A, B, C, D, ASSERTION](a: String, b: String, c: String, d: String, configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  72. def forAll[A, B, C, D, ASSERTION](a: String, b: String, c: String, d: String)(fun: (A, B, C, D) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  73. def forAll[A, B, C, D, ASSERTION](fun: (A, B, C, D) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  74. def forAll[A, B, C, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), configParams: PropertyCheckConfigParam*)(fun: (A, B, C) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  75. def forAll[A, B, C, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String))(fun: (A, B, C) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  76. def forAll[A, B, C, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], configParams: PropertyCheckConfigParam*)(fun: (A, B, C) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  77. def forAll[A, B, C, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C])(fun: (A, B, C) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  78. def forAll[A, B, C, ASSERTION](a: String, b: String, c: String, configParams: PropertyCheckConfigParam*)(fun: (A, B, C) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  79. def forAll[A, B, C, ASSERTION](a: String, b: String, c: String)(fun: (A, B, C) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  80. def forAll[A, B, C, ASSERTION](fun: (A, B, C) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  81. def forAll[A, B, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), configParams: PropertyCheckConfigParam*)(fun: (A, B) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  82. def forAll[A, B, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String))(fun: (A, B) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  83. def forAll[A, B, ASSERTION](genA: Generator[A], genB: Generator[B], configParams: PropertyCheckConfigParam*)(fun: (A, B) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  84. def forAll[A, B, ASSERTION](genA: Generator[A], genB: Generator[B])(fun: (A, B) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  85. def forAll[A, B, ASSERTION](a: String, b: String, configParams: PropertyCheckConfigParam*)(fun: (A, B) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  86. def forAll[A, B, ASSERTION](a: String, b: String)(fun: (A, B) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  87. def forAll[A, B, ASSERTION](fun: (A, B) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  88. def forAll[A, ASSERTION](genAndNameA: (Generator[A], String), configParams: PropertyCheckConfigParam*)(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  89. def forAll[A, ASSERTION](genAndNameA: (Generator[A], String))(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  90. def forAll[A, ASSERTION](genA: Generator[A], configParams: PropertyCheckConfigParam*)(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  91. def forAll[A, ASSERTION](genA: Generator[A])(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  92. def forAll[A, ASSERTION](a: String, configParams: PropertyCheckConfigParam*)(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  93. def forAll[A, ASSERTION](a: String)(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  94. def forAll[A, ASSERTION](fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

  95. def forAll(configParams: PropertyCheckConfigParam*): ConfiguredPropertyCheck

    Performs a property check by applying the specified property check function to arguments supplied by implicitly passed generators, modifying the values in the implicitly passed PropertyGenConfig object with explicitly passed parameter values.

    Performs a property check by applying the specified property check function to arguments supplied by implicitly passed generators, modifying the values in the implicitly passed PropertyGenConfig object with explicitly passed parameter values.

    This method creates a ConfiguredPropertyCheck object that has six overloaded apply methods that take a function. Thus it is used with functions of all six arities. Here are some examples:

    forAll (minSize(1), maxSize(10)) { (a: String) =>
      a.length should equal ((a).length)
    }
    
    forAll (minSize(1), maxSize(10)) { (a: String, b: String) =>
      a.length + b.length should equal ((a + b).length)
    }
    
    forAll (minSize(1), maxSize(10)) { (a: String, b: String, c: String) =>
      a.length + b.length + c.length should equal ((a + b + c).length)
    }
    
    forAll (minSize(1), maxSize(10)) { (a: String, b: String, c: String, d: String) =>
      a.length + b.length + c.length + d.length should equal ((a + b + c + d).length)
    }
    
    forAll (minSize(1), maxSize(10)) { (a: String, b: String, c: String, d: String, e: String) =>
      a.length + b.length + c.length + d.length + e.length should equal ((a + b + c + d + e).length)
    }
    
    forAll (minSize(1), maxSize(10)) { (a: String, b: String, c: String, d: String, e: String, f: String) =>
      a.length + b.length + c.length + d.length + e.length + f.length should equal ((a + b + c + d + e + f).length)
    }
    

    configParams

    a variable length list of PropertyCheckConfigParam objects that should override corresponding values in the PropertyCheckConfiguration implicitly passed to the apply methods of the ConfiguredPropertyCheck object returned by this method.

    Definition Classes
    GeneratorDrivenPropertyChecks
  96. def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, ASSERTION](table: TableFor22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor22.

    Performs a property check by applying the specified property check function to each row of the specified TableFor22.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  97. def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, ASSERTION](table: TableFor21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor21.

    Performs a property check by applying the specified property check function to each row of the specified TableFor21.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  98. def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, ASSERTION](table: TableFor20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor20.

    Performs a property check by applying the specified property check function to each row of the specified TableFor20.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  99. def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, ASSERTION](table: TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor19.

    Performs a property check by applying the specified property check function to each row of the specified TableFor19.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  100. def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, ASSERTION](table: TableFor18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor18.

    Performs a property check by applying the specified property check function to each row of the specified TableFor18.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  101. def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, ASSERTION](table: TableFor17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor17.

    Performs a property check by applying the specified property check function to each row of the specified TableFor17.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  102. def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ASSERTION](table: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor16.

    Performs a property check by applying the specified property check function to each row of the specified TableFor16.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  103. def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ASSERTION](table: TableFor15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor15.

    Performs a property check by applying the specified property check function to each row of the specified TableFor15.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  104. def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, ASSERTION](table: TableFor14[A, B, C, D, E, F, G, H, I, J, K, L, M, N])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor14.

    Performs a property check by applying the specified property check function to each row of the specified TableFor14.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  105. def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, ASSERTION](table: TableFor13[A, B, C, D, E, F, G, H, I, J, K, L, M])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor13.

    Performs a property check by applying the specified property check function to each row of the specified TableFor13.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  106. def forAll[A, B, C, D, E, F, G, H, I, J, K, L, ASSERTION](table: TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])(fun: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor12.

    Performs a property check by applying the specified property check function to each row of the specified TableFor12.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  107. def forAll[A, B, C, D, E, F, G, H, I, J, K, ASSERTION](table: TableFor11[A, B, C, D, E, F, G, H, I, J, K])(fun: (A, B, C, D, E, F, G, H, I, J, K) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor11.

    Performs a property check by applying the specified property check function to each row of the specified TableFor11.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  108. def forAll[A, B, C, D, E, F, G, H, I, J, ASSERTION](table: TableFor10[A, B, C, D, E, F, G, H, I, J])(fun: (A, B, C, D, E, F, G, H, I, J) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor10.

    Performs a property check by applying the specified property check function to each row of the specified TableFor10.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  109. def forAll[A, B, C, D, E, F, G, H, I, ASSERTION](table: TableFor9[A, B, C, D, E, F, G, H, I])(fun: (A, B, C, D, E, F, G, H, I) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor9.

    Performs a property check by applying the specified property check function to each row of the specified TableFor9.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  110. def forAll[A, B, C, D, E, F, G, H, ASSERTION](table: TableFor8[A, B, C, D, E, F, G, H])(fun: (A, B, C, D, E, F, G, H) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor8.

    Performs a property check by applying the specified property check function to each row of the specified TableFor8.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  111. def forAll[A, B, C, D, E, F, G, ASSERTION](table: TableFor7[A, B, C, D, E, F, G])(fun: (A, B, C, D, E, F, G) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor7.

    Performs a property check by applying the specified property check function to each row of the specified TableFor7.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  112. def forAll[A, B, C, D, E, F, ASSERTION](table: TableFor6[A, B, C, D, E, F])(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor6.

    Performs a property check by applying the specified property check function to each row of the specified TableFor6.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  113. def forAll[A, B, C, D, E, ASSERTION](table: TableFor5[A, B, C, D, E])(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor5.

    Performs a property check by applying the specified property check function to each row of the specified TableFor5.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  114. def forAll[A, B, C, D, ASSERTION](table: TableFor4[A, B, C, D])(fun: (A, B, C, D) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor4.

    Performs a property check by applying the specified property check function to each row of the specified TableFor4.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  115. def forAll[A, B, C, ASSERTION](table: TableFor3[A, B, C])(fun: (A, B, C) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor3.

    Performs a property check by applying the specified property check function to each row of the specified TableFor3.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  116. def forAll[A, B, ASSERTION](table: TableFor2[A, B])(fun: (A, B) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor2.

    Performs a property check by applying the specified property check function to each row of the specified TableFor2.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  117. def forAll[A, ASSERTION](table: TableFor1[A])(fun: (A) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor1.

    Performs a property check by applying the specified property check function to each row of the specified TableFor1.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  118. def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, ASSERTION](table: TableFor22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor22 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor22 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  119. def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, ASSERTION](table: TableFor21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor21 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor21 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  120. def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, ASSERTION](table: TableFor20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor20 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor20 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  121. def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, ASSERTION](table: TableFor19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor19 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor19 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  122. def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, ASSERTION](table: TableFor18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor18 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor18 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  123. def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, ASSERTION](table: TableFor17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor17 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor17 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  124. def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ASSERTION](table: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor16 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor16 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  125. def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ASSERTION](table: TableFor15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor15 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor15 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  126. def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, ASSERTION](table: TableFor14[A, B, C, D, E, F, G, H, I, J, K, L, M, N])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor14 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor14 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  127. def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, ASSERTION](table: TableFor13[A, B, C, D, E, F, G, H, I, J, K, L, M])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor13 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor13 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  128. def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, ASSERTION](table: TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])(fun: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor12 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor12 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  129. def forEvery[A, B, C, D, E, F, G, H, I, J, K, ASSERTION](table: TableFor11[A, B, C, D, E, F, G, H, I, J, K])(fun: (A, B, C, D, E, F, G, H, I, J, K) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor11 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor11 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  130. def forEvery[A, B, C, D, E, F, G, H, I, J, ASSERTION](table: TableFor10[A, B, C, D, E, F, G, H, I, J])(fun: (A, B, C, D, E, F, G, H, I, J) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor10 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor10 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  131. def forEvery[A, B, C, D, E, F, G, H, I, ASSERTION](table: TableFor9[A, B, C, D, E, F, G, H, I])(fun: (A, B, C, D, E, F, G, H, I) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor9 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor9 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  132. def forEvery[A, B, C, D, E, F, G, H, ASSERTION](table: TableFor8[A, B, C, D, E, F, G, H])(fun: (A, B, C, D, E, F, G, H) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor8 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor8 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  133. def forEvery[A, B, C, D, E, F, G, ASSERTION](table: TableFor7[A, B, C, D, E, F, G])(fun: (A, B, C, D, E, F, G) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor7 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor7 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  134. def forEvery[A, B, C, D, E, F, ASSERTION](table: TableFor6[A, B, C, D, E, F])(fun: (A, B, C, D, E, F) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor6 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor6 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  135. def forEvery[A, B, C, D, E, ASSERTION](table: TableFor5[A, B, C, D, E])(fun: (A, B, C, D, E) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor5 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor5 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  136. def forEvery[A, B, C, D, ASSERTION](table: TableFor4[A, B, C, D])(fun: (A, B, C, D) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor4 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor4 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  137. def forEvery[A, B, C, ASSERTION](table: TableFor3[A, B, C])(fun: (A, B, C) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor3 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor3 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  138. def forEvery[A, B, ASSERTION](table: TableFor2[A, B])(fun: (A, B) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor2 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor2 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  139. def forEvery[A, ASSERTION](table: TableFor1[A])(fun: (A) ⇒ ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

    Performs a property check by applying the specified property check function to each row of the specified TableFor1 and reporting every error.

    Performs a property check by applying the specified property check function to each row of the specified TableFor1 and reporting every error.

    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.

    table

    the table of data with which to perform the property check

    fun

    the property check function to apply to each row of data in the table

    Definition Classes
    TableDrivenPropertyChecks
  140. def frequency[T](first: (Int, Generator[T]), second: (Int, Generator[T]), rest: (Int, Generator[T])*): Generator[T]

    Definition Classes
    CommonGenerators
  141. def function0s[A](implicit genOfA: Generator[A]): Generator[() ⇒ A]

    Definition Classes
    CommonGenerators
  142. def function10s[A, B, C, D, E, F, G, H, I, J, K](implicit genOfK: Generator[K], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K]): Generator[(A, B, C, D, E, F, G, H, I, J) ⇒ K]

    Definition Classes
    CommonGenerators
  143. def function11s[A, B, C, D, E, F, G, H, I, J, K, L](implicit genOfL: Generator[L], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L]): Generator[(A, B, C, D, E, F, G, H, I, J, K) ⇒ L]

    Definition Classes
    CommonGenerators
  144. def function12s[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit genOfM: Generator[M], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L) ⇒ M]

    Definition Classes
    CommonGenerators
  145. def function13s[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit genOfN: Generator[N], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ N]

    Definition Classes
    CommonGenerators
  146. def function14s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit genOfO: Generator[O], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ O]

    Definition Classes
    CommonGenerators
  147. def function15s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit genOfP: Generator[P], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ P]

    Definition Classes
    CommonGenerators
  148. def function16s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit genOfQ: Generator[Q], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ Q]

    Definition Classes
    CommonGenerators
  149. def function17s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit genOfR: Generator[R], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q], typeInfoR: TypeInfo[R]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ R]

    Definition Classes
    CommonGenerators
  150. def function18s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit genOfS: Generator[S], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q], typeInfoR: TypeInfo[R], typeInfoS: TypeInfo[S]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ S]

    Definition Classes
    CommonGenerators
  151. def function19s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit genOfT: Generator[T], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q], typeInfoR: TypeInfo[R], typeInfoS: TypeInfo[S], typeInfoT: TypeInfo[T]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ T]

    Definition Classes
    CommonGenerators
  152. def function1s[A, B](implicit genOfB: Generator[B], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B]): Generator[(A) ⇒ B]

    Definition Classes
    CommonGenerators
  153. def function20s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit genOfU: Generator[U], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q], typeInfoR: TypeInfo[R], typeInfoS: TypeInfo[S], typeInfoT: TypeInfo[T], typeInfoU: TypeInfo[U]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ U]

    Definition Classes
    CommonGenerators
  154. def function21s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit genOfV: Generator[V], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q], typeInfoR: TypeInfo[R], typeInfoS: TypeInfo[S], typeInfoT: TypeInfo[T], typeInfoU: TypeInfo[U], typeInfoV: TypeInfo[V]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ V]

    Definition Classes
    CommonGenerators
  155. def function22s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W](implicit genOfW: Generator[W], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q], typeInfoR: TypeInfo[R], typeInfoS: TypeInfo[S], typeInfoT: TypeInfo[T], typeInfoU: TypeInfo[U], typeInfoV: TypeInfo[V], typeInfoW: TypeInfo[W]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ W]

    Definition Classes
    CommonGenerators
  156. def function2s[A, B, C](implicit genOfC: Generator[C], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C]): Generator[(A, B) ⇒ C]

    Definition Classes
    CommonGenerators
  157. def function3s[A, B, C, D](implicit genOfD: Generator[D], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D]): Generator[(A, B, C) ⇒ D]

    Definition Classes
    CommonGenerators
  158. def function4s[A, B, C, D, E](implicit genOfE: Generator[E], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E]): Generator[(A, B, C, D) ⇒ E]

    Definition Classes
    CommonGenerators
  159. def function5s[A, B, C, D, E, F](implicit genOfF: Generator[F], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F]): Generator[(A, B, C, D, E) ⇒ F]

    Definition Classes
    CommonGenerators
  160. def function6s[A, B, C, D, E, F, G](implicit genOfG: Generator[G], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G]): Generator[(A, B, C, D, E, F) ⇒ G]

    Definition Classes
    CommonGenerators
  161. def function7s[A, B, C, D, E, F, G, H](implicit genOfH: Generator[H], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H]): Generator[(A, B, C, D, E, F, G) ⇒ H]

    Definition Classes
    CommonGenerators
  162. def function8s[A, B, C, D, E, F, G, H, I](implicit genOfI: Generator[I], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I]): Generator[(A, B, C, D, E, F, G, H) ⇒ I]

    Definition Classes
    CommonGenerators
  163. def function9s[A, B, C, D, E, F, G, H, I, J](implicit genOfJ: Generator[J], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J]): Generator[(A, B, C, D, E, F, G, H, I) ⇒ J]

    Definition Classes
    CommonGenerators
  164. implicit val generatorDrivenConfig: PropertyCheckConfiguration

    Implicit PropertyCheckConfig value providing default configuration values.

    Implicit PropertyCheckConfig value providing default configuration values.

    Definition Classes
    Configuration
  165. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  166. def getParameter(configParams: Seq[PropertyCheckConfigParam], c: PropertyCheckConfiguration): Parameter

    Definition Classes
    Configuration
  167. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  168. def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) ⇒ W)(deconstruct: (W) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S], genOfT: Generator[T], genOfU: Generator[U], genOfV: Generator[V]): Generator[W]

    Definition Classes
    CommonGenerators
  169. def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) ⇒ V)(deconstruct: (V) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S], genOfT: Generator[T], genOfU: Generator[U]): Generator[V]

    Definition Classes
    CommonGenerators
  170. def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) ⇒ U)(deconstruct: (U) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S], genOfT: Generator[T]): Generator[U]

    Definition Classes
    CommonGenerators
  171. def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) ⇒ T)(deconstruct: (T) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S]): Generator[T]

    Definition Classes
    CommonGenerators
  172. def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) ⇒ S)(deconstruct: (S) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R]): Generator[S]

    Definition Classes
    CommonGenerators
  173. def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) ⇒ R)(deconstruct: (R) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q]): Generator[R]

    Definition Classes
    CommonGenerators
  174. def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ Q)(deconstruct: (Q) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P]): Generator[Q]

    Definition Classes
    CommonGenerators
  175. def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) ⇒ P)(deconstruct: (P) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O]): Generator[P]

    Definition Classes
    CommonGenerators
  176. def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) ⇒ O)(deconstruct: (O) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N]): Generator[O]

    Definition Classes
    CommonGenerators
  177. def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M) ⇒ N)(deconstruct: (N) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M]): Generator[N]

    Definition Classes
    CommonGenerators
  178. def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M](construct: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ M)(deconstruct: (M) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L]): Generator[M]

    Definition Classes
    CommonGenerators
  179. def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L](construct: (A, B, C, D, E, F, G, H, I, J, K) ⇒ L)(deconstruct: (L) ⇒ (A, B, C, D, E, F, G, H, I, J, K))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K]): Generator[L]

    Definition Classes
    CommonGenerators
  180. def instancesOf[A, B, C, D, E, F, G, H, I, J, K](construct: (A, B, C, D, E, F, G, H, I, J) ⇒ K)(deconstruct: (K) ⇒ (A, B, C, D, E, F, G, H, I, J))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J]): Generator[K]

    Definition Classes
    CommonGenerators
  181. def instancesOf[A, B, C, D, E, F, G, H, I, J](construct: (A, B, C, D, E, F, G, H, I) ⇒ J)(deconstruct: (J) ⇒ (A, B, C, D, E, F, G, H, I))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I]): Generator[J]

    Definition Classes
    CommonGenerators
  182. def instancesOf[A, B, C, D, E, F, G, H, I](construct: (A, B, C, D, E, F, G, H) ⇒ I)(deconstruct: (I) ⇒ (A, B, C, D, E, F, G, H))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H]): Generator[I]

    Definition Classes
    CommonGenerators
  183. def instancesOf[A, B, C, D, E, F, G, H](construct: (A, B, C, D, E, F, G) ⇒ H)(deconstruct: (H) ⇒ (A, B, C, D, E, F, G))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G]): Generator[H]

    Definition Classes
    CommonGenerators
  184. def instancesOf[A, B, C, D, E, F, G](construct: (A, B, C, D, E, F) ⇒ G)(deconstruct: (G) ⇒ (A, B, C, D, E, F))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F]): Generator[G]

    Definition Classes
    CommonGenerators
  185. def instancesOf[A, B, C, D, E, F](construct: (A, B, C, D, E) ⇒ F)(deconstruct: (F) ⇒ (A, B, C, D, E))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E]): Generator[F]

    Definition Classes
    CommonGenerators
  186. def instancesOf[A, B, C, D, E](construct: (A, B, C, D) ⇒ E)(deconstruct: (E) ⇒ (A, B, C, D))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D]): Generator[E]

    Definition Classes
    CommonGenerators
  187. def instancesOf[A, B, C, D](construct: (A, B, C) ⇒ D)(deconstruct: (D) ⇒ (A, B, C))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C]): Generator[D]

    Definition Classes
    CommonGenerators
  188. def instancesOf[A, B, C](construct: (A, B) ⇒ C)(deconstruct: (C) ⇒ (A, B))(implicit genOfA: Generator[A], genOfB: Generator[B]): Generator[C]

    Definition Classes
    CommonGenerators
  189. def instancesOf[A, B](construct: (A) ⇒ B)(deconstruct: (B) ⇒ A)(implicit genOfA: Generator[A]): Generator[B]

    Definition Classes
    CommonGenerators
  190. val ints: Generator[Int]

    Definition Classes
    CommonGenerators
  191. def intsBetween(from: Int, to: Int): Generator[Int]

    Definition Classes
    CommonGenerators
  192. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  193. def lists[T](implicit genOfT: Generator[T]): Generator[List[T]] with HavingLength[List[T]]

    Definition Classes
    CommonGenerators
  194. val longs: Generator[Long]

    Definition Classes
    CommonGenerators
  195. def longsBetween(from: Long, to: Long): Generator[Long]

    Definition Classes
    CommonGenerators
  196. def maps[K, V](implicit genOfTupleKV: Generator[(K, V)]): Generator[Map[K, V]] with HavingSize[Map[K, V]]

    Definition Classes
    CommonGenerators
  197. def maxDiscardedFactor(value: PosZDouble): MaxDiscardedFactor

    Returns a MaxDiscardedFactor property check configuration parameter containing the passed value, which specifies the factor of discarded property evaluations allowed during property evaluation.

    Returns a MaxDiscardedFactor property check configuration parameter containing the passed value, which specifies the factor of discarded property evaluations allowed during property evaluation.

    Definition Classes
    Configuration
  198. def minSize(value: PosZInt): MinSize

    Returns a MinSize property check configuration parameter containing the passed value, which specifies the minimum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).

    Returns a MinSize property check configuration parameter containing the passed value, which specifies the minimum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).

    Definition Classes
    Configuration
  199. def minSuccessful(value: PosInt): MinSuccessful

    Returns a MinSuccessful property check configuration parameter containing the passed value, which specifies the minimum number of successful property evaluations required for the property to pass.

    Returns a MinSuccessful property check configuration parameter containing the passed value, which specifies the minimum number of successful property evaluations required for the property to pass.

    Definition Classes
    Configuration
  200. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  201. val negDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators
  202. val negDoubles: Generator[NegDouble]

    Definition Classes
    CommonGenerators
  203. def negDoublesBetween(from: NegDouble, to: NegDouble): Generator[NegDouble]

    Definition Classes
    CommonGenerators
  204. val negFiniteDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators
  205. val negFiniteDoubles: Generator[NegFiniteDouble]

    Definition Classes
    CommonGenerators
  206. def negFiniteDoublesBetween(from: NegFiniteDouble, to: NegFiniteDouble): Generator[NegFiniteDouble]

    Definition Classes
    CommonGenerators
  207. val negFiniteFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators
  208. val negFiniteFloats: Generator[NegFiniteFloat]

    Definition Classes
    CommonGenerators
  209. def negFiniteFloatsBetween(from: NegFiniteFloat, to: NegFiniteFloat): Generator[NegFiniteFloat]

    Definition Classes
    CommonGenerators
  210. val negFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators
  211. val negFloats: Generator[NegFloat]

    Definition Classes
    CommonGenerators
  212. def negFloatsBetween(from: NegFloat, to: NegFloat): Generator[NegFloat]

    Definition Classes
    CommonGenerators
  213. val negIntValues: Generator[Int]

    Definition Classes
    CommonGenerators
  214. val negInts: Generator[NegInt]

    Definition Classes
    CommonGenerators
  215. def negIntsBetween(from: NegInt, to: NegInt): Generator[NegInt]

    Definition Classes
    CommonGenerators
  216. val negLongValues: Generator[Long]

    Definition Classes
    CommonGenerators
  217. val negLongs: Generator[NegLong]

    Definition Classes
    CommonGenerators
  218. def negLongsBetween(from: NegLong, to: NegLong): Generator[NegLong]

    Definition Classes
    CommonGenerators
  219. val negZDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators
  220. val negZDoubles: Generator[NegZDouble]

    Definition Classes
    CommonGenerators
  221. def negZDoublesBetween(from: NegZDouble, to: NegZDouble): Generator[NegZDouble]

    Definition Classes
    CommonGenerators
  222. val negZFiniteDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators
  223. val negZFiniteDoubles: Generator[NegZFiniteDouble]

    Definition Classes
    CommonGenerators
  224. def negZFiniteDoublesBetween(from: NegZFiniteDouble, to: NegZFiniteDouble): Generator[NegZFiniteDouble]

    Definition Classes
    CommonGenerators
  225. val negZFiniteFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators
  226. val negZFiniteFloats: Generator[NegZFiniteFloat]

    Definition Classes
    CommonGenerators
  227. def negZFiniteFloatsBetween(from: NegZFiniteFloat, to: NegZFiniteFloat): Generator[NegZFiniteFloat]

    Definition Classes
    CommonGenerators
  228. val negZFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators
  229. val negZFloats: Generator[NegZFloat]

    Definition Classes
    CommonGenerators
  230. def negZFloatsBetween(from: NegZFloat, to: NegZFloat): Generator[NegZFloat]

    Definition Classes
    CommonGenerators
  231. val negZIntValues: Generator[Int]

    Definition Classes
    CommonGenerators
  232. val negZInts: Generator[NegZInt]

    Definition Classes
    CommonGenerators
  233. def negZIntsBetween(from: NegZInt, to: NegZInt): Generator[NegZInt]

    Definition Classes
    CommonGenerators
  234. val negZLongValues: Generator[Long]

    Definition Classes
    CommonGenerators
  235. val negZLongs: Generator[NegZLong]

    Definition Classes
    CommonGenerators
  236. def negZLongsBetween(from: NegZLong, to: NegZLong): Generator[NegZLong]

    Definition Classes
    CommonGenerators
  237. val nonZeroDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators
  238. val nonZeroDoubles: Generator[NonZeroDouble]

    Definition Classes
    CommonGenerators
  239. def nonZeroDoublesBetween(from: NonZeroDouble, to: NonZeroDouble): Generator[NonZeroDouble]

    Definition Classes
    CommonGenerators
  240. val nonZeroFiniteDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators
  241. val nonZeroFiniteDoubles: Generator[NonZeroFiniteDouble]

    Definition Classes
    CommonGenerators
  242. def nonZeroFiniteDoublesBetween(from: NonZeroFiniteDouble, to: NonZeroFiniteDouble): Generator[NonZeroFiniteDouble]

    Definition Classes
    CommonGenerators
  243. val nonZeroFiniteFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators
  244. val nonZeroFiniteFloats: Generator[NonZeroFiniteFloat]

    Definition Classes
    CommonGenerators
  245. def nonZeroFiniteFloatsBetween(from: NonZeroFiniteFloat, to: NonZeroFiniteFloat): Generator[NonZeroFiniteFloat]

    Definition Classes
    CommonGenerators
  246. val nonZeroFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators
  247. val nonZeroFloats: Generator[NonZeroFloat]

    Definition Classes
    CommonGenerators
  248. def nonZeroFloatsBetween(from: NonZeroFloat, to: NonZeroFloat): Generator[NonZeroFloat]

    Definition Classes
    CommonGenerators
  249. val nonZeroIntValues: Generator[Int]

    Definition Classes
    CommonGenerators
  250. val nonZeroInts: Generator[NonZeroInt]

    Definition Classes
    CommonGenerators
  251. def nonZeroIntsBetween(from: NonZeroInt, to: NonZeroInt): Generator[NonZeroInt]

    Definition Classes
    CommonGenerators
  252. val nonZeroLongValues: Generator[Long]

    Definition Classes
    CommonGenerators
  253. val nonZeroLongs: Generator[NonZeroLong]

    Definition Classes
    CommonGenerators
  254. def nonZeroLongsBetween(from: NonZeroLong, to: NonZeroLong): Generator[NonZeroLong]

    Definition Classes
    CommonGenerators
  255. final def notify(): Unit

    Definition Classes
    AnyRef
  256. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  257. val numericCharValues: Generator[Char]

    Definition Classes
    CommonGenerators
  258. val numericChars: Generator[NumericChar]

    Definition Classes
    CommonGenerators
  259. val posDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators
  260. val posDoubles: Generator[PosDouble]

    Definition Classes
    CommonGenerators
  261. def posDoublesBetween(from: PosDouble, to: PosDouble): Generator[PosDouble]

    Definition Classes
    CommonGenerators
  262. val posFiniteDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators
  263. val posFiniteDoubles: Generator[PosFiniteDouble]

    Definition Classes
    CommonGenerators
  264. def posFiniteDoublesBetween(from: PosFiniteDouble, to: PosFiniteDouble): Generator[PosFiniteDouble]

    Definition Classes
    CommonGenerators
  265. val posFiniteFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators
  266. val posFiniteFloats: Generator[PosFiniteFloat]

    Definition Classes
    CommonGenerators
  267. def posFiniteFloatsBetween(from: PosFiniteFloat, to: PosFiniteFloat): Generator[PosFiniteFloat]

    Definition Classes
    CommonGenerators
  268. val posFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators
  269. val posFloats: Generator[PosFloat]

    Definition Classes
    CommonGenerators
  270. def posFloatsBetween(from: PosFloat, to: PosFloat): Generator[PosFloat]

    Definition Classes
    CommonGenerators
  271. val posIntValues: Generator[Int]

    Definition Classes
    CommonGenerators
  272. val posInts: Generator[PosInt]

    Definition Classes
    CommonGenerators
  273. def posIntsBetween(from: PosInt, to: PosInt): Generator[PosInt]

    Definition Classes
    CommonGenerators
  274. val posLongValues: Generator[Long]

    Definition Classes
    CommonGenerators
  275. val posLongs: Generator[PosLong]

    Definition Classes
    CommonGenerators
  276. def posLongsBetween(from: PosLong, to: PosLong): Generator[PosLong]

    Definition Classes
    CommonGenerators
  277. val posZDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators
  278. val posZDoubles: Generator[PosZDouble]

    Definition Classes
    CommonGenerators
  279. def posZDoublesBetween(from: PosZDouble, to: PosZDouble): Generator[PosZDouble]

    Definition Classes
    CommonGenerators
  280. val posZFiniteDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators
  281. val posZFiniteDoubles: Generator[PosZFiniteDouble]

    Definition Classes
    CommonGenerators
  282. def posZFiniteDoublesBetween(from: PosZFiniteDouble, to: PosZFiniteDouble): Generator[PosZFiniteDouble]

    Definition Classes
    CommonGenerators
  283. val posZFiniteFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators
  284. val posZFiniteFloats: Generator[PosZFiniteFloat]

    Definition Classes
    CommonGenerators
  285. def posZFiniteFloatsBetween(from: PosZFiniteFloat, to: PosZFiniteFloat): Generator[PosZFiniteFloat]

    Definition Classes
    CommonGenerators
  286. val posZFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators
  287. val posZFloats: Generator[PosZFloat]

    Definition Classes
    CommonGenerators
  288. def posZFloatsBetween(from: PosZFloat, to: PosZFloat): Generator[PosZFloat]

    Definition Classes
    CommonGenerators
  289. val posZIntValues: Generator[Int]

    Definition Classes
    CommonGenerators
  290. val posZInts: Generator[PosZInt]

    Definition Classes
    CommonGenerators
  291. def posZIntsBetween(from: PosZInt, to: PosZInt): Generator[PosZInt]

    Definition Classes
    CommonGenerators
  292. val posZLongValues: Generator[Long]

    Definition Classes
    CommonGenerators
  293. val posZLongs: Generator[PosZLong]

    Definition Classes
    CommonGenerators
  294. def posZLongsBetween(from: PosZLong, to: PosZLong): Generator[PosZLong]

    Definition Classes
    CommonGenerators
  295. def sets[T](implicit genOfT: Generator[T]): Generator[Set[T]] with HavingSize[Set[T]]

    Definition Classes
    CommonGenerators
  296. val shorts: Generator[Short]

    Definition Classes
    CommonGenerators
  297. def shortsBetween(from: Short, to: Short): Generator[Short]

    Definition Classes
    CommonGenerators
  298. def sizeRange(value: PosZInt): SizeRange

    Returns a SizeRange property check configuration parameter containing the passed value, that (with minSize) specifies the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).

    Returns a SizeRange property check configuration parameter containing the passed value, that (with minSize) specifies the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).

    Note that the size range is added to minSize in order to calculate the maximum size passed to ScalaCheck. Using a range allows compile-time checking of a non-negative number being specified.

    Definition Classes
    Configuration
  299. def sortedMaps[K, V](implicit genOfTupleKV: Generator[(K, V)], ordering: Ordering[K]): Generator[SortedMap[K, V]] with HavingSize[SortedMap[K, V]]

    Definition Classes
    CommonGenerators
  300. def sortedSets[T](implicit genOfT: Generator[T], ordering: Ordering[T]): Generator[SortedSet[T]] with HavingSize[SortedSet[T]]

    Definition Classes
    CommonGenerators
  301. def specificValue[T](theValue: T): Generator[T]

    Definition Classes
    CommonGenerators
  302. def specificValues[T](first: T, second: T, rest: T*): Generator[T]

    Definition Classes
    CommonGenerators
  303. val strings: Generator[String]

    Definition Classes
    CommonGenerators
  304. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  305. def toString(): String

    Definition Classes
    AnyRef → Any
  306. def tuple10s[A, B, C, D, E, F, G, H, I, J](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J]): Generator[(A, B, C, D, E, F, G, H, I, J)]

    Definition Classes
    CommonGenerators
  307. def tuple11s[A, B, C, D, E, F, G, H, I, J, K](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K]): Generator[(A, B, C, D, E, F, G, H, I, J, K)]

    Definition Classes
    CommonGenerators
  308. def tuple12s[A, B, C, D, E, F, G, H, I, J, K, L](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L)]

    Definition Classes
    CommonGenerators
  309. def tuple13s[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

    Definition Classes
    CommonGenerators
  310. def tuple14s[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

    Definition Classes
    CommonGenerators
  311. def tuple15s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

    Definition Classes
    CommonGenerators
  312. def tuple16s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

    Definition Classes
    CommonGenerators
  313. def tuple17s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

    Definition Classes
    CommonGenerators
  314. def tuple18s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

    Definition Classes
    CommonGenerators
  315. def tuple19s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

    Definition Classes
    CommonGenerators
  316. def tuple20s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S], genOfT: Generator[T]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

    Definition Classes
    CommonGenerators
  317. def tuple21s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S], genOfT: Generator[T], genOfU: Generator[U]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

    Definition Classes
    CommonGenerators
  318. def tuple22s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S], genOfT: Generator[T], genOfU: Generator[U], genOfV: Generator[V]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

    Definition Classes
    CommonGenerators
  319. def tuple2s[A, B](implicit genOfA: Generator[A], genOfB: Generator[B]): Generator[(A, B)]

    Definition Classes
    CommonGenerators
  320. def tuple3s[A, B, C](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C]): Generator[(A, B, C)]

    Definition Classes
    CommonGenerators
  321. def tuple4s[A, B, C, D](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D]): Generator[(A, B, C, D)]

    Definition Classes
    CommonGenerators
  322. def tuple5s[A, B, C, D, E](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E]): Generator[(A, B, C, D, E)]

    Definition Classes
    CommonGenerators
  323. def tuple6s[A, B, C, D, E, F](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F]): Generator[(A, B, C, D, E, F)]

    Definition Classes
    CommonGenerators
  324. def tuple7s[A, B, C, D, E, F, G](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G]): Generator[(A, B, C, D, E, F, G)]

    Definition Classes
    CommonGenerators
  325. def tuple8s[A, B, C, D, E, F, G, H](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H]): Generator[(A, B, C, D, E, F, G, H)]

    Definition Classes
    CommonGenerators
  326. def tuple9s[A, B, C, D, E, F, G, H, I](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I]): Generator[(A, B, C, D, E, F, G, H, I)]

    Definition Classes
    CommonGenerators
  327. def vectors[T](implicit genOfT: Generator[T]): Generator[Vector[T]] with HavingLength[Vector[T]]

    Definition Classes
    CommonGenerators
  328. final def wait(): Unit

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  331. def whenever[T](condition: Boolean)(fun: ⇒ T)(implicit wa: WheneverAsserting[T]): Result

    Evaluates the passed code block if the passed boolean condition is true, else throws DiscardedEvaluationException.

    Evaluates the passed code block if the passed boolean condition is true, else throws DiscardedEvaluationException.

    The whenever method can be used inside property check functions to discard invocations of the function with data for which it is known the property would fail. For example, given the following Fraction class:

    class Fraction(n: Int, d: Int) {
    
      require(d != 0)
      require(d != Integer.MIN_VALUE)
      require(n != Integer.MIN_VALUE)
    
      val numer = if (d < 0) -1 * n else n
      val denom = d.abs
    
      override def toString = numer + " / " + denom
    }
    

    import org.scalatest.prop.TableDrivenPropertyChecks._
    
    val fractions =
      Table(
        ("n", "d"),
        (  1,   2),
        ( -1,   2),
        (  1,  -2),
        ( -1,  -2),
        (  3,   1),
        ( -3,   1),
        ( -3,   0),
        (  3,  -1),
        (  3,  Integer.MIN_VALUE),
        (Integer.MIN_VALUE, 3),
        ( -3,  -1)
      )
    

    Imagine you wanted to check a property against this class with data that includes some value that are rejected by the constructor, such as a denominator of zero, which should result in an IllegalArgumentException. You could use whenever to discard any rows in the fraction that represent illegal arguments, like this:

    import org.scalatest.matchers.Matchers._
    
    forAll (fractions) { (n: Int, d: Int) =>
    
      whenever (d != 0 && d != Integer.MIN_VALUE
          && n != Integer.MIN_VALUE) {
    
        val f = new Fraction(n, d)
    
        if (n < 0 && d < 0 || n > 0 && d > 0)
          f.numer should be > 0
        else if (n != 0)
          f.numer should be < 0
        else
          f.numer should === (0)
    
        f.denom should be > 0
      }
    }
    

    In this example, rows 6, 8, and 9 have values that would cause a false to be passed to whenever. (For example, in row 6, d is 0, which means d != 0 will be false.) For those rows, whenever will throw DiscardedEvaluationException, which will cause the forAll method to discard that row.

    condition

    the boolean condition that determines whether whenever will evaluate the fun function (condition is true) or throws DiscardedEvaluationException (condition is false)

    fun

    the function to evaluate if the specified condition is true

    Definition Classes
    Whenever
  332. def workers(value: PosInt): Workers

    Returns a Workers property check configuration parameter containing the passed value, which specifies the number of worker threads to use when evaluating a property.

    Returns a Workers property check configuration parameter containing the passed value, which specifies the number of worker threads to use when evaluating a property.

    Definition Classes
    Configuration

Deprecated Value Members

  1. def maxDiscarded(value: Int): MaxDiscarded

    Returns a MaxDiscarded property check configuration parameter containing the passed value, which specifies the maximum number of discarded property evaluations allowed during property evaluation.

    Returns a MaxDiscarded property check configuration parameter containing the passed value, which specifies the maximum number of discarded property evaluations allowed during property evaluation.

    Definition Classes
    Configuration
    Annotations
    @deprecated
    Deprecated

    use maxDiscardedFactor instead

    Exceptions thrown
    IllegalArgumentException

    if specified value is less than zero.

  2. def maxSize(value: Int): MaxSize

    Returns a MaxSize property check configuration parameter containing the passed value, which specifies the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).

    Returns a MaxSize property check configuration parameter containing the passed value, which specifies the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).

    Note that the maximum size should be greater than or equal to the minimum size. This requirement is enforced by the PropertyCheckConfig constructor and the forAll methods of traits PropertyChecks and Checkers. In other words, it is enforced at the point both a maximum and minimum size are provided together.

    Definition Classes
    Configuration
    Annotations
    @deprecated
    Deprecated

    use SizeRange instead

    Exceptions thrown
    IllegalArgumentException

    if specified value is less than zero.

Inherited from Configuration

Inherited from CommonGenerators

Inherited from TableDrivenPropertyChecks

Inherited from Tables

Inherited from Whenever

Inherited from AnyRef

Inherited from Any

Ungrouped