Important Note: The library the documentation has moved to www.mockneat.com. The information found on this wiki is quite outdated. Please check the new site.

MockUnit<T> is a @FunctionalInterface that has exactly one non-default abstract method:

@FunctionalInterface
@SuppressWarnings("unchecked")
public interface MockUnit<T> {

    // Functional Method
    Supplier<T> supplier();

// ...

}

For the moment there are 8 MockUnit types including the generic MockUnit<T>:

It's important to note that almost every method of MockNeat class returns a MockUnit<T> or an instance of its implementations.

MockNeat m = MockNeat.threadLocal();

// A mockUnit that can generate integers in [0, 100) interval
MockUnit<Integer> intMockUnit = m.ints().bound(100);

// Generating an integer with the mockUnit
int integer = intMockUnit.val();

// Generating another integer with the mockUnit
int integer2 = intMockUnit.val()

In the same time each MockUnit<T> is "smart" enough to generate "children" units that inherit the "inner" behaviour of their parent, but adding some particular behaviour or their own.

With the intMockUnit from the previous example we can "generate" another MockUnit that has the ability to generate lists of integers (List<Integer>) in the same interval [0, 100):

// A mockUnit that can generate list of integers
MockUnit<List<Integer>> listMockUnit = intMockUnit.list(100);

// Generating a list of integers
List<Integer> list = listMockUnit.val();

// Generating another list of integers
List<Integer> list2 = listMockUnit.val();

Without keeping the intermediary references we can write "incremental chains" of MockUnits that are passing their behaviour further and further.

Usually (with some exceptions) a chain like this is "lazy", and no value is generated until calling a "closing" method, like val():

List<Integer[]> listArray = m.ints() 
                             .range(0, 100)
                             .array(100)
                             .list(ArrayList.class, 100)
                             .val();

Breaking the previous example: