trait GeneratorDrivenPropertyChecks extends CommonGenerators with Whenever with Configuration
Trait containing methods that faciliate property checks against generated data using Generator.
This trait contains forAll
methods that provide various ways to check properties using
generated data. It also contains a wherever
method that can be used to indicate a property
need only hold whenever some condition is true.
For an example of trait GeneratorDrivenPropertyChecks
in action, imagine you want to test this Fraction
class:
class Fraction(n: Int, d: Int) { require(d != 0) require(d != Integer.MIN_VALUE) require(n != Integer.MIN_VALUE) val numer = if (d < 0) -1 * n else n val denom = d.abs override def toString = numer + " / " + denom }
To test the behavior of Fraction
, you could mix in or import the members of GeneratorDrivenPropertyChecks
(and Matchers
) and check a property using a forAll
method, like this:
forAll { (n: Int, d: Int) => whenever (d != 0 && d != Integer.MIN_VALUE && n != Integer.MIN_VALUE) { val f = new Fraction(n, d) if (n < 0 && d < 0 || n > 0 && d > 0) f.numer should be > 0 else if (n != 0) f.numer should be < 0 else f.numer should be === 0 f.denom should be > 0 } }
Trait GeneratorDrivenPropertyChecks
provides overloaded forAll
methods
that allow you to check properties using the data provided by Generator. The simplest form
of forAll
method takes two parameter lists, the second of which is implicit. The first parameter list
is a "property" function with one to six parameters. An implicit Generator generator object needs to be supplied for.
The forAll
method will pass each row of data to each parameter type. ScalaTest provides many implicit Generators for
common types such as Int
, String
, List[Float]
, etc., in its Generator companion
object. So long as you use types for which ScalaTest already provides implicit Generators, you needn't
worry about them. Most often you can simply pass a property function to forAll
, and the compiler will grab the implicit
values provided by ScalaTest.
The forAll
methods use the supplied Generators to generate example
arguments and pass them to the property function, and
generate a GeneratorDrivenPropertyCheckFailedException
if the function
completes abruptly for any exception that would normally cause a test to
fail in ScalaTest other than DiscardedEvaluationException
. An
DiscardedEvaluationException
,
which is thrown by the whenever
method (defined in trait Whenever, which this trait extends) to indicate
a condition required by the property function is not met by a row
of passed data, will simply cause forAll
to discard that row of data.
Supplying argument names
You can optionally specify string names for the arguments passed to a property function, which will be used
in any error message when describing the argument values that caused the failure. To supply the names, place them in a comma separated list
in parentheses after forAll
before the property function (a curried form of forAll
). Here's
an example:
forAll ("a", "b") { (a: String, b: String) => a.length + b.length should equal ((a + b).length + 1) // Should fail }
When this fails, you'll see an error message that includes this:
Occurred when passed generated values ( a = "", b = "" )
When you don't supply argument names, the error message will say arg0
, arg1
, etc..
For example, this property check:
forAll { (a: String, b: String) => a.length + b.length should equal ((a + b).length + 1) // Should fail }
Will fail with an error message that includes:
Occurred when passed generated values ( arg0 = "", arg1 = "" )
Supplying generators
ScalaTest provides a nice library of compositors that makes it easy to create your own custom generators. If you
want to supply custom generators to a property check, place them in parentheses after forAll
, before
the property check function (a curried form of forAll
).
For example, to create a generator of even integers between (and including) -2000 and 2000, you could write this:
import org.scalatest.prop.Generator val evenInts = for (n <- Generator.chooseInt(-1000, 1000)) yield 2 * n
Given this generator, you could use it on a property check like this:
forAll (evenInts) { (n) => n % 2 should equal (0) }
Custom generators are necessary when you want to pass data types not supported by ScalaTest's Generators,
but are also useful when some of the values in the full range for the passed types are not valid. For such values you
would use a whenever
clause. In the Fraction
class shown above, neither the passed numerator or
denominator can be Integer.MIN_VALUE
, and the passed denominator cannot be zero. This shows up in the
whenever
clause like this:
whenever (d != 0 && d != Integer.MIN_VALUE && n != Integer.MIN_VALUE) { ...
You could in addition define generators for the numerator and denominator that only produce valid values, like this:
val validNumers = for (n <- Generator.chooseInt(Integer.MIN_VALUE + 1, Integer.MAX_VALUE)) yield n val validDenoms = for (d <- validNumers if d != 0) yield d
You could then use them in the property check like this:
forAll (validNumers, validDenoms) { (n: Int, d: Int) => whenever (d != 0 && d != Integer.MIN_VALUE && n != Integer.MIN_VALUE) { val f = new Fraction(n, d) if (n < 0 && d < 0 || n > 0 && d > 0) f.numer should be > 0 else if (n != 0) f.numer should be < 0 else f.numer should be === 0 f.denom should be > 0 } }
Supplying both generators and argument names
If you want to supply both generators and named arguments, you can do so by providing a list of (<generator>, <name>)
pairs
in parentheses after forAll
, before the property function. Here's an example:
forAll ((validNumers, "n"), (validDenoms, "d")) { (n: Int, d: Int) => whenever (d != 0 && d != Integer.MIN_VALUE && n != Integer.MIN_VALUE) { val f = new Fraction(n, d) if (n < 0 && d < 0 || n > 0 && d > 0) f.numer should be > 0 else if (n != 0) f.numer should be < 0 else f.numer should be === 0 f.denom should be > 0 } }
Were this property check to fail, it would mention the names n and d in the error message, like this:
Occurred when passed generated values ( n = 17, d = 21 )
Property check configuration
The property checks performed by the forAll
methods of this trait can be flexibly configured via the services
provided by supertrait Configuration
. The five configuration parameters for property checks along with their
default values and meanings are described in the following table:
Configuration Parameter | Default Value | Meaning |
---|---|---|
minSuccessful | 100 | the minimum number of successful property evaluations required for the property to pass |
maxDiscarded | 500 | the maximum number of discarded property evaluations allowed during a property check |
minSize | 0 | the minimum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists) |
sizeRange | 100 | the size range parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists) |
workers | 1 | specifies the number of worker threads to use during property evaluation |
The forAll
methods of trait GeneratorDrivenPropertyChecks
each take a PropertyCheckConfiguration
object as an implicit parameter. This object provides values for each of the five configuration parameters. Trait Configuration
provides an implicit val
named generatorDrivenConfig
with each configuration parameter set to its default value.
If you want to set one or more configuration parameters to a different value for all property checks in a suite you can override this
val (or hide it, for example, if you are importing the members of the GeneratorDrivenPropertyChecks
companion object rather
than mixing in the trait.) For example, if
you want all parameters at their defaults except for minSize
and sizeRange
, you can override
generatorDrivenConfig
, like this:
implicit override val generatorDrivenConfig = PropertyCheckConfiguration(minSize = 10, sizeRange = 10)
Or, hide it by declaring a variable of the same name in whatever scope you want the changed values to be in effect:
implicit val generatorDrivenConfig = PropertyCheckConfiguration(minSize = 10, sizeRange = 10)
In addition to taking a PropertyCheckConfiguration
object as an implicit parameter, the forAll
methods of trait
GeneratorDrivenPropertyChecks
also take a variable length argument list of PropertyCheckConfigParam
objects that you can use to override the values provided by the implicit PropertyCheckConfiguration
for a single forAll
invocation. For example, if you want to set minSuccessful
to 500 for just one particular forAll
invocation,
you can do so like this:
forAll (minSuccessful(500)) { (n: Int, d: Int) => ...
This invocation of forAll
will use 500 for minSuccessful
and whatever values are specified by the
implicitly passed PropertyCheckConfiguration
object for the other configuration parameters.
If you want to set multiple configuration parameters in this way, just list them separated by commas:
forAll (minSuccessful(500), maxDiscardedFactor(0.6)) { (n: Int, d: Int) => ...
If you are using an overloaded form of forAll
that already takes an initial parameter list, just
add the configuration parameters after the list of generators, names, or generator/name pairs, as in:
// If providing argument names forAll ("n", "d", minSuccessful(500), maxDiscardedFactor(0.6)) { (n: Int, d: Int) => ... // If providing generators forAll (validNumers, validDenoms, minSuccessful(500), maxDiscardedFactor(0.6)) { (n: Int, d: Int) => ... // If providing (<generators>, <name>) pairs forAll ((validNumers, "n"), (validDenoms, "d"), minSuccessful(500), maxDiscardedFactor(0.6)) { (n: Int, d: Int) => ...
For more information, see the documentation for supertrait Configuration
.
- Grouped
- Alphabetic
- By Inheritance
- GeneratorDrivenPropertyChecks
- Configuration
- Whenever
- CommonGenerators
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- case class MaxDiscardedFactor(value: PosZDouble) extends PropertyCheckConfigParam with Product with Serializable
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 throwsDiscardedEvaluationException
, which is produced by awhenever
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 withDiscardedEvaluationException
.Similarly, in
Checkers
, a property evaluation is discarded if the expression to the left of ScalaCheck's==>
operator is false. Here's an example:// forAll defined in
Checkers
forAll { (n: Int) => (n > 0) ==> doubleIt(n) == (n * 2) }For either kind of property check,
MaxDiscardedFactor
indicates the maximum fraction of total tests that may be discarded, relative to the number of successful tests. For example, if this is set to 4.0, and you are running 100 tests, it may discard up to 400 tries before considering the test to be org.scalatest.prop.PropertyCheckResult.Exhausted.- value
the permitted number of discarded tests, as a multiple of successful ones.
- Definition Classes
- Configuration
- case class MinSize(value: PosZInt) extends PropertyCheckConfigParam with Product with Serializable
A
PropertyCheckConfigParam
that specifies the minimum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).A
PropertyCheckConfigParam
that specifies the minimum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).- Definition Classes
- Configuration
- case class MinSuccessful(value: PosInt) extends PropertyCheckConfigParam with Product with Serializable
A
PropertyCheckConfigParam
that specifies the minimum number of successful property evaluations required for the property to pass.A
PropertyCheckConfigParam
that specifies the minimum number of successful property evaluations required for the property to pass.Once this many evaluations have passed, the property will return PropertyCheckResult.Success.
- Definition Classes
- Configuration
- sealed abstract class PropertyCheckConfigParam extends Product with Serializable
Abstract class defining a family of configuration parameters for property checks.
Abstract class defining a family of configuration parameters for property checks.
The subclasses of this abstract class are used to pass configuration information to the
forAll
methods of traitsPropertyChecks
(for ScalaTest-style property checks) andCheckers
(for ScalaCheck-style property checks).- Definition Classes
- Configuration
- case class PropertyCheckConfiguration(minSuccessful: PosInt = PosInt.ensuringValid(10), maxDiscardedFactor: PosZDouble = PosZDouble.ensuringValid(5.0), minSize: PosZInt = Configuration.minSize.get(), sizeRange: PosZInt = Configuration.sizeRange.get(), workers: PosInt = PosInt.ensuringValid(1)) extends Product with Serializable
Describes the configuration to use when evaluating a property.
Describes the configuration to use when evaluating a property.
- minSuccessful
the minimum number of successful property evaluations required for the property to pass; see MinSuccessful
- maxDiscardedFactor
how many generated values may be discarded, as a multiple of the successful attempts, before the property check is considered to be org.scalatest.prop.PropertyCheckResult.Exhausted; see MaxDiscardedFactor
- minSize
the minimum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists); see MinSize
- sizeRange
the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists); see SizeRange
- workers
number of worker threads to use when evaluating a property; see Workers
- Definition Classes
- Configuration
- case class SizeRange(value: PosZInt) extends PropertyCheckConfigParam with Product with Serializable
A
PropertyCheckConfigParam
that (with minSize) specifies the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).A
PropertyCheckConfigParam
that (with minSize) specifies the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).Note that the size range is added to minSize in order to calculate the maximum size passed to ScalaCheck. Using a range allows compile-time checking of a non-negative number being specified.
- Definition Classes
- Configuration
- case class Workers(value: PosInt) extends PropertyCheckConfigParam with Product with Serializable
A
PropertyCheckConfigParam
that specifies the number of worker threads to use when evaluating a property.A
PropertyCheckConfigParam
that specifies the number of worker threads to use when evaluating a property.Property evaluation runs on a single thread by default, but may run multiple threads if desired. If so, the evaluation will generally run faster. However, be careful not to use this if there is any risk of deadlocks, race conditions, or other hazards of multi-threaded code in evaluating this property or the code under test.
- Definition Classes
- Configuration
- class ConfiguredPropertyCheck extends AnyRef
Performs a configured property checks by applying property check functions passed to its
apply
methods to arguments supplied by implicitly passed generators, modifying the values in thePropertyGenConfig
object passed implicitly to itsapply
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 thePropertyGenConfig
object passed implicitly to itsapply
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 ofPropertyCheckConfigParam
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 Members
- object PropertyCheckConfiguration extends Serializable
Internal utility functions for configuration management.
Internal utility functions for configuration management.
- Definition Classes
- Configuration
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##(): Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- 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 ofto
. (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
andto
values as edges.The implicit Chooser is used to pick random values of the type. That should do most of the heavy lifting.
Since this underlies the more-specific
xxsBetween()
functions, you may use either those or this when appropriate. For example, this:intsBetween(1, 100)
and
between(1, 100)
are functionally identical so long as the types of the parameters are clear to the compiler. Use whichever suits your project's coding style better.
- T
the type to choose a value from
- from
the lower bound of the range to choose from
- to
the upper bound of the range to choose from
- ord
an instance of
Ordering[T]
, which should usually be in implicit scope- chooser
an instance of
Chooser[T]
, which should usually be in implicit scope- gen
an instance of
Generator[T]
, which should usually be in implicit scope- returns
a new Generator, that produces values in the specified range
- Definition Classes
- CommonGenerators
- val booleans: Generator[Boolean]
A Generator that produces Boolean values.
A Generator that produces Boolean values.
- Definition Classes
- CommonGenerators
- val bytes: Generator[Byte]
A Generator that produces Byte values.
A Generator that produces Byte values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- val chars: Generator[Char]
A Generator that produces Char values.
A Generator that produces Char values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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.
- A
the type to be generated
- count
the number of values to generate
- genOfA
the Generator to use
- pf
a PartialFunction that takes the generated values, and sorts them into "buckets" by String names
- returns
statistics on how many values wound up in each bucket
- Definition Classes
- CommonGenerators
- def clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- val doubles: Generator[Double]
A Generator that produces Double values.
A Generator that produces Double values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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]
.- L
the Left type for an Either
- R
the Right type for an Either
- genOfL
a Generator that produces type L
- genOfR
a Generator that produces type R
- returns
a Generator that produces
Either[L, R]
- Definition Classes
- CommonGenerators
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- 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.
- T
the type to be produced
- first
a Generator to choose from
- second
another Generator to choose from
- rest
any number of additional Generators to choose from
- returns
a single Generator that invokes each of its constituents roughly the same number of times
- Definition Classes
- CommonGenerators
- def finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- 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
.- Definition Classes
- CommonGenerators
- val finiteDoubles: Generator[FiniteDouble]
A Generator that produces FiniteDouble values.
A Generator that produces FiniteDouble values.
- Definition Classes
- CommonGenerators
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val finiteFloats: Generator[FiniteFloat]
A Generator that produces FiniteFloat values.
A Generator that produces FiniteFloat values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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.
- returns
a Generator that will produce smallish prime numbers
- Definition Classes
- CommonGenerators
- val floats: Generator[Float]
A Generator that produces Float values.
A Generator that produces Float values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- def forAll[A, B, C, D, E, F, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), genAndNameD: (Generator[D], String), genAndNameE: (Generator[E], String), genAndNameF: (Generator[F], String), configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E, F) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, F, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), genAndNameD: (Generator[D], String), genAndNameE: (Generator[E], String), genAndNameF: (Generator[F], String))(fun: (A, B, C, D, E, F) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, F, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], genF: Generator[F], configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E, F) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, F, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], genF: Generator[F])(fun: (A, B, C, D, E, F) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, F, ASSERTION](a: String, b: String, c: String, d: String, e: String, f: String, configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E, F) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], genF: Generator[F], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, F, ASSERTION](a: String, b: String, c: String, d: String, e: String, f: String)(fun: (A, B, C, D, E, F) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], genF: Generator[F], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, F, ASSERTION](fun: (A, B, C, D, E, F) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], genF: Generator[F], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), genAndNameD: (Generator[D], String), genAndNameE: (Generator[E], String), configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), genAndNameD: (Generator[D], String), genAndNameE: (Generator[E], String))(fun: (A, B, C, D, E) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E])(fun: (A, B, C, D, E) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, ASSERTION](a: String, b: String, c: String, d: String, e: String, configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D, E) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, ASSERTION](a: String, b: String, c: String, d: String, e: String)(fun: (A, B, C, D, E) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, E, ASSERTION](fun: (A, B, C, D, E) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], genE: Generator[E], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), genAndNameD: (Generator[D], String), configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), genAndNameD: (Generator[D], String))(fun: (A, B, C, D) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D])(fun: (A, B, C, D) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, ASSERTION](a: String, b: String, c: String, d: String, configParams: PropertyCheckConfigParam*)(fun: (A, B, C, D) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, ASSERTION](a: String, b: String, c: String, d: String)(fun: (A, B, C, D) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, D, ASSERTION](fun: (A, B, C, D) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], genD: Generator[D], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String), configParams: PropertyCheckConfigParam*)(fun: (A, B, C) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), genAndNameC: (Generator[C], String))(fun: (A, B, C) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C], configParams: PropertyCheckConfigParam*)(fun: (A, B, C) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, ASSERTION](genA: Generator[A], genB: Generator[B], genC: Generator[C])(fun: (A, B, C) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, ASSERTION](a: String, b: String, c: String, configParams: PropertyCheckConfigParam*)(fun: (A, B, C) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, ASSERTION](a: String, b: String, c: String)(fun: (A, B, C) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, C, ASSERTION](fun: (A, B, C) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], genC: Generator[C], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String), configParams: PropertyCheckConfigParam*)(fun: (A, B) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, ASSERTION](genAndNameA: (Generator[A], String), genAndNameB: (Generator[B], String))(fun: (A, B) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, ASSERTION](genA: Generator[A], genB: Generator[B], configParams: PropertyCheckConfigParam*)(fun: (A, B) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, ASSERTION](genA: Generator[A], genB: Generator[B])(fun: (A, B) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, ASSERTION](a: String, b: String, configParams: PropertyCheckConfigParam*)(fun: (A, B) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, ASSERTION](a: String, b: String)(fun: (A, B) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, B, ASSERTION](fun: (A, B) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], genB: Generator[B], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, ASSERTION](genAndNameA: (Generator[A], String), configParams: PropertyCheckConfigParam*)(fun: (A) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, ASSERTION](genAndNameA: (Generator[A], String))(fun: (A) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, ASSERTION](genA: Generator[A], configParams: PropertyCheckConfigParam*)(fun: (A) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, ASSERTION](genA: Generator[A])(fun: (A) => ASSERTION)(implicit config: PropertyCheckConfiguration, prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, ASSERTION](a: String, configParams: PropertyCheckConfigParam*)(fun: (A) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, ASSERTION](a: String)(fun: (A) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll[A, ASSERTION](fun: (A) => ASSERTION)(implicit config: PropertyCheckConfiguration, genA: Generator[A], prettifier: Prettifier, pos: Position, asserting: PropCheckerAsserting[ASSERTION]): Result
- def forAll(configParams: PropertyCheckConfigParam*): ConfiguredPropertyCheck
Performs a property check by applying the specified property check function to arguments supplied by implicitly passed generators, modifying the values in the implicitly passed
PropertyGenConfig
object with explicitly passed parameter values.Performs a property check by applying the specified property check function to arguments supplied by implicitly passed generators, modifying the values in the implicitly passed
PropertyGenConfig
object with explicitly passed parameter values.This method creates a
ConfiguredPropertyCheck
object that has six overloaded apply methods that take a function. Thus it is used with functions of all six arities. Here are some examples:forAll (minSize(1), sizeRange(9)) { (a: String) => a.length should equal ((a).length) } forAll (minSize(1), sizeRange(9)) { (a: String, b: String) => a.length + b.length should equal ((a + b).length) } forAll (minSize(1), sizeRange(9)) { (a: String, b: String, c: String) => a.length + b.length + c.length should equal ((a + b + c).length) } forAll (minSize(1), sizeRange(9)) { (a: String, b: String, c: String, d: String) => a.length + b.length + c.length + d.length should equal ((a + b + c + d).length) } forAll (minSize(1), sizeRange(9)) { (a: String, b: String, c: String, d: String, e: String) => a.length + b.length + c.length + d.length + e.length should equal ((a + b + c + d + e).length) } forAll (minSize(1), sizeRange(9)) { (a: String, b: String, c: String, d: String, e: String, f: String) => a.length + b.length + c.length + d.length + e.length + f.length should equal ((a + b + c + d + e + f).length) }
- configParams
a variable length list of
PropertyCheckConfigParam
objects that should override corresponding values in thePropertyCheckConfiguration
implicitly passed to theapply
methods of theConfiguredPropertyCheck
object returned by this method.
- 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.
- T
the type being produced by all of these Generators
- first
a Generator and its weight
- second
another Generator and its weight
- rest
as many more Generator and weight pairs as you like
- returns
a single Generator, that invokes its constituents according to their weights
- Definition Classes
- CommonGenerators
- 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.
- A
the type to return from the generated functions
- returns
a Generator that produces functions that return values of type A
- Definition Classes
- CommonGenerators
- def function10s[A, B, C, D, E, F, G, H, I, J, K](implicit genOfK: Generator[K], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K]): Generator[(A, B, C, D, E, F, G, H, I, J) => K]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function11s[A, B, C, D, E, F, G, H, I, J, K, L](implicit genOfL: Generator[L], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L]): Generator[(A, B, C, D, E, F, G, H, I, J, K) => L]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function12s[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit genOfM: Generator[M], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L) => M]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function13s[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit genOfN: Generator[N], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M) => N]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function14s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit genOfO: Generator[O], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N) => O]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function15s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit genOfP: Generator[P], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => P]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function16s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit genOfQ: Generator[Q], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => Q]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function17s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit genOfR: Generator[R], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q], typeInfoR: TypeInfo[R]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => R]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function18s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit genOfS: Generator[S], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q], typeInfoR: TypeInfo[R], typeInfoS: TypeInfo[S]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => S]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function19s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit genOfT: Generator[T], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q], typeInfoR: TypeInfo[R], typeInfoS: TypeInfo[S], typeInfoT: TypeInfo[T]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => T]
See function1s.
See function1s.
- Definition Classes
- 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.- A
the input type for the generated functions
- B
the result type for the generated functions
- genOfB
a Generator for the desired result type B
- typeInfoA
automatically-created type information for type A
- typeInfoB
automatically-created type information for type B
- returns
a Generator that produces functions that take values of A and returns values of B
- Definition Classes
- CommonGenerators
- 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.
- Definition Classes
- CommonGenerators
- def function21s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit genOfV: Generator[V], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q], typeInfoR: TypeInfo[R], typeInfoS: TypeInfo[S], typeInfoT: TypeInfo[T], typeInfoU: TypeInfo[U], typeInfoV: TypeInfo[V]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => V]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function22s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W](implicit genOfW: Generator[W], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J], typeInfoK: TypeInfo[K], typeInfoL: TypeInfo[L], typeInfoM: TypeInfo[M], typeInfoN: TypeInfo[N], typeInfoO: TypeInfo[O], typeInfoP: TypeInfo[P], typeInfoQ: TypeInfo[Q], typeInfoR: TypeInfo[R], typeInfoS: TypeInfo[S], typeInfoT: TypeInfo[T], typeInfoU: TypeInfo[U], typeInfoV: TypeInfo[V], typeInfoW: TypeInfo[W]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) => W]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function2s[A, B, C](implicit genOfC: Generator[C], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C]): Generator[(A, B) => C]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function3s[A, B, C, D](implicit genOfD: Generator[D], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D]): Generator[(A, B, C) => D]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function4s[A, B, C, D, E](implicit genOfE: Generator[E], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E]): Generator[(A, B, C, D) => E]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function5s[A, B, C, D, E, F](implicit genOfF: Generator[F], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F]): Generator[(A, B, C, D, E) => F]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function6s[A, B, C, D, E, F, G](implicit genOfG: Generator[G], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G]): Generator[(A, B, C, D, E, F) => G]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function7s[A, B, C, D, E, F, G, H](implicit genOfH: Generator[H], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H]): Generator[(A, B, C, D, E, F, G) => H]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function8s[A, B, C, D, E, F, G, H, I](implicit genOfI: Generator[I], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I]): Generator[(A, B, C, D, E, F, G, H) => I]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- def function9s[A, B, C, D, E, F, G, H, I, J](implicit genOfJ: Generator[J], typeInfoA: TypeInfo[A], typeInfoB: TypeInfo[B], typeInfoC: TypeInfo[C], typeInfoD: TypeInfo[D], typeInfoE: TypeInfo[E], typeInfoF: TypeInfo[F], typeInfoG: TypeInfo[G], typeInfoH: TypeInfo[H], typeInfoI: TypeInfo[I], typeInfoJ: TypeInfo[J]): Generator[(A, B, C, D, E, F, G, H, I) => J]
See function1s.
See function1s.
- Definition Classes
- CommonGenerators
- implicit val generatorDrivenConfig: PropertyCheckConfiguration
Implicit
PropertyCheckConfig
value providing default configuration values.Implicit
PropertyCheckConfig
value providing default configuration values.- Definition Classes
- Configuration
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- 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.
- configParams
optionally, some parameters that differ from the provided
c
- returns
a fully-set-up Configuration.Parameter object, ready to evaluate properties with.
- Definition Classes
- Configuration
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- 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 ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) => V)(deconstruct: (V) => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S], genOfT: Generator[T], genOfU: Generator[U]): Generator[V]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) => U)(deconstruct: (U) => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S], genOfT: Generator[T]): Generator[U]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) => T)(deconstruct: (T) => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S]): Generator[T]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) => S)(deconstruct: (S) => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R]): Generator[S]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) => R)(deconstruct: (R) => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q]): Generator[R]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) => Q)(deconstruct: (Q) => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P]): Generator[Q]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) => P)(deconstruct: (P) => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O]): Generator[P]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M, N) => O)(deconstruct: (O) => (A, B, C, D, E, F, G, H, I, J, K, L, M, N))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N]): Generator[O]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M, N](construct: (A, B, C, D, E, F, G, H, I, J, K, L, M) => N)(deconstruct: (N) => (A, B, C, D, E, F, G, H, I, J, K, L, M))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M]): Generator[N]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L, M](construct: (A, B, C, D, E, F, G, H, I, J, K, L) => M)(deconstruct: (M) => (A, B, C, D, E, F, G, H, I, J, K, L))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L]): Generator[M]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J, K, L](construct: (A, B, C, D, E, F, G, H, I, J, K) => L)(deconstruct: (L) => (A, B, C, D, E, F, G, H, I, J, K))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K]): Generator[L]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J, K](construct: (A, B, C, D, E, F, G, H, I, J) => K)(deconstruct: (K) => (A, B, C, D, E, F, G, H, I, J))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J]): Generator[K]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I, J](construct: (A, B, C, D, E, F, G, H, I) => J)(deconstruct: (J) => (A, B, C, D, E, F, G, H, I))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I]): Generator[J]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H, I](construct: (A, B, C, D, E, F, G, H) => I)(deconstruct: (I) => (A, B, C, D, E, F, G, H))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H]): Generator[I]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G, H](construct: (A, B, C, D, E, F, G) => H)(deconstruct: (H) => (A, B, C, D, E, F, G))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G]): Generator[H]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F, G](construct: (A, B, C, D, E, F) => G)(deconstruct: (G) => (A, B, C, D, E, F))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F]): Generator[G]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E, F](construct: (A, B, C, D, E) => F)(deconstruct: (F) => (A, B, C, D, E))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E]): Generator[F]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D, E](construct: (A, B, C, D) => E)(deconstruct: (E) => (A, B, C, D))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D]): Generator[E]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C, D](construct: (A, B, C) => D)(deconstruct: (D) => (A, B, C))(implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C]): Generator[D]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- CommonGenerators
- def instancesOf[A, B, C](construct: (A, B) => C)(deconstruct: (C) => (A, B))(implicit genOfA: Generator[A], genOfB: Generator[B]): Generator[C]
See the simple
[A, B]
version ofinstancesOf()
for details.See the simple
[A, B]
version ofinstancesOf()
for details.- Definition Classes
- 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 aPerson
and deconstructs it back to its component pieces. From those, it creates a Generator.The last parameters -- the
(strings, posZIntValues)
-- are the Generators for the component types. If you are good with using the default Generators for those types, you can just let those parameters be resolved implicitly. (But in this case, that could result in negative ages, which doesn't make any sense.)After creating a Generator this way, you can use it like any other Generator in your property checks.
Alternatively, you can construct Generators for case classes using for comprehensions, like this:
implicit val persons: Generator[Person] = for { name <- strings age <- posZIntValues } yield Person(name, age)
Which approach you use is mainly up to personal taste and the coding standards of your project.
- A
the input type
- B
the target type to be generated
- construct
a constructor that builds the target type from its constituents; most often, a case class constructor
- deconstruct
a deconstructor function that takes the target type and breaks is down into its constituents
- genOfA
a Generator for the input type
- returns
a Generator for the target type
- Definition Classes
- CommonGenerators
- val ints: Generator[Int]
A Generator that produces Int values.
A Generator that produces Int values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def lists[T](implicit genOfT: Generator[T]): Generator[List[T]] with HavingLength[List[T]]
Given an existing
Generator[T]
, this creates aGenerator[List[T]]
.Given an existing
Generator[T]
, this creates aGenerator[List[T]]
.- T
the type that we are producing a List of
- genOfT
a Generator that produces values of type T
- returns
a List of values of type T
- Definition Classes
- CommonGenerators
- val longs: Generator[Long]
A Generator that produces Long values.
A Generator that produces Long values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- def maps[K, V](implicit genOfTupleKV: Generator[(K, V)]): Generator[Map[K, V]] with 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.
- K
the type of the keys for the Map
- V
the type of the values for the Map
- returns
a Generator of Maps from K to V
- Definition Classes
- CommonGenerators
- def maxDiscardedFactor(value: PosZDouble): MaxDiscardedFactor
Returns a
MaxDiscardedFactor
property check configuration parameter containing the passed value, which specifies the factor of discarded property evaluations allowed during property evaluation.Returns a
MaxDiscardedFactor
property check configuration parameter containing the passed value, which specifies the factor of discarded property evaluations allowed during property evaluation.- Definition Classes
- Configuration
- def minSize(value: PosZInt): MinSize
Returns a
MinSize
property check configuration parameter containing the passed value, which specifies the minimum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).Returns a
MinSize
property check configuration parameter containing the passed value, which specifies the minimum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).- Definition Classes
- Configuration
- def minSuccessful(value: PosInt): MinSuccessful
Returns a
MinSuccessful
property check configuration parameter containing the passed value, which specifies the minimum number of successful property evaluations required for the property to pass.Returns a
MinSuccessful
property check configuration parameter containing the passed value, which specifies the minimum number of successful property evaluations required for the property to pass.- Definition Classes
- Configuration
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- val negDoubleValues: Generator[Double]
A Generator that produces negative Double values, not including zero but including infinity and
NaN
.A Generator that produces negative Double values, not including zero but including infinity and
NaN
.- Definition Classes
- CommonGenerators
- val negDoubles: Generator[NegDouble]
A Generator that produces NegDouble values.
A Generator that produces NegDouble values.
- Definition Classes
- CommonGenerators
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val negFiniteDoubles: Generator[NegFiniteDouble]
A Generator that produces NegFiniteDouble values.
A Generator that produces NegFiniteDouble values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val negFiniteFloats: Generator[NegFiniteFloat]
A Generator that produces NegFiniteFloat values.
A Generator that produces NegFiniteFloat values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val negFloats: Generator[NegFloat]
A Generator that produces NegFloat values.
A Generator that produces NegFloat values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- val negIntValues: Generator[Int]
A Generator that produces negative Int values, not including zero.
A Generator that produces negative Int values, not including zero.
- Definition Classes
- CommonGenerators
- val negInts: Generator[NegInt]
A Generator that produces NegInt values.
A Generator that produces NegInt values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- val negLongValues: Generator[Long]
A Generator that produces negative Long values, not including zero.
A Generator that produces negative Long values, not including zero.
- Definition Classes
- CommonGenerators
- val negLongs: Generator[NegLong]
A Generator that produces NegLong values.
A Generator that produces NegLong values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val negZDoubles: Generator[NegZDouble]
A Generator that produces NegZDouble values.
A Generator that produces NegZDouble values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val negZFiniteDoubles: Generator[NegZFiniteDouble]
A Generator that produces NegZFiniteDouble values.
A Generator that produces NegZFiniteDouble values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val negZFiniteFloats: Generator[NegZFiniteFloat]
A Generator that produces NegZFiniteFloat values.
A Generator that produces NegZFiniteFloat values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val negZFloats: Generator[NegZFloat]
A Generator that produces NegZFloat values.
A Generator that produces NegZFloat values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- val negZIntValues: Generator[Int]
A Generator that produces negative Int values, including zero.
A Generator that produces negative Int values, including zero.
- Definition Classes
- CommonGenerators
- val negZInts: Generator[NegZInt]
A Generator that produces NegZInt values.
A Generator that produces NegZInt values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- val negZLongValues: Generator[Long]
A Generator that produces negative Long values, including zero.
A Generator that produces negative Long values, including zero.
- Definition Classes
- CommonGenerators
- val negZLongs: Generator[NegZLong]
A Generator that produces NegZLong values.
A Generator that produces NegZLong values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val nonZeroDoubles: Generator[NonZeroDouble]
A Generator that produces NonZeroDouble values.
A Generator that produces NonZeroDouble values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val nonZeroFiniteDoubles: Generator[NonZeroFiniteDouble]
A Generator that produces NonZeroFiniteDouble values.
A Generator that produces NonZeroFiniteDouble values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val nonZeroFiniteFloats: Generator[NonZeroFiniteFloat]
A Generator that produces NonZeroFiniteFloat values.
A Generator that produces NonZeroFiniteFloat values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val nonZeroFloats: Generator[NonZeroFloat]
A Generator that produces NonZeroFloat values.
A Generator that produces NonZeroFloat values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- val nonZeroIntValues: Generator[Int]
A Generator that produces non-zero Int values.
A Generator that produces non-zero Int values.
- Definition Classes
- CommonGenerators
- val nonZeroInts: Generator[NonZeroInt]
A Generator that produces NonZeroInt values.
A Generator that produces NonZeroInt values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- val nonZeroLongValues: Generator[Long]
A Generator that produces non-zero Long values.
A Generator that produces non-zero Long values.
- Definition Classes
- CommonGenerators
- val nonZeroLongs: Generator[NonZeroLong]
A Generator that produces NonZeroLong values.
A Generator that produces NonZeroLong values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- val numericCharValues: Generator[Char]
A Generator that produces digit Chars.
A Generator that produces digit Chars.
- Definition Classes
- CommonGenerators
- val numericChars: Generator[NumericChar]
A Generator that produces NumericChar values.
A Generator that produces NumericChar values.
- Definition Classes
- CommonGenerators
- def options[T](implicit genOfT: Generator[T]): Generator[Option[T]]
Given an existing
Generator[T]
, this creates aGenerator[Option[T]]
.Given an existing
Generator[T]
, this creates aGenerator[Option[T]]
.- T
the type that we are producing an Option of
- genOfT
a Generator that produces values of type T
- returns
a Generator that produces
Option[T]
- Definition Classes
- CommonGenerators
- 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
.- G
the "good" type for an Or
- B
the "bad" type for an Or
- genOfG
a Generator that produces type G
- genOfB
a Generator that produces type B
- returns
a Generator that produces
G Or B
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val posDoubles: Generator[PosDouble]
A Generator that produces PosDouble values.
A Generator that produces PosDouble values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val posFiniteDoubles: Generator[PosFiniteDouble]
A Generator that produces PosFiniteDouble values.
A Generator that produces PosFiniteDouble values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val posFiniteFloats: Generator[PosFiniteFloat]
A Generator that produces PosFiniteFloat values.
A Generator that produces PosFiniteFloat values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val posFloats: Generator[PosFloat]
A Generator that produces PosFloat values.
A Generator that produces PosFloat values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- val posIntValues: Generator[Int]
A Generator that produces positive Int values, not including zero.
A Generator that produces positive Int values, not including zero.
- Definition Classes
- CommonGenerators
- val posInts: Generator[PosInt]
A Generator that produces PosInt values.
A Generator that produces PosInt values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- val posLongValues: Generator[Long]
A Generator that produces positive Long values, not including zero.
A Generator that produces positive Long values, not including zero.
- Definition Classes
- CommonGenerators
- val posLongs: Generator[PosLong]
A Generator that produces PosLong values.
A Generator that produces PosLong values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val posZDoubles: Generator[PosZDouble]
A Generator that produces PosZDouble values.
A Generator that produces PosZDouble values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- val posZFiniteDoubleValues: Generator[Double]
A Generator that produces positive Int values.
A Generator that produces positive Int values.
- Definition Classes
- CommonGenerators
- val posZFiniteDoubles: Generator[PosZFiniteDouble]
A Generator that produces PosZFiniteDouble values.
A Generator that produces PosZFiniteDouble values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val posZFiniteFloats: Generator[PosZFiniteFloat]
A Generator that produces PosZFiniteFloat values.
A Generator that produces PosZFiniteFloat values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- 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
.- Definition Classes
- CommonGenerators
- val posZFloats: Generator[PosZFloat]
A Generator that produces PosZFloat values.
A Generator that produces PosZFloat values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- val posZIntValues: Generator[Int]
A Generator that produces positive Int values, including zero.
A Generator that produces positive Int values, including zero.
- Definition Classes
- CommonGenerators
- val posZInts: Generator[PosZInt]
A Generator that produces PosZInt values.
A Generator that produces PosZInt values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- val posZLongValues: Generator[Long]
A Generator that produces positive Long values, including zero.
A Generator that produces positive Long values, including zero.
- Definition Classes
- CommonGenerators
- val posZLongs: Generator[PosZLong]
A Generator that produces PosZLong values.
A Generator that produces PosZLong values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- def sets[T](implicit genOfT: Generator[T]): Generator[Set[T]] with 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
Set
s when you use this Generator.The resulting Generator also has the HavingSize trait, so you can use it to generate Sets with specific sizes.
- T
the type to produce
- genOfT
a Generator that produces values of type T
- returns
a Generator that produces
Set[T]
.
- Definition Classes
- CommonGenerators
- val shorts: Generator[Short]
A Generator that produces Short values.
A Generator that produces Short values.
- Definition Classes
- 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 ofto
.- from
one end of the desired range
- to
the other end of the desired range
- returns
a value within that range, inclusive of the bounds
- Definition Classes
- CommonGenerators
- def sizeRange(value: PosZInt): SizeRange
Returns a
SizeRange
property check configuration parameter containing the passed value, that (with minSize) specifies the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).Returns a
SizeRange
property check configuration parameter containing the passed value, that (with minSize) specifies the maximum size parameter to provide to ScalaCheck, which it will use when generating objects for which size matters (such as strings or lists).Note that the size range is added to minSize in order to calculate the maximum size passed to ScalaCheck. Using a range allows compile-time checking of a non-negative number being specified.
- Definition Classes
- Configuration
- def sortedMaps[K, V](implicit genOfTupleKV: Generator[(K, V)], ordering: Ordering[K]): Generator[SortedMap[K, V]] with HavingSize[SortedMap[K, V]]
Given a Generator that produces Tuples of key/value pairs, this gives you one that produces SortedMaps with those pairs.
Given a Generator that produces Tuples of key/value pairs, this gives you one that produces SortedMaps with those pairs.
If you are simply looking for random pairing of the key and value types, this is pretty easy to use: if both the key and value types have Generators, then the Tuple and SortedMap ones will be automatically and implicitly created when you need them.
The resulting Generator also has the HavingSize trait, so you can use it to generate SortedMaps with specific sizes.
- K
the type of the keys for the SortedMap
- V
the type of the values for the SortedMap
- returns
a Generator of SortedMaps from K to V
- Definition Classes
- CommonGenerators
- def sortedSets[T](implicit genOfT: Generator[T], ordering: Ordering[T]): Generator[SortedSet[T]] with 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
SortedSet
s when you use this Generator.The resulting Generator also has the HavingSize trait, so you can use it to generate SortedSets with specific sizes.
- T
the type to produce
- genOfT
a Generator that produces values of type T
- returns
a Generator that produces
SortedSet[T]
.
- Definition Classes
- CommonGenerators
- 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.
- T
the type of that value
- theValue
the value to produce
- returns
a Generator that will always produce that value
- Definition Classes
- 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.- T
the type that will be produced by the resulting Generator
- first
a value of type T
- second
another value of type T
- rest
more values of type T, as many as you wish
- returns
a Generator that produces exactly the specified values
- Definition Classes
- CommonGenerators
- val strings: Generator[String]
A Generator that produces String values.
A Generator that produces String values.
- Definition Classes
- CommonGenerators
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def tuple10s[A, B, C, D, E, F, G, H, I, J](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J]): Generator[(A, B, C, D, E, F, G, H, I, J)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple11s[A, B, C, D, E, F, G, H, I, J, K](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K]): Generator[(A, B, C, D, E, F, G, H, I, J, K)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple12s[A, B, C, D, E, F, G, H, I, J, K, L](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple13s[A, B, C, D, E, F, G, H, I, J, K, L, M](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple14s[A, B, C, D, E, F, G, H, I, J, K, L, M, N](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple15s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple16s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple17s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple18s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple19s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple20s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S], genOfT: Generator[T]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple21s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S], genOfT: Generator[T], genOfU: Generator[U]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple22s[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I], genOfJ: Generator[J], genOfK: Generator[K], genOfL: Generator[L], genOfM: Generator[M], genOfN: Generator[N], genOfO: Generator[O], genOfP: Generator[P], genOfQ: Generator[Q], genOfR: Generator[R], genOfS: Generator[S], genOfT: Generator[T], genOfU: Generator[U], genOfV: Generator[V]): Generator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]
See tuple2s.
See tuple2s.
- Definition Classes
- 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.
- A
the first type in the Tuple
- B
the second type in the Tuple
- genOfA
a Generator for type A
- genOfB
a Generator for type B
- returns
a Generator that produces the desired types, Tupled together.
- Definition Classes
- CommonGenerators
- def tuple3s[A, B, C](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C]): Generator[(A, B, C)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple4s[A, B, C, D](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D]): Generator[(A, B, C, D)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple5s[A, B, C, D, E](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E]): Generator[(A, B, C, D, E)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple6s[A, B, C, D, E, F](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F]): Generator[(A, B, C, D, E, F)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple7s[A, B, C, D, E, F, G](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G]): Generator[(A, B, C, D, E, F, G)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple8s[A, B, C, D, E, F, G, H](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H]): Generator[(A, B, C, D, E, F, G, H)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def tuple9s[A, B, C, D, E, F, G, H, I](implicit genOfA: Generator[A], genOfB: Generator[B], genOfC: Generator[C], genOfD: Generator[D], genOfE: Generator[E], genOfF: Generator[F], genOfG: Generator[G], genOfH: Generator[H], genOfI: Generator[I]): Generator[(A, B, C, D, E, F, G, H, I)]
See tuple2s.
See tuple2s.
- Definition Classes
- CommonGenerators
- def vectors[T](implicit genOfT: Generator[T]): Generator[Vector[T]] with 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
Vector
s when you use this Generator.The resulting Generator also has the HavingLength trait, so you can use it to generate Vectors with specific lengths.
- T
the type to produce
- genOfT
a Generator that produces values of type T
- returns
a Generator that produces values of type
Vector[T]
- Definition Classes
- CommonGenerators
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- 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 followingFraction
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 usewhenever
to discard any rows in thefraction
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 meansd
!=
0
will be false.) For those rows,whenever
will throwDiscardedEvaluationException
, which will cause theforAll
method to discard that row.- condition
the boolean condition that determines whether
whenever
will evaluate thefun
function (condition
is true) or throwsDiscardedEvaluationException
(condition
is false)- fun
the function to evaluate if the specified
condition
is true
- Definition Classes
- Whenever
- def workers(value: PosInt): Workers
Returns a
Workers
property check configuration parameter containing the passed value, which specifies the number of worker threads to use when evaluating a property.Returns a
Workers
property check configuration parameter containing the passed value, which specifies the number of worker threads to use when evaluating a property.- Definition Classes
- Configuration
Inherited from Configuration
Inherited from Whenever
Inherited from CommonGenerators
Inherited from AnyRef
Inherited from Any
Creating Generators from Specific Values
These functions let you create Generators that only return specific values
Creating Higher-Order Generators from other Generators
Generators for Many Common Types
These cover types from both the Scala Standard Library and Scalactic
Generators that produce the values from Scalactic Types
Scalactic has many highly-precise numeric types such as NonZeroLong,
PosZFloat or FiniteDouble. These help you make sure your code is using
exactly the numbers you intend, and they are very convenient for using with
Generators. But if the code under test is not using Scalactic, you
sometimes find that you need to type .value
a lot. These Generators do that
for so: you can choose a precise numeric Generator, but get the conventional
numeric type from it.
Generators for standard Collections
These functions take one or more types T
, and create Generators that
produce collections of T
.
Range-based Generator Creation
Functions that create Generators for values in a specific range of a specific type.
Generators that Produce Functions
These functions create Generators that produce random functions with specified parameter and return types.
Generators for instances of case classes
These functions are one way to create Generators for case class instances.