Object/Trait

org.scalatest.prop

PropertyChecks

Related Docs: trait PropertyChecks | package prop

Permalink

object PropertyChecks extends PropertyChecks

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

Source
PropertyChecks.scala
Linear Supertypes
Ordering
  1. Grouped
  2. Alphabetic
  3. By Inheritance
Inherited
  1. PropertyChecks
  2. PropertyChecks
  3. GeneratorDrivenPropertyChecks
  4. Configuration
  5. CommonGenerators
  6. TableDrivenPropertyChecks
  7. Tables
  8. Whenever
  9. AnyRef
  10. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. class ConfiguredPropertyCheck extends AnyRef

    Permalink

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

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

    Instances of this class are returned by trait GeneratorDrivenPropertyChecks forAll method that accepts a variable length argument list of PropertyCheckConfigParam objects. Thus it is used with functions of all six arities. Here are some examples:

    forAll (minSize(1), sizeRange(9)) { (a: String) =>
      a.length should equal ((a).length)
    }
    
    forAll (minSize(1), sizeRange(9)) { (a: String, b: String) =>
      a.length + b.length should equal ((a + b).length)
    }
    
    forAll (minSize(1), sizeRange(9)) { (a: String, b: String, c: String) =>
      a.length + b.length + c.length should equal ((a + b + c).length)
    }
    
    forAll (minSize(1), sizeRange(9)) { (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), sizeRange(9)) { (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), sizeRange(9)) { (a: String, b: String, c: String, d: String, e: String, f: String) =>
      a.length + b.length + c.length + d.length + e.length + f.length should equal ((a + b + c + d + e + f).length)
    }
    

    In the first example above, the ConfiguredPropertyCheck object is returned by:

    forAll (minSize(1), sizeRange(9))
    

    The code that follows is an invocation of one of the ConfiguredPropertyCheck apply methods:

    { (a: String) =>
      a.length should equal ((a).length)
    }
    

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

    Permalink

    A PropertyCheckConfigParam that specifies how many generated values may be discarded, as a multiple of the successful attempts, before the property check is considered to be org.scalatest.prop.PropertyCheckResult.Exhausted.

    A PropertyCheckConfigParam that specifies how many generated values may be discarded, as a multiple of the successful attempts, before the property check is considered to be org.scalatest.prop.PropertyCheckResult.Exhausted.

    In GeneratorDrivenPropertyChecks, a property evaluation is discarded if it throws DiscardedEvaluationException, which is produced by a whenever clause that evaluates to false. For example, consider this ScalaTest property check:

    // forAll defined in GeneratorDrivenPropertyChecks
    forAll { (n: Int) =>
      whenever (n > 0) {
        doubleIt(n) should equal (n * 2)
      }
    }
    
    

    In the above code, whenever a non-positive n is passed, the property function will complete abruptly with DiscardedEvaluationException.

    Similarly, in Checkers, a property evaluation is discarded if the expression to the left of ScalaCheck's ==> operator is false. Here's an example:

    // forAll defined in Checkers
    forAll { (n: Int) =>
      (n > 0) ==> doubleIt(n) == (n * 2)
    }
    
    

    For either kind of property check, MaxDiscardedFactor indicates the maximum fraction of total tests that may be discarded, relative to the number of successful tests. For example, if this is set to 4.0, and you are running 100 tests, it may discard up to 400 tries before considering the test to be org.scalatest.prop.PropertyCheckResult.Exhausted.

    value

    the permitted number of discarded tests, as a multiple of successful ones.

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

    Permalink

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

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

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

    Permalink

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

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

    Once this many evaluations have passed, the property will return PropertyCheckResult.Success.

    Definition Classes
    Configuration
  5. sealed abstract class PropertyCheckConfigParam extends Product with Serializable

    Permalink

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

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

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

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

    Permalink

    Describes the configuration to use when evaluating a property.

    Describes the configuration to use when evaluating a property.

    minSuccessful

    the minimum number of successful property evaluations required for the property to pass; see MinSuccessful

    maxDiscardedFactor

    how many generated values may be discarded, as a multiple of the successful attempts, before the property check is considered to be org.scalatest.prop.PropertyCheckResult.Exhausted; see MaxDiscardedFactor

    minSize

    the minimum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists); see MinSize

    sizeRange

    the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists); see SizeRange

    workers

    number of worker threads to use when evaluating a property; see Workers

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

    Permalink

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

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

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

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

    Permalink

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

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

    Property evaluation runs on a single thread by default, but may run multiple threads if desired. If so, the evaluation will generally run faster. However, be careful not to use this if there is any risk of deadlocks, race conditions, or other hazards of multi-threaded code in evaluating this property or the code under test.

    Definition Classes
    Configuration

Value Members

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

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

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

    Permalink
    Definition Classes
    AnyRef → Any
  4. object PropertyCheckConfiguration extends Serializable

    Permalink

    Internal utility functions for configuration management.

    Internal utility functions for configuration management.

    Definition Classes
    Configuration
  5. object Table

    Permalink

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

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

    For example, you could create a table of 5 rows and 2 colums like this:

    import org.scalatest.prop.Tables._
    
    val examples =
      Table(
        ("a", "b"),
        (  1,   2),
        (  2,   4),
        (  4,   8),
        (  8,  16),
        ( 16,  32)
      )
    

    Because you supplied 2 members in each tuple, the type you'll get back will be a TableFor2. If you wanted a table with just one column you could write this:

    val moreExamples =
      Table(
        "powerOfTwo",
             1,
             2,
             4,
             8,
             16
      )
    

    Or if you wanted a table with 10 columns and 10 rows, you could do this:

    val multiplicationTable =
      Table(
        ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j"),
        (  1,   2,   3,   4,   5,   6,   7,   8,   9,  10),
        (  2,   4,   6,   8,  10,  12,  14,  16,  18,  20),
        (  3,   6,   9,  12,  15,  18,  21,  24,  27,  30),
        (  4,   8,  12,  16,  20,  24,  28,  32,  36,  40),
        (  5,  10,  15,  20,  25,  30,  35,  40,  45,  50),
        (  6,  12,  18,  24,  30,  36,  42,  48,  54,  60),
        (  7,  14,  21,  28,  35,  42,  49,  56,  63,  70),
        (  8,  16,  24,  32,  40,  48,  56,  64,  72,  80),
        (  9,  18,  27,  36,  45,  54,  63,  72,  81,  90),
        ( 10,  20,  30,  40,  50,  60,  70,  80,  90, 100)
      )
    

    The type of multiplicationTable would be TableFor10. You can pass the resulting tables to a forAll method (defined in trait PropertyChecks), to perform a property check with the data in the table. Or, because tables are sequences of tuples, you can treat them as a Seq.

    Definition Classes
    Tables
  6. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  7. def between[T](from: T, to: T)(implicit ord: Ordering[T], chooser: Chooser[T], gen: Generator[T]): Generator[T]

    Permalink

    Create a Generator that returns values in the specified range.

    Create a Generator that returns values in the specified range.

    This is the general-purpose function that underlies all of the other xxsBetween() functions in CommonGenerators. It works with any type for which there is an Ordering, a Generator, and a Chooser, making it easy to create Generators for ranges within that type.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to. (However "less than or equal" is defined for this type.)

    The "edges" -- the edge case values -- for this type will be taken from the implicit Generator. This function then filters out any that aren't within the specified range, and adds the from and to values as edges.

    The implicit Chooser is used to pick random values of the type. That should do most of the heavy lifting.

    Since this underlies the more-specific xxsBetween() functions, you may use either those or this when appropriate. For example, this:

    intsBetween(1, 100)

    and

    between(1, 100)

    are functionally identical so long as the types of the parameters are clear to the compiler. Use whichever suits your project's coding style better.

    T

    the type to choose a value from

    from

    the lower bound of the range to choose from

    to

    the upper bound of the range to choose from

    ord

    an instance of Ordering[T], which should usually be in implicit scope

    chooser

    an instance of Chooser[T], which should usually be in implicit scope

    gen

    an instance of Generator[T], which should usually be in implicit scope

    returns

    a new Generator, that produces values in the specified range

    Definition Classes
    CommonGenerators
  8. val booleans: Generator[Boolean]

    Permalink

    A Generator that produces Boolean values.

    A Generator that produces Boolean values.

    Definition Classes
    CommonGenerators
  9. val bytes: Generator[Byte]

    Permalink

    A Generator that produces Byte values.

    A Generator that produces Byte values.

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

    Permalink

    Create a Generator that returns Bytes in the specified range.

    Create a Generator that returns Bytes in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces Char values.

    A Generator that produces Char values.

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

    Permalink

    Create a Generator that returns Chars in the specified range.

    Create a Generator that returns Chars in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    Generate a bunch of values from a Generator, and distribute them into buckets.

    Generate a bunch of values from a Generator, and distribute them into buckets.

    This function mainly exists for the purpose of testing your Generator, and making sure that it is actually creating data with the sort of distribution you expect. You provide the Generator, the number of values to create, and a function that "classifies" each value with a String; it returns a Classification that collates all of the results. You can then look at the Classification to see if the proportions match your expectations.

    For example, consider this simple classification of small numbers:

    val classification: Classification =
      CommonGenerators.classify(10000, CommonGenerators.intsBetween(0, 9))
      {
        case x if (x % 2) == 0 => "even"
        case _ => "odd"
      }

    As expected, the results come out evenly:

    classification: org.scalatest.prop.Classification =
    50% odd
    50% even

    The options provided in the PartialFunction do not have to be comprehensive; it is legal for some generated values to not match any of the choices. In this case, those values will not be accounted for in the resulting Classification.

    A

    the type to be generated

    count

    the number of values to generate

    genOfA

    the Generator to use

    pf

    a PartialFunction that takes the generated values, and sorts them into "buckets" by String names

    returns

    statistics on how many values wound up in each bucket

    Definition Classes
    CommonGenerators
  14. def clone(): AnyRef

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

    Permalink

    A Generator that produces Double values.

    A Generator that produces Double values.

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

    Permalink

    Create a Generator that returns Doubles in the specified range.

    Create a Generator that returns Doubles in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

    Definition Classes
    CommonGenerators
  17. def eithers[L, R](implicit genOfL: Generator[L], genOfR: Generator[R]): Generator[Either[L, R]]

    Permalink

    Given Generators for two types, L and R, this provides one for Either[L, R].

    Given Generators for two types, L and R, this provides one for Either[L, R].

    L

    the Left type for an Either

    R

    the Right type for an Either

    genOfL

    a Generator that produces type L

    genOfR

    a Generator that produces type R

    returns

    a Generator that produces Either[L, R]

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

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

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

    Permalink

    Given a number of Generators, this creates one that invokes each of its constituents with roughly the same frequency.

    Given a number of Generators, this creates one that invokes each of its constituents with roughly the same frequency.

    Consider this example:

    val numbers: Generator[Char] = ... // generates only digits
    val letters: Generator[Char] = ... // generates only letters
    val punct: Generator[Char]   = ... // generates only punctuation
    
    val chars: Generator[Char] = evenly(numbers, letters, punct)

    The chars Generator should produce numbers, letters and punctuation, each about a third of the time.

    Keep in mind that the distribution is invoked randomly, so these are rough proportions. As you invoke the Generator more times, you should see results that are closer and closer to an equal distribution, but the random element will generally keep it inexact.

    As usual, the resulting Generator will use the Randomizer passed in to Generator.next() to choose which of the constituent Generators to invoke. So if you use the same seed to initialize your Randomizer, you should get the same results.

    Note that all of the constituent Generators must produce the same type.

    T

    the type to be produced

    first

    a Generator to choose from

    second

    another Generator to choose from

    rest

    any number of additional Generators to choose from

    returns

    a single Generator that invokes each of its constituents roughly the same number of times

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

    Definition Classes
    TableDrivenPropertyChecks
  43. def finalize(): Unit

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

    Permalink

    A Generator that produces Double values, including zero but not including infinities or NaN.

    A Generator that produces Double values, including zero but not including infinities or NaN.

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

    Permalink

    A Generator that produces FiniteDouble values.

    A Generator that produces FiniteDouble values.

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

    Permalink

    Create a Generator that returns FiniteDoubles in the specified range.

    Create a Generator that returns FiniteDoubles in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces Float values, including zero but not including infinities or NaN.

    A Generator that produces Float values, including zero but not including infinities or NaN.

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

    Permalink

    A Generator that produces FiniteFloat values.

    A Generator that produces FiniteFloat values.

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

    Permalink

    Create a Generator that returns FiniteFloats in the specified range.

    Create a Generator that returns FiniteFloats in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

    Definition Classes
    CommonGenerators
  50. lazy val first1000Primes: Generator[Int]

    Permalink

    A Generator of prime numbers.

    A Generator of prime numbers.

    As the name implies, this doesn't try to generate entirely arbitrary prime numbers. Instead, it takes the simpler and more efficient approach of choosing randomly from a hard-coded table of the first 1000 primes. As a result, the largest number that can be produced from this is 7919.

    returns

    a Generator that will produce smallish prime numbers

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

    Permalink

    A Generator that produces Float values.

    A Generator that produces Float values.

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

    Permalink

    Create a Generator that returns Floats in the specified range.

    Create a Generator that returns Floats in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Permalink

    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), sizeRange(9)) { (a: String) =>
      a.length should equal ((a).length)
    }
    
    forAll (minSize(1), sizeRange(9)) { (a: String, b: String) =>
      a.length + b.length should equal ((a + b).length)
    }
    
    forAll (minSize(1), sizeRange(9)) { (a: String, b: String, c: String) =>
      a.length + b.length + c.length should equal ((a + b + c).length)
    }
    
    forAll (minSize(1), sizeRange(9)) { (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), sizeRange(9)) { (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), sizeRange(9)) { (a: String, b: String, c: String, d: String, e: String, f: String) =>
      a.length + b.length + c.length + d.length + e.length + f.length should equal ((a + b + c + d + e + f).length)
    }
    

    configParams

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

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

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

    The difference between forEvery and forAll is that forEvery will continue to inspect all elements after first failure, and report all failures, whereas forAll will stop on (and only report) the first failure.

    table

    the table of data with which to perform the property check

    fun

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

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

    Permalink

    Given a number of Generators, and the weightings for each one, this creates a Generator that invokes each of its components according to its weighting.

    Given a number of Generators, and the weightings for each one, this creates a Generator that invokes each of its components according to its weighting.

    For example, consider this:

    val evens: Generator[Int] = ... // generates even Ints
    val odds: Generator[Int] = ... // generates odd Ints
    val zeros: Generator[Int] = specificValue(0)
    
    val mixed: Generator[Int] = frequency(
      (5, evens),
      (4, odds),
      (1, zeros)
    )

    The total weighting is (5 + 4 + 1) = 10. So the resulting Generator will produce an even number (10 / 5) = 50% the time, an odd number (10 / 4) = 40% of the time, and zero (10 / 1) = 10% of the time.

    Keep in mind that the distribution is invoked randomly, so these are rough proportions. As you invoke the Generator more times, you should see results that are closer and closer to the specified proportions, but the random element will generally keep it inexact.

    As usual, the resulting Generator will use the Randomizer passed in to Generator.next() to choose which of the constituent Generators to invoke. So if you use the same seed to initialize your Randomizer, you should get the same results.

    Note that all of the constituent Generators must produce the same type.

    T

    the type being produced by all of these Generators

    first

    a Generator and its weight

    second

    another Generator and its weight

    rest

    as many more Generator and weight pairs as you like

    returns

    a single Generator, that invokes its constituents according to their weights

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

    Permalink

    Given a Generator that produces values of type A, this returns one that produces functions that return a T.

    Given a Generator that produces values of type A, this returns one that produces functions that return a T.

    The functions produced here are nullary -- they take no parameters, they just spew out values of type A.

    A

    the type to return from the generated functions

    returns

    a Generator that produces functions that return values of type A

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    Create a Generator of functions from type A to type B.

    Create a Generator of functions from type A to type B.

    Note that the generated functions are, necessarily, pretty random. In practice, the function you get from a function1s call (and its variations, up through function22s) takes the hashes of its input values, combines those with a randomly-chosen number, and combines them in order to choose the generated value B.

    That said, each of the generated functions is deterministic: given the same input parameters and the same randomly-chosen number, you will always get the same B result. And the toString function on the generated function will show the formula you need to use in order to recreate that, which will look something like:

    (a: Int, b: String, c: Float) =>
      org.scalatest.prop.valueOf[String](a, b, c)(131)

    The number and type of the a, b, c, etc, parameters, as well as the type parameter of valueOf, will depend on the function type you are generating, but they will always follow this pattern. valueOf is the underlying function that takes these parameters and the randomly-chosen number, and returns a value of the specified type.

    So if a property evaluation fails, the display of the generated function will tell you how to call valueOf to recreate the failure.

    The typeInfo parameters are automatically created via macros; you should generally not try to pass them manually.

    A

    the input type for the generated functions

    B

    the result type for the generated functions

    genOfB

    a Generator for the desired result type B

    typeInfoA

    automatically-created type information for type A

    typeInfoB

    automatically-created type information for type B

    returns

    a Generator that produces functions that take values of A and returns values of B

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

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

    Permalink

    See function1s.

    Definition Classes
    CommonGenerators
  164. implicit val generatorDrivenConfig: PropertyCheckConfiguration

    Permalink

    Implicit PropertyCheckConfig value providing default configuration values.

    Implicit PropertyCheckConfig value providing default configuration values.

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

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

    Permalink

    Given some optional PropertyCheckConfigParams and a PropertyCheckConfiguration, compute the resulting Configuration.Parameter.

    Given some optional PropertyCheckConfigParams and a PropertyCheckConfiguration, compute the resulting Configuration.Parameter.

    This function deals with resolving the various forms of these configuration values, into a consistent form suitable for using in properties.

    Duplicate PropertyCheckConfigParam entries are not permitted in the configParams list.

    TODO: should this function be public? It feels like an internal implementation detail -- I think it should be private.

    configParams

    optionally, some parameters that differ from the provided c

    returns

    a fully-set-up Configuration.Parameter object, ready to evaluate properties with.

    Definition Classes
    Configuration
  167. def hashCode(): Int

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    See the simple [A, B] version of instancesOf() for details.

    See the simple [A, B] version of instancesOf() for details.

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

    Permalink

    The instancesOf function (which has overloads depending on how many parameters you need) is one way to create a Generator for case classes and other situations where you want to build a type out of other types.

    The instancesOf function (which has overloads depending on how many parameters you need) is one way to create a Generator for case classes and other situations where you want to build a type out of other types.

    To understand how it works, look at this example:

    case class Person(name: String, age: Int)
    implicit val persons: Generator[Person] =
      instancesOf(Person) { p =>
        (p.name, p.age)
      } (strings, posZIntValues)

    What's going on here? instancesOf is taking two types (String and Int), a function (a case class constructor) that turns those types into a third type (Person), and a second function that takes a Person and deconstructs it back to its component pieces. From those, it creates a Generator.

    The last parameters -- the (strings, posZIntValues) -- are the Generators for the component types. If you are good with using the default Generators for those types, you can just let those parameters be resolved implicitly. (But in this case, that could result in negative ages, which doesn't make any sense.)

    After creating a Generator this way, you can use it like any other Generator in your property checks.

    Alternatively, you can construct Generators for case classes using for comprehensions, like this:

    implicit val persons: Generator[Person] = for {
      name <- strings
      age <- posZIntValues
    }
      yield Person(name, age)

    Which approach you use is mainly up to personal taste and the coding standards of your project.

    A

    the input type

    B

    the target type to be generated

    construct

    a constructor that builds the target type from its constituents; most often, a case class constructor

    deconstruct

    a deconstructor function that takes the target type and breaks is down into its constituents

    genOfA

    a Generator for the input type

    returns

    a Generator for the target type

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

    Permalink

    A Generator that produces Int values.

    A Generator that produces Int values.

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

    Permalink

    Create a Generator that returns Ints in the specified range.

    Create a Generator that returns Ints in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

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

    Permalink

    Given an existing Generator[T], this creates a Generator[List[T]].

    Given an existing Generator[T], this creates a Generator[List[T]].

    T

    the type that we are producing a List of

    genOfT

    a Generator that produces values of type T

    returns

    a List of values of type T

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

    Permalink

    A Generator that produces Long values.

    A Generator that produces Long values.

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

    Permalink

    Create a Generator that returns Longs in the specified range.

    Create a Generator that returns Longs in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    Given a Generator that produces Tuples of key/value pairs, this gives you one that produces Maps with those pairs.

    Given a Generator that produces Tuples of key/value pairs, this gives you one that produces Maps with those pairs.

    If you are simply looking for random pairing of the key and value types, this is pretty easy to use: if both the key and value types have Generators, then the Tuple and Map ones will be automatically and implicitly created when you need them.

    The resulting Generator also has the HavingSize trait, so you can use it to generate Maps with specific sizes.

    K

    the type of the keys for the Map

    V

    the type of the values for the Map

    returns

    a Generator of Maps from K to V

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

    Permalink

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

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

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

    Permalink

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

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

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

    Permalink

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

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

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

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

    Permalink

    A Generator that produces negative Double values, not including zero but including infinity and NaN.

    A Generator that produces negative Double values, not including zero but including infinity and NaN.

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

    Permalink

    A Generator that produces NegDouble values.

    A Generator that produces NegDouble values.

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

    Permalink

    Create a Generator that returns NegDoubles in the specified range.

    Create a Generator that returns NegDoubles in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces negative Double values, not including zero, infinity or NaN.

    A Generator that produces negative Double values, not including zero, infinity or NaN.

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

    Permalink

    A Generator that produces NegFiniteDouble values.

    A Generator that produces NegFiniteDouble values.

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

    Permalink

    Create a Generator that returns NegFiniteDoubles in the specified range.

    Create a Generator that returns NegFiniteDoubles in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces negative Float values, not including zero, infinity or NaN.

    A Generator that produces negative Float values, not including zero, infinity or NaN.

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

    Permalink

    A Generator that produces NegFiniteFloat values.

    A Generator that produces NegFiniteFloat values.

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

    Permalink

    Create a Generator that returns NegFiniteFloats in the specified range.

    Create a Generator that returns NegFiniteFloats in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces negative Float values, not including zero but including infinity and NaN.

    A Generator that produces negative Float values, not including zero but including infinity and NaN.

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

    Permalink

    A Generator that produces NegFloat values.

    A Generator that produces NegFloat values.

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

    Permalink

    Create a Generator that returns NegFloats in the specified range.

    Create a Generator that returns NegFloats in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces negative Int values, not including zero.

    A Generator that produces negative Int values, not including zero.

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

    Permalink

    A Generator that produces NegInt values.

    A Generator that produces NegInt values.

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

    Permalink

    Create a Generator that returns NegInts in the specified range.

    Create a Generator that returns NegInts in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces negative Long values, not including zero.

    A Generator that produces negative Long values, not including zero.

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

    Permalink

    A Generator that produces NegLong values.

    A Generator that produces NegLong values.

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

    Permalink

    Create a Generator that returns NegLongs in the specified range.

    Create a Generator that returns NegLongs in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces negative Double values, including zero, infinity and NaN.

    A Generator that produces negative Double values, including zero, infinity and NaN.

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

    Permalink

    A Generator that produces NegZDouble values.

    A Generator that produces NegZDouble values.

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

    Permalink

    Create a Generator that returns NegZDoubles in the specified range.

    Create a Generator that returns NegZDoubles in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces negative Double values, including zero but not including infinity or NaN.

    A Generator that produces negative Double values, including zero but not including infinity or NaN.

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

    Permalink

    A Generator that produces NegZFiniteDouble values.

    A Generator that produces NegZFiniteDouble values.

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

    Permalink

    Create a Generator that returns NegZFiniteDoubles in the specified range.

    Create a Generator that returns NegZFiniteDoubles in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces negative Float values, including zero but not including infinity or NaN.

    A Generator that produces negative Float values, including zero but not including infinity or NaN.

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

    Permalink

    A Generator that produces NegZFiniteFloat values.

    A Generator that produces NegZFiniteFloat values.

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

    Permalink

    Create a Generator that returns NegZFiniteFloats in the specified range.

    Create a Generator that returns NegZFiniteFloats in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces negative Float values, including zero, infinity and NaN.

    A Generator that produces negative Float values, including zero, infinity and NaN.

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

    Permalink

    A Generator that produces NegZFloat values.

    A Generator that produces NegZFloat values.

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

    Permalink

    Create a Generator that returns NegZFloats in the specified range.

    Create a Generator that returns NegZFloats in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces negative Int values, including zero.

    A Generator that produces negative Int values, including zero.

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

    Permalink

    A Generator that produces NegZInt values.

    A Generator that produces NegZInt values.

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

    Permalink

    Create a Generator that returns NegZInts in the specified range.

    Create a Generator that returns NegZInts in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces negative Long values, including zero.

    A Generator that produces negative Long values, including zero.

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

    Permalink

    A Generator that produces NegZLong values.

    A Generator that produces NegZLong values.

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

    Permalink

    Create a Generator that returns NegZLongs in the specified range.

    Create a Generator that returns NegZLongs in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces non-zero Double values, including infinity and NaN.

    A Generator that produces non-zero Double values, including infinity and NaN.

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

    Permalink

    A Generator that produces NonZeroDouble values.

    A Generator that produces NonZeroDouble values.

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

    Permalink

    Create a Generator that returns NonZeroDoubles in the specified range.

    Create a Generator that returns NonZeroDoubles in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces non-zero Double values, not including infinity and NaN.

    A Generator that produces non-zero Double values, not including infinity and NaN.

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

    Permalink

    A Generator that produces NonZeroFiniteDouble values.

    A Generator that produces NonZeroFiniteDouble values.

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

    Permalink

    Create a Generator that returns NonZeroFiniteDoubles in the specified range.

    Create a Generator that returns NonZeroFiniteDoubles in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces non-zero Float values, not including infinity or NaN.

    A Generator that produces non-zero Float values, not including infinity or NaN.

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

    Permalink

    A Generator that produces NonZeroFiniteFloat values.

    A Generator that produces NonZeroFiniteFloat values.

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

    Permalink

    Create a Generator that returns NonZeroFiniteFloats in the specified range.

    Create a Generator that returns NonZeroFiniteFloats in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces non-zero Float values, including infinity and NaN.

    A Generator that produces non-zero Float values, including infinity and NaN.

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

    Permalink

    A Generator that produces NonZeroFloat values.

    A Generator that produces NonZeroFloat values.

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

    Permalink

    Create a Generator that returns NonZeroFloats in the specified range.

    Create a Generator that returns NonZeroFloats in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces non-zero Int values.

    A Generator that produces non-zero Int values.

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

    Permalink

    A Generator that produces NonZeroInt values.

    A Generator that produces NonZeroInt values.

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

    Permalink

    Create a Generator that returns NonZeroInts in the specified range.

    Create a Generator that returns NonZeroInts in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces non-zero Long values.

    A Generator that produces non-zero Long values.

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

    Permalink

    A Generator that produces NonZeroLong values.

    A Generator that produces NonZeroLong values.

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

    Permalink

    Create a Generator that returns NonZeroLongs in the specified range.

    Create a Generator that returns NonZeroLongs in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

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

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

    Permalink

    A Generator that produces digit Chars.

    A Generator that produces digit Chars.

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

    Permalink

    A Generator that produces NumericChar values.

    A Generator that produces NumericChar values.

    Definition Classes
    CommonGenerators
  259. def options[T](implicit genOfT: Generator[T]): Generator[Option[T]]

    Permalink

    Given an existing Generator[T], this creates a Generator[Option[T]].

    Given an existing Generator[T], this creates a Generator[Option[T]].

    T

    the type that we are producing an Option of

    genOfT

    a Generator that produces values of type T

    returns

    a Generator that produces Option[T]

    Definition Classes
    CommonGenerators
  260. def ors[G, B](implicit genOfG: Generator[G], genOfB: Generator[B]): Generator[Or[G, B]]

    Permalink

    Given Generators for two types, G and B, this provides one for G Or B.

    Given Generators for two types, G and B, this provides one for G Or B.

    G

    the "good" type for an Or

    B

    the "bad" type for an Or

    genOfG

    a Generator that produces type G

    genOfB

    a Generator that produces type B

    returns

    a Generator that produces G Or B

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

    Permalink

    A Generator that produces positive Double values, not including zero but including infinity and NaN.

    A Generator that produces positive Double values, not including zero but including infinity and NaN.

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

    Permalink

    A Generator that produces PosDouble values.

    A Generator that produces PosDouble values.

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

    Permalink

    Create a Generator that returns PosDoubles in the specified range.

    Create a Generator that returns PosDoubles in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces positive Double values, not including zero, infinity or NaN.

    A Generator that produces positive Double values, not including zero, infinity or NaN.

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

    Permalink

    A Generator that produces PosFiniteDouble values.

    A Generator that produces PosFiniteDouble values.

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

    Permalink

    Create a Generator that returns PosFiniteDoubles in the specified range.

    Create a Generator that returns PosFiniteDoubles in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces positive Float values, not including zero, infinity or NaN.

    A Generator that produces positive Float values, not including zero, infinity or NaN.

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

    Permalink

    A Generator that produces PosFiniteFloat values.

    A Generator that produces PosFiniteFloat values.

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

    Permalink

    Create a Generator that returns PosFiniteFloats in the specified range.

    Create a Generator that returns PosFiniteFloats in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces positive Float values, not including zero but including infinites and NaN.

    A Generator that produces positive Float values, not including zero but including infinites and NaN.

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

    Permalink

    A Generator that produces PosFloat values.

    A Generator that produces PosFloat values.

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

    Permalink

    Create a Generator that returns PosFloats in the specified range.

    Create a Generator that returns PosFloats in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces positive Int values, not including zero.

    A Generator that produces positive Int values, not including zero.

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

    Permalink

    A Generator that produces PosInt values.

    A Generator that produces PosInt values.

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

    Permalink

    Create a Generator that returns PosInts in the specified range.

    Create a Generator that returns PosInts in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces positive Long values, not including zero.

    A Generator that produces positive Long values, not including zero.

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

    Permalink

    A Generator that produces PosLong values.

    A Generator that produces PosLong values.

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

    Permalink

    Create a Generator that returns PosLongs in the specified range.

    Create a Generator that returns PosLongs in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces positive Double values, including zero, infinity and NaN.

    A Generator that produces positive Double values, including zero, infinity and NaN.

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

    Permalink

    A Generator that produces PosZDouble values.

    A Generator that produces PosZDouble values.

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

    Permalink

    Create a Generator that returns PosZDoubles in the specified range.

    Create a Generator that returns PosZDoubles in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces positive Int values.

    A Generator that produces positive Int values.

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

    Permalink

    A Generator that produces PosZFiniteDouble values.

    A Generator that produces PosZFiniteDouble values.

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

    Permalink

    Create a Generator that returns PosZFiniteDoubles in the specified range.

    Create a Generator that returns PosZFiniteDoubles in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces positive Float values, including zero but not including infinity or NaN.

    A Generator that produces positive Float values, including zero but not including infinity or NaN.

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

    Permalink

    A Generator that produces PosZFiniteFloat values.

    A Generator that produces PosZFiniteFloat values.

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

    Permalink

    Create a Generator that returns PosZFiniteFloats in the specified range.

    Create a Generator that returns PosZFiniteFloats in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces positive Float values, including zero, infinity and NaN.

    A Generator that produces positive Float values, including zero, infinity and NaN.

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

    Permalink

    A Generator that produces PosZFloat values.

    A Generator that produces PosZFloat values.

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

    Permalink

    Create a Generator that returns PosZFloats in the specified range.

    Create a Generator that returns PosZFloats in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces positive Int values, including zero.

    A Generator that produces positive Int values, including zero.

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

    Permalink

    A Generator that produces PosZInt values.

    A Generator that produces PosZInt values.

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

    Permalink

    Create a Generator that returns PosZInts in the specified range.

    Create a Generator that returns PosZInts in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    A Generator that produces positive Long values, including zero.

    A Generator that produces positive Long values, including zero.

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

    Permalink

    A Generator that produces PosZLong values.

    A Generator that produces PosZLong values.

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

    Permalink

    Create a Generator that returns PosZLongs in the specified range.

    Create a Generator that returns PosZLongs in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

    Given a Generator that produces values of type T, this creates one for a Set of T.

    Given a Generator that produces values of type T, this creates one for a Set of T.

    Note that the Set type is considered to have a "size", so you can use the configuration parameters Configuration.minSize and Configuration.sizeRange to constrain the sizes of the resulting Sets when you use this Generator.

    The resulting Generator also has the HavingSize trait, so you can use it to generate Sets with specific sizes.

    T

    the type to produce

    genOfT

    a Generator that produces values of type T

    returns

    a Generator that produces Set[T].

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

    Permalink

    A Generator that produces Short values.

    A Generator that produces Short values.

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

    Permalink

    Create a Generator that returns Shorts in the specified range.

    Create a Generator that returns Shorts in the specified range.

    The range is inclusive: both from and to may be produced by this Generator. Moreover, from and to are considered to be edge cases, so they usually will be produced in a typical run.

    The value of from must be less than or equal to the value of to.

    from

    one end of the desired range

    to

    the other end of the desired range

    returns

    a value within that range, inclusive of the bounds

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

    Permalink

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

    Permalink

    Given a Generator that produces Tuples of key/value pairs, this gives you one that produces SortedMaps with those pairs.

    Given a Generator that produces Tuples of key/value pairs, this gives you one that produces SortedMaps with those pairs.

    If you are simply looking for random pairing of the key and value types, this is pretty easy to use: if both the key and value types have Generators, then the Tuple and SortedMap ones will be automatically and implicitly created when you need them.

    The resulting Generator also has the HavingSize trait, so you can use it to generate SortedMaps with specific sizes.

    K

    the type of the keys for the SortedMap

    V

    the type of the values for the SortedMap

    returns

    a Generator of SortedMaps from K to V

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

    Permalink

    Given a Generator that produces values of type T, this creates one for a SortedSet of T.

    Given a Generator that produces values of type T, this creates one for a SortedSet of T.

    Note that the SortedSet type is considered to have a "size", so you can use the configuration parameters Configuration.minSize and Configuration.sizeRange to constrain the sizes of the resulting SortedSets when you use this Generator.

    The resulting Generator also has the HavingSize trait, so you can use it to generate SortedSets with specific sizes.

    T

    the type to produce

    genOfT

    a Generator that produces values of type T

    returns

    a Generator that produces SortedSet[T].

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

    Permalink

    Creates a Generator that will always return exactly the same value.

    Creates a Generator that will always return exactly the same value.

    This is specialized, but occasionally useful. It is mainly appropriate when you have a function that requires a Generator, but only one value makes sense for the Property you are evaluating.

    T

    the type of that value

    theValue

    the value to produce

    returns

    a Generator that will always produce that value

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

    Permalink

    Given a list of values of type T, this creates a Generator that will only produce those values.

    Given a list of values of type T, this creates a Generator that will only produce those values.

    The order in which the values are produced is random, based on the Randomizer passed in to the next function. It may produce the same value multiple times.

    T

    the type that will be produced by the resulting Generator

    first

    a value of type T

    second

    another value of type T

    rest

    more values of type T, as many as you wish

    returns

    a Generator that produces exactly the specified values

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

    Permalink

    A Generator that produces String values.

    A Generator that produces String values.

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

    Permalink
    Definition Classes
    AnyRef
  307. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  308. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  309. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  310. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  311. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  312. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  313. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  314. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  315. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  316. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  317. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  318. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  319. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  320. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

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

    Permalink

    Given Generators for types A and B, get one that produces Tuples of those types.

    Given Generators for types A and B, get one that produces Tuples of those types.

    tuple2s (and its variants, up through tuple22s) will create Generators on demand for essentially arbitrary Tuples, so long as you have Generators in implicit scope for all of the component types.

    A

    the first type in the Tuple

    B

    the second type in the Tuple

    genOfA

    a Generator for type A

    genOfB

    a Generator for type B

    returns

    a Generator that produces the desired types, Tupled together.

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

    Permalink

    See tuple2s.

    See tuple2s.

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

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  324. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  325. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  326. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  327. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

    Definition Classes
    CommonGenerators
  328. 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)]

    Permalink

    See tuple2s.

    See tuple2s.

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

    Permalink

    Given a Generator for type T, this creates one for a Vector of T.

    Given a Generator for type T, this creates one for a Vector of T.

    Note that the Vector type is considered to have a "size", so you can use the configuration parameters Configuration.minSize and Configuration.sizeRange to constrain the sizes of the resulting Vectors when you use this Generator.

    The resulting Generator also has the HavingLength trait, so you can use it to generate Vectors with specific lengths.

    T

    the type to produce

    genOfT

    a Generator that produces values of type T

    returns

    a Generator that produces values of type Vector[T]

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

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

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

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

    Permalink

    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
  334. def workers(value: PosInt): Workers

    Permalink

    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

Inherited from PropertyChecks

Inherited from Configuration

Inherited from CommonGenerators

Inherited from TableDrivenPropertyChecks

Inherited from Tables

Inherited from Whenever

Inherited from AnyRef

Inherited from Any

Creating Generators from Specific Values

These functions let you create Generators that only return specific values

Creating Higher-Order Generators from other Generators

These functions let you create Generators that are built from more than one existing Generator.

Generators for Many Common Types

These cover types from both the Scala Standard Library and Scalactic

Generators that produce the values from Scalactic Types

Scalactic has many highly-precise numeric types such as NonZeroLong, PosZFloat or FiniteDouble. These help you make sure your code is using exactly the numbers you intend, and they are very convenient for using with Generators. But if the code under test is not using Scalactic, you sometimes find that you need to type .value a lot. These Generators do that for so: you can choose a precise numeric Generator, but get the conventional numeric type from it.

Generators for standard Collections

These functions take one or more types T, and create Generators that produce collections of T.

Range-based Generator Creation

Functions that create Generators for values in a specific range of a specific type.

Generators that Produce Functions

These functions create Generators that produce random functions with specified parameter and return types.

Generators for instances of case classes

These functions are one way to create Generators for case class instances.

Tools for Developing Generators

Ungrouped