Prevent stubbing of equals method

Question

I would like to test my class' equals() method but Mockito seems to be calling the stub version every time. My test is as follows;

PluginResourceAdapter adapter = mock (PluginResourceAdapter.class);
PluginResourceAdapter other = mock (PluginResourceAdapter.class);

when(adapter.getNumberOfEndpointActivation()).thenReturn(1);
when(other.getNumberOfEndpointActivation()).thenReturn(0);

boolean result = adapter.equals(other);
assertFalse(result);

I know I cannot stub the equals method which means Mockito should be calling my real implementation but its not.

I have also tried this:

when (adapter.equals(any()).thenCallRealMethod()

but I get the same result.

Answer 1

Even beyond Mockito's limitations, it doesn't make much sense for a mocked object to use a real equals method, if for no other reason than that equals methods almost always use fields, and mocked objects never run any of their constructors or field initializers.

Also, be aware of what you're testing: In a test of Foo, ideally you should never mock Foo, even to set up a Foo to compare against. Otherwise, it's easy to inadvertently test that Mockito works, rather than testing your own component's logic.

You have a few workarounds:

• As Garrett Hall mentioned, create real objects. This may require factoring out the "data objects" from the services that use them, and mocking the services while using real data objects. This is probably a good idea overall.

• Create a manual mock or fake by subclassing PluginResourceAdapter or implementing the relevant interface outside of Mockito. This frees you to define all methods as needed, including equals and hashCode.

• Create an equivalentTo method, which isn't the same as equals (and thus isn't as useful for Map or Set objects, for instance) but that has mockable semantics you can define on your own.

  This would also let you test equivalentTo freely with a mock, and simply have equals delegate to that presumably-well-tested implementation.

• Extract an object that tests equality, and mock that. You could also use Guava's Equivalence there, or a Comparator where you test a.compareTo(b) == 0.

  class YourClass {
    class AdapterEquivalence {
      boolean adaptersAreEqual(
          PluginResourceAdapter a, PluginResourceAdapter b) {
        return a.equals(b);
      }
    }
  
    /** Visible for testing. Replace in tests. */
    AdapterEquivalence adapterEquivalence = new AdapterEquivalence();
  }
  

Note that one other potential workaround—spying on existing instances—will also redefine equals and hashCode and won't help you here.

Answer 2

By default equals() returns true if object have the same address in memory.
So

PluginResourceAdapter adapter; PluginResourceAdapter other; adapter = other = mock (PluginResourceAdapter.class);

returns true to you. If you want false use

PluginResourceAdapter adapter = mock (PluginResourceAdapter.class); PluginResourceAdapter other = mock (PluginResourceAdapter.class);

Answer 3

If you want to test the real equals then you need to create a real object and call the equals method on it. I'm not sure why you are using mocks.