scalatestCoreDotty
API
Generated with
scalatestCoreDotty/org.scalatest/org.scalatest.prop/PropertyChecks

PropertyChecks

org.scalatest.prop.PropertyChecks
See thePropertyChecks companion trait
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.

Attributes

Companion
trait
Graph
Supertypes
trait Tables
trait Whenever
class Object
trait Matchable
class Any
Show all
Self type

Members list

Type members

Inherited classlikes

class ConfiguredPropertyCheck(configParams: Seq[PropertyCheckConfigParam])

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)
}

Value parameters

configParams

a variable length list of PropertyCheckConfigParam objects that should override corresponding values in the PropertyCheckConfiguration implicitly passed to the apply methods of instances of this class.

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
Supertypes
class Object
trait Matchable
class Any
case class MaxDiscardedFactor(value: PosZDouble) extends PropertyCheckConfigParam

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 parameters

value

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

Attributes

Inherited from:
Configuration
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
case class MinSize(value: PosZInt) extends PropertyCheckConfigParam

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

Attributes

Inherited from:
Configuration
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
case class MinSuccessful(value: PosInt) extends PropertyCheckConfigParam

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.

Attributes

Inherited from:
Configuration
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
sealed abstract class PropertyCheckConfigParam extends Product, Serializable

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

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

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

Attributes

Inherited from:
Configuration
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
Known subtypes
class MinSize
class SizeRange
class Workers
case class PropertyCheckConfiguration(minSuccessful: PosInt, maxDiscardedFactor: PosZDouble, minSize: PosZInt, sizeRange: PosZInt, workers: PosInt)

Describes the configuration to use when evaluating a property.

Describes the configuration to use when evaluating a property.

Value parameters

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

minSuccessful

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

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

Attributes

Inherited from:
Configuration
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object PropertyCheckConfiguration

Internal utility functions for configuration management.

Internal utility functions for configuration management.

Attributes

Inherited from:
Configuration
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
case class SizeRange(value: PosZInt) extends PropertyCheckConfigParam

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.

Attributes

Inherited from:
Configuration
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Table

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.

Attributes

Inherited from:
Tables
Supertypes
class Object
trait Matchable
class Any
case class Workers(value: PosInt) extends PropertyCheckConfigParam

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.

Attributes

Inherited from:
Configuration
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all

Value members

Inherited methods

def between[T](from: T, to: T)(implicit ord: Ordering[T], chooser: Chooser[T], gen: Generator[T]): Generator[T]

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.

Type parameters

T

the type to choose a value from

Value parameters

chooser

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

from

the lower bound of the range to choose from

gen

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

ord

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

to

the upper bound of the range to choose from

Attributes

Returns

a new Generator, that produces values in the specified range

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Type parameters

A

the type to be generated

Value parameters

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

Attributes

Returns

statistics on how many values wound up in each bucket

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

Inherited from:
CommonGenerators
def eithers[L, R](implicit genOfL: Generator[L], genOfR: Generator[R]): Generator[Either[L, R]]

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

Type parameters

L

the Left type for an Either

R

the Right type for an Either

Value parameters

genOfL

a Generator that produces type L

genOfR

a Generator that produces type R

Attributes

Returns

a Generator that produces Either[L, R]

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

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.

Type parameters

T

the type to be produced

Value parameters

first

a Generator to choose from

rest

any number of additional Generators to choose from

second

another Generator to choose from

Attributes

Returns

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

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, N, ASSERTION](table: TableFor14[A, B, C, D, E, F, G, H, I, J, K, L, M, N])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, M, ASSERTION](table: TableFor13[A, B, C, D, E, F, G, H, I, J, K, L, M])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, L, ASSERTION](table: TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])(fun: (A, B, C, D, E, F, G, H, I, J, K, L) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, K, ASSERTION](table: TableFor11[A, B, C, D, E, F, G, H, I, J, K])(fun: (A, B, C, D, E, F, G, H, I, J, K) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, J, ASSERTION](table: TableFor10[A, B, C, D, E, F, G, H, I, J])(fun: (A, B, C, D, E, F, G, H, I, J) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, I, ASSERTION](table: TableFor9[A, B, C, D, E, F, G, H, I])(fun: (A, B, C, D, E, F, G, H, I) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, H, ASSERTION](table: TableFor8[A, B, C, D, E, F, G, H])(fun: (A, B, C, D, E, F, G, H) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, G, ASSERTION](table: TableFor7[A, B, C, D, E, F, G])(fun: (A, B, C, D, E, F, G) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, C, D, E, F, ASSERTION](table: TableFor6[A, B, C, D, E, F])(fun: (A, B, C, D, E, F) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, C, D, E, ASSERTION](table: TableFor5[A, B, C, D, E])(fun: (A, B, C, D, E) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, C, D, ASSERTION](table: TableFor4[A, B, C, D])(fun: (A, B, C, D) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, C, ASSERTION](table: TableFor3[A, B, C])(fun: (A, B, C) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, B, ASSERTION](table: TableFor2[A, B])(fun: (A, B) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def exists[A, ASSERTION](table: TableFor1[A])(fun: A => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

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

Attributes

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

Attributes

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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
def forAll[A, ASSERTION](genA: Generator[A])(fun: A => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
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

Attributes

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

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
def forAll[A, ASSERTION](fun: A => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result

Attributes

Inherited from:
GeneratorDrivenPropertyChecks
def forAll(configParams: PropertyCheckConfigParam*): ConfiguredPropertyCheck

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

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

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

forAll (minSize(1), 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)
}

Value parameters

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.

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, N, ASSERTION](table: TableFor14[A, B, C, D, E, F, G, H, I, J, K, L, M, N])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, M, ASSERTION](table: TableFor13[A, B, C, D, E, F, G, H, I, J, K, L, M])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, L, ASSERTION](table: TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])(fun: (A, B, C, D, E, F, G, H, I, J, K, L) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, K, ASSERTION](table: TableFor11[A, B, C, D, E, F, G, H, I, J, K])(fun: (A, B, C, D, E, F, G, H, I, J, K) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, J, ASSERTION](table: TableFor10[A, B, C, D, E, F, G, H, I, J])(fun: (A, B, C, D, E, F, G, H, I, J) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, I, ASSERTION](table: TableFor9[A, B, C, D, E, F, G, H, I])(fun: (A, B, C, D, E, F, G, H, I) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, H, ASSERTION](table: TableFor8[A, B, C, D, E, F, G, H])(fun: (A, B, C, D, E, F, G, H) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, G, ASSERTION](table: TableFor7[A, B, C, D, E, F, G])(fun: (A, B, C, D, E, F, G) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, F, ASSERTION](table: TableFor6[A, B, C, D, E, F])(fun: (A, B, C, D, E, F) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, C, D, E, ASSERTION](table: TableFor5[A, B, C, D, E])(fun: (A, B, C, D, E) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, C, D, ASSERTION](table: TableFor4[A, B, C, D])(fun: (A, B, C, D) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, C, ASSERTION](table: TableFor3[A, B, C])(fun: (A, B, C) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, B, ASSERTION](table: TableFor2[A, B])(fun: (A, B) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forAll[A, ASSERTION](table: TableFor1[A])(fun: A => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, N, ASSERTION](table: TableFor14[A, B, C, D, E, F, G, H, I, J, K, L, M, N])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, M, ASSERTION](table: TableFor13[A, B, C, D, E, F, G, H, I, J, K, L, M])(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, L, ASSERTION](table: TableFor12[A, B, C, D, E, F, G, H, I, J, K, L])(fun: (A, B, C, D, E, F, G, H, I, J, K, L) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, K, ASSERTION](table: TableFor11[A, B, C, D, E, F, G, H, I, J, K])(fun: (A, B, C, D, E, F, G, H, I, J, K) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, J, ASSERTION](table: TableFor10[A, B, C, D, E, F, G, H, I, J])(fun: (A, B, C, D, E, F, G, H, I, J) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, I, ASSERTION](table: TableFor9[A, B, C, D, E, F, G, H, I])(fun: (A, B, C, D, E, F, G, H, I) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, H, ASSERTION](table: TableFor8[A, B, C, D, E, F, G, H])(fun: (A, B, C, D, E, F, G, H) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, G, ASSERTION](table: TableFor7[A, B, C, D, E, F, G])(fun: (A, B, C, D, E, F, G) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, F, ASSERTION](table: TableFor6[A, B, C, D, E, F])(fun: (A, B, C, D, E, F) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, C, D, E, ASSERTION](table: TableFor5[A, B, C, D, E])(fun: (A, B, C, D, E) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, C, D, ASSERTION](table: TableFor4[A, B, C, D])(fun: (A, B, C, D) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, C, ASSERTION](table: TableFor3[A, B, C])(fun: (A, B, C) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, B, ASSERTION](table: TableFor2[A, B])(fun: (A, B) => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

Inherited from:
TableDrivenPropertyChecks
def forEvery[A, ASSERTION](table: TableFor1[A])(fun: A => ASSERTION)(implicit asserting: TableAsserting[ASSERTION], prettifier: Prettifier, pos: Position): Result

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

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

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

Value parameters

fun

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

table

the table of data with which to perform the property check

Attributes

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

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.

Type parameters

T

the type being produced by all of these Generators

Value parameters

first

a Generator and its weight

rest

as many more Generator and weight pairs as you like

second

another Generator and its weight

Attributes

Returns

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

Inherited from:
CommonGenerators
def function0s[A](implicit genOfA: Generator[A]): Generator[() => A]

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.

Type parameters

A

the type to return from the generated functions

Value parameters

genOfT

a Generator that produces functions that return A

Attributes

Returns

a Generator that produces functions that return values of type A

Inherited from:
CommonGenerators
def function10s[A, B, C, D, E, F, G, H, I, J, K](implicit genOfK: Generator[K], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K]): Generator[(A, B, C, D, E, F, G, H, I, J) => K]

See function1s.

See function1s.

Attributes

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

See function1s.

See function1s.

Attributes

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

See function1s.

See function1s.

Attributes

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

See function1s.

See function1s.

Attributes

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

See function1s.

See function1s.

Attributes

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

See function1s.

See function1s.

Attributes

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

See function1s.

See function1s.

Attributes

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

See function1s.

See function1s.

Attributes

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

See function1s.

See function1s.

Attributes

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

See function1s.

See function1s.

Attributes

Inherited from:
CommonGenerators
def function1s[A, B](implicit genOfB: Generator[B], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B]): Generator[A => B]

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.

Type parameters

A

the input type for the generated functions

B

the result type for the generated functions

Value parameters

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

Attributes

Returns

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

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

See function1s.

See function1s.

Attributes

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

See function1s.

See function1s.

Attributes

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

See function1s.

See function1s.

Attributes

Inherited from:
CommonGenerators
def function2s[A, B, C](implicit genOfC: Generator[C], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C]): Generator[(A, B) => C]

See function1s.

See function1s.

Attributes

Inherited from:
CommonGenerators
def function3s[A, B, C, D](implicit genOfD: Generator[D], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D]): Generator[(A, B, C) => D]

See function1s.

See function1s.

Attributes

Inherited from:
CommonGenerators
def function4s[A, B, C, D, E](implicit genOfE: Generator[E], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E]): Generator[(A, B, C, D) => E]

See function1s.

See function1s.

Attributes

Inherited from:
CommonGenerators
def function5s[A, B, C, D, E, F](implicit genOfF: Generator[F], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F]): Generator[(A, B, C, D, E) => F]

See function1s.

See function1s.

Attributes

Inherited from:
CommonGenerators
def function6s[A, B, C, D, E, F, G](implicit genOfG: Generator[G], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G]): Generator[(A, B, C, D, E, F) => G]

See function1s.

See function1s.

Attributes

Inherited from:
CommonGenerators
def function7s[A, B, C, D, E, F, G, H](implicit genOfH: Generator[H], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H]): Generator[(A, B, C, D, E, F, G) => H]

See function1s.

See function1s.

Attributes

Inherited from:
CommonGenerators
def function8s[A, B, C, D, E, F, G, H, I](implicit genOfI: Generator[I], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I]): Generator[(A, B, C, D, E, F, G, H) => I]

See function1s.

See function1s.

Attributes

Inherited from:
CommonGenerators
def function9s[A, B, C, D, E, F, G, H, I, J](implicit genOfJ: Generator[J], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J]): Generator[(A, B, C, D, E, F, G, H, I) => J]

See function1s.

See function1s.

Attributes

Inherited from:
CommonGenerators
def getParameter(configParams: Seq[PropertyCheckConfigParam], config: PropertyCheckConfiguration): Parameter

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.

Value parameters

c

a configuration object, describing how to run property evaluations

configParams

optionally, some parameters that differ from the provided c

Attributes

Returns

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

Inherited from:
Configuration
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]

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

Inherited from:
CommonGenerators
def instancesOf[A, B, C, D, E, F, G, H, I, J, K](construct: (A, B, C, D, E, F, G, H, I, J) => K)(deconstruct: K => (A, B, C, D, E, F, G, H, I, J))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J]): Generator[K]

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

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

Attributes

Inherited from:
CommonGenerators
def instancesOf[A, B, C, D, E, F, G, H, I, J](construct: (A, B, C, D, E, F, G, H, I) => J)(deconstruct: J => (A, B, C, D, E, F, G, H, I))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I]): Generator[J]

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

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

Attributes

Inherited from:
CommonGenerators
def instancesOf[A, B, C, D, E, F, G, H, I](construct: (A, B, C, D, E, F, G, H) => I)(deconstruct: I => (A, B, C, D, E, F, G, H))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H]): Generator[I]

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

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

Attributes

Inherited from:
CommonGenerators
def instancesOf[A, B, C, D, E, F, G, H](construct: (A, B, C, D, E, F, G) => H)(deconstruct: H => (A, B, C, D, E, F, G))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G]): Generator[H]

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

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

Attributes

Inherited from:
CommonGenerators
def instancesOf[A, B, C, D, E, F, G](construct: (A, B, C, D, E, F) => G)(deconstruct: G => (A, B, C, D, E, F))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F]): Generator[G]

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

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

Attributes

Inherited from:
CommonGenerators
def instancesOf[A, B, C, D, E, F](construct: (A, B, C, D, E) => F)(deconstruct: F => (A, B, C, D, E))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E]): Generator[F]

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

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

Attributes

Inherited from:
CommonGenerators
def instancesOf[A, B, C, D, E](construct: (A, B, C, D) => E)(deconstruct: E => (A, B, C, D))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D]): Generator[E]

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

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

Attributes

Inherited from:
CommonGenerators
def instancesOf[A, B, C, D](construct: (A, B, C) => D)(deconstruct: D => (A, B, C))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C]): Generator[D]

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

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

Attributes

Inherited from:
CommonGenerators
def instancesOf[A, B, C](construct: (A, B) => C)(deconstruct: C => (A, B))(implicit genOfA: Generator[A], genOfB: Generator[B]): Generator[C]

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

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

Attributes

Inherited from:
CommonGenerators
def instancesOf[A, B](construct: A => B)(deconstruct: B => A)(implicit genOfA: Generator[A]): Generator[B]

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.

Type parameters

A

the input type

B

the target type to be generated

Value parameters

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

Attributes

Returns

a Generator for the target type

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

Inherited from:
CommonGenerators
def lists[T](implicit genOfT: Generator[T]): Generator[List[T]] & HavingLength[List[T]]

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

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

Type parameters

T

the type that we are producing a List of

Value parameters

genOfT

a Generator that produces values of type T

Attributes

Returns

a List of values of type T

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

Inherited from:
CommonGenerators
def maps[K, V](implicit genOfTupleKV: Generator[(K, V)]): Generator[Map[K, V]] & HavingSize[Map[K, V]]

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.

Type parameters

K

the type of the keys for the Map

V

the type of the values for the Map

Value parameters

genOfTuple2KV

a Generator that produces Tuples of K and V

Attributes

Returns

a Generator of Maps from K to V

Inherited from:
CommonGenerators
def maxDiscardedFactor(value: PosZDouble): MaxDiscardedFactor

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

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

Attributes

Inherited from:
Configuration
def minSize(value: PosZInt): MinSize

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

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

Attributes

Inherited from:
Configuration
def minSuccessful(value: PosInt): MinSuccessful

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

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

Attributes

Inherited from:
Configuration
def negDoublesBetween(from: NegDouble, to: NegDouble): Generator[NegDouble]

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

Inherited from:
CommonGenerators
def options[T](implicit genOfT: Generator[T]): Generator[Option[T]]

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

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

Type parameters

T

the type that we are producing an Option of

Value parameters

genOfT

a Generator that produces values of type T

Attributes

Returns

a Generator that produces Option[T]

Inherited from:
CommonGenerators
def ors[G, B](implicit genOfG: Generator[G], genOfB: Generator[B]): Generator[Or[G, B]]

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.

Type parameters

B

the "bad" type for an Or

G

the "good" type for an Or

Value parameters

genOfB

a Generator that produces type B

genOfG

a Generator that produces type G

Attributes

Returns

a Generator that produces G Or B

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

Inherited from:
CommonGenerators
def sets[T](implicit genOfT: Generator[T]): Generator[Set[T]] & HavingSize[Set[T]]

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.

Type parameters

T

the type to produce

Value parameters

genOfT

a Generator that produces values of type T

Attributes

Returns

a Generator that produces Set[T].

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

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.

Value parameters

from

one end of the desired range

to

the other end of the desired range

Attributes

Returns

a value within that range, inclusive of the bounds

Inherited from:
CommonGenerators
def sizeRange(value: PosZInt): SizeRange

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

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

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

Attributes

Inherited from:
Configuration
def sortedMaps[K, V](implicit genOfTupleKV: Generator[(K, V)], ordering: Ordering[K]): Generator[SortedMap[K, V]] & HavingSize[SortedMap[K, V]]

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.

Type parameters

K

the type of the keys for the SortedMap

V

the type of the values for the SortedMap

Value parameters

genOfTuple2KV

a Generator that produces Tuples of K and V

Attributes

Returns

a Generator of SortedMaps from K to V

Inherited from:
CommonGenerators
def sortedSets[T](implicit genOfT: Generator[T], ordering: Ordering[T]): Generator[SortedSet[T]] & HavingSize[SortedSet[T]]

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.

Type parameters

T

the type to produce

Value parameters

genOfT

a Generator that produces values of type T

Attributes

Returns

a Generator that produces SortedSet[T].

Inherited from:
CommonGenerators
def specificValue[T](theValue: T): Generator[T]

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.

Type parameters

T

the type of that value

Value parameters

theValue

the value to produce

Attributes

Returns

a Generator that will always produce that value

Inherited from:
CommonGenerators
def specificValues[T](first: T, second: T, rest: T*): Generator[T]

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.

Type parameters

T

the type that will be produced by the resulting Generator

Value parameters

first

a value of type T

rest

more values of type T, as many as you wish

second

another value of type T

Attributes

Returns

a Generator that produces exactly the specified values

Inherited from:
CommonGenerators
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)]

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

Inherited from:
CommonGenerators
def tuple2s[A, B](implicit genOfA: Generator[A], genOfB: Generator[B]): Generator[(A, B)]

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.

Type parameters

A

the first type in the Tuple

B

the second type in the Tuple

Value parameters

genOfA

a Generator for type A

genOfB

a Generator for type B

Attributes

Returns

a Generator that produces the desired types, Tupled together.

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

See tuple2s.

See tuple2s.

Attributes

Inherited from:
CommonGenerators
def tuple4s[A, B, C, D](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D]): Generator[(A, B, C, D)]

See tuple2s.

See tuple2s.

Attributes

Inherited from:
CommonGenerators
def tuple5s[A, B, C, D, E](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E]): Generator[(A, B, C, D, E)]

See tuple2s.

See tuple2s.

Attributes

Inherited from:
CommonGenerators
def tuple6s[A, B, C, D, E, F](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F]): Generator[(A, B, C, D, E, F)]

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

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

See tuple2s.

See tuple2s.

Attributes

Inherited from:
CommonGenerators
def vectors[T](implicit genOfT: Generator[T]): Generator[Vector[T]] & HavingLength[Vector[T]]

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.

Type parameters

T

the type to produce

Value parameters

genOfT

a Generator that produces values of type T

Attributes

Returns

a Generator that produces values of type Vector[T]

Inherited from:
CommonGenerators
def whenever[T](condition: Boolean)(fun: => T)(implicit wa: WheneverAsserting[T]): Result

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

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

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

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

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

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

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

import org.scalatest.prop.TableDrivenPropertyChecks._

val fractions =
 Table(
   ("n", "d"),
   (  1,   2),
   ( -1,   2),
   (  1,  -2),
   ( -1,  -2),
   (  3,   1),
   ( -3,   1),
   ( -3,   0),
   (  3,  -1),
   (  3,  Integer.MIN_VALUE),
   (Integer.MIN_VALUE, 3),
   ( -3,  -1)
 )

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

import org.scalatest.matchers.Matchers._

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

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

   val f = new Fraction(n, d)

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

   f.denom should be > 0
 }
}

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

Value parameters

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

Attributes

Inherited from:
Whenever
def workers(value: PosInt): Workers

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

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

Attributes

Inherited from:
Configuration

Inherited fields

val booleans: Generator[Boolean]

A Generator that produces Boolean values.

A Generator that produces Boolean values.

Attributes

Inherited from:
CommonGenerators
val bytes: Generator[Byte]

A Generator that produces Byte values.

A Generator that produces Byte values.

Attributes

Inherited from:
CommonGenerators
val chars: Generator[Char]

A Generator that produces Char values.

A Generator that produces Char values.

Attributes

Inherited from:
CommonGenerators
val doubles: Generator[Double]

A Generator that produces Double values.

A Generator that produces Double values.

Attributes

Inherited from:
CommonGenerators
val finiteDoubleValues: Generator[Double]

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.

Attributes

Inherited from:
CommonGenerators
val finiteDoubles: Generator[FiniteDouble]

A Generator that produces FiniteDouble values.

A Generator that produces FiniteDouble values.

Attributes

Inherited from:
CommonGenerators
val finiteFloatValues: Generator[Float]

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.

Attributes

Inherited from:
CommonGenerators
val finiteFloats: Generator[FiniteFloat]

A Generator that produces FiniteFloat values.

A Generator that produces FiniteFloat values.

Attributes

Inherited from:
CommonGenerators
lazy val first1000Primes: Generator[Int]

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.

Attributes

Returns

a Generator that will produce smallish prime numbers

Inherited from:
CommonGenerators
val floats: Generator[Float]

A Generator that produces Float values.

A Generator that produces Float values.

Attributes

Inherited from:
CommonGenerators
val ints: Generator[Int]

A Generator that produces Int values.

A Generator that produces Int values.

Attributes

Inherited from:
CommonGenerators
val longs: Generator[Long]

A Generator that produces Long values.

A Generator that produces Long values.

Attributes

Inherited from:
CommonGenerators
val negDoubleValues: Generator[Double]

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.

Attributes

Inherited from:
CommonGenerators
val negDoubles: Generator[NegDouble]

A Generator that produces NegDouble values.

A Generator that produces NegDouble values.

Attributes

Inherited from:
CommonGenerators
val negFiniteDoubleValues: Generator[Double]

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.

Attributes

Inherited from:
CommonGenerators
val negFiniteDoubles: Generator[NegFiniteDouble]

A Generator that produces NegFiniteDouble values.

A Generator that produces NegFiniteDouble values.

Attributes

Inherited from:
CommonGenerators
val negFiniteFloatValues: Generator[Float]

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.

Attributes

Inherited from:
CommonGenerators
val negFiniteFloats: Generator[NegFiniteFloat]

A Generator that produces NegFiniteFloat values.

A Generator that produces NegFiniteFloat values.

Attributes

Inherited from:
CommonGenerators
val negFloatValues: Generator[Float]

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.

Attributes

Inherited from:
CommonGenerators
val negFloats: Generator[NegFloat]

A Generator that produces NegFloat values.

A Generator that produces NegFloat values.

Attributes

Inherited from:
CommonGenerators
val negIntValues: Generator[Int]

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

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

Attributes

Inherited from:
CommonGenerators
val negInts: Generator[NegInt]

A Generator that produces NegInt values.

A Generator that produces NegInt values.

Attributes

Inherited from:
CommonGenerators
val negLongValues: Generator[Long]

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

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

Attributes

Inherited from:
CommonGenerators
val negLongs: Generator[NegLong]

A Generator that produces NegLong values.

A Generator that produces NegLong values.

Attributes

Inherited from:
CommonGenerators
val negZDoubleValues: Generator[Double]

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

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

Attributes

Inherited from:
CommonGenerators
val negZDoubles: Generator[NegZDouble]

A Generator that produces NegZDouble values.

A Generator that produces NegZDouble values.

Attributes

Inherited from:
CommonGenerators
val negZFiniteDoubleValues: Generator[Double]

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.

Attributes

Inherited from:
CommonGenerators
val negZFiniteDoubles: Generator[NegZFiniteDouble]

A Generator that produces NegZFiniteDouble values.

A Generator that produces NegZFiniteDouble values.

Attributes

Inherited from:
CommonGenerators
val negZFiniteFloatValues: Generator[Float]

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.

Attributes

Inherited from:
CommonGenerators
val negZFiniteFloats: Generator[NegZFiniteFloat]

A Generator that produces NegZFiniteFloat values.

A Generator that produces NegZFiniteFloat values.

Attributes

Inherited from:
CommonGenerators
val negZFloatValues: Generator[Float]

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

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

Attributes

Inherited from:
CommonGenerators
val negZFloats: Generator[NegZFloat]

A Generator that produces NegZFloat values.

A Generator that produces NegZFloat values.

Attributes

Inherited from:
CommonGenerators
val negZIntValues: Generator[Int]

A Generator that produces negative Int values, including zero.

A Generator that produces negative Int values, including zero.

Attributes

Inherited from:
CommonGenerators
val negZInts: Generator[NegZInt]

A Generator that produces NegZInt values.

A Generator that produces NegZInt values.

Attributes

Inherited from:
CommonGenerators
val negZLongValues: Generator[Long]

A Generator that produces negative Long values, including zero.

A Generator that produces negative Long values, including zero.

Attributes

Inherited from:
CommonGenerators
val negZLongs: Generator[NegZLong]

A Generator that produces NegZLong values.

A Generator that produces NegZLong values.

Attributes

Inherited from:
CommonGenerators
val nonZeroDoubleValues: Generator[Double]

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

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

Attributes

Inherited from:
CommonGenerators
val nonZeroDoubles: Generator[NonZeroDouble]

A Generator that produces NonZeroDouble values.

A Generator that produces NonZeroDouble values.

Attributes

Inherited from:
CommonGenerators
val nonZeroFiniteDoubleValues: Generator[Double]

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.

Attributes

Inherited from:
CommonGenerators
val nonZeroFiniteDoubles: Generator[NonZeroFiniteDouble]

A Generator that produces NonZeroFiniteDouble values.

A Generator that produces NonZeroFiniteDouble values.

Attributes

Inherited from:
CommonGenerators
val nonZeroFiniteFloatValues: Generator[Float]

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.

Attributes

Inherited from:
CommonGenerators
val nonZeroFiniteFloats: Generator[NonZeroFiniteFloat]

A Generator that produces NonZeroFiniteFloat values.

A Generator that produces NonZeroFiniteFloat values.

Attributes

Inherited from:
CommonGenerators
val nonZeroFloatValues: Generator[Float]

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

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

Attributes

Inherited from:
CommonGenerators
val nonZeroFloats: Generator[NonZeroFloat]

A Generator that produces NonZeroFloat values.

A Generator that produces NonZeroFloat values.

Attributes

Inherited from:
CommonGenerators
val nonZeroIntValues: Generator[Int]

A Generator that produces non-zero Int values.

A Generator that produces non-zero Int values.

Attributes

Inherited from:
CommonGenerators
val nonZeroInts: Generator[NonZeroInt]

A Generator that produces NonZeroInt values.

A Generator that produces NonZeroInt values.

Attributes

Inherited from:
CommonGenerators
val nonZeroLongValues: Generator[Long]

A Generator that produces non-zero Long values.

A Generator that produces non-zero Long values.

Attributes

Inherited from:
CommonGenerators
val nonZeroLongs: Generator[NonZeroLong]

A Generator that produces NonZeroLong values.

A Generator that produces NonZeroLong values.

Attributes

Inherited from:
CommonGenerators
val numericCharValues: Generator[Char]

A Generator that produces digit Chars.

A Generator that produces digit Chars.

Attributes

Inherited from:
CommonGenerators
val numericChars: Generator[NumericChar]

A Generator that produces NumericChar values.

A Generator that produces NumericChar values.

Attributes

Inherited from:
CommonGenerators
val posDoubleValues: Generator[Double]

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.

Attributes

Inherited from:
CommonGenerators
val posDoubles: Generator[PosDouble]

A Generator that produces PosDouble values.

A Generator that produces PosDouble values.

Attributes

Inherited from:
CommonGenerators
val posFiniteDoubleValues: Generator[Double]

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.

Attributes

Inherited from:
CommonGenerators
val posFiniteDoubles: Generator[PosFiniteDouble]

A Generator that produces PosFiniteDouble values.

A Generator that produces PosFiniteDouble values.

Attributes

Inherited from:
CommonGenerators
val posFiniteFloatValues: Generator[Float]

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.

Attributes

Inherited from:
CommonGenerators
val posFiniteFloats: Generator[PosFiniteFloat]

A Generator that produces PosFiniteFloat values.

A Generator that produces PosFiniteFloat values.

Attributes

Inherited from:
CommonGenerators
val posFloatValues: Generator[Float]

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.

Attributes

Inherited from:
CommonGenerators
val posFloats: Generator[PosFloat]

A Generator that produces PosFloat values.

A Generator that produces PosFloat values.

Attributes

Inherited from:
CommonGenerators
val posIntValues: Generator[Int]

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

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

Attributes

Inherited from:
CommonGenerators
val posInts: Generator[PosInt]

A Generator that produces PosInt values.

A Generator that produces PosInt values.

Attributes

Inherited from:
CommonGenerators
val posLongValues: Generator[Long]

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

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

Attributes

Inherited from:
CommonGenerators
val posLongs: Generator[PosLong]

A Generator that produces PosLong values.

A Generator that produces PosLong values.

Attributes

Inherited from:
CommonGenerators
val posZDoubleValues: Generator[Double]

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

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

Attributes

Inherited from:
CommonGenerators
val posZDoubles: Generator[PosZDouble]

A Generator that produces PosZDouble values.

A Generator that produces PosZDouble values.

Attributes

Inherited from:
CommonGenerators
val posZFiniteDoubleValues: Generator[Double]

A Generator that produces positive Int values.

A Generator that produces positive Int values.

Attributes

Inherited from:
CommonGenerators
val posZFiniteDoubles: Generator[PosZFiniteDouble]

A Generator that produces PosZFiniteDouble values.

A Generator that produces PosZFiniteDouble values.

Attributes

Inherited from:
CommonGenerators
val posZFiniteFloatValues: Generator[Float]

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.

Attributes

Inherited from:
CommonGenerators
val posZFiniteFloats: Generator[PosZFiniteFloat]

A Generator that produces PosZFiniteFloat values.

A Generator that produces PosZFiniteFloat values.

Attributes

Inherited from:
CommonGenerators
val posZFloatValues: Generator[Float]

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

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

Attributes

Inherited from:
CommonGenerators
val posZFloats: Generator[PosZFloat]

A Generator that produces PosZFloat values.

A Generator that produces PosZFloat values.

Attributes

Inherited from:
CommonGenerators
val posZIntValues: Generator[Int]

A Generator that produces positive Int values, including zero.

A Generator that produces positive Int values, including zero.

Attributes

Inherited from:
CommonGenerators
val posZInts: Generator[PosZInt]

A Generator that produces PosZInt values.

A Generator that produces PosZInt values.

Attributes

Inherited from:
CommonGenerators
val posZLongValues: Generator[Long]

A Generator that produces positive Long values, including zero.

A Generator that produces positive Long values, including zero.

Attributes

Inherited from:
CommonGenerators
val posZLongs: Generator[PosZLong]

A Generator that produces PosZLong values.

A Generator that produces PosZLong values.

Attributes

Inherited from:
CommonGenerators
val shorts: Generator[Short]

A Generator that produces Short values.

A Generator that produces Short values.

Attributes

Inherited from:
CommonGenerators
val strings: Generator[String]

A Generator that produces String values.

A Generator that produces String values.

Attributes

Inherited from:
CommonGenerators

Implicits

Inherited implicits

implicit val generatorDrivenConfig: PropertyCheckConfiguration

Implicit PropertyCheckConfig value providing default configuration values.

Implicit PropertyCheckConfig value providing default configuration values.

Attributes

Inherited from:
Configuration
Generated with