Arbitrary (Javaslang Test 2.0.6 API)

Type Parameters:

T - The type of the arbitrary object.

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
```
@FunctionalInterface
public interface Arbitrary<T>
```
Represents an arbitrary object of type T.

Since:

1.2.0

Author:

Daniel Dietrich

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`Gen<T>`	`apply(int size)` Returns a generator for objects of type T.
`default Arbitrary<T>`	`filter(Predicate<? super T> predicate)` Returns an Arbitrary based on this Arbitrary which produces values that fulfill the given predicate.
`default <U> Arbitrary<U>`	`flatMap(Function<? super T,? extends Arbitrary<? extends U>> mapper)` Maps arbitrary objects T to arbitrary object U.
`static Arbitrary<Integer>`	`integer()` Generates arbitrary integer values.
`static <T> Arbitrary<List<T>>`	`list(Arbitrary<T> arbitraryT)` Generates arbitrary lists based on a given element generator arbitraryT.
`default <U> Arbitrary<U>`	`map(Function<? super T,? extends U> mapper)` Maps arbitrary objects T to arbitrary object U.
`default Arbitrary<T>`	`peek(Consumer<? super T> action)`
`static <T> Arbitrary<Stream<T>>`	`stream(Arbitrary<T> arbitraryT)` Generates arbitrary streams based on a given element generator arbitraryT.
`static Arbitrary<String>`	`string(Gen<Character> gen)` Generates arbitrary strings based on a given alphabet represented by gen.
`default <U> U`	`transform(Function<? super Arbitrary<T>,? extends U> f)` Transforms this `Arbitrary`.

Method Detail

apply

Gen<T> apply(int size)

Returns a generator for objects of type T. Use Gen.map(Function) and Gen.flatMap(Function) to combine object generators.

Example:

 
 // represents arbitrary binary trees of a certain depth n
 final class ArbitraryTree implements Arbitrary<BinaryTree<Integer>> {
     @Override
     public Gen<BinaryTree<Integer>> apply(int n) {
         return Gen.choose(-1000, 1000).flatMap(value -> {
                  if (n == 0) {
                      return Gen.of(BinaryTree.leaf(value));
                  } else {
                      return Gen.frequency(
                              Tuple.of(1, Gen.of(BinaryTree.leaf(value))),
                              Tuple.of(4, Gen.of(BinaryTree.branch(apply(n / 2).get(), value, apply(n / 2).get())))
                      );
                  }
         });
     }
 }

 // tree generator with a size hint of 10
 final Gen<BinaryTree<Integer>> treeGen = new ArbitraryTree().apply(10);

 // stream sum of tree node values to console for 100 arbitrary trees
 Stream.of(() -> treeGen.apply(RNG.get())).map(Tree::sum).take(100).stdout();

Parameters:: size - A (not necessarily positive) size parameter which may be interpreted individually and is constant for all arbitrary objects regarding one property check.
Returns:: A generator for objects of type T.

filter
```
default Arbitrary<T> filter(Predicate<? super T> predicate)
```
Returns an Arbitrary based on this Arbitrary which produces values that fulfill the given predicate.

Parameters:

predicate - A predicate

Returns:

A new generator

flatMap
```
default  Arbitrary flatMap(Function<? super T,? extends Arbitrary<? extends U>> mapper)
```
Maps arbitrary objects T to arbitrary object U.

Type Parameters:

U - New type of arbitrary objects

Parameters:

mapper - A function that maps arbitrary Ts to arbitrary Us given a mapper.

Returns:

A new Arbitrary

map
```
default  Arbitrary map(Function<? super T,? extends U> mapper)
```
Maps arbitrary objects T to arbitrary object U.

Type Parameters:

U - Type of the mapped object

Parameters:

mapper - A function that maps an arbitrary T to an object of type U.

Returns:

A new generator

peek

default Arbitrary<T> peek(Consumer<? super T> action)

transform
```
default  U transform(Function<? super Arbitrary<T>,? extends U> f)
```
Transforms this Arbitrary.

Type Parameters:

U - Type of transformation result

Parameters:

f - A transformation

Returns:

An instance of type U

Throws:

NullPointerException - if f is null

integer
```
static Arbitrary<Integer> integer()
```
Generates arbitrary integer values.

Returns:

A new Arbitrary of Integer

string

static Arbitrary<String> string(Gen<Character> gen)

Generates arbitrary strings based on a given alphabet represented by gen.

Example:

 
 Arbitrary.string(
     Gen.frequency(
         Tuple.of(1, Gen.choose('A', 'Z')),
         Tuple.of(1, Gen.choose('a', 'z')),
         Tuple.of(1, Gen.choose('0', '9'))));

Parameters:: gen - A character generator
Returns:: a new Arbitrary of String

list
```
static <T> Arbitrary<List<T>> list(Arbitrary<T> arbitraryT)
```
Generates arbitrary lists based on a given element generator arbitraryT.
Example:
```
 
 Arbitrary.list(Arbitrary.integer());
 
 
```
Type Parameters:

T - Component type of the List

Parameters:

arbitraryT - Arbitrary elements of type T

Returns:

a new Arbitrary of List<T>

stream
```
static <T> Arbitrary<Stream<T>> stream(Arbitrary<T> arbitraryT)
```
Generates arbitrary streams based on a given element generator arbitraryT.
Example:
```
 
 Arbitrary.stream(Arbitrary.integer());
 
 
```
Type Parameters:

T - Component type of the Stream

Parameters:

arbitraryT - Arbitrary elements of type T

Returns:

a new Arbitrary of Stream<T>

Interface Arbitrary<T>

Method Summary

Method Detail

apply

filter

flatMap

map

peek

transform

integer

string

list

stream