Fixes mockito#2311

src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java

@@ -18,9 +18,20 @@ public interface ContainsExtraTypeInfo {
      */
     String toStringWithType();
 
+    /**
+     * Returns more verbose description of the object which include type information and fully qualified class name
+     */
+    String toStringWithFullName();
+
     /**
      * Checks if target target has matching type.
      * If the type matches, there is no point in rendering result from {@link #toStringWithType()}
      */
     boolean typeMatches(Object target);
+
+    /**
+     * Checks if target target's class has same simple name.
+     * If the simple names matches, we need to use {@link #toStringWithFullName()}
+     */
+    boolean sameName(Object target);
 }

src/main/java/org/mockito/internal/matchers/Equals.java

@@ -55,8 +55,18 @@ public String toStringWithType() {
         return "(" + wanted.getClass().getSimpleName() + ") " + describe(wanted);
     }
 
+    @Override
+    public String toStringWithFullName() {
+        return "(" + wanted.getClass().getCanonicalName() + ") " + describe(wanted);
+    }
+
     @Override
     public boolean typeMatches(Object target) {
         return wanted != null && target != null && target.getClass() == wanted.getClass();
     }
+
+    @Override
+    public boolean sameName(Object target) {
+        return wanted != null && target != null && target.getClass().getSimpleName().equals(wanted.getClass().getSimpleName());
+    }
 }

src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java

@@ -32,6 +32,8 @@ private Iterator<FormattedText> applyPrintSettings(
         for (final ArgumentMatcher matcher : matchers) {
             if (matcher instanceof ContainsExtraTypeInfo && printSettings.extraTypeInfoFor(i)) {
                 out.add(new FormattedText(((ContainsExtraTypeInfo) matcher).toStringWithType()));
+            } else if(matcher instanceof ContainsExtraTypeInfo && printSettings.fullyQualifiedNameFor(i)){
+                out.add(new FormattedText(((ContainsExtraTypeInfo) matcher).toStringWithFullName()));
             } else {
                 out.add(new FormattedText(MatcherToString.toString(matcher)));
             }

src/main/java/org/mockito/internal/reporting/PrintSettings.java

@@ -19,6 +19,7 @@ public class PrintSettings {
     public static final int MAX_LINE_LENGTH = 45;
     private boolean multiline;
     private List<Integer> withTypeInfo = new LinkedList<>();
+    private List<Integer> withFullyQualifiedName = new LinkedList<>();
 
     public void setMultiline(boolean multiline) {
         this.multiline = multiline;
@@ -38,10 +39,18 @@ public boolean extraTypeInfoFor(int argumentIndex) {
         return withTypeInfo.contains(argumentIndex);
     }
 
+    public boolean fullyQualifiedNameFor(int argumentIndex) {
+        return withFullyQualifiedName.contains(argumentIndex);
+    }
+
     public void setMatchersToBeDescribedWithExtraTypeInfo(Integer[] indexesOfMatchers) {
         this.withTypeInfo = Arrays.asList(indexesOfMatchers);
     }
 
+    public void setMatchersToBeDescribedWithFullName(Integer[] indexesOfMatchers) {
+        this.withFullyQualifiedName= Arrays.asList(indexesOfMatchers);
+    }
+
     public String print(List<ArgumentMatcher> matchers, Invocation invocation) {
         MatchersPrinter matchersPrinter = new MatchersPrinter();
         String qualifiedName =

src/main/java/org/mockito/internal/reporting/SmartPrinter.java

@@ -28,17 +28,21 @@ public SmartPrinter(
         this(
                 wanted,
                 Collections.singletonList(actual),
-                indexesOfMatchersToBeDescribedWithExtraTypeInfo);
+                indexesOfMatchersToBeDescribedWithExtraTypeInfo,
+                new Integer[0]);
     }
 
     public SmartPrinter(
             MatchableInvocation wanted,
             List<Invocation> allActualInvocations,
-            Integer... indexesOfMatchersToBeDescribedWithExtraTypeInfo) {
+            Integer[] indexesOfMatchersToBeDescribedWithExtraTypeInfo,
+            Integer[] indexesOfMatchersToBeDescribedWithFullName) {
         PrintSettings printSettings = new PrintSettings();
         printSettings.setMultiline(isMultiLine(wanted, allActualInvocations));
         printSettings.setMatchersToBeDescribedWithExtraTypeInfo(
                 indexesOfMatchersToBeDescribedWithExtraTypeInfo);
+        printSettings.setMatchersToBeDescribedWithFullName(
+                indexesOfMatchersToBeDescribedWithFullName);
 
         this.wanted = printSettings.print(wanted);
 

src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java

@@ -48,4 +48,28 @@ private static boolean safelyMatches(ArgumentMatcher m, Object arg) {
     private static boolean toStringEquals(ArgumentMatcher m, Object arg) {
         return m.toString().equals(String.valueOf(arg));
     }
+
+    /**
+     * Suspiciously not matching arguments are those that don't match, and the classes have same simple name.
+     */
+    public static Integer[] getNotMatchingArgsWithSameNameIndexes(
+        List<ArgumentMatcher> matchers, Object[] arguments) {
+        if (matchers.size() != arguments.length) {
+            return new Integer[0];
+        }
+
+        List<Integer> suspicious = new LinkedList<>();
+        int i = 0;
+        for (ArgumentMatcher m : matchers) {
+            if (m instanceof ContainsExtraTypeInfo
+                && !safelyMatches(m, arguments[i])
+                && !((ContainsExtraTypeInfo) m).typeMatches(arguments[i])
+                && ((ContainsExtraTypeInfo) m).sameName(arguments[i])) {
+                suspicious.add(i);
+            }
+            i++;
+        }
+        return suspicious.toArray(new Integer[0]);
+    }
+
 }

src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java

@@ -11,6 +11,7 @@
 import static org.mockito.internal.invocation.InvocationsFinder.findInvocations;
 import static org.mockito.internal.invocation.InvocationsFinder.findPreviousVerifiedInOrder;
 import static org.mockito.internal.invocation.InvocationsFinder.findSimilarInvocation;
+import static org.mockito.internal.verification.argumentmatching.ArgumentMatchingTool.getNotMatchingArgsWithSameNameIndexes;
 import static org.mockito.internal.verification.argumentmatching.ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes;
 
 import java.util.List;
@@ -41,7 +42,9 @@ public static void checkMissingInvocation(
 
         Integer[] indexesOfSuspiciousArgs =
                 getSuspiciouslyNotMatchingArgsIndexes(wanted.getMatchers(), similar.getArguments());
-        SmartPrinter smartPrinter = new SmartPrinter(wanted, invocations, indexesOfSuspiciousArgs);
+        Integer[] indexesOfArgsWithSameSimpleName =
+            getNotMatchingArgsWithSameNameIndexes(wanted.getMatchers(), similar.getArguments());
+        SmartPrinter smartPrinter = new SmartPrinter(wanted, invocations, indexesOfSuspiciousArgs,indexesOfArgsWithSameSimpleName);
         List<Location> actualLocations =
                 ListUtil.convert(
                         invocations,

src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java

@@ -115,10 +115,21 @@ public String toStringWithType() {
                 return "";
             }
 
+            @Override
+            public String toStringWithFullName() {
+                return "";
+            }
+
             @Override
             public boolean typeMatches(Object target) {
                 return true;
             }
+
+            @Override
+            public boolean sameName(Object target) {
+                return true;
+            }
+
         }
 
         // given