org.scalatest.prop

GeneratorDrivenPropertyChecks

trait GeneratorDrivenPropertyChecks extends CommonGenerators with Whenever with Configuration

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
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. GeneratorDrivenPropertyChecks
  2. Configuration
  3. Whenever
  4. CommonGenerators
  5. AnyRef
  6. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. class ConfiguredPropertyCheck extends AnyRef

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

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

    Definition Classes
    Configuration

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

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

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

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

  5. sealed abstract class PropertyCheckConfigParam extends Product with Serializable

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

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

    Definition Classes
    Configuration

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

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

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

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

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

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

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

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

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

    Configuration object for property checks.

  12. trait PropertyCheckConfigurable extends AnyRef

    Definition Classes
    Configuration
    Annotations
    @deprecated
    Deprecated

    Use PropertyCheckConfiguration directly instead.

Value Members

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

    Definition Classes
    AnyRef

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

    Definition Classes
    Any

  3. final def ##(): Int

    Definition Classes
    AnyRef → Any

  4. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  5. final def ==(arg0: Any): Boolean

    Definition Classes
    Any

  6. implicit def PropertyCheckConfig2PropertyCheckConfiguration(p: PropertyCheckConfig): PropertyCheckConfiguration

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

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

    Definition Classes
    Configuration

  7. object PropertyCheckConfiguration extends Serializable

    Definition Classes
    Configuration

  8. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  9. val bytes: Generator[Byte]

    Definition Classes
    CommonGenerators

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

    Definition Classes
    CommonGenerators

  11. val chars: Generator[Char]

    Definition Classes
    CommonGenerators

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

    Definition Classes
    CommonGenerators

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

    Definition Classes
    CommonGenerators

  14. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  15. val doubles: Generator[Double]

    Definition Classes
    CommonGenerators

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

    Definition Classes
    CommonGenerators

  17. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  18. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

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

    Definition Classes
    CommonGenerators

  20. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

  21. val finiteDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators

  22. val finiteDoubles: Generator[FiniteDouble]

    Definition Classes
    CommonGenerators

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

    Definition Classes
    CommonGenerators

  24. val finiteFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators

  25. val finiteFloats: Generator[FiniteFloat]

    Definition Classes
    CommonGenerators

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

    Definition Classes
    CommonGenerators

  27. def first1000Primes: Generator[Int]

    Definition Classes
    CommonGenerators

  28. val floats: Generator[Float]

    Definition Classes
    CommonGenerators

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

    Definition Classes
    CommonGenerators

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Definition Classes
    CommonGenerators

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

    Definition Classes
    CommonGenerators

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

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

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

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

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

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

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

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

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

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

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

    Definition Classes
    CommonGenerators

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

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

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

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

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

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

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

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

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

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

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

  97. implicit val generatorDrivenConfig: PropertyCheckConfiguration

    Implicit PropertyCheckConfig value providing default configuration values.

    Implicit PropertyCheckConfig value providing default configuration values.

    Definition Classes
    Configuration

  98. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any

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

    Definition Classes
    Configuration

  100. def hashCode(): Int

    Definition Classes
    AnyRef → Any

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  122. def instancesOf[A, B](construct: (A) ⇒ B)(deconstruct: (B) ⇒ A)(implicit genOfA: Generator[A]): Generator[B]

    Definition Classes
    CommonGenerators

  123. val ints: Generator[Int]

    Definition Classes
    CommonGenerators

  124. def intsBetween(from: Int, to: Int): Generator[Int]

    Definition Classes
    CommonGenerators

  125. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  126. def lists[T](implicit genOfT: Generator[T]): Generator[List[T]] with HavingLength[List[T]]

    Definition Classes
    CommonGenerators

  127. val longs: Generator[Long]

    Definition Classes
    CommonGenerators

  128. def longsBetween(from: Long, to: Long): Generator[Long]

    Definition Classes
    CommonGenerators

  129. def maps[K, V](implicit genOfTupleKV: Generator[(K, V)]): Generator[Map[K, V]] with HavingSize[Map[K, V]]

    Definition Classes
    CommonGenerators

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

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

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

  133. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  134. val negDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators

  135. val negDoubles: Generator[NegDouble]

    Definition Classes
    CommonGenerators

  136. def negDoublesBetween(from: NegDouble, to: NegDouble): Generator[NegDouble]

    Definition Classes
    CommonGenerators

  137. val negFiniteDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators

  138. val negFiniteDoubles: Generator[NegFiniteDouble]

    Definition Classes
    CommonGenerators

  139. def negFiniteDoublesBetween(from: NegFiniteDouble, to: NegFiniteDouble): Generator[NegFiniteDouble]

    Definition Classes
    CommonGenerators

  140. val negFiniteFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators

  141. val negFiniteFloats: Generator[NegFiniteFloat]

    Definition Classes
    CommonGenerators

  142. def negFiniteFloatsBetween(from: NegFiniteFloat, to: NegFiniteFloat): Generator[NegFiniteFloat]

    Definition Classes
    CommonGenerators

  143. val negFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators

  144. val negFloats: Generator[NegFloat]

    Definition Classes
    CommonGenerators

  145. def negFloatsBetween(from: NegFloat, to: NegFloat): Generator[NegFloat]

    Definition Classes
    CommonGenerators

  146. val negIntValues: Generator[Int]

    Definition Classes
    CommonGenerators

  147. val negInts: Generator[NegInt]

    Definition Classes
    CommonGenerators

  148. def negIntsBetween(from: NegInt, to: NegInt): Generator[NegInt]

    Definition Classes
    CommonGenerators

  149. val negLongValues: Generator[Long]

    Definition Classes
    CommonGenerators

  150. val negLongs: Generator[NegLong]

    Definition Classes
    CommonGenerators

  151. def negLongsBetween(from: NegLong, to: NegLong): Generator[NegLong]

    Definition Classes
    CommonGenerators

  152. val negZDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators

  153. val negZDoubles: Generator[NegZDouble]

    Definition Classes
    CommonGenerators

  154. def negZDoublesBetween(from: NegZDouble, to: NegZDouble): Generator[NegZDouble]

    Definition Classes
    CommonGenerators

  155. val negZFiniteDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators

  156. val negZFiniteDoubles: Generator[NegZFiniteDouble]

    Definition Classes
    CommonGenerators

  157. def negZFiniteDoublesBetween(from: NegZFiniteDouble, to: NegZFiniteDouble): Generator[NegZFiniteDouble]

    Definition Classes
    CommonGenerators

  158. val negZFiniteFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators

  159. val negZFiniteFloats: Generator[NegZFiniteFloat]

    Definition Classes
    CommonGenerators

  160. def negZFiniteFloatsBetween(from: NegZFiniteFloat, to: NegZFiniteFloat): Generator[NegZFiniteFloat]

    Definition Classes
    CommonGenerators

  161. val negZFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators

  162. val negZFloats: Generator[NegZFloat]

    Definition Classes
    CommonGenerators

  163. def negZFloatsBetween(from: NegZFloat, to: NegZFloat): Generator[NegZFloat]

    Definition Classes
    CommonGenerators

  164. val negZIntValues: Generator[Int]

    Definition Classes
    CommonGenerators

  165. val negZInts: Generator[NegZInt]

    Definition Classes
    CommonGenerators

  166. def negZIntsBetween(from: NegZInt, to: NegZInt): Generator[NegZInt]

    Definition Classes
    CommonGenerators

  167. val negZLongValues: Generator[Long]

    Definition Classes
    CommonGenerators

  168. val negZLongs: Generator[NegZLong]

    Definition Classes
    CommonGenerators

  169. def negZLongsBetween(from: NegZLong, to: NegZLong): Generator[NegZLong]

    Definition Classes
    CommonGenerators

  170. val nonZeroDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators

  171. val nonZeroDoubles: Generator[NonZeroDouble]

    Definition Classes
    CommonGenerators

  172. def nonZeroDoublesBetween(from: NonZeroDouble, to: NonZeroDouble): Generator[NonZeroDouble]

    Definition Classes
    CommonGenerators

  173. val nonZeroFiniteDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators

  174. val nonZeroFiniteDoubles: Generator[NonZeroFiniteDouble]

    Definition Classes
    CommonGenerators

  175. def nonZeroFiniteDoublesBetween(from: NonZeroFiniteDouble, to: NonZeroFiniteDouble): Generator[NonZeroFiniteDouble]

    Definition Classes
    CommonGenerators

  176. val nonZeroFiniteFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators

  177. val nonZeroFiniteFloats: Generator[NonZeroFiniteFloat]

    Definition Classes
    CommonGenerators

  178. def nonZeroFiniteFloatsBetween(from: NonZeroFiniteFloat, to: NonZeroFiniteFloat): Generator[NonZeroFiniteFloat]

    Definition Classes
    CommonGenerators

  179. val nonZeroFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators

  180. val nonZeroFloats: Generator[NonZeroFloat]

    Definition Classes
    CommonGenerators

  181. def nonZeroFloatsBetween(from: NonZeroFloat, to: NonZeroFloat): Generator[NonZeroFloat]

    Definition Classes
    CommonGenerators

  182. val nonZeroIntValues: Generator[Int]

    Definition Classes
    CommonGenerators

  183. val nonZeroInts: Generator[NonZeroInt]

    Definition Classes
    CommonGenerators

  184. def nonZeroIntsBetween(from: NonZeroInt, to: NonZeroInt): Generator[NonZeroInt]

    Definition Classes
    CommonGenerators

  185. val nonZeroLongValues: Generator[Long]

    Definition Classes
    CommonGenerators

  186. val nonZeroLongs: Generator[NonZeroLong]

    Definition Classes
    CommonGenerators

  187. def nonZeroLongsBetween(from: NonZeroLong, to: NonZeroLong): Generator[NonZeroLong]

    Definition Classes
    CommonGenerators

  188. final def notify(): Unit

    Definition Classes
    AnyRef

  189. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  190. val numericCharValues: Generator[Char]

    Definition Classes
    CommonGenerators

  191. val numericChars: Generator[NumericChar]

    Definition Classes
    CommonGenerators

  192. val posDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators

  193. val posDoubles: Generator[PosDouble]

    Definition Classes
    CommonGenerators

  194. def posDoublesBetween(from: PosDouble, to: PosDouble): Generator[PosDouble]

    Definition Classes
    CommonGenerators

  195. val posFiniteDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators

  196. val posFiniteDoubles: Generator[PosFiniteDouble]

    Definition Classes
    CommonGenerators

  197. def posFiniteDoublesBetween(from: PosFiniteDouble, to: PosFiniteDouble): Generator[PosFiniteDouble]

    Definition Classes
    CommonGenerators

  198. val posFiniteFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators

  199. val posFiniteFloats: Generator[PosFiniteFloat]

    Definition Classes
    CommonGenerators

  200. def posFiniteFloatsBetween(from: PosFiniteFloat, to: PosFiniteFloat): Generator[PosFiniteFloat]

    Definition Classes
    CommonGenerators

  201. val posFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators

  202. val posFloats: Generator[PosFloat]

    Definition Classes
    CommonGenerators

  203. def posFloatsBetween(from: PosFloat, to: PosFloat): Generator[PosFloat]

    Definition Classes
    CommonGenerators

  204. val posIntValues: Generator[Int]

    Definition Classes
    CommonGenerators

  205. val posInts: Generator[PosInt]

    Definition Classes
    CommonGenerators

  206. def posIntsBetween(from: PosInt, to: PosInt): Generator[PosInt]

    Definition Classes
    CommonGenerators

  207. val posLongValues: Generator[Long]

    Definition Classes
    CommonGenerators

  208. val posLongs: Generator[PosLong]

    Definition Classes
    CommonGenerators

  209. def posLongsBetween(from: PosLong, to: PosLong): Generator[PosLong]

    Definition Classes
    CommonGenerators

  210. val posZDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators

  211. val posZDoubles: Generator[PosZDouble]

    Definition Classes
    CommonGenerators

  212. def posZDoublesBetween(from: PosZDouble, to: PosZDouble): Generator[PosZDouble]

    Definition Classes
    CommonGenerators

  213. val posZFiniteDoubleValues: Generator[Double]

    Definition Classes
    CommonGenerators

  214. val posZFiniteDoubles: Generator[PosZFiniteDouble]

    Definition Classes
    CommonGenerators

  215. def posZFiniteDoublesBetween(from: PosZFiniteDouble, to: PosZFiniteDouble): Generator[PosZFiniteDouble]

    Definition Classes
    CommonGenerators

  216. val posZFiniteFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators

  217. val posZFiniteFloats: Generator[PosZFiniteFloat]

    Definition Classes
    CommonGenerators

  218. def posZFiniteFloatsBetween(from: PosZFiniteFloat, to: PosZFiniteFloat): Generator[PosZFiniteFloat]

    Definition Classes
    CommonGenerators

  219. val posZFloatValues: Generator[Float]

    Definition Classes
    CommonGenerators

  220. val posZFloats: Generator[PosZFloat]

    Definition Classes
    CommonGenerators

  221. def posZFloatsBetween(from: PosZFloat, to: PosZFloat): Generator[PosZFloat]

    Definition Classes
    CommonGenerators

  222. val posZIntValues: Generator[Int]

    Definition Classes
    CommonGenerators

  223. val posZInts: Generator[PosZInt]

    Definition Classes
    CommonGenerators

  224. def posZIntsBetween(from: PosZInt, to: PosZInt): Generator[PosZInt]

    Definition Classes
    CommonGenerators

  225. val posZLongValues: Generator[Long]

    Definition Classes
    CommonGenerators

  226. val posZLongs: Generator[PosZLong]

    Definition Classes
    CommonGenerators

  227. def posZLongsBetween(from: PosZLong, to: PosZLong): Generator[PosZLong]

    Definition Classes
    CommonGenerators

  228. def sets[T](implicit genOfT: Generator[T]): Generator[Set[T]] with HavingSize[Set[T]]

    Definition Classes
    CommonGenerators

  229. val shorts: Generator[Short]

    Definition Classes
    CommonGenerators

  230. def shortsBetween(from: Short, to: Short): Generator[Short]

    Definition Classes
    CommonGenerators

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

  232. def sortedMaps[K, V](implicit genOfTupleKV: Generator[(K, V)], ordering: Ordering[K]): Generator[SortedMap[K, V]] with HavingSize[SortedMap[K, V]]

    Definition Classes
    CommonGenerators

  233. def sortedSets[T](implicit genOfT: Generator[T], ordering: Ordering[T]): Generator[SortedSet[T]] with HavingSize[SortedSet[T]]

    Definition Classes
    CommonGenerators

  234. def specificValue[T](theValue: T): Generator[T]

    Definition Classes
    CommonGenerators

  235. def specificValues[T](first: T, second: T, rest: T*): Generator[T]

    Definition Classes
    CommonGenerators

  236. val strings: Generator[String]

    Definition Classes
    CommonGenerators

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

    Definition Classes
    AnyRef

  238. def toString(): String

    Definition Classes
    AnyRef → Any

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

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

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

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

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

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

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

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

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

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

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

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

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

  252. def tuple2s[A, B](implicit genOfA: Generator[A], genOfB: Generator[B]): Generator[(A, B)]

    Definition Classes
    CommonGenerators

  253. def tuple3s[A, B, C](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C]): Generator[(A, B, C)]

    Definition Classes
    CommonGenerators

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

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

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

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

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

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

  260. def vectors[T](implicit genOfT: Generator[T]): Generator[Vector[T]] with HavingLength[Vector[T]]

    Definition Classes
    CommonGenerators

  261. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  263. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

  265. def workers(value: PosInt): Workers

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

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

    Definition Classes
    Configuration

Deprecated Value Members

  1. def maxDiscarded(value: Int): MaxDiscarded

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

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

    Definition Classes
    Configuration
    Annotations
    @deprecated
    Deprecated

    use maxDiscardedFactor instead

    Exceptions thrown
    IllegalArgumentException

    if specified value is less than zero.

  2. def maxSize(value: Int): MaxSize

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

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

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

    Definition Classes
    Configuration
    Annotations
    @deprecated
    Deprecated

    use SizeRange instead

    Exceptions thrown
    IllegalArgumentException

    if specified value is less than zero.

Inherited from Configuration

Inherited from Whenever

Inherited from CommonGenerators

Inherited from AnyRef

Inherited from Any

Ungrouped