GeneratorDrivenPropertyChecks

Trait containing methods that faciliate property checks against generated data using Generator.

This trait contains forAll methods that provide various ways to check properties using generated data. It also contains a wherever method that can be used to indicate a property need only hold whenever some condition is true.

For an example of trait GeneratorDrivenPropertyChecks in action, 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
}

To test the behavior of Fraction, you could mix in or import the members of GeneratorDrivenPropertyChecks (and Matchers) and check a property using a forAll method, 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 should be === 0

    f.denom should be > 0
  }
}

Trait GeneratorDrivenPropertyChecks provides overloaded forAll methods that allow you to check properties using the data provided by Generator. The simplest form of forAll method takes two parameter lists, the second of which is implicit. The first parameter list is a "property" function with one to six parameters. An implicit Generator generator object needs to be supplied for. The forAll method will pass each row of data to each parameter type. ScalaTest provides many implicit Generators for common types such as Int, String, List[Float], etc., in its Generator companion object. So long as you use types for which ScalaTest already provides implicit Generators, you needn't worry about them. Most often you can simply pass a property function to forAll, and the compiler will grab the implicit values provided by ScalaTest.

The forAll methods use the supplied Generators to generate example arguments and pass them to the property function, and generate a GeneratorDrivenPropertyCheckFailedException if the function completes abruptly for any exception that would normally cause a test to fail in ScalaTest other than DiscardedEvaluationException. An DiscardedEvaluationException, which is thrown by the whenever method (defined in trait Whenever, which this trait extends) to indicate a condition required by the property function is not met by a row of passed data, will simply cause forAll to discard that row of data.

Supplying argument names

You can optionally specify string names for the arguments passed to a property function, which will be used in any error message when describing the argument values that caused the failure. To supply the names, place them in a comma separated list in parentheses after forAll before the property function (a curried form of forAll). Here's an example:

forAll ("a", "b") { (a: String, b: String) =>
  a.length + b.length should equal ((a + b).length + 1) // Should fail
}

When this fails, you'll see an error message that includes this:

Occurred when passed generated values (
  a = "",
  b = ""
)

When you don't supply argument names, the error message will say arg0, arg1, etc.. For example, this property check:

forAll { (a: String, b: String) =>
  a.length + b.length should equal ((a + b).length + 1) // Should fail
}

Will fail with an error message that includes:

Occurred when passed generated values (
  arg0 = "",
  arg1 = ""
)

Supplying generators

ScalaTest provides a nice library of compositors that makes it easy to create your own custom generators. If you want to supply custom generators to a property check, place them in parentheses after forAll, before the property check function (a curried form of forAll).

For example, to create a generator of even integers between (and including) -2000 and 2000, you could write this:

import org.scalatest.prop.Generator

val evenInts = for (n <- Generator.chooseInt(-1000, 1000)) yield 2 * n

Given this generator, you could use it on a property check like this:

forAll (evenInts) { (n) => n % 2 should equal (0) }

Custom generators are necessary when you want to pass data types not supported by ScalaTest's Generators, but are also useful when some of the values in the full range for the passed types are not valid. For such values you would use a whenever clause. In the Fraction class shown above, neither the passed numerator or denominator can be Integer.MIN_VALUE, and the passed denominator cannot be zero. This shows up in the whenever clause like this:

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

You could in addition define generators for the numerator and denominator that only produce valid values, like this:

val validNumers =
  for (n <- Generator.chooseInt(Integer.MIN_VALUE + 1, Integer.MAX_VALUE)) yield n
val validDenoms =
  for (d <- validNumers if d != 0) yield d

You could then use them in the property check like this:

forAll (validNumers, validDenoms) { (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 be === 0

    f.denom should be > 0
  }
}

Supplying both generators and argument names

If you want to supply both generators and named arguments, you can do so by providing a list of (<generator>, <name>) pairs in parentheses after forAll, before the property function. Here's an example:

forAll ((validNumers, "n"), (validDenoms, "d")) { (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 be === 0

    f.denom should be > 0
  }
}

Were this property check to fail, it would mention the names n and d in the error message, like this:

Occurred when passed generated values (
  n = 17,
  d = 21
)

Property check configuration

The property checks performed by the forAll methods of this trait can be flexibly configured via the services provided by supertrait Configuration. The five configuration parameters for property checks along with their default values and meanings are described in the following table:

Configuration Parameter	Default Value	Meaning
minSuccessful	100	the minimum number of successful property evaluations required for the property to pass
maxDiscarded	500	the maximum number of discarded property evaluations allowed during a property check
minSize	0	the minimum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists)
maxSize	100	the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists)
workers	1	specifies the number of worker threads to use during property evaluation

The forAll methods of trait GeneratorDrivenPropertyChecks each take a PropertyCheckConfiguration object as an implicit parameter. This object provides values for each of the five configuration parameters. Trait Configuration provides an implicit val named generatorDrivenConfig with each configuration parameter set to its default value. If you want to set one or more configuration parameters to a different value for all property checks in a suite you can override this val (or hide it, for example, if you are importing the members of the GeneratorDrivenPropertyChecks companion object rather than mixing in the trait.) For example, if you want all parameters at their defaults except for minSize and maxSize, you can override generatorDrivenConfig, like this:

implicit override val generatorDrivenConfig =
  PropertyCheckConfiguration(minSize = 10, sizeRange = 10)

Or, hide it by declaring a variable of the same name in whatever scope you want the changed values to be in effect:

implicit val generatorDrivenConfig =
  PropertyCheckConfiguration(minSize = 10, sizeRange = 10)

In addition to taking a PropertyCheckConfiguration object as an implicit parameter, the forAll methods of trait GeneratorDrivenPropertyChecks also take a variable length argument list of PropertyCheckConfigParam objects that you can use to override the values provided by the implicit PropertyCheckConfiguration for a single forAll invocation. For example, if you want to set minSuccessful to 500 for just one particular forAll invocation, you can do so like this:

forAll (minSuccessful(500)) { (n: Int, d: Int) => ...

This invocation of forAll will use 500 for minSuccessful and whatever values are specified by the implicitly passed PropertyCheckConfiguration object for the other configuration parameters. If you want to set multiple configuration parameters in this way, just list them separated by commas:

forAll (minSuccessful(500), maxDiscardedFactor(0.6)) { (n: Int, d: Int) => ...

If you are using an overloaded form of forAll that already takes an initial parameter list, just add the configuration parameters after the list of generators, names, or generator/name pairs, as in:

// If providing argument names
forAll ("n", "d", minSuccessful(500), maxDiscarded(300)) {
  (n: Int, d: Int) => ...

// If providing generators
forAll (validNumers, validDenoms, minSuccessful(500), maxDiscarded(300)) {
  (n: Int, d: Int) => ...

// If providing (<generators>, <name>) pairs
forAll ((validNumers, "n"), (validDenoms, "d"), minSuccessful(500), maxDiscarded(300)) {
  (n: Int, d: Int) => ...

For more information, see the documentation for supertrait Configuration.

Linear Supertypes

Configuration, Whenever, CommonGenerators, AnyRef, Any

Known Subclasses

GeneratorDrivenPropertyChecks, PropertyChecks, PropertyChecks

Type Members

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.
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.
Instances of this class are returned by trait GeneratorDrivenPropertyChecks forAll method that accepts a variable length argument list of PropertyCheckConfigParam objects. 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)
}
```
In the first example above, the ConfiguredPropertyCheck object is returned by:
```
forAll (minSize(1), maxSize(10))
```
The code that follows is an invocation of one of the ConfiguredPropertyCheck apply methods:
```
{ (a: String) =>
  a.length should equal ((a).length)
}
```
case class MaxDiscardedFactor(value: PosZDouble) extends PropertyCheckConfigParam with Product with Serializable

Definition Classes
Configuration
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).
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).

Definition Classes
Configuration
Exceptions thrown
IllegalArgumentException if specified value is less than zero.
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.
A PropertyCheckConfigParam that specifies the minimum number of successful property evaluations required for the property to pass.

Definition Classes
Configuration
sealed abstract class PropertyCheckConfigParam extends Product with Serializable

Abstract class defining a family of configuration parameters for property checks.
Abstract class defining a family of configuration parameters for property checks.
The subclasses of this abstract class are used to pass configuration information to the forAll methods of traits PropertyChecks (for ScalaTest-style property checks) and Checkers(for ScalaCheck-style property checks).

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

Definition Classes
Configuration
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).
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).
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
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.
A PropertyCheckConfigParam that specifies the number of worker threads to use when evaluating a property.

Definition Classes
Configuration
Exceptions thrown
IllegalArgumentException if specified value is less than or equal to zero.
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.
A PropertyCheckConfigParam that specifies the maximum number of discarded property evaluations allowed during property evaluation.
In GeneratorDrivenPropertyChecks, a property evaluation is discarded if it throws DiscardedEvaluationException, which is produce by whenever clause that evaluates to false. For example, consider this ScalaTest property check:
```
// forAll defined in GeneratorDrivenPropertyChecks
forAll { (n: Int) =>
  whenever (n > 0) {
    doubleIt(n) should equal (n * 2)
  }
}
```
In the above code, whenever a non-positive n is passed, the property function will complete abruptly with DiscardedEvaluationException.
Similarly, in Checkers, a property evaluation is discarded if the expression to the left of ScalaCheck's ==> operator is false. Here's an example:
```
// forAll defined in Checkers
forAll { (n: Int) =>
  (n > 0) ==> doubleIt(n) == (n * 2)
}
```
For either kind of property check, MaxDiscarded indicates the maximum number of discarded evaluations that will be allowed. As soon as one past this number of evaluations indicates it needs to be discarded, the property check will fail.
Definition Classes
Configuration
Annotations
@deprecated
Deprecated
Exceptions thrown
IllegalArgumentException if specified value is less than zero.
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).
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).
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.
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.
Configuration object for property checks.
The default values for the parameters are:

minSuccessful 100

maxDiscarded 500

minSize 0

maxSize 100

workers 1

minSuccessful
the minimum number of successful property evaluations required for the property to pass.
maxDiscarded
the maximum number of discarded property evaluations allowed during a property check
minSize
the minimum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).
maxSize
the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).
workers
specifies the number of worker threads to use during property evaluation

Definition Classes
Configuration
Annotations
@deprecated
Deprecated
Use PropertyCheckConfiguration instead
Exceptions thrown
IllegalArgumentException if the specified minSuccessful value is less than or equal to zero, the specified maxDiscarded value is less than zero, the specified minSize value is less than zero, the specified maxSize value is less than zero, the specified minSize is greater than the specified or default value of maxSize, or the specified workers value is less than or equal to zero.
trait PropertyCheckConfigurable extends AnyRef

Definition Classes
Configuration
Annotations
@deprecated
Deprecated
Use PropertyCheckConfiguration directly instead.

Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes
AnyRef → Any
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
object PropertyCheckConfiguration extends Serializable

Definition Classes
Configuration
final def asInstanceOf[T0]: T0

Definition Classes
Any
val bytes: Generator[Byte]

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

Definition Classes
CommonGenerators
val chars: Generator[Char]

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

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

Definition Classes
CommonGenerators
def clone(): AnyRef

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

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

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

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

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

Definition Classes
CommonGenerators
def finalize(): Unit

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

Definition Classes
CommonGenerators
val finiteDoubles: Generator[FiniteDouble]

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

Definition Classes
CommonGenerators
val finiteFloatValues: Generator[Float]

Definition Classes
CommonGenerators
val finiteFloats: Generator[FiniteFloat]

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

Definition Classes
CommonGenerators
def first1000Primes: Generator[Int]

Definition Classes
CommonGenerators
val floats: Generator[Float]

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

Definition Classes
CommonGenerators
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
def forAll[A, ASSERTION](genAndNameA: (Generator[A], String), configParams: PropertyCheckConfigParam*)(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
def forAll[A, ASSERTION](genAndNameA: (Generator[A], String))(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
def forAll[A, ASSERTION](genA: Generator[A], configParams: PropertyCheckConfigParam*)(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
def forAll[A, ASSERTION](genA: Generator[A])(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
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
def forAll[A, ASSERTION](a: String)(fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
def forAll[A, ASSERTION](fun: (A) ⇒ ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
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.
def frequency[T](first: (Int, Generator[T]), second: (Int, Generator[T]), rest: (Int, Generator[T])*): Generator[T]

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

Definition Classes
CommonGenerators
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
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
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
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
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
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
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
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
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
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
def function1s[A, B](implicit genOfB: Generator[B], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B]): Generator[(A) ⇒ B]

Definition Classes
CommonGenerators
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
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
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
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
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
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
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
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
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
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
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
implicit val generatorDrivenConfig: PropertyCheckConfiguration

Implicit PropertyCheckConfig value providing default configuration values.
Implicit PropertyCheckConfig value providing default configuration values.

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

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

Definition Classes
Configuration
def hashCode(): Int

Definition Classes
AnyRef → Any
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
def instancesOf[A, B](construct: (A) ⇒ B)(deconstruct: (B) ⇒ A)(implicit genOfA: Generator[A]): Generator[B]

Definition Classes
CommonGenerators
val ints: Generator[Int]

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

Definition Classes
CommonGenerators
final def isInstanceOf[T0]: Boolean

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

Definition Classes
CommonGenerators
val longs: Generator[Long]

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

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

Definition Classes
CommonGenerators
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
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
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
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val negDoubleValues: Generator[Double]

Definition Classes
CommonGenerators
val negDoubles: Generator[NegDouble]

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

Definition Classes
CommonGenerators
val negFiniteDoubleValues: Generator[Double]

Definition Classes
CommonGenerators
val negFiniteDoubles: Generator[NegFiniteDouble]

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

Definition Classes
CommonGenerators
val negFiniteFloatValues: Generator[Float]

Definition Classes
CommonGenerators
val negFiniteFloats: Generator[NegFiniteFloat]

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

Definition Classes
CommonGenerators
val negFloatValues: Generator[Float]

Definition Classes
CommonGenerators
val negFloats: Generator[NegFloat]

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

Definition Classes
CommonGenerators
val negIntValues: Generator[Int]

Definition Classes
CommonGenerators
val negInts: Generator[NegInt]

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

Definition Classes
CommonGenerators
val negLongValues: Generator[Long]

Definition Classes
CommonGenerators
val negLongs: Generator[NegLong]

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

Definition Classes
CommonGenerators
val negZDoubleValues: Generator[Double]

Definition Classes
CommonGenerators
val negZDoubles: Generator[NegZDouble]

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

Definition Classes
CommonGenerators
val negZFiniteDoubleValues: Generator[Double]

Definition Classes
CommonGenerators
val negZFiniteDoubles: Generator[NegZFiniteDouble]

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

Definition Classes
CommonGenerators
val negZFiniteFloatValues: Generator[Float]

Definition Classes
CommonGenerators
val negZFiniteFloats: Generator[NegZFiniteFloat]

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

Definition Classes
CommonGenerators
val negZFloatValues: Generator[Float]

Definition Classes
CommonGenerators
val negZFloats: Generator[NegZFloat]

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

Definition Classes
CommonGenerators
val negZIntValues: Generator[Int]

Definition Classes
CommonGenerators
val negZInts: Generator[NegZInt]

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

Definition Classes
CommonGenerators
val negZLongValues: Generator[Long]

Definition Classes
CommonGenerators
val negZLongs: Generator[NegZLong]

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

Definition Classes
CommonGenerators
val nonZeroDoubleValues: Generator[Double]

Definition Classes
CommonGenerators
val nonZeroDoubles: Generator[NonZeroDouble]

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

Definition Classes
CommonGenerators
val nonZeroFiniteDoubleValues: Generator[Double]

Definition Classes
CommonGenerators
val nonZeroFiniteDoubles: Generator[NonZeroFiniteDouble]

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

Definition Classes
CommonGenerators
val nonZeroFiniteFloatValues: Generator[Float]

Definition Classes
CommonGenerators
val nonZeroFiniteFloats: Generator[NonZeroFiniteFloat]

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

Definition Classes
CommonGenerators
val nonZeroFloatValues: Generator[Float]

Definition Classes
CommonGenerators
val nonZeroFloats: Generator[NonZeroFloat]

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

Definition Classes
CommonGenerators
val nonZeroIntValues: Generator[Int]

Definition Classes
CommonGenerators
val nonZeroInts: Generator[NonZeroInt]

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

Definition Classes
CommonGenerators
val nonZeroLongValues: Generator[Long]

Definition Classes
CommonGenerators
val nonZeroLongs: Generator[NonZeroLong]

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

Definition Classes
CommonGenerators
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val numericCharValues: Generator[Char]

Definition Classes
CommonGenerators
val numericChars: Generator[NumericChar]

Definition Classes
CommonGenerators
val posDoubleValues: Generator[Double]

Definition Classes
CommonGenerators
val posDoubles: Generator[PosDouble]

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

Definition Classes
CommonGenerators
val posFiniteDoubleValues: Generator[Double]

Definition Classes
CommonGenerators
val posFiniteDoubles: Generator[PosFiniteDouble]

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

Definition Classes
CommonGenerators
val posFiniteFloatValues: Generator[Float]

Definition Classes
CommonGenerators
val posFiniteFloats: Generator[PosFiniteFloat]

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

Definition Classes
CommonGenerators
val posFloatValues: Generator[Float]

Definition Classes
CommonGenerators
val posFloats: Generator[PosFloat]

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

Definition Classes
CommonGenerators
val posIntValues: Generator[Int]

Definition Classes
CommonGenerators
val posInts: Generator[PosInt]

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

Definition Classes
CommonGenerators
val posLongValues: Generator[Long]

Definition Classes
CommonGenerators
val posLongs: Generator[PosLong]

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

Definition Classes
CommonGenerators
val posZDoubleValues: Generator[Double]

Definition Classes
CommonGenerators
val posZDoubles: Generator[PosZDouble]

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

Definition Classes
CommonGenerators
val posZFiniteDoubleValues: Generator[Double]

Definition Classes
CommonGenerators
val posZFiniteDoubles: Generator[PosZFiniteDouble]

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

Definition Classes
CommonGenerators
val posZFiniteFloatValues: Generator[Float]

Definition Classes
CommonGenerators
val posZFiniteFloats: Generator[PosZFiniteFloat]

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

Definition Classes
CommonGenerators
val posZFloatValues: Generator[Float]

Definition Classes
CommonGenerators
val posZFloats: Generator[PosZFloat]

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

Definition Classes
CommonGenerators
val posZIntValues: Generator[Int]

Definition Classes
CommonGenerators
val posZInts: Generator[PosZInt]

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

Definition Classes
CommonGenerators
val posZLongValues: Generator[Long]

Definition Classes
CommonGenerators
val posZLongs: Generator[PosZLong]

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

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

Definition Classes
CommonGenerators
val shorts: Generator[Short]

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

Definition Classes
CommonGenerators
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
def sortedMaps[K, V](implicit genOfTupleKV: Generator[(K, V)], ordering: Ordering[K]): Generator[SortedMap[K, V]] with HavingSize[SortedMap[K, V]]

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

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

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

Definition Classes
CommonGenerators
val strings: Generator[String]

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

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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
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
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
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
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
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
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
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
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
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
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
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
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
def tuple2s[A, B](implicit genOfA: Generator[A], genOfB: Generator[B]): Generator[(A, B)]

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

Definition Classes
CommonGenerators
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
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
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
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
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
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
def vectors[T](implicit genOfT: Generator[T]): Generator[Vector[T]] with HavingLength[Vector[T]]

Definition Classes
CommonGenerators
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )
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
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

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

Related Docs: object GeneratorDrivenPropertyChecks | package prop

trait GeneratorDrivenPropertyChecks extends CommonGenerators with Whenever with Configuration

Supplying argument names

Supplying generators

Supplying both generators and argument names

Property check configuration

Type Members

class ConfiguredPropertyCheck extends AnyRef

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

case class MinSize(value: PosZInt) extends PropertyCheckConfigParam with Product with Serializable

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

sealed abstract class PropertyCheckConfigParam extends Product with Serializable

case class SizeRange(value: PosZInt) extends PropertyCheckConfigParam with Product with Serializable

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

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

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

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

trait PropertyCheckConfigurable extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit def PropertyCheckConfig2PropertyCheckConfiguration(p: PropertyCheckConfig): PropertyCheckConfiguration

object PropertyCheckConfiguration extends Serializable

final def asInstanceOf[T0]: T0

val bytes: Generator[Byte]

def bytesBetween(from: Byte, to: Byte): Generator[Byte]

val chars: Generator[Char]

def charsBetween(from: Char, to: Char): Generator[Char]

def classify[A](count: PosInt, genOfA: Generator[A])(pf: PartialFunction[A, String]): Classification

def clone(): AnyRef

val doubles: Generator[Double]

def doublesBetween(from: Double, to: Double): Generator[Double]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evenly[T](first: Generator[T], second: Generator[T], rest: Generator[T]*): Generator[T]

def finalize(): Unit

val finiteDoubleValues: Generator[Double]

val finiteDoubles: Generator[FiniteDouble]

def finiteDoublesBetween(from: FiniteDouble, to: FiniteDouble): Generator[FiniteDouble]

val finiteFloatValues: Generator[Float]

val finiteFloats: Generator[FiniteFloat]

def finiteFloatsBetween(from: FiniteFloat, to: FiniteFloat): Generator[FiniteFloat]

def first1000Primes: Generator[Int]

val floats: Generator[Float]

def floatsBetween(from: Float, to: Float): Generator[Float]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def forAll(configParams: PropertyCheckConfigParam*): ConfiguredPropertyCheck

def frequency[T](first: (Int, Generator[T]), second: (Int, Generator[T]), rest: (Int, Generator[T])*): Generator[T]

def function0s[A](implicit genOfA: Generator[A]): Generator[() ⇒ A]

def function1s[A, B](implicit genOfB: Generator[B], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B]): Generator[(A) ⇒ B]

def function2s[A, B, C](implicit genOfC: Generator[C], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C]): Generator[(A, B) ⇒ C]

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]

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]

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]

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]

implicit val generatorDrivenConfig: PropertyCheckConfiguration

final def getClass(): Class[_]

def getParameter(configParams: Seq[PropertyCheckConfigParam], c: PropertyCheckConfiguration): Parameter

def hashCode(): Int

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]