net.java.quickcheck.generator
Class CombinedGenerators

java.lang.Object
  extended by net.java.quickcheck.generator.CombinedGenerators

@Iterables
@Samples
public class CombinedGenerators
extends Object

CombinedGenerators can be used to create custom Generators.


Field Summary
static int DEFAULT_COLLECTION_MAX_SIZE
           
static int DEFAULT_MAX_TRIES
           
 
Constructor Summary
CombinedGenerators()
           
 
Method Summary
static
<T> Generator<T[]>
arrays(Generator<? extends T> content, Class<T> type)
          Create a generator of arrays with values from the content generator.
static
<T> Generator<T[]>
arrays(Generator<? extends T> content, Generator<Integer> size, Class<T> type)
          Create a generator of arrays with values from the content generator.
static Generator<byte[]> byteArrays()
          Create a generator of byte arrays.
static Generator<byte[]> byteArrays(Generator<Byte> content, Generator<Integer> size)
          Create a generator of byte arrays.
static Generator<byte[]> byteArrays(Generator<Integer> size)
          Create a generator of byte arrays.
static
<T> StatefulGenerator<T>
ensureValues(Collection<T> ensuredValues)
          Create a deterministic generator which guarantees that all values from the ensuredValues collection will be returned if enough calls to Generator.next() are issued (i.e. ensuredValues.size() <= # of runs).
static
<T> StatefulGenerator<T>
ensureValues(Collection<T> ensuredValues, Generator<T> otherValues)
           Create a deterministic generator which guarantees that all values from the ensuredValues collection will be returned if enough calls to Generator.next() are issued (i.e. ensuredValues.size() <= # of runs).
static
<T> StatefulGenerator<T>
ensureValues(T... content)
          Create a deterministic generator which guarantees that all values from the ensuredValues array will be returned if enough calls to Generator.next() are issued (i.e. ensuredValues.size() <= # of runs).
static
<T> Generator<T>
excludeValues(Collection<T> values, Collection<T> excluded)
          Create a generator that omits a given set of values.
static
<T> Generator<T>
excludeValues(Collection<T> values, T... excluded)
          Create a generator that omits a given set of values.
static
<T> Generator<T>
excludeValues(Generator<T> generator, Collection<T> excluded)
          Create a generator that omits a given set of values.
static
<T> Generator<T>
excludeValues(Generator<T> generator, T... excluded)
          Create a generator that omits a given set of values.
static
<T> Generator<T>
excludeValues(Generator<T> generator, T excluded)
          Create a generator that omits a given value.
static
<T> FrequencyGenerator<T>
frequency(Generator<T> generator, int weight)
           Create a frequency generator.
static Generator<int[]> intArrays()
          Create a generator of integer arrays.
static Generator<int[]> intArrays(Generator<Integer> size)
          Create a generator of integer arrays.
static Generator<int[]> intArrays(Generator<Integer> content, Generator<Integer> size)
          Create a generator of integer arrays.
static
<T> Generator<Iterator<T>>
iterators(Generator<? extends T> content)
          Create a generator of iterators.
static
<T> Generator<Iterator<T>>
iterators(Generator<? extends T> content, Generator<Integer> size)
          Create a generator of iterators.
static
<T> Generator<List<T>>
lists(Generator<? extends T> content)
          Create a generator of lists with values from the content generator.
static
<T> Generator<List<T>>
lists(Generator<? extends T> content, Generator<Integer> size)
          Create a generator of lists with values from the content generator.
static
<T> Generator<List<T>>
lists(Generator<? extends T> content, int low)
          Create a generator of lists with values from the content generator.
static
<T> Generator<List<T>>
lists(Generator<? extends T> content, int low, int high)
          Create a generator of lists with values from the content generator.
static
<K,V> Generator<Map<K,V>>
maps(Generator<K> keys, Generator<V> values)
          Create a generator of maps.
static
<K,V> Generator<Map<K,V>>
maps(Generator<K> keys, Generator<V> values, Generator<Integer> size)
          Create a generator of maps.
static
<K,V> Generator<Map<K,V>>
maps(Map<K,V> supermap)
          Create a generator of maps from a given map.
static
<K,V> Generator<Map<K,V>>
maps(Map<K,V> supermap, Generator<Integer> sizes)
          Create a generator of maps from a given map.
static
<T> Generator<T[]>
nonEmptyArrays(Generator<? extends T> content, Class<T> type)
          Create a generator of arrays that are not empty.
static
<T> Generator<Iterator<T>>
nonEmptyIterators(Generator<T> content)
          Create a generator of iterators.
static
<T> Generator<List<T>>
nonEmptyLists(Generator<? extends T> content)
          Create a generator of non-empty lists with values from the content generator.
static
<T> Generator<Set<T>>
nonEmptySets(Generator<? extends T> content)
          Create a generator of sets that are not empty.
static
<T> Generator<T>
nullsAnd(Generator<T> generator)
          Create a generator as a combination of a null value generator and generator of type T.
static
<T> Generator<T>
nullsAnd(Generator<T> generator, int weight)
          Create a generator as a combination of a null value generator and generator of type T.
static
<T> ExtendibleGenerator<T,T>
oneOf(Generator<T> generator)
          OneOf is a convenience method for frequency(Generator, int) when all generator share the same weight.
static
<A,B> Generator<Pair<A,B>>
pairs(Generator<A> first, Generator<B> second)
          Create a generator of pairs of type A for the left value and type B for the right value.
static
<T> Generator<Set<T>>
sets(Generator<? extends T> content)
          Create a generator of sets with values from the content generator.
static
<T> Generator<Set<T>>
sets(Generator<? extends T> content, Generator<Integer> size)
          Create a generator of sets with values from the content generator.
static
<T> Generator<Set<T>>
sets(Generator<? extends T> content, int low, int high)
          Create a generator of sets with values from the content generator.
static
<T> Generator<Set<T>>
sets(Set<T> superset)
          Create a generator of subsets from a given set.
static
<T> Generator<Set<T>>
sets(Set<T> superset, Generator<Integer> size)
          Create a generator of subsets from a given set.
static
<T extends Comparable<T>>
Generator<List<T>>
sortedLists(Generator<T> content)
          Create a generator of sorted lists with values from the content generator.
static
<T extends Comparable<T>>
Generator<List<T>>
sortedLists(Generator<T> content, Generator<Integer> size)
          Create a generator of sorted lists with values from the content generator.
static
<T extends Comparable<T>>
Generator<List<T>>
sortedLists(Generator<T> content, int low, int high)
          Create a generator of sorted lists with values from the content generator.
static
<A,B,C> Generator<Triple<A,B,C>>
triples(Generator<A> first, Generator<B> second, Generator<C> third)
          Create a generator of triples of the types A, B and C for first, second and third value.
static
<T> StatefulGenerator<T>
uniqueValues(Generator<T> generator)
           Create a generator that ensures unique values The actual values are created with an arbitrary generator.
static
<T> StatefulGenerator<T>
uniqueValues(Generator<T> generator, Comparator<? super T> comparator)
           Create a generator that ensures unique values.
static
<T> StatefulGenerator<T>
uniqueValues(Generator<T> generator, Comparator<? super T> comparator, int tries)
           Create a generator that ensures unique values.
static
<T> StatefulGenerator<T>
uniqueValues(Generator<T> generator, int tries)
           Create a generator that ensures unique values.
static
<T> Generator<List<T>>
vectors(Generator<T> content, int size)
          Create a generator which will create vectors (here lists) of type T.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

DEFAULT_COLLECTION_MAX_SIZE

public static final int DEFAULT_COLLECTION_MAX_SIZE
See Also:
Constant Field Values

DEFAULT_MAX_TRIES

public static final int DEFAULT_MAX_TRIES
See Also:
Constant Field Values
Constructor Detail

CombinedGenerators

public CombinedGenerators()
Method Detail

frequency

public static <T> FrequencyGenerator<T> frequency(Generator<T> generator,
                                                  int weight)

Create a frequency generator. The frequency of Generator usage depends on the generator weight.

Type Parameters:
T - type of values generated by the generators.
Parameters:
generator - pairs of generators and their weights used to created the values

oneOf

public static <T> ExtendibleGenerator<T,T> oneOf(Generator<T> generator)
OneOf is a convenience method for frequency(Generator, int) when all generator share the same weight.


vectors

public static <T> Generator<List<T>> vectors(Generator<T> content,
                                             int size)
Create a generator which will create vectors (here lists) of type T.

Type Parameters:
T - Type of the list values.
Parameters:
size - Number of element in the vector.

pairs

public static <A,B> Generator<Pair<A,B>> pairs(Generator<A> first,
                                               Generator<B> second)
Create a generator of pairs of type A for the left value and type B for the right value.

Type Parameters:
A - Type of left value.
B - Type of right value.
Parameters:
first - Generator for left values.
second - Generator for right values.

triples

public static <A,B,C> Generator<Triple<A,B,C>> triples(Generator<A> first,
                                                       Generator<B> second,
                                                       Generator<C> third)
Create a generator of triples of the types A, B and C for first, second and third value.

Type Parameters:
A - Type of first value.
B - Type of second value.
C - Type of third value.
Parameters:
first - Generator for first values.
second - Generator for second values.
third - Generator for third values.

nullsAnd

public static <T> Generator<T> nullsAnd(Generator<T> generator)
Create a generator as a combination of a null value generator and generator of type T.

Type Parameters:
T - Type of the values generated.

nullsAnd

public static <T> Generator<T> nullsAnd(Generator<T> generator,
                                        int weight)
Create a generator as a combination of a null value generator and generator of type T.

Type Parameters:
T - Type of the values generated.
Parameters:
weight - weight of the provided generator

sets

public static <T> Generator<Set<T>> sets(Generator<? extends T> content)
Create a generator of sets with values from the content generator.

Type Parameters:
T - type of set elements generated
Parameters:
content - generator providing the content of sets generated

sets

public static <T> Generator<Set<T>> sets(Generator<? extends T> content,
                                         Generator<Integer> size)
Create a generator of sets with values from the content generator.

Type Parameters:
T - type of set elements generated
Parameters:
content - generator providing the content of sets generated
size - size of the sets generated

sets

public static <T> Generator<Set<T>> sets(Generator<? extends T> content,
                                         int low,
                                         int high)
Create a generator of sets with values from the content generator. Length is between high and low.

Type Parameters:
T - type of set elements generated
Parameters:
content - generator providing the content of sets generated
low - minimal size
high - max size

nonEmptySets

public static <T> Generator<Set<T>> nonEmptySets(Generator<? extends T> content)
Create a generator of sets that are not empty.

Type Parameters:
T - type of set elements generated
Parameters:
content - generator providing the content of sets generated

sets

public static <T> Generator<Set<T>> sets(Set<T> superset)
Create a generator of subsets from a given set.

Type Parameters:
T - type of set elements generated
Parameters:
superset - of the generated set

sets

public static <T> Generator<Set<T>> sets(Set<T> superset,
                                         Generator<Integer> size)
Create a generator of subsets from a given set.

Type Parameters:
T - type of set elements generated
Parameters:
superset - of the generated set
size - of the generated set

iterators

public static <T> Generator<Iterator<T>> iterators(Generator<? extends T> content)
Create a generator of iterators.

Values of the elements will be taken from the content generator.

Type Parameters:
T - type of iterator elements generated
Parameters:
content - generator providing the content of iterators generated

nonEmptyIterators

public static <T> Generator<Iterator<T>> nonEmptyIterators(Generator<T> content)
Create a generator of iterators.

Values of the elements will be taken from the content generator. The generated iterator will have at least one element.

Type Parameters:
T - type of iterator elements generated
Parameters:
content - generator providing the content of iterators generated

iterators

public static <T> Generator<Iterator<T>> iterators(Generator<? extends T> content,
                                                   Generator<Integer> size)
Create a generator of iterators.

Values of the elements will be taken from the content generator. The length of the iterators will be determined with the size generator.

Type Parameters:
T - type of iterator elements generated
Parameters:
content - generator providing the content of iterators generated
size - used to determine the number of elements of the iterator

lists

public static <T> Generator<List<T>> lists(Generator<? extends T> content)
Create a generator of lists with values from the content generator. Length values of lists generated will be created with Distribution.UNIFORM.

Type Parameters:
T - type of list elements generated
Parameters:
content - generator providing the content of lists generated

nonEmptyLists

public static <T> Generator<List<T>> nonEmptyLists(Generator<? extends T> content)
Create a generator of non-empty lists with values from the content generator. Length values of lists generated will be created with Distribution.UNIFORM.

Type Parameters:
T - type of list elements generated
Parameters:
content - generator providing the content of lists generated

lists

public static <T> Generator<List<T>> lists(Generator<? extends T> content,
                                           Generator<Integer> size)
Create a generator of lists with values from the content generator. Length values of lists generated will be created with size generator.

Type Parameters:
T - type of list elements generated
Parameters:
content - generator providing the content of lists generated
size - integer used to determine the list size

lists

public static <T> Generator<List<T>> lists(Generator<? extends T> content,
                                           int low,
                                           int high)
Create a generator of lists with values from the content generator. Length is between high and low.

Type Parameters:
T - type of list elements generated
Parameters:
content - generator providing the content of lists generated
low - minimal size
high - max size

lists

public static <T> Generator<List<T>> lists(Generator<? extends T> content,
                                           int low)
Create a generator of lists with values from the content generator. Length is at least low.

Type Parameters:
T - type of list elements generated
Parameters:
content - generator providing the content of lists generated
low - minimal size. If low is larger than DEFAULT_COLLECTION_MAX_SIZE then it is the upper size bound as well.

sortedLists

public static <T extends Comparable<T>> Generator<List<T>> sortedLists(Generator<T> content)
Create a generator of sorted lists with values from the content generator.

Type Parameters:
T - type of list elements generated
Parameters:
content - generator providing the content of lists generated

sortedLists

public static <T extends Comparable<T>> Generator<List<T>> sortedLists(Generator<T> content,
                                                                       int low,
                                                                       int high)
Create a generator of sorted lists with values from the content generator. Length is between high and low.

Type Parameters:
T - type of list elements generated
Parameters:
content - generator providing the content of lists generated
low - minimal size
high - max size

sortedLists

public static <T extends Comparable<T>> Generator<List<T>> sortedLists(Generator<T> content,
                                                                       Generator<Integer> size)
Create a generator of sorted lists with values from the content generator. Length is between high and low.

Type Parameters:
T - type of list elements generated
Parameters:
content - generator providing the content of lists generated
size - integer used to determine the list size

arrays

public static <T> Generator<T[]> arrays(Generator<? extends T> content,
                                        Class<T> type)
Create a generator of arrays with values from the content generator. Length values of array generated will be created with Distribution.UNIFORM.

Type Parameters:
T - type of arrays elements generated
Parameters:
content - generator providing the content of arrays generated
type - type of arrays generated

nonEmptyArrays

public static <T> Generator<T[]> nonEmptyArrays(Generator<? extends T> content,
                                                Class<T> type)
Create a generator of arrays that are not empty.

Type Parameters:
T - type of arrays elements generated
Parameters:
content - generator providing the content of arrays generated
type - type of arrays generated

arrays

public static <T> Generator<T[]> arrays(Generator<? extends T> content,
                                        Generator<Integer> size,
                                        Class<T> type)
Create a generator of arrays with values from the content generator. Length values of arrays generated will be created with size generator.

Type Parameters:
T - type of arrays elements generated
Parameters:
content - generator providing the content of arrays generated
size - integer used to determine the array size
type - type of arrays generated

byteArrays

public static Generator<byte[]> byteArrays()
Create a generator of byte arrays. The length of arrays generated will be determined by the ByteArrayGenerator.MIN_SIZE and ByteArrayGenerator.MAX_SIZE constants.


byteArrays

public static Generator<byte[]> byteArrays(Generator<Integer> size)
Create a generator of byte arrays. Length values of arrays generated will be created with size generator.

Parameters:
size - integer used to determine the array size

byteArrays

public static Generator<byte[]> byteArrays(Generator<Byte> content,
                                           Generator<Integer> size)
Create a generator of byte arrays. Length values of arrays generated will be created with size generator.

Parameters:
size - integer used to determine the array size
content - generator for the byte array content

intArrays

public static Generator<int[]> intArrays()
Create a generator of integer arrays.


intArrays

public static Generator<int[]> intArrays(Generator<Integer> size)
Create a generator of integer arrays. Length values of arrays generated will be created with size generator.

Parameters:
size - integer used to determine the array size

intArrays

public static Generator<int[]> intArrays(Generator<Integer> content,
                                         Generator<Integer> size)
Create a generator of integer arrays. Length values of arrays generated will be created with size generator.

Parameters:
size - integer used to determine the array size
content - generator for the integer array content

maps

public static <K,V> Generator<Map<K,V>> maps(Generator<K> keys,
                                             Generator<V> values)
Create a generator of maps.

This is a generator for simple maps where the values are not related to the keys.

Parameters:
keys - Generator for the keys of the map
values - Generator for the values of the map

maps

public static <K,V> Generator<Map<K,V>> maps(Generator<K> keys,
                                             Generator<V> values,
                                             Generator<Integer> size)
Create a generator of maps.

This is a generator for simple maps where the values are not related to the keys.

Parameters:
keys - Generator for the keys of the map
values - Generator for the values of the map
size - integer used to determine the size of the generated map

maps

public static <K,V> Generator<Map<K,V>> maps(Map<K,V> supermap)
Create a generator of maps from a given map.

The entry set of the generated maps are subsets of the given map's entry set.

Parameters:
supermap - of the generated maps

maps

public static <K,V> Generator<Map<K,V>> maps(Map<K,V> supermap,
                                             Generator<Integer> sizes)
Create a generator of maps from a given map.

The entry set of the generated maps are subsets of the given map's entry set.

Parameters:
supermap - of the generated maps
sizes - of the generated maps

ensureValues

public static <T> StatefulGenerator<T> ensureValues(Collection<T> ensuredValues)
Create a deterministic generator which guarantees that all values from the ensuredValues collection will be returned if enough calls to Generator.next() are issued (i.e. ensuredValues.size() <= # of runs). The order of values is undefined.

Type Parameters:
T - type of values return by the generator

ensureValues

public static <T> StatefulGenerator<T> ensureValues(T... content)
Create a deterministic generator which guarantees that all values from the ensuredValues array will be returned if enough calls to Generator.next() are issued (i.e. ensuredValues.size() <= # of runs). The order of values is undefined.

Type Parameters:
T - type of values return by the generator

ensureValues

public static <T> StatefulGenerator<T> ensureValues(Collection<T> ensuredValues,
                                                    Generator<T> otherValues)

Create a deterministic generator which guarantees that all values from the ensuredValues collection will be returned if enough calls to Generator.next() are issued (i.e. ensuredValues.size() <= # of runs). The order of values is undefined.

If all values of ensuredValues are generated calls to Generator.next() will return values from the otherValues generator.

Type Parameters:
T - type of values return by the generator

uniqueValues

public static <T> StatefulGenerator<T> uniqueValues(Generator<T> generator,
                                                    int tries)

Create a generator that ensures unique values.

The actual values are created with an arbitrary generator.

Note: unique generator depends on valid implementation of equals and hashCode method of the content type generated.

Type Parameters:
T - type of values return by the generator
Parameters:
generator - used to create the raw values. This generator can create duplicate values
tries - Number of tries to create a new unique value. After this number of tries is exceeded the generation aborts with a GeneratorException.
Returns:
unique generator instance

uniqueValues

public static <T> StatefulGenerator<T> uniqueValues(Generator<T> generator,
                                                    Comparator<? super T> comparator,
                                                    int tries)

Create a generator that ensures unique values.

The actual values are created with an arbitrary generator.

Unique generator depends on the Comparator implementation to decide if two instances are the same (i.e. when the comparator returns 0 for Comparator.compare(Object, Object)).

Type Parameters:
T - type of values returned by the generator
Parameters:
generator - used to create the raw values. This generator can create duplicate values
comparator - that decides if two values are of the same equivalence class.
tries - Number of tries to create a new unique value. After this number of tries is exceeded the generation aborts with a GeneratorException.
Returns:
unique generator instance

uniqueValues

public static <T> StatefulGenerator<T> uniqueValues(Generator<T> generator,
                                                    Comparator<? super T> comparator)

Create a generator that ensures unique values.

The actual values are created with an arbitrary generator.

Unique generator depends on the Comparator implementation to decide if two instances are the same (i.e. when the comparator returns 0 for Comparator.compare(Object, Object)).

Type Parameters:
T - type of values returned by the generator
Parameters:
generator - used to create the raw values. This generator can create duplicate values
comparator - that decides if two values are of the same equivalence class.
Returns:
unique generator instance

uniqueValues

public static <T> StatefulGenerator<T> uniqueValues(Generator<T> generator)

Create a generator that ensures unique values

The actual values are created with an arbitrary generator.

Note: unique generator depends on valid implementation of equals and hashCode method of the content type generated.

Type Parameters:
T - type of values return by the generator
Parameters:
generator - used to create the raw values. This generator can create duplicate values
Returns:
unique generator instance

excludeValues

public static <T> Generator<T> excludeValues(Generator<T> generator,
                                             T excluded)
Create a generator that omits a given value.

Parameters:
generator - used to create the raw values.
excluded - value. This value will not be returned.

excludeValues

public static <T> Generator<T> excludeValues(Generator<T> generator,
                                             T... excluded)
Create a generator that omits a given set of values.

Parameters:
generator - used to create the raw values.
excluded - values. These values will not be returned.

excludeValues

public static <T> Generator<T> excludeValues(Collection<T> values,
                                             T... excluded)
Create a generator that omits a given set of values.

Parameters:
values - of generator
excluded - values. These values will not be returned.

excludeValues

public static <T> Generator<T> excludeValues(Collection<T> values,
                                             Collection<T> excluded)
Create a generator that omits a given set of values.

Parameters:
values - of generator
excluded - values. These values will not be returned.

excludeValues

public static <T> Generator<T> excludeValues(Generator<T> generator,
                                             Collection<T> excluded)
Create a generator that omits a given set of values.

Parameters:
generator - used to create the raw values.
excluded - values. These values will not be returned.


Copyright © 2011. All Rights Reserved.