Mock returning java.util.Optional should return Optional.empty() by default (Java 8) about mockito HOT 7 OPEN

That would be great, but for now our build has to be compatible with Java 5. So 
we cannot yet use Java 6,7 or 8 symbols or types.

However a specific jdk8 distribution of mockito is clearly not ruled out.

Why not dynamically include modules if a required Java version (or any other 
library) is present?

The Spring Framework does something like this in many places, mainly to load 
plugins depending on the presence of a certain class in the class path. See 
https://github.com/spring-projects/spring-framework/blob/master/spring-web/src/m
ain/java/org/springframework/web/client/RestTemplate.java#L130

Demo code that loads a class only if the Java version meets a certain 
requirement follows (with console output and simplified error handling to keep 
things simple).

public final class DynamicImport {
    private static final int JAVA_VERSION;

    static {
        final String versionString = System.getProperty("java.version");
        final Matcher matcher = Pattern.compile("^1\\.(\\d+)\\.\\d+_\\d+$").matcher(versionString);

        if (!matcher.matches()) {
            throw new IllegalStateException(String.format("Can't parse Java version [%s]", versionString));
        }

        JAVA_VERSION = Integer.parseInt(matcher.group(1));
    }

    private DynamicImport() {
        // utility class
    }

    public static void includeClass(final int minVersion, final String className, final ClassLoader loader) {
        if (JAVA_VERSION < minVersion) {
            System.out.println(String.format("Skipping loading of class [%s]: Java version %d is lower than required %d", className,
                    JAVA_VERSION, minVersion));
            return;
        }

        try {
            System.out.println(String.format("Loading class [%s]", className));
            Class.forName(className, true, loader);
        } catch (final ClassNotFoundException e) {
            throw new IllegalStateException(String.format("Error loading class [%s]: %s", className, e), e);
        }
    }
}

Yeah I know this is possible, we do something similar for JUnit. However as it 
involves the JDK it requires to change the build scripts, the dev environment, 
the ci, etc.

These tasks may be more relevant if we create a pure jdk8 version.

Agreed.

It would be nice if Mockito would support this by default, but ... it is very 
easy to add this yourself using a default answer. I have put an example here: 
https://gist.github.com/diversit/ef6a1025ac9d1dc2a113

+1 for the feature

Do you mind opening a ticket in github? 
https://github.com/mockito/mockito/issues

We can use reflection to avoid compiling against jdk8

If you reach this via Google: I created a GitHub issue since I couldn't find 
one: https://github.com/mockito/mockito/issues/191