Fixes mockito#2311

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

@@ -9,18 +9,25 @@
  * When ArgumentMatcher fails, chance is that the actual object has the same output of toString() than
  * the wanted object. This looks weird when failures are reported.
  * Therefore when matcher fails but toString() yields the same outputs,
- * we will try to use the {@link #toStringWithType()} method.
+ * we will try to use the {@link #toStringWithType(boolean)} method.
  */
 public interface ContainsExtraTypeInfo {
 
     /**
+     * @param useFullyQualifiedClassName - uses fully qualified class name if true else simple class name
      * Returns more verbose description of the object which include type information
      */
-    String toStringWithType();
+    String toStringWithType(boolean useFullyQualifiedClassName);
 
     /**
      * Checks if target target has matching type.
-     * If the type matches, there is no point in rendering result from {@link #toStringWithType()}
+     * If the type matches, there is no point in rendering result from {@link #toStringWithType(boolean)}
      */
     boolean typeMatches(Object target);
+
+    /**
+     *
+     * @return Returns the Class of the argument
+     */
+    Class getWantedClass();
 }

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

@@ -51,12 +51,18 @@ public int hashCode() {
     }
 
     @Override
-    public String toStringWithType() {
-        return "(" + wanted.getClass().getSimpleName() + ") " + describe(wanted);
+    public String toStringWithType(boolean useFullyQualifiedClassName) {
+        return "(" + (useFullyQualifiedClassName ? wanted.getClass().getCanonicalName() : wanted.getClass().getSimpleName()) + ") " + describe(wanted);
     }
 
     @Override
     public boolean typeMatches(Object target) {
         return wanted != null && target != null && target.getClass() == wanted.getClass();
     }
+
+    @Override
+    public Class getWantedClass() {
+        return wanted.getClass();
+    }
+
 }

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

@@ -31,7 +31,10 @@ private Iterator<FormattedText> applyPrintSettings(
         int i = 0;
         for (final ArgumentMatcher matcher : matchers) {
             if (matcher instanceof ContainsExtraTypeInfo && printSettings.extraTypeInfoFor(i)) {
-                out.add(new FormattedText(((ContainsExtraTypeInfo) matcher).toStringWithType()));
+                out.add(new FormattedText(((ContainsExtraTypeInfo) matcher).toStringWithType(false)));
+            } else if(matcher instanceof ContainsExtraTypeInfo
+                      && printSettings.fullyQualifiedNameFor(((ContainsExtraTypeInfo) matcher).getWantedClass().getSimpleName())){
+                out.add(new FormattedText(((ContainsExtraTypeInfo) matcher).toStringWithType(true)));
             } else {
                 out.add(new FormattedText(MatcherToString.toString(matcher)));
             }

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

@@ -5,8 +5,10 @@
 package org.mockito.internal.reporting;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
 
 import org.mockito.ArgumentMatcher;
 import org.mockito.internal.matchers.text.MatchersPrinter;
@@ -19,6 +21,7 @@ public class PrintSettings {
     public static final int MAX_LINE_LENGTH = 45;
     private boolean multiline;
     private List<Integer> withTypeInfo = new LinkedList<>();
+    private Set<String> withFullyQualifiedName = Collections.emptySet();
 
     public void setMultiline(boolean multiline) {
         this.multiline = multiline;
@@ -38,10 +41,18 @@ public boolean extraTypeInfoFor(int argumentIndex) {
         return withTypeInfo.contains(argumentIndex);
     }
 
+    public boolean fullyQualifiedNameFor(String simpleClassName) {
+        return withFullyQualifiedName.contains(simpleClassName);
+    }
+
     public void setMatchersToBeDescribedWithExtraTypeInfo(Integer[] indexesOfMatchers) {
         this.withTypeInfo = Arrays.asList(indexesOfMatchers);
     }
 
+    public void setMatchersToBeDescribedWithFullName(Set<String> indexesOfMatchers) {
+        this.withFullyQualifiedName= indexesOfMatchers;
+    }
+
     public String print(List<ArgumentMatcher> matchers, Invocation invocation) {
         MatchersPrinter matchersPrinter = new MatchersPrinter();
         String qualifiedName =

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

@@ -7,6 +7,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 
 import org.mockito.invocation.Invocation;
 import org.mockito.invocation.MatchableInvocation;
@@ -28,17 +29,21 @@ public SmartPrinter(
         this(
                 wanted,
                 Collections.singletonList(actual),
-                indexesOfMatchersToBeDescribedWithExtraTypeInfo);
+                indexesOfMatchersToBeDescribedWithExtraTypeInfo,
+                Collections.emptySet());
     }
 
     public SmartPrinter(
             MatchableInvocation wanted,
             List<Invocation> allActualInvocations,
-            Integer... indexesOfMatchersToBeDescribedWithExtraTypeInfo) {
+            Integer[] indexesOfMatchersToBeDescribedWithExtraTypeInfo,
+            Set<String> classNamesToBeDescribedWithFullName) {
         PrintSettings printSettings = new PrintSettings();
         printSettings.setMultiline(isMultiLine(wanted, allActualInvocations));
         printSettings.setMatchersToBeDescribedWithExtraTypeInfo(
                 indexesOfMatchersToBeDescribedWithExtraTypeInfo);
+        printSettings.setMatchersToBeDescribedWithFullName(
+                classNamesToBeDescribedWithFullName);
 
         this.wanted = printSettings.print(wanted);
 

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

@@ -4,8 +4,13 @@
  */
 package org.mockito.internal.verification.argumentmatching;
 
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.mockito.ArgumentMatcher;
 import org.mockito.internal.matchers.ContainsExtraTypeInfo;
@@ -48,4 +53,30 @@ 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 Set<String> getNotMatchingArgsWithSameName(
+            List<ArgumentMatcher> matchers, Object[] arguments) {
+        Set<String> repeatedClassNames = new HashSet<>();
+        Map<String, Set<String>> classesHavingSameName = new HashMap<>();
+        for (ArgumentMatcher m : matchers) {
+            if (m instanceof ContainsExtraTypeInfo) {
+                Class wantedClass = ((ContainsExtraTypeInfo) m).getWantedClass();
+                classesHavingSameName.computeIfAbsent(wantedClass.getSimpleName(), className -> new HashSet<>())
+                                     .add(wantedClass.getCanonicalName());
+            }
+        }
+        for (Object argument : arguments) {
+            Class wantedClass = argument.getClass();
+            classesHavingSameName.computeIfAbsent(wantedClass.getSimpleName(), className -> new HashSet<>())
+                                 .add(wantedClass.getCanonicalName());
+        }
+        return classesHavingSameName.entrySet().stream()
+                                    .filter(classEntry -> classEntry.getValue().size() > 1)
+                                    .map(classEntry -> classEntry.getKey())
+                                    .collect(Collectors.toSet());
+    }
+
 }

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

@@ -11,9 +11,11 @@
 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.getNotMatchingArgsWithSameName;
 import static org.mockito.internal.verification.argumentmatching.ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes;
 
 import java.util.List;
+import java.util.Set;
 
 import org.mockito.internal.reporting.SmartPrinter;
 import org.mockito.internal.util.collections.ListUtil;
@@ -41,7 +43,9 @@ public static void checkMissingInvocation(
 
         Integer[] indexesOfSuspiciousArgs =
                 getSuspiciouslyNotMatchingArgsIndexes(wanted.getMatchers(), similar.getArguments());
-        SmartPrinter smartPrinter = new SmartPrinter(wanted, invocations, indexesOfSuspiciousArgs);
+        Set<String> classesWithSameSimpleName =
+            getNotMatchingArgsWithSameName(wanted.getMatchers(), similar.getArguments());
+        SmartPrinter smartPrinter = new SmartPrinter(wanted, invocations, indexesOfSuspiciousArgs,classesWithSameSimpleName);
         List<Location> actualLocations =
                 ListUtil.convert(
                         invocations,

src/test/java/org/mockito/internal/matchers/EqualsTest.java

@@ -28,21 +28,21 @@ public void shouldArraysBeEqual() {
 
     @Test
     public void shouldDescribeWithExtraTypeInfo() throws Exception {
-        String descStr = new Equals(100).toStringWithType();
+        String descStr = new Equals(100).toStringWithType(false);
 
         assertEquals("(Integer) 100", descStr);
     }
 
     @Test
     public void shouldDescribeWithExtraTypeInfoOfLong() throws Exception {
-        String descStr = new Equals(100L).toStringWithType();
+        String descStr = new Equals(100L).toStringWithType(false);
 
         assertEquals("(Long) 100L", descStr);
     }
 
     @Test
     public void shouldDescribeWithTypeOfString() throws Exception {
-        String descStr = new Equals("x").toStringWithType();
+        String descStr = new Equals("x").toStringWithType(false);
 
         assertEquals("(String) \"x\"", descStr);
     }

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

@@ -111,14 +111,20 @@ public boolean matches(String item) {
             }
 
             @Override
-            public String toStringWithType() {
+            public String toStringWithType(boolean useFullyQualifiedClassName) {
                 return "";
             }
 
             @Override
             public boolean typeMatches(Object target) {
                 return true;
             }
+
+            @Override
+            public Class getWantedClass() {
+                return String.class;
+            }
+
         }
 
         // given