Allow Java 8 default ("defender") methods to be tested

Java 8 allows default methods on interfaces. It seems like a legitimate use case to test these, by mocking the results of non-default methods of the interface. Here’s a (hypothetical) example that currently doesn’t work with Mockito:

import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;

public class Java8DefaultMethodTest {

    interface I {
        int i();
        default int f() {
            return i() + 1;
        }
    }

    @Test
    public void testFAddsOne() {
        I h = Mockito.mock(I.class);
        Mockito.when(h.i()).thenReturn(2);
        Assert.assertEquals(3, h.f());
    }
}

What is needed to make this work?

I’ve tried adding Mockito.when(h.f()).thenCallRealMethod() but this didn’t work. Also, there has been a related question (see Google Code ticket #456) which is similar in that it is related to Java 8 default methods but not the same because it deals with implementations of interfaces containing default methods.

[runeflobakk]

Typically, default methods are convenience methods which calls abstract methods which must be implemented by concrete classes. They offer some alternate ways to access the regular abstract interface methods, and as such the behaviour of the default methods are directly dependent on how abstract methods are stubbed (or not). Trivial example:

interface A {
  byte[] process(InputStream in);

  default byte[] process(byte[] bytes) {
    return process(new ByteArrayInputStream(bytes));
  }
}

When mocking A, I am only interested in stubbing the process(InputStream in)method, and not worry about if my code calls the method accepting an InputStream or a byte[] argument.

I use the following code to say “call all real default methods”:

mock(A.class, withSettings()
   .defaultAnswer(invocation -> invocation.getMethod().isDefault() ? invocation.callRealMethod() : RETURNS_DEFAULTS.answer(invocation)));

Just wanted to tell about my use case, and maybe it is such a common case that the API should offer some easy way to do just that? This enables me to just stub the abstract method, and the result of the default method depends on the abstract method.

(And I really wish it was possible to define final default methods in Java interfaces, but that’s another discussion 😉 )

[hbf]

@raphw You say that the test

    interface I {
        int i();
        default int f() {
            return i() + 1;
        }
    }

    @Test
    public void testFAddsOne() {
        I h = Mockito.mock(I.class);
        when(h.i()).thenReturn(2);
        when(h.f()).thenCallRealMethod();
        assertEquals(3, h.f());
    }

passes for you. I’m trying this against Mockito 1.10.19 and it fails:

java.lang.NoSuchMethodError: java.lang.Object.f()I

Are you using the 2.x branch?