From d544cfc3f2944153fde4fb8e8cfcc2f2bad7596a Mon Sep 17 00:00:00 2001 From: thisisdexter Date: Wed, 9 Jun 2021 08:37:09 +0530 Subject: [PATCH 1/4] Fixes mockito#2311 Prints fully qualified class name when the simple names of arguments match. --- .../matchers/ContainsExtraTypeInfo.java | 11 +++++++++ .../org/mockito/internal/matchers/Equals.java | 10 ++++++++ .../matchers/text/MatchersPrinter.java | 2 ++ .../internal/reporting/PrintSettings.java | 9 +++++++ .../internal/reporting/SmartPrinter.java | 8 +++++-- .../ArgumentMatchingTool.java | 24 +++++++++++++++++++ .../checkers/MissingInvocationChecker.java | 5 +++- .../ArgumentMatchingToolTest.java | 11 +++++++++ 8 files changed, 77 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java b/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java index 3b69fbcf9c..557b1cfcc0 100644 --- a/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java +++ b/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); } diff --git a/src/main/java/org/mockito/internal/matchers/Equals.java b/src/main/java/org/mockito/internal/matchers/Equals.java index d04131d414..219f3c91e3 100644 --- a/src/main/java/org/mockito/internal/matchers/Equals.java +++ b/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()); + } } diff --git a/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java b/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java index 589b072edb..5a77ac4483 100644 --- a/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java +++ b/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java @@ -32,6 +32,8 @@ private Iterator 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))); } diff --git a/src/main/java/org/mockito/internal/reporting/PrintSettings.java b/src/main/java/org/mockito/internal/reporting/PrintSettings.java index 2869ed316c..5044a35590 100644 --- a/src/main/java/org/mockito/internal/reporting/PrintSettings.java +++ b/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 withTypeInfo = new LinkedList<>(); + private List 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 matchers, Invocation invocation) { MatchersPrinter matchersPrinter = new MatchersPrinter(); String qualifiedName = diff --git a/src/main/java/org/mockito/internal/reporting/SmartPrinter.java b/src/main/java/org/mockito/internal/reporting/SmartPrinter.java index 71a7c369a4..6efdb11577 100644 --- a/src/main/java/org/mockito/internal/reporting/SmartPrinter.java +++ b/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 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); diff --git a/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java b/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java index f13d980659..86e6b56241 100644 --- a/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java +++ b/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 matchers, Object[] arguments) { + if (matchers.size() != arguments.length) { + return new Integer[0]; + } + + List 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]); + } + } diff --git a/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java b/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java index e34555621d..c8452aad4d 100644 --- a/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java +++ b/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 actualLocations = ListUtil.convert( invocations, diff --git a/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java b/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java index d54c7f4cbc..6947b1b576 100644 --- a/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java +++ b/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 From 446c5fedde17e261392502531f6c0b976c20a51f Mon Sep 17 00:00:00 2001 From: thisisdexter Date: Sun, 13 Jun 2021 12:12:22 +0530 Subject: [PATCH 2/4] Fixes mockito#2311 Made changes to Equals.toStringWithType by reusing same method to achieve both cases by sending a boolean as an input, based on which either simple name or fully qualified name will be used for describing the type. Also in the method ArgumentMatchingTool.getNotMatchingArgsWithSameName return Set which return the simple names of classes having more than one classes with different FQCN. --- .../matchers/ContainsExtraTypeInfo.java | 18 ++++----- .../org/mockito/internal/matchers/Equals.java | 14 +++---- .../matchers/text/MatchersPrinter.java | 7 ++-- .../internal/reporting/PrintSettings.java | 12 +++--- .../internal/reporting/SmartPrinter.java | 7 ++-- .../ArgumentMatchingTool.java | 37 +++++++++++-------- .../checkers/MissingInvocationChecker.java | 9 +++-- .../mockito/internal/matchers/EqualsTest.java | 6 +-- .../ArgumentMatchingToolTest.java | 11 ++---- 9 files changed, 60 insertions(+), 61 deletions(-) diff --git a/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java b/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java index 557b1cfcc0..4c9edcbf9d 100644 --- a/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java +++ b/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java @@ -9,29 +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(); - - /** - * Returns more verbose description of the object which include type information and fully qualified class name - */ - String toStringWithFullName(); + 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); /** - * Checks if target target's class has same simple name. - * If the simple names matches, we need to use {@link #toStringWithFullName()} + * + * @return Returns the Class of the argument */ - boolean sameName(Object target); + Class getWantedClass(); } diff --git a/src/main/java/org/mockito/internal/matchers/Equals.java b/src/main/java/org/mockito/internal/matchers/Equals.java index 219f3c91e3..7f825f8eb8 100644 --- a/src/main/java/org/mockito/internal/matchers/Equals.java +++ b/src/main/java/org/mockito/internal/matchers/Equals.java @@ -51,13 +51,8 @@ public int hashCode() { } @Override - public String toStringWithType() { - return "(" + wanted.getClass().getSimpleName() + ") " + describe(wanted); - } - - @Override - public String toStringWithFullName() { - return "(" + wanted.getClass().getCanonicalName() + ") " + describe(wanted); + public String toStringWithType(boolean useFullyQualifiedClassName) { + return "(" + (useFullyQualifiedClassName ? wanted.getClass().getCanonicalName() : wanted.getClass().getSimpleName()) + ") " + describe(wanted); } @Override @@ -66,7 +61,8 @@ public boolean typeMatches(Object target) { } @Override - public boolean sameName(Object target) { - return wanted != null && target != null && target.getClass().getSimpleName().equals(wanted.getClass().getSimpleName()); + public Class getWantedClass() { + return wanted.getClass(); } + } diff --git a/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java b/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java index 5a77ac4483..cb60fa8000 100644 --- a/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java +++ b/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java @@ -31,9 +31,10 @@ private Iterator applyPrintSettings( int i = 0; 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())); + 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))); } diff --git a/src/main/java/org/mockito/internal/reporting/PrintSettings.java b/src/main/java/org/mockito/internal/reporting/PrintSettings.java index 5044a35590..86ae3a1e5d 100644 --- a/src/main/java/org/mockito/internal/reporting/PrintSettings.java +++ b/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,7 +21,7 @@ public class PrintSettings { public static final int MAX_LINE_LENGTH = 45; private boolean multiline; private List withTypeInfo = new LinkedList<>(); - private List withFullyQualifiedName = new LinkedList<>(); + private Set withFullyQualifiedName = Collections.emptySet(); public void setMultiline(boolean multiline) { this.multiline = multiline; @@ -39,16 +41,16 @@ public boolean extraTypeInfoFor(int argumentIndex) { return withTypeInfo.contains(argumentIndex); } - public boolean fullyQualifiedNameFor(int argumentIndex) { - return withFullyQualifiedName.contains(argumentIndex); + public boolean fullyQualifiedNameFor(String simpleClassName) { + return withFullyQualifiedName.contains(simpleClassName); } public void setMatchersToBeDescribedWithExtraTypeInfo(Integer[] indexesOfMatchers) { this.withTypeInfo = Arrays.asList(indexesOfMatchers); } - public void setMatchersToBeDescribedWithFullName(Integer[] indexesOfMatchers) { - this.withFullyQualifiedName= Arrays.asList(indexesOfMatchers); + public void setMatchersToBeDescribedWithFullName(Set indexesOfMatchers) { + this.withFullyQualifiedName= indexesOfMatchers; } public String print(List matchers, Invocation invocation) { diff --git a/src/main/java/org/mockito/internal/reporting/SmartPrinter.java b/src/main/java/org/mockito/internal/reporting/SmartPrinter.java index 6efdb11577..135d5447d1 100644 --- a/src/main/java/org/mockito/internal/reporting/SmartPrinter.java +++ b/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; @@ -29,20 +30,20 @@ public SmartPrinter( wanted, Collections.singletonList(actual), indexesOfMatchersToBeDescribedWithExtraTypeInfo, - new Integer[0]); + Collections.emptySet()); } public SmartPrinter( MatchableInvocation wanted, List allActualInvocations, Integer[] indexesOfMatchersToBeDescribedWithExtraTypeInfo, - Integer[] indexesOfMatchersToBeDescribedWithFullName) { + Set classNamesToBeDescribedWithFullName) { PrintSettings printSettings = new PrintSettings(); printSettings.setMultiline(isMultiLine(wanted, allActualInvocations)); printSettings.setMatchersToBeDescribedWithExtraTypeInfo( indexesOfMatchersToBeDescribedWithExtraTypeInfo); printSettings.setMatchersToBeDescribedWithFullName( - indexesOfMatchersToBeDescribedWithFullName); + classNamesToBeDescribedWithFullName); this.wanted = printSettings.print(wanted); diff --git a/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java b/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java index 86e6b56241..4ba7cbb745 100644 --- a/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java +++ b/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; @@ -52,24 +57,26 @@ private static boolean toStringEquals(ArgumentMatcher m, Object arg) { /** * Suspiciously not matching arguments are those that don't match, and the classes have same simple name. */ - public static Integer[] getNotMatchingArgsWithSameNameIndexes( - List matchers, Object[] arguments) { - if (matchers.size() != arguments.length) { - return new Integer[0]; - } - - List suspicious = new LinkedList<>(); - int i = 0; + public static Set getNotMatchingArgsWithSameName( + List matchers, Object[] arguments) { + Set repeatedClassNames = new HashSet<>(); + Map> classesHavingSameName = new HashMap<>(); 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); + if (m instanceof ContainsExtraTypeInfo) { + Class wantedClass = ((ContainsExtraTypeInfo) m).getWantedClass(); + classesHavingSameName.computeIfAbsent(wantedClass.getSimpleName(), className -> new HashSet<>()) + .add(wantedClass.getCanonicalName()); } - i++; } - return suspicious.toArray(new Integer[0]); + 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()); } } diff --git a/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java b/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java index c8452aad4d..cda2c58950 100644 --- a/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java +++ b/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java @@ -11,10 +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.getNotMatchingArgsWithSameNameIndexes; +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; @@ -42,9 +43,9 @@ public static void checkMissingInvocation( Integer[] indexesOfSuspiciousArgs = getSuspiciouslyNotMatchingArgsIndexes(wanted.getMatchers(), similar.getArguments()); - Integer[] indexesOfArgsWithSameSimpleName = - getNotMatchingArgsWithSameNameIndexes(wanted.getMatchers(), similar.getArguments()); - SmartPrinter smartPrinter = new SmartPrinter(wanted, invocations, indexesOfSuspiciousArgs,indexesOfArgsWithSameSimpleName); + Set classesWithSameSimpleName = + getNotMatchingArgsWithSameName(wanted.getMatchers(), similar.getArguments()); + SmartPrinter smartPrinter = new SmartPrinter(wanted, invocations, indexesOfSuspiciousArgs,classesWithSameSimpleName); List actualLocations = ListUtil.convert( invocations, diff --git a/src/test/java/org/mockito/internal/matchers/EqualsTest.java b/src/test/java/org/mockito/internal/matchers/EqualsTest.java index 26f87c2dbc..0a7be5afdd 100644 --- a/src/test/java/org/mockito/internal/matchers/EqualsTest.java +++ b/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); } diff --git a/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java b/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java index 6947b1b576..039e562a8c 100644 --- a/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java +++ b/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java @@ -111,12 +111,7 @@ public boolean matches(String item) { } @Override - public String toStringWithType() { - return ""; - } - - @Override - public String toStringWithFullName() { + public String toStringWithType(boolean useFullyQualifiedClassName) { return ""; } @@ -126,8 +121,8 @@ public boolean typeMatches(Object target) { } @Override - public boolean sameName(Object target) { - return true; + public Class getWantedClass() { + return String.class; } } From 265e99593a1de621f62a7e29907b5e8e4b2db7ff Mon Sep 17 00:00:00 2001 From: thisisdexter Date: Sat, 26 Jun 2021 11:24:49 +0530 Subject: [PATCH 3/4] Have refactored the changes in MatchersPrinter. In Equals have passed qualified class name instead of the boolean. Also removed getWantedClass and instead made getWanted public and used it. Have also added 3 test cases for cases where some arguments have same simple class name. --- .../matchers/ContainsExtraTypeInfo.java | 10 +- .../org/mockito/internal/matchers/Equals.java | 12 +- .../matchers/text/MatchersPrinter.java | 17 ++- .../ArgumentMatchingTool.java | 2 +- .../mockito/internal/matchers/EqualsTest.java | 6 +- .../ArgumentMatchingToolTest.java | 6 +- src/test/java/org/mockitousage/IMethods.java | 50 ++++++++ .../java/org/mockitousage/MethodsImpl.java | 25 ++++ ...tiveMessagesWhenVerificationFailsTest.java | 114 ++++++++++++++++++ 9 files changed, 217 insertions(+), 25 deletions(-) diff --git a/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java b/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java index 4c9edcbf9d..c853bce840 100644 --- a/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java +++ b/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java @@ -14,20 +14,20 @@ public interface ContainsExtraTypeInfo { /** - * @param useFullyQualifiedClassName - uses fully qualified class name if true else simple class name + * @param className - name of the class to be printed in description * Returns more verbose description of the object which include type information */ - String toStringWithType(boolean useFullyQualifiedClassName); + String toStringWithType(String className); /** * Checks if target target has matching type. - * If the type matches, there is no point in rendering result from {@link #toStringWithType(boolean)} + * If the type matches, there is no point in rendering result from {@link #toStringWithType(String)} */ boolean typeMatches(Object target); /** * - * @return Returns the Class of the argument + * @return Returns the wanted argument */ - Class getWantedClass(); + Object getWanted(); } diff --git a/src/main/java/org/mockito/internal/matchers/Equals.java b/src/main/java/org/mockito/internal/matchers/Equals.java index 7f825f8eb8..0af522bd86 100644 --- a/src/main/java/org/mockito/internal/matchers/Equals.java +++ b/src/main/java/org/mockito/internal/matchers/Equals.java @@ -31,7 +31,8 @@ private String describe(Object object) { return ValuePrinter.print(object); } - protected final Object getWanted() { + @Override + public final Object getWanted() { return wanted; } @@ -51,8 +52,8 @@ public int hashCode() { } @Override - public String toStringWithType(boolean useFullyQualifiedClassName) { - return "(" + (useFullyQualifiedClassName ? wanted.getClass().getCanonicalName() : wanted.getClass().getSimpleName()) + ") " + describe(wanted); + public String toStringWithType(String className) { + return "(" + className + ") " + describe(wanted); } @Override @@ -60,9 +61,4 @@ public boolean typeMatches(Object target) { return wanted != null && target != null && target.getClass() == wanted.getClass(); } - @Override - public Class getWantedClass() { - return wanted.getClass(); - } - } diff --git a/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java b/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java index cb60fa8000..36a1f0d218 100644 --- a/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java +++ b/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java @@ -30,11 +30,18 @@ private Iterator applyPrintSettings( List out = new LinkedList<>(); int i = 0; for (final ArgumentMatcher matcher : matchers) { - if (matcher instanceof ContainsExtraTypeInfo && printSettings.extraTypeInfoFor(i)) { - 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))); + if (matcher instanceof ContainsExtraTypeInfo) { + ContainsExtraTypeInfo typeInfoMatcher = (ContainsExtraTypeInfo) matcher; + Class wantedClass = typeInfoMatcher.getWanted().getClass(); + String simpleNameOfArgument = wantedClass.getSimpleName(); + + if (printSettings.extraTypeInfoFor(i)) { + out.add(new FormattedText(typeInfoMatcher.toStringWithType(wantedClass.getSimpleName()))); + } else if (printSettings.fullyQualifiedNameFor(simpleNameOfArgument)) { + out.add(new FormattedText(typeInfoMatcher.toStringWithType(wantedClass.getCanonicalName()))); + } else { + out.add(new FormattedText(MatcherToString.toString(matcher))); + } } else { out.add(new FormattedText(MatcherToString.toString(matcher))); } diff --git a/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java b/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java index 4ba7cbb745..928bf9ebc2 100644 --- a/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java +++ b/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java @@ -63,7 +63,7 @@ public static Set getNotMatchingArgsWithSameName( Map> classesHavingSameName = new HashMap<>(); for (ArgumentMatcher m : matchers) { if (m instanceof ContainsExtraTypeInfo) { - Class wantedClass = ((ContainsExtraTypeInfo) m).getWantedClass(); + Class wantedClass = ((ContainsExtraTypeInfo) m).getWanted().getClass(); classesHavingSameName.computeIfAbsent(wantedClass.getSimpleName(), className -> new HashSet<>()) .add(wantedClass.getCanonicalName()); } diff --git a/src/test/java/org/mockito/internal/matchers/EqualsTest.java b/src/test/java/org/mockito/internal/matchers/EqualsTest.java index 0a7be5afdd..ba5c578b57 100644 --- a/src/test/java/org/mockito/internal/matchers/EqualsTest.java +++ b/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(false); + String descStr = new Equals(100).toStringWithType(Integer.class.getSimpleName()); assertEquals("(Integer) 100", descStr); } @Test public void shouldDescribeWithExtraTypeInfoOfLong() throws Exception { - String descStr = new Equals(100L).toStringWithType(false); + String descStr = new Equals(100L).toStringWithType(Long.class.getSimpleName()); assertEquals("(Long) 100L", descStr); } @Test public void shouldDescribeWithTypeOfString() throws Exception { - String descStr = new Equals("x").toStringWithType(false); + String descStr = new Equals("x").toStringWithType(String.class.getSimpleName()); assertEquals("(String) \"x\"", descStr); } diff --git a/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java b/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java index 039e562a8c..7a720ddc2d 100644 --- a/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java +++ b/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java @@ -111,7 +111,7 @@ public boolean matches(String item) { } @Override - public String toStringWithType(boolean useFullyQualifiedClassName) { + public String toStringWithType(String className) { return ""; } @@ -121,8 +121,8 @@ public boolean typeMatches(Object target) { } @Override - public Class getWantedClass() { - return String.class; + public Object getWanted() { + return ""; } } diff --git a/src/test/java/org/mockitousage/IMethods.java b/src/test/java/org/mockitousage/IMethods.java index 5a12b47ba9..3f0b9ec6d7 100644 --- a/src/test/java/org/mockitousage/IMethods.java +++ b/src/test/java/org/mockitousage/IMethods.java @@ -238,4 +238,54 @@ String simpleMethod( String forObject(Object object); String genericToString(T arg); + + void overloadedMethodWithSameClassNameArguments(java.sql.Date javaDate, Date date); + + void overloadedMethodWithSameClassNameArguments(Date date, java.sql.Date javaDate); + + void overloadedMethodWithDifferentClassNameArguments(String String, Integer i); + + void overloadedMethodWithDifferentClassNameArguments(Integer i, String string); + + void overloadedMethodWithSameClassNameArguments(java.sql.Date javaDate, String string, Date date); + + void overloadedMethodWithSameClassNameArguments(Date date, String string, java.sql.Date javaDate); + + /** + * Using this class to test cases where two classes have same simple name + */ + public static class Date { + + private int value; + + public Date(int value) { + this.value = value; + } + + @Override + public String toString() { + return String.valueOf(value); + } + + @Override + public boolean equals(Object o) { + if (this == o){ + return true; + } + if (o == null || getClass() != o.getClass()){ + return false; + } + Date date = (Date) o; + return value == date.value; + } + + @Override + public int hashCode() { + return Objects.hash(value); + } + + } + + } + diff --git a/src/test/java/org/mockitousage/MethodsImpl.java b/src/test/java/org/mockitousage/MethodsImpl.java index eafb91b093..51c4dca8fd 100644 --- a/src/test/java/org/mockitousage/MethodsImpl.java +++ b/src/test/java/org/mockitousage/MethodsImpl.java @@ -448,4 +448,29 @@ public Void voidReturningMethod() { public String genericToString(T arg) { return null; } + + @Override + public void overloadedMethodWithSameClassNameArguments(java.sql.Date javaDate, Date date) { + } + + @Override + public void overloadedMethodWithSameClassNameArguments(Date date, java.sql.Date javaDate) { + } + + @Override + public void overloadedMethodWithDifferentClassNameArguments(String string, Integer i) { + } + + @Override + public void overloadedMethodWithDifferentClassNameArguments(Integer i, String string) { + } + + @Override + public void overloadedMethodWithSameClassNameArguments(java.sql.Date javaDate, String string, Date date) { + } + + @Override + public void overloadedMethodWithSameClassNameArguments(Date date, String string, java.sql.Date javaDate) { + } + } diff --git a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java index f0350f93cf..ac26fdb75e 100644 --- a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java +++ b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java @@ -9,6 +9,8 @@ import static org.mockito.AdditionalMatchers.aryEq; import static org.mockito.Mockito.*; +import java.sql.Date; + import org.junit.Before; import org.junit.Ignore; import org.junit.Test; @@ -386,6 +388,118 @@ public void should_never_break_method_string_when_no_args_in_method() throws Exc } } + @Test + public void should_print_fully_qualified_name_when_arguments_classes_have_same_simple_name() { + try { + mock.overloadedMethodWithSameClassNameArguments(new Date(0), new IMethods.Date(0)); + verify(mock).overloadedMethodWithSameClassNameArguments(new IMethods.Date(0), new Date(0)); + fail(); + } catch (Throwable e) { + String wanted = + "\n" + + "Argument(s) are different! Wanted:" + + "\n" + + "iMethods.overloadedMethodWithSameClassNameArguments(" + + "\n" + + " (org.mockitousage.IMethods.Date) 0," + + "\n" + + " (java.sql.Date) 1970-01-01" + + "\n" + + ");"; + + assertThat(e).hasMessageContaining(wanted); + + String actual = + "\n" + + "Actual invocations have different arguments:" + + "\n" + + "iMethods.overloadedMethodWithSameClassNameArguments(" + + "\n" + + " (java.sql.Date) 1970-01-01," + + "\n" + + " (org.mockitousage.IMethods.Date) 0" + + "\n" + + ");"; + assertThat(e).hasMessageContaining(actual); + } + } + + @Test + public void should_not_print_fully_qualified_name_when_arguments_classes_have_different_simple_name() { + try { + mock.overloadedMethodWithDifferentClassNameArguments("string", 0); + verify(mock).overloadedMethodWithDifferentClassNameArguments(0, "string"); + fail(); + } catch (Throwable e) { + String wanted = + "\n" + + "Argument(s) are different! Wanted:" + + "\n" + + "iMethods.overloadedMethodWithDifferentClassNameArguments(" + + "\n" + + " 0," + + "\n" + + " \"string\"" + + "\n" + + ");"; + + assertThat(e).hasMessageContaining(wanted); + + String actual = + "\n" + + "Actual invocations have different arguments:" + + "\n" + + "iMethods.overloadedMethodWithDifferentClassNameArguments(" + + "\n" + + " \"string\"," + + "\n" + + " 0" + + "\n" + + ");"; + assertThat(e).hasMessageContaining(actual); + } + } + + @Test + public void should_print_fully_qualified_name_when_some_arguments_classes_have_same_simple_name() { + try { + mock.overloadedMethodWithSameClassNameArguments(new Date(0), "string", new IMethods.Date(0)); + verify(mock).overloadedMethodWithSameClassNameArguments(new IMethods.Date(0), "string", new Date(0)); + fail(); + } catch (Throwable e) { + String wanted = + "\n" + + "Argument(s) are different! Wanted:" + + "\n" + + "iMethods.overloadedMethodWithSameClassNameArguments(" + + "\n" + + " (org.mockitousage.IMethods.Date) 0," + + "\n" + + " \"string\"," + + "\n" + + " (java.sql.Date) 1970-01-01" + + "\n" + + ");"; + + assertThat(e).hasMessageContaining(wanted); + + String actual = + "\n" + + "Actual invocations have different arguments:" + + "\n" + + "iMethods.overloadedMethodWithSameClassNameArguments(" + + "\n" + + " (java.sql.Date) 1970-01-01," + + "\n" + + " \"string\"," + + "\n" + + " (org.mockitousage.IMethods.Date) 0" + + "\n" + + ");"; + assertThat(e).hasMessageContaining(actual); + } + } + @Test @Ignore("issue 380 related") public void should_print_method_name_and_arguments_of_other_interactions_of_same_method() From a84e17794534e69909612692dc0edc3804b512c4 Mon Sep 17 00:00:00 2001 From: thisisdexter Date: Sat, 26 Jun 2021 18:28:07 +0530 Subject: [PATCH 4/4] Fixes mockito#2311 Fixed the style issues, by running gradlew :spotlessApply Also needed to handle the case where argument is null, which gave null pointer while getting class name from the object. --- .../matchers/ContainsExtraTypeInfo.java | 2 +- .../org/mockito/internal/matchers/Equals.java | 1 - .../matchers/text/MatchersPrinter.java | 17 ++- .../internal/reporting/PrintSettings.java | 2 +- .../internal/reporting/SmartPrinter.java | 3 +- .../ArgumentMatchingTool.java | 27 ++-- .../checkers/MissingInvocationChecker.java | 6 +- .../ArgumentMatchingToolTest.java | 1 - src/test/java/org/mockitousage/IMethods.java | 14 +- .../java/org/mockitousage/MethodsImpl.java | 21 +-- ...tiveMessagesWhenVerificationFailsTest.java | 144 +++++++++--------- 11 files changed, 125 insertions(+), 113 deletions(-) diff --git a/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java b/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java index c853bce840..8c698fdccf 100644 --- a/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java +++ b/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java @@ -9,7 +9,7 @@ * 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(boolean)} method. + * we will try to use the {@link #toStringWithType(String)} method. */ public interface ContainsExtraTypeInfo { diff --git a/src/main/java/org/mockito/internal/matchers/Equals.java b/src/main/java/org/mockito/internal/matchers/Equals.java index 0af522bd86..8b07b2da75 100644 --- a/src/main/java/org/mockito/internal/matchers/Equals.java +++ b/src/main/java/org/mockito/internal/matchers/Equals.java @@ -60,5 +60,4 @@ public String toStringWithType(String className) { public boolean typeMatches(Object target) { return wanted != null && target != null && target.getClass() == wanted.getClass(); } - } diff --git a/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java b/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java index 36a1f0d218..9ceab39755 100644 --- a/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java +++ b/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java @@ -32,14 +32,21 @@ private Iterator applyPrintSettings( for (final ArgumentMatcher matcher : matchers) { if (matcher instanceof ContainsExtraTypeInfo) { ContainsExtraTypeInfo typeInfoMatcher = (ContainsExtraTypeInfo) matcher; - Class wantedClass = typeInfoMatcher.getWanted().getClass(); - String simpleNameOfArgument = wantedClass.getSimpleName(); + Object wanted = typeInfoMatcher.getWanted(); + String simpleNameOfArgument = + wanted != null ? wanted.getClass().getSimpleName() : ""; + String fullyQualifiedClassName = + wanted != null ? wanted.getClass().getCanonicalName() : ""; if (printSettings.extraTypeInfoFor(i)) { - out.add(new FormattedText(typeInfoMatcher.toStringWithType(wantedClass.getSimpleName()))); + out.add( + new FormattedText( + typeInfoMatcher.toStringWithType(simpleNameOfArgument))); } else if (printSettings.fullyQualifiedNameFor(simpleNameOfArgument)) { - out.add(new FormattedText(typeInfoMatcher.toStringWithType(wantedClass.getCanonicalName()))); - } else { + out.add( + new FormattedText( + typeInfoMatcher.toStringWithType(fullyQualifiedClassName))); + } else { out.add(new FormattedText(MatcherToString.toString(matcher))); } } else { diff --git a/src/main/java/org/mockito/internal/reporting/PrintSettings.java b/src/main/java/org/mockito/internal/reporting/PrintSettings.java index 86ae3a1e5d..41794adcb0 100644 --- a/src/main/java/org/mockito/internal/reporting/PrintSettings.java +++ b/src/main/java/org/mockito/internal/reporting/PrintSettings.java @@ -50,7 +50,7 @@ public void setMatchersToBeDescribedWithExtraTypeInfo(Integer[] indexesOfMatcher } public void setMatchersToBeDescribedWithFullName(Set indexesOfMatchers) { - this.withFullyQualifiedName= indexesOfMatchers; + this.withFullyQualifiedName = indexesOfMatchers; } public String print(List matchers, Invocation invocation) { diff --git a/src/main/java/org/mockito/internal/reporting/SmartPrinter.java b/src/main/java/org/mockito/internal/reporting/SmartPrinter.java index 135d5447d1..f4b1f71d40 100644 --- a/src/main/java/org/mockito/internal/reporting/SmartPrinter.java +++ b/src/main/java/org/mockito/internal/reporting/SmartPrinter.java @@ -42,8 +42,7 @@ public SmartPrinter( printSettings.setMultiline(isMultiLine(wanted, allActualInvocations)); printSettings.setMatchersToBeDescribedWithExtraTypeInfo( indexesOfMatchersToBeDescribedWithExtraTypeInfo); - printSettings.setMatchersToBeDescribedWithFullName( - classNamesToBeDescribedWithFullName); + printSettings.setMatchersToBeDescribedWithFullName(classNamesToBeDescribedWithFullName); this.wanted = printSettings.print(wanted); diff --git a/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java b/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java index 928bf9ebc2..060ea0913e 100644 --- a/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java +++ b/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java @@ -59,24 +59,31 @@ private static boolean toStringEquals(ArgumentMatcher m, Object arg) { */ public static Set getNotMatchingArgsWithSameName( List matchers, Object[] arguments) { - Set repeatedClassNames = new HashSet<>(); Map> classesHavingSameName = new HashMap<>(); for (ArgumentMatcher m : matchers) { if (m instanceof ContainsExtraTypeInfo) { - Class wantedClass = ((ContainsExtraTypeInfo) m).getWanted().getClass(); - classesHavingSameName.computeIfAbsent(wantedClass.getSimpleName(), className -> new HashSet<>()) - .add(wantedClass.getCanonicalName()); + Object wanted = ((ContainsExtraTypeInfo) m).getWanted(); + if (wanted == null) { + continue; + } + Class wantedClass = wanted.getClass(); + classesHavingSameName + .computeIfAbsent(wantedClass.getSimpleName(), className -> new HashSet<>()) + .add(wantedClass.getCanonicalName()); } } for (Object argument : arguments) { + if (argument == null) { + continue; + } Class wantedClass = argument.getClass(); - classesHavingSameName.computeIfAbsent(wantedClass.getSimpleName(), className -> new HashSet<>()) - .add(wantedClass.getCanonicalName()); + 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()); + .filter(classEntry -> classEntry.getValue().size() > 1) + .map(classEntry -> classEntry.getKey()) + .collect(Collectors.toSet()); } - } diff --git a/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java b/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java index cda2c58950..aeb86b962d 100644 --- a/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java +++ b/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java @@ -44,8 +44,10 @@ public static void checkMissingInvocation( Integer[] indexesOfSuspiciousArgs = getSuspiciouslyNotMatchingArgsIndexes(wanted.getMatchers(), similar.getArguments()); Set classesWithSameSimpleName = - getNotMatchingArgsWithSameName(wanted.getMatchers(), similar.getArguments()); - SmartPrinter smartPrinter = new SmartPrinter(wanted, invocations, indexesOfSuspiciousArgs,classesWithSameSimpleName); + getNotMatchingArgsWithSameName(wanted.getMatchers(), similar.getArguments()); + SmartPrinter smartPrinter = + new SmartPrinter( + wanted, invocations, indexesOfSuspiciousArgs, classesWithSameSimpleName); List actualLocations = ListUtil.convert( invocations, diff --git a/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java b/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java index 7a720ddc2d..5f55faf3b2 100644 --- a/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java +++ b/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java @@ -124,7 +124,6 @@ public boolean typeMatches(Object target) { public Object getWanted() { return ""; } - } // given diff --git a/src/test/java/org/mockitousage/IMethods.java b/src/test/java/org/mockitousage/IMethods.java index 3f0b9ec6d7..12897422da 100644 --- a/src/test/java/org/mockitousage/IMethods.java +++ b/src/test/java/org/mockitousage/IMethods.java @@ -247,9 +247,11 @@ String simpleMethod( void overloadedMethodWithDifferentClassNameArguments(Integer i, String string); - void overloadedMethodWithSameClassNameArguments(java.sql.Date javaDate, String string, Date date); + void overloadedMethodWithSameClassNameArguments( + java.sql.Date javaDate, String string, Date date); - void overloadedMethodWithSameClassNameArguments(Date date, String string, java.sql.Date javaDate); + void overloadedMethodWithSameClassNameArguments( + Date date, String string, java.sql.Date javaDate); /** * Using this class to test cases where two classes have same simple name @@ -269,10 +271,10 @@ public String toString() { @Override public boolean equals(Object o) { - if (this == o){ + if (this == o) { return true; } - if (o == null || getClass() != o.getClass()){ + if (o == null || getClass() != o.getClass()) { return false; } Date date = (Date) o; @@ -283,9 +285,5 @@ public boolean equals(Object o) { public int hashCode() { return Objects.hash(value); } - } - - } - diff --git a/src/test/java/org/mockitousage/MethodsImpl.java b/src/test/java/org/mockitousage/MethodsImpl.java index 51c4dca8fd..bb69656712 100644 --- a/src/test/java/org/mockitousage/MethodsImpl.java +++ b/src/test/java/org/mockitousage/MethodsImpl.java @@ -450,27 +450,22 @@ public String genericToString(T arg) { } @Override - public void overloadedMethodWithSameClassNameArguments(java.sql.Date javaDate, Date date) { - } + public void overloadedMethodWithSameClassNameArguments(java.sql.Date javaDate, Date date) {} @Override - public void overloadedMethodWithSameClassNameArguments(Date date, java.sql.Date javaDate) { - } + public void overloadedMethodWithSameClassNameArguments(Date date, java.sql.Date javaDate) {} @Override - public void overloadedMethodWithDifferentClassNameArguments(String string, Integer i) { - } + public void overloadedMethodWithDifferentClassNameArguments(String string, Integer i) {} @Override - public void overloadedMethodWithDifferentClassNameArguments(Integer i, String string) { - } + public void overloadedMethodWithDifferentClassNameArguments(Integer i, String string) {} @Override - public void overloadedMethodWithSameClassNameArguments(java.sql.Date javaDate, String string, Date date) { - } + public void overloadedMethodWithSameClassNameArguments( + java.sql.Date javaDate, String string, Date date) {} @Override - public void overloadedMethodWithSameClassNameArguments(Date date, String string, java.sql.Date javaDate) { - } - + public void overloadedMethodWithSameClassNameArguments( + Date date, String string, java.sql.Date javaDate) {} } diff --git a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java index ac26fdb75e..94f660284c 100644 --- a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java +++ b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java @@ -392,110 +392,116 @@ public void should_never_break_method_string_when_no_args_in_method() throws Exc public void should_print_fully_qualified_name_when_arguments_classes_have_same_simple_name() { try { mock.overloadedMethodWithSameClassNameArguments(new Date(0), new IMethods.Date(0)); - verify(mock).overloadedMethodWithSameClassNameArguments(new IMethods.Date(0), new Date(0)); + verify(mock) + .overloadedMethodWithSameClassNameArguments(new IMethods.Date(0), new Date(0)); fail(); } catch (Throwable e) { String wanted = - "\n" - + "Argument(s) are different! Wanted:" - + "\n" - + "iMethods.overloadedMethodWithSameClassNameArguments(" - + "\n" - + " (org.mockitousage.IMethods.Date) 0," - + "\n" - + " (java.sql.Date) 1970-01-01" - + "\n" - + ");"; + "\n" + + "Argument(s) are different! Wanted:" + + "\n" + + "iMethods.overloadedMethodWithSameClassNameArguments(" + + "\n" + + " (org.mockitousage.IMethods.Date) 0," + + "\n" + + " (java.sql.Date) 1970-01-01" + + "\n" + + ");"; assertThat(e).hasMessageContaining(wanted); String actual = - "\n" - + "Actual invocations have different arguments:" - + "\n" - + "iMethods.overloadedMethodWithSameClassNameArguments(" - + "\n" - + " (java.sql.Date) 1970-01-01," - + "\n" - + " (org.mockitousage.IMethods.Date) 0" - + "\n" - + ");"; + "\n" + + "Actual invocations have different arguments:" + + "\n" + + "iMethods.overloadedMethodWithSameClassNameArguments(" + + "\n" + + " (java.sql.Date) 1970-01-01," + + "\n" + + " (org.mockitousage.IMethods.Date) 0" + + "\n" + + ");"; assertThat(e).hasMessageContaining(actual); } } @Test - public void should_not_print_fully_qualified_name_when_arguments_classes_have_different_simple_name() { + public void + should_not_print_fully_qualified_name_when_arguments_classes_have_different_simple_name() { try { mock.overloadedMethodWithDifferentClassNameArguments("string", 0); verify(mock).overloadedMethodWithDifferentClassNameArguments(0, "string"); fail(); } catch (Throwable e) { String wanted = - "\n" - + "Argument(s) are different! Wanted:" - + "\n" - + "iMethods.overloadedMethodWithDifferentClassNameArguments(" - + "\n" - + " 0," - + "\n" - + " \"string\"" - + "\n" - + ");"; + "\n" + + "Argument(s) are different! Wanted:" + + "\n" + + "iMethods.overloadedMethodWithDifferentClassNameArguments(" + + "\n" + + " 0," + + "\n" + + " \"string\"" + + "\n" + + ");"; assertThat(e).hasMessageContaining(wanted); String actual = - "\n" - + "Actual invocations have different arguments:" - + "\n" - + "iMethods.overloadedMethodWithDifferentClassNameArguments(" - + "\n" - + " \"string\"," - + "\n" - + " 0" - + "\n" - + ");"; + "\n" + + "Actual invocations have different arguments:" + + "\n" + + "iMethods.overloadedMethodWithDifferentClassNameArguments(" + + "\n" + + " \"string\"," + + "\n" + + " 0" + + "\n" + + ");"; assertThat(e).hasMessageContaining(actual); } } @Test - public void should_print_fully_qualified_name_when_some_arguments_classes_have_same_simple_name() { + public void + should_print_fully_qualified_name_when_some_arguments_classes_have_same_simple_name() { try { - mock.overloadedMethodWithSameClassNameArguments(new Date(0), "string", new IMethods.Date(0)); - verify(mock).overloadedMethodWithSameClassNameArguments(new IMethods.Date(0), "string", new Date(0)); + mock.overloadedMethodWithSameClassNameArguments( + new Date(0), "string", new IMethods.Date(0)); + verify(mock) + .overloadedMethodWithSameClassNameArguments( + new IMethods.Date(0), "string", new Date(0)); fail(); } catch (Throwable e) { String wanted = - "\n" - + "Argument(s) are different! Wanted:" - + "\n" - + "iMethods.overloadedMethodWithSameClassNameArguments(" - + "\n" - + " (org.mockitousage.IMethods.Date) 0," - + "\n" - + " \"string\"," - + "\n" - + " (java.sql.Date) 1970-01-01" - + "\n" - + ");"; + "\n" + + "Argument(s) are different! Wanted:" + + "\n" + + "iMethods.overloadedMethodWithSameClassNameArguments(" + + "\n" + + " (org.mockitousage.IMethods.Date) 0," + + "\n" + + " \"string\"," + + "\n" + + " (java.sql.Date) 1970-01-01" + + "\n" + + ");"; assertThat(e).hasMessageContaining(wanted); String actual = - "\n" - + "Actual invocations have different arguments:" - + "\n" - + "iMethods.overloadedMethodWithSameClassNameArguments(" - + "\n" - + " (java.sql.Date) 1970-01-01," - + "\n" - + " \"string\"," - + "\n" - + " (org.mockitousage.IMethods.Date) 0" - + "\n" - + ");"; + "\n" + + "Actual invocations have different arguments:" + + "\n" + + "iMethods.overloadedMethodWithSameClassNameArguments(" + + "\n" + + " (java.sql.Date) 1970-01-01," + + "\n" + + " \"string\"," + + "\n" + + " (org.mockitousage.IMethods.Date) 0" + + "\n" + + ");"; assertThat(e).hasMessageContaining(actual); } }