object CommonGenerators extends CommonGenerators
An import-able version of CommonGenerators.
You should not usually need to import this directly, since it is mixed into GeneratorDrivenPropertyChecks and TableDrivenPropertyChecks.
- Source
- CommonGenerators.scala
- Grouped
- Alphabetic
- By Inheritance
- CommonGenerators
- CommonGenerators
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Value Members
-
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
- @native() @throws( ... )
-
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: Any): 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
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
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
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
-
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
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( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
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.