Arbitraries (jqwik 0.9.3 API)

java.lang.Object
- net.jqwik.api.Arbitraries

public class Arbitraries
extends java.lang.Object

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static BigDecimalArbitrary`	`bigDecimals()` Create an arbitrary that generates values of type BigDecimal.
`static BigIntegerArbitrary`	`bigIntegers()` Create an arbitrary that generates values of type BigInteger.
`static ByteArbitrary`	`bytes()` Create an arbitrary that generates values of type Byte.
`static CharacterArbitrary`	`chars()`
`static <T> Arbitrary<T>`	`constant(T value)` Create an arbitrary that will always generate the same value.
`static <T> Arbitrary<T>`	`defaultFor(java.lang.Class<T> type, java.lang.Class<?>... typeParameters)` Find a registered arbitrary that will be used to generate values of type T.
`static DoubleArbitrary`	`doubles()` Create an arbitrary that generates values of type Double.
`static FloatArbitrary`	`floats()` Create an arbitrary that generates values of type Float.
`static <T> Arbitrary<T>`	`frequency(java.util.List<Tuple.Tuple2<java.lang.Integer,T>> frequencies)` Create an arbitrary that will randomly choose between all given values of the same type T.
`static <T> Arbitrary<T>`	`frequency(Tuple.Tuple2<java.lang.Integer,T>... frequencies)` Create an arbitrary that will randomly choose between all given values of the same type T.
`static <T> Arbitrary<T>`	`frequencyOf(java.util.List<Tuple.Tuple2<java.lang.Integer,Arbitrary<T>>> frequencies)` Create an arbitrary that will randomly choose between all given arbitraries of the same type T.
`static <T> Arbitrary<T>`	`frequencyOf(Tuple.Tuple2<java.lang.Integer,Arbitrary<T>>... frequencies)` Create an arbitrary that will randomly choose between all given arbitraries of the same type T.
`static <T> Arbitrary<T>`	`fromGenerator(RandomGenerator<T> generator)` Create an arbitrary of type T from a corresponding generator of type T.
`static IntegerArbitrary`	`integers()` Create an arbitrary that generates values of type Integer.
`static <T> Arbitrary<T>`	`lazy(java.util.function.Supplier<Arbitrary<T>> arbitrarySupplier)` Create an arbitrary that will evaluate arbitrarySupplier as soon as it is used for generating values.
`static LongArbitrary`	`longs()` Create an arbitrary that generates values of type Long.
`static Arbitrary<java.lang.Character>`	`of(char[] values)` Create an arbitrary of character values.
`static <T extends java.lang.Enum> Arbitrary<T>`	`of(java.lang.Class<T> enumClass)` Create an arbitrary for enum values of type T.
`static <T> Arbitrary<T>`	`of(java.util.List<T> values)` Create an arbitrary that will randomly choose from a given list of values.
`static <T> Arbitrary<T>`	`of(T... values)` Create an arbitrary that will randomly choose from a given array of values.
`static <T> Arbitrary<T>`	`oneOf(Arbitrary<T> first, Arbitrary<T>... rest)` Create an arbitrary that will randomly choose between all given arbitraries of the same type T.
`static <T> Arbitrary<T>`	`oneOf(java.util.List<Arbitrary<T>> all)` Create an arbitrary that will randomly choose between all given arbitraries of the same type T.
`static Arbitrary<java.util.Random>`	`randoms()` Create an arbitrary for Random objects.
`static <T> Arbitrary<T>`	`randomValue(java.util.function.Function<java.util.Random,T> generator)` Create an arbitrary that will generate values of type T using a generator function.
`static <T> Arbitrary<T>`	`recursive(java.util.function.Supplier<Arbitrary<T>> base, java.util.function.Function<Arbitrary<T>,Arbitrary<T>> recur, int depth)` Create an arbitrary by deterministic recursion.
`static <T> Arbitrary<T>`	`samples(T... samples)` Create an arbitrary that will provide the sample values from first to last and then start again at the beginning.
`static <M> ActionSequenceArbitrary<M>`	`sequences(Arbitrary<Action<M>> actionArbitrary)` Create an arbitrary to create a sequence of actions.
`static ShortArbitrary`	`shorts()` Create an arbitrary that generates values of type Short.
`static <T> Arbitrary<java.util.List<T>>`	`shuffle(java.util.List<T> values)` Create an arbitrary that will always generate a list which is a permutation of the values handed to it.
`static <T> Arbitrary<java.util.List<T>>`	`shuffle(T... values)` Create an arbitrary that will always generate a list which is a permutation of the values handed to it.
`static StringArbitrary`	`strings()` Create an arbitrary that generates values of type String.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - fromGenerator
```
public static <T> Arbitrary<T> fromGenerator(RandomGenerator<T> generator)
```
    Create an arbitrary of type T from a corresponding generator of type T.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    generator - The generator to be used for generating the values
    
    Returns:
    
    a new arbitrary instance
  - randomValue
```
public static <T> Arbitrary<T> randomValue(java.util.function.Function<java.util.Random,T> generator)
```
    Create an arbitrary that will generate values of type T using a generator function. The generated values are unshrinkable.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    generator - The generator function to be used for generating the values
    
    Returns:
    
    a new arbitrary instance
  - randoms
```
public static Arbitrary<java.util.Random> randoms()
```
    Create an arbitrary for Random objects.
    
    Returns:
    
    a new arbitrary instance
  - of
```
@SafeVarargs
public static <T> Arbitrary<T> of(T... values)
```
    Create an arbitrary that will randomly choose from a given array of values. A generated value will be shrunk towards the start of the array.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    values - The array of values to choose from
    
    Returns:
    
    a new arbitrary instance
  - of
```
public static <T> Arbitrary<T> of(java.util.List<T> values)
```
    Create an arbitrary that will randomly choose from a given list of values. A generated value will be shrunk towards the start of the list.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    values - The list of values to choose from
    
    Returns:
    
    a new arbitrary instance
  - of
```
public static Arbitrary<java.lang.Character> of(char[] values)
```
    Create an arbitrary of character values.
    
    Parameters:
    
    values - The array of characters to choose from.
    
    Returns:
    
    a new arbitrary instance
  - of
```
public static <T extends java.lang.Enum> Arbitrary<T> of(java.lang.Class<T> enumClass)
```
    Create an arbitrary for enum values of type T.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    enumClass - The enum class.
    
    Returns:
    
    a new arbitrary instance
  - oneOf
```
@SafeVarargs
public static <T> Arbitrary<T> oneOf(Arbitrary<T> first,
                                                  Arbitrary<T>... rest)
```
    Create an arbitrary that will randomly choose between all given arbitraries of the same type T.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    first - The first arbitrary to choose form
    
    rest - An array of arbitraries to choose from
    
    Returns:
    
    a new arbitrary instance
  - oneOf
```
public static <T> Arbitrary<T> oneOf(java.util.List<Arbitrary<T>> all)
```
    Create an arbitrary that will randomly choose between all given arbitraries of the same type T.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    all - A list of arbitraries to choose from
    
    Returns:
    
    a new arbitrary instance
  - frequency
```
@SafeVarargs
public static <T> Arbitrary<T> frequency(Tuple.Tuple2<java.lang.Integer,T>... frequencies)
```
    Create an arbitrary that will randomly choose between all given values of the same type T. The probability distribution is weighted with the first parameter of the tuple.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    frequencies - An array of tuples of which the first parameter gives the weight and the second the value.
    
    Returns:
    
    a new arbitrary instance
  - frequency
```
public static <T> Arbitrary<T> frequency(java.util.List<Tuple.Tuple2<java.lang.Integer,T>> frequencies)
```
    Create an arbitrary that will randomly choose between all given values of the same type T. The probability distribution is weighted with the first parameter of the tuple.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    frequencies - A list of tuples of which the first parameter gives the weight and the second the value.
    
    Returns:
    
    a new arbitrary instance
  - frequencyOf
```
@SafeVarargs
public static <T> Arbitrary<T> frequencyOf(Tuple.Tuple2<java.lang.Integer,Arbitrary<T>>... frequencies)
```
    Create an arbitrary that will randomly choose between all given arbitraries of the same type T. The probability distribution is weighted with the first parameter of the tuple.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    frequencies - An array of tuples of which the first parameter gives the weight and the second the arbitrary.
    
    Returns:
    
    a new arbitrary instance
  - frequencyOf
```
public static <T> Arbitrary<T> frequencyOf(java.util.List<Tuple.Tuple2<java.lang.Integer,Arbitrary<T>>> frequencies)
```
    Create an arbitrary that will randomly choose between all given arbitraries of the same type T. The probability distribution is weighted with the first parameter of the tuple.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    frequencies - A list of tuples of which the first parameter gives the weight and the second the arbitrary.
    
    Returns:
    
    a new arbitrary instance
  - integers
```
public static IntegerArbitrary integers()
```
    Create an arbitrary that generates values of type Integer.
    
    Returns:
    
    a new arbitrary instance
  - longs
```
public static LongArbitrary longs()
```
    Create an arbitrary that generates values of type Long.
    
    Returns:
    
    a new arbitrary instance
  - bigIntegers
```
public static BigIntegerArbitrary bigIntegers()
```
    Create an arbitrary that generates values of type BigInteger.
    
    Returns:
    
    a new arbitrary instance
  - floats
```
public static FloatArbitrary floats()
```
    Create an arbitrary that generates values of type Float.
    
    Returns:
    
    a new arbitrary instance
  - bigDecimals
```
public static BigDecimalArbitrary bigDecimals()
```
    Create an arbitrary that generates values of type BigDecimal.
    
    Returns:
    
    a new arbitrary instance
  - doubles
```
public static DoubleArbitrary doubles()
```
    Create an arbitrary that generates values of type Double.
    
    Returns:
    
    a new arbitrary instance
  - bytes
```
public static ByteArbitrary bytes()
```
    Create an arbitrary that generates values of type Byte.
    
    Returns:
    
    a new arbitrary instance
  - shorts
```
public static ShortArbitrary shorts()
```
    Create an arbitrary that generates values of type Short.
    
    Returns:
    
    a new arbitrary instance
  - strings
```
public static StringArbitrary strings()
```
    Create an arbitrary that generates values of type String.
    
    Returns:
    
    a new arbitrary instance
  - chars
```
public static CharacterArbitrary chars()
```
  - samples
```
@SafeVarargs
public static <T> Arbitrary<T> samples(T... samples)
```
    Create an arbitrary that will provide the sample values from first to last and then start again at the beginning. Shrinking of samples is tried towards the start of the samples.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    samples - The array of sample values
    
    Returns:
    
    a new arbitrary instance
  - constant
```
public static <T> Arbitrary<T> constant(T value)
```
    Create an arbitrary that will always generate the same value.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    value - The value to "generate"
    
    Returns:
    
    a new arbitrary instance
  - shuffle
```
public static <T> Arbitrary<java.util.List<T>> shuffle(T... values)
```
    Create an arbitrary that will always generate a list which is a permutation of the values handed to it. Permutations will not be shrunk.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    values - The values to permute
    
    Returns:
    
    a new arbitrary instance
  - shuffle
```
public static <T> Arbitrary<java.util.List<T>> shuffle(java.util.List<T> values)
```
    Create an arbitrary that will always generate a list which is a permutation of the values handed to it. Permutations will not be shrunk.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    values - The values to permute
    
    Returns:
    
    a new arbitrary instance
  - defaultFor
```
public static <T> Arbitrary<T> defaultFor(java.lang.Class<T> type,
                                          java.lang.Class<?>... typeParameters)
```
    Find a registered arbitrary that will be used to generate values of type T. All default arbitrary providers and all registered arbitrary providers are considered. This is more or less the same mechanism that jqwik uses to find arbitraries for property method parameters.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    type - The type of the value to find an arbitrary for
    
    typeParameters - The type parameters if type is a generic type
    
    Returns:
    
    a new arbitrary instance
    
    Throws:
    
    CannotFindArbitraryException - if there is no registered arbitrary provider to serve this type
  - lazy
```
public static <T> Arbitrary<T> lazy(java.util.function.Supplier<Arbitrary<T>> arbitrarySupplier)
```
    Create an arbitrary that will evaluate arbitrarySupplier as soon as it is used for generating values. This is useful (and necessary) when arbitrary providing functions use other arbitrary providing functions in a recursive way. Without the use of lazy() this would result in a stack overflow.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    arbitrarySupplier - The supplier function being used to generate an arbitrary
    
    Returns:
    
    a new arbitrary instance
  - recursive
```
public static <T> Arbitrary<T> recursive(java.util.function.Supplier<Arbitrary<T>> base,
                                         java.util.function.Function<Arbitrary<T>,Arbitrary<T>> recur,
                                         int depth)
```
    Create an arbitrary by deterministic recursion. This is useful (and necessary) when arbitrary providing functions use other arbitrary providing functions in a recursive way. Without the use of lazy() this would result in a stack overflow.
    
    Type Parameters:
    
    T - The type of values to generate
    
    Parameters:
    
    base - The supplier returning the recursion's base case
    
    recur - The function to extend the base case
    
    depth - The number of times to invoke recursion
    
    Returns:
    
    a new arbitrary instance
  - sequences
```
public static <M> ActionSequenceArbitrary<M> sequences(Arbitrary<Action<M>> actionArbitrary)
```
    Create an arbitrary to create a sequence of actions. Useful for stateful testing.
    
    Type Parameters:
    
    M - The type of actions to generate
    
    Parameters:
    
    actionArbitrary - The arbitrary to generate individual actions.
    
    Returns:
    
    a new arbitrary instance

Class Arbitraries

Method Summary

Methods inherited from class java.lang.Object

Method Detail

fromGenerator

randomValue

randoms

of

of

of

of

oneOf

oneOf

frequency

frequency

frequencyOf

frequencyOf

integers

longs

bigIntegers

floats

bigDecimals

doubles

bytes

shorts

strings

chars

samples

constant

shuffle

shuffle

defaultFor

lazy

recursive

sequences