org.scalatest.prop

GeneratorDrivenPropertyChecks

object GeneratorDrivenPropertyChecks extends GeneratorDrivenPropertyChecks

Linear Supertypes
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. GeneratorDrivenPropertyChecks
  2. GeneratorDrivenPropertyChecks
  3. Configuration
  4. Whenever
  5. CommonGenerators
  6. AnyRef
  7. 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.

    Definition Classes
    GeneratorDrivenPropertyChecks
  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