Mock returning java.util.Optional should return Optional.empty() by default (Java 8)

[GoogleCodeExporter]

This issue is closely related to #349, however I am referring to the now 
standard type java.util.Optional in Java 8 instead of Guava's.

A stubbed method that returns Optional<?> should return Optional.empty() if no 
explicit behavior is defined. This is equivalent to returning null for regular 
methods.

Introducing this feature would add no extra dependencies. However, it would 
require a test whether the code is running in Java 8.

Original issue reported on code.google.com by phjar...@gmail.com on 8 Jul 2014 at 8:44

[GoogleCodeExporter]

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.

Original comment by brice.du...@gmail.com on 8 Jul 2014 at 9:12

• Added labels: jdk8

[GoogleCodeExporter]

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);
        }
    }
}

Original comment by phjar...@gmail.com on 8 Jul 2014 at 9:35

[GoogleCodeExporter]

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.

Original comment by brice.du...@gmail.com on 8 Jul 2014 at 10:29

[GoogleCodeExporter]

Agreed.

Original comment by phjar...@gmail.com on 8 Jul 2014 at 10:35

[GoogleCodeExporter]

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

Original comment by jdb...@diversit.eu on 2 Dec 2014 at 8:47

[GoogleCodeExporter]

+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

Original comment by szcze...@gmail.com on 2 Dec 2014 at 9:28

[GoogleCodeExporter]

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

Original comment by netmi...@gmail.com on 2 Apr 2015 at 6:04