Package de.cuioss.test.generator.internal.net.java.quickcheck.generator

Class CombinedGenerators

java.lang.Object

de.cuioss.test.generator.internal.net.java.quickcheck.generator.CombinedGenerators

public class CombinedGenerators
extends Object

CombinedGenerators can be used to create custom Generators.

Field Summary

Fields

Modifier and Type	Field	Description
static int	DEFAULT_COLLECTION_MAX_SIZE
static int	DEFAULT_MAX_TRIES

Constructor Summary

Constructors

Constructor	Description
CombinedGenerators()

Method Summary

Modifier and Type	Method	Description
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 <T> Generator<T[]>	arrays(Generator<? extends T> content, 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> Generator<List<T>>	duplicates(Iterable<T> input)	Create a generator that produces lists of duplicates.
static <T> Generator<List<T>>	duplicates(T... input)	Create a generator that produces lists of duplicates.
static <T> StatefulGenerator<T>	ensureValues(Iterable<T> ensuredValues)	Create a deterministic generator which guarantees that all values from the ensuredValues collection will be return Generator.next() are issued (i.e.
static <T> StatefulGenerator<T>	ensureValues(Iterable<T> ensuredValues, int window, Generator<T> otherValues)	Create a generator which guarantees that all values from the ensuredValues will be return Generator.next() are issued.
static <T> StatefulGenerator<T>	ensureValues(Iterable<T> ensuredValues, Generator<T> otherValues)	Create a deterministic generator which guarantees that all values from the ensuredValues collection will be return Generator.next() are issued (i.e.
static <T> StatefulGenerator<T>	ensureValues(T... content)	Create a deterministic generator which guarantees that all values from the ensuredValues array will be return Generator.next() are issued (i.e.
static <T> Generator<T>	excludeValues(Generator<T> generator, Iterable<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(Iterable<T> values, Iterable<T> excluded)	Create a generator that omits a given set of values.
static <T> Generator<T>	excludeValues(Iterable<T> values, T... excluded)	Create a generator that omits a given set of values.
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, 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 <T> Generator<List<T>>	lists(Generator<? extends T> content, Generator<Integer> size)	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> Generator<T>	nullsAnd(T... values)	Create a generator return the given values.
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, int low, int high)	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(Iterable<T> superset)	Create a generator of subsets from a given set.
static <T> Generator<Set<T>>	sets(Iterable<T> superset, Generator<Integer> size)	Create a generator of subsets from a given set.
static <T> Generator<Set<T>>	sets(T... superset)
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, int low, int high)	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<Pair<T,T>>	sortedPairs(Generator<T> content)	Create a generator of pairs where first value <= second value.
static <T extends Comparable<T>> Generator<Triple<T,T,T>>	sortedTriple(Generator<T> content)	Create a generator of triples where first value <= second value <= third value.
static <T extends Comparable<T>> Generator<List<T>>	strictlyOrdered(Generator<T> input)	A generator for a lists.
static <T extends Comparable<T>> Generator<List<T>>	strictlyOrdered(Generator<T> input, int low, int high)	A generator for a lists.
static <T> Generator<List<T>>	strictlyOrdered(Generator<T> input, Comparator<T> comparator)	A generator for a lists.
static <T> Generator<List<T>>	strictlyOrdered(Generator<T> input, Comparator<T> comparator, Generator<Integer> size)	A generator for a lists.
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
static <T> StatefulGenerator<T>	uniqueValues(Generator<T> generator, int tries)	Create a generator that ensures unique values.
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> 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.

sortedPairs

public static <T extends Comparable<T>> Generator<Pair<T,T>> sortedPairs(Generator<T> content)

Create a generator of pairs where first value <= second value.

Type Parameters:

T - Type of the pair values.

Parameters:

content - Generator for content of the pair 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

@SafeVarargs
public static <T> Generator<T> nullsAnd(T... values)

Create a generator return the given values.

Type Parameters:

T - Type of the values generated.

sortedTriple

public static <T extends Comparable<T>> Generator<Triple<T,T,T>> sortedTriple(Generator<T> content)

Create a generator of triples where first value <= second value <= third value.

Type Parameters:

T - Type of the triple values.

Parameters:

content - Generator for content of the triple 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

@SafeVarargs
public static <T> Generator<Set<T>> sets(T... superset)

sets

public static <T> Generator<Set<T>> sets(Iterable<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(Iterable<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

duplicates

@SafeVarargs
public static <T> Generator<List<T>> duplicates(T... input)

Create a generator that produces lists of duplicates.

Returns:

a list derived from the input values. At least one input value is more than once in the resulting list.

duplicates

public static <T> Generator<List<T>> duplicates(Iterable<T> input)

Create a generator that produces lists of duplicates.

Returns:

a list derived from the input values. At least one input value is more than once in the resulting list.

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(Iterable<T> ensuredValues)

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

Type Parameters:

T - type of values return

ensureValues

@SafeVarargs
public static <T> StatefulGenerator<T> ensureValues(T... content)

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

Type Parameters:

T - type of values return

ensureValues

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

Create a deterministic generator which guarantees that all values from the ensuredValues collection will be return 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 generator.

Type Parameters:

T - type of values return

ensureValues

public static <T> StatefulGenerator<T> ensureValues(Iterable<T> ensuredValues,
                                                    int window,
                                                    Generator<T> otherValues)

Create a generator which guarantees that all values from the ensuredValues will be return Generator.next() are issued.

The order of values is undefined. All other values in the window and after the window are taken from the generator otherValues.

Type Parameters:

T - type of values return

Parameters:

window - After window number of calls to Generator.next() it is guaranteed that all ensured values were return

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

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 return for Comparator.compare(Object, Object)).

Type Parameters:

T - type of values return

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 return for Comparator.compare(Object, Object)).

Type Parameters:

T - type of values return

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

Parameters:

generator - used to create the raw values. This generator can create duplicate values

Returns:

unique generator instance

excludeValues

@SafeVarargs
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 return

excludeValues

@SafeVarargs
public static <T> Generator<T> excludeValues(Iterable<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 return

excludeValues

public static <T> Generator<T> excludeValues(Iterable<T> values,
                                             Iterable<T> excluded)

Create a generator that omits a given set of values.

Parameters:

values - of generator

excluded - values. These values will not be return

excludeValues

public static <T> Generator<T> excludeValues(Generator<T> generator,
                                             Iterable<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 return

strictlyOrdered

public static <T extends Comparable<T>> Generator<List<T>> strictlyOrdered(Generator<T> input)

A generator for a lists. The values in the lists are strictly increasing.

For every element x in the list: x(n) < x(n+1).

Parameters:

input - values generator

strictlyOrdered

public static <T extends Comparable<T>> Generator<List<T>> strictlyOrdered(Generator<T> input,
                                                                           int low,
                                                                           int high)

A generator for a lists. The values in the lists are strictly increasing.

For every element x in the list: x(n) < x(n+1).

Parameters:

input - values generator

low - minimum size of the lists

high - maximum size of the lists

strictlyOrdered

public static <T> Generator<List<T>> strictlyOrdered(Generator<T> input,
                                                     Comparator<T> comparator)

A generator for a lists. The values in the lists are strictly increasing.

For every element x in the list: x(n) < x(n+1).

This Generator can be used to generate a list of strictly decreasing values: CombinedGenerators.strictlyOrdered(ts, Collections.<T> reverseOrder());

Parameters:

input - values generator

comparator - that orders the values

strictlyOrdered

public static <T> Generator<List<T>> strictlyOrdered(Generator<T> input,
                                                     Comparator<T> comparator,
                                                     Generator<Integer> size)

A generator for a lists. The values in the lists are strictly increasing.

For every element x in the list: x(n) < x(n+1).

Parameters:

input - values generator

comparator - that orders the values

size - of the resulting lists