Merge changes from topic "revert-3499701-revert-3495771-upgrade-mockito-ONHERLZGCH-WJXLGYIWAH" into main
* changes:
mockito: work around re-entrant stubbing of android.os.Process
Revert^2 "Mockito: Suppress errorprone error"
Revert^2 "mockito: Add back removed FieldSetter"
Revert^2 "mockito: remove opentest4j dependency"
Revert^2 "Upgrade mockito to v3.12.4"
diff --git a/Android.bp b/Android.bp
index f26703d..96fc7eb 100644
--- a/Android.bp
+++ b/Android.bp
@@ -64,6 +64,8 @@
// dexmaker instead and including it causes conflicts.
exclude_srcs: [
"src/main/java/org/mockito/internal/creation/bytebuddy/**/*.java",
+ "src/main/java/org/mockito/internal/util/reflection/ModuleMemberAccessor.java",
+ "src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java",
],
},
host: {
@@ -77,10 +79,11 @@
errorprone: {
javacflags: [
- "-Xep:CollectionIncompatibleType:WARN", // b/74213384
+ "-Xep:CollectionIncompatibleType:WARN", // b/74213384
"-Xep:BoxedPrimitiveEquality:WARN",
+ "-Xep:ReturnValueIgnored:WARN",
],
- }
+ },
}
// Compatibility library for Maven artifact naming scheme
diff --git a/METADATA b/METADATA
index d97975c..95980ba 100644
--- a/METADATA
+++ b/METADATA
@@ -1,3 +1,20 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update external/mockito
+# For more info, check https://cs.android.com/android/platform/superproject/main/+/main:tools/external_updater/README.md
+
+name: "mockito"
+description: "Most popular mocking framework for Java"
third_party {
license_type: NOTICE
+ last_upgrade_date {
+ year: 2025
+ month: 2
+ day: 17
+ }
+ identifier {
+ type: "Archive"
+ value: "https://github.com/mockito/mockito/archive/v3.12.4.tar.gz"
+ version: "v3.12.4"
+ primary_source: true
+ }
}
diff --git a/README.version b/README.version
deleted file mode 100644
index 3cce812..0000000
--- a/README.version
+++ /dev/null
@@ -1,13 +0,0 @@
-URL: https://github.com/mockito/mockito
-Version: v2.23.0
-License: Apache 2.0
-Description: Mockito is a mocking framework with a clean and simple API.
-
-For Android, we need to combine Mockito with a MockMaker provided by the
-Dexmaker module.
-
-The source can be updated using the update_source.sh script.
-
-Local Modifications:
- Fixed DefaultMockitoSession constructor. (I14ed7c032a974c3a65caaf091d36d9667ea331b6)
- New API to clean up all inline mocks after test (8bdfbf053ab6e4fc14a3eaecb613f5838fdf0f09)
diff --git a/build.gradle b/build.gradle
index 4ecc4f3..d932bb8 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,63 +1,145 @@
-apply plugin: 'java'
+buildscript {
+ repositories {
+ mavenLocal() //for local testing of mockito-release-tools
+ google()
+ maven { url 'https://plugins.gradle.org/m2/' }
+ }
-configurations {
- // similar to 'default', export compile-time dependencies
- host.extendsFrom(hostCompile)
- target.extendsFrom(targetCompile)
+ dependencies {
+ classpath 'gradle.plugin.nl.javadude.gradle.plugins:license-gradle-plugin:0.14.0'
+ classpath 'net.ltgt.gradle:gradle-errorprone-plugin:2.0.2'
+
+ classpath "io.github.gradle-nexus:publish-plugin:1.1.0"
+ classpath 'org.shipkit:shipkit-changelog:1.1.15'
+ classpath 'org.shipkit:shipkit-auto-version:1.1.19'
+
+ classpath 'com.google.googlejavaformat:google-java-format:1.11.0'
+ classpath 'com.android.tools.build:gradle:4.0.2'
+ classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.21"
+ }
}
-sourceSets {
- host {
- java {
- srcDirs = ['src', 'cglib-and-asm/src']
- }
+plugins {
+ id 'com.diffplug.gradle.spotless' version '4.5.1'
+ id 'eclipse'
+ id 'com.github.ben-manes.versions' version '0.39.0'
+ id 'biz.aQute.bnd.builder' version '5.3.0'
+ id 'ru.vyarus.animalsniffer' version '1.5.2'
+}
+
+description = 'Mockito mock objects library core API and implementation'
+
+apply plugin: 'base'
+archivesBaseName = 'mockito-core'
+
+apply from: 'gradle/shipkit.gradle'
+
+apply from: 'gradle/root/ide.gradle'
+apply from: 'gradle/root/gradle-fix.gradle'
+apply from: 'gradle/java-library.gradle'
+apply from: 'gradle/license.gradle'
+apply from: 'gradle/root/coverage.gradle'
+
+apply from: 'gradle/mockito-core/inline-mock.gradle'
+apply from: 'gradle/mockito-core/osgi.gradle'
+apply from: 'gradle/mockito-core/javadoc.gradle'
+apply from: 'gradle/mockito-core/testing.gradle'
+
+apply from: 'gradle/dependencies.gradle'
+
+allprojects { proj ->
+ repositories {
+ mavenCentral()
+ google()
+ }
+ plugins.withId('java') {
+ proj.apply from: "$rootDir/gradle/errorprone.gradle"
+ }
+ tasks.withType(JavaCompile) {
+ //I don't believe those warnings add value given modern IDEs
+ options.warnings = false
+ options.encoding = 'UTF-8'
+ }
+ tasks.withType(Javadoc) {
+ options.addStringOption('Xdoclint:none', '-quiet')
+ options.addStringOption('encoding', 'UTF-8')
+ options.addStringOption('charSet', 'UTF-8')
+ options.setSource('8')
}
- target {
- java {
- srcDirs = ['src']
- exclude 'org/mockito/internal/creation/cglib/**',
- 'org/mockito/internal/creation/jmock/**',
- 'org/mockito/internal/creation/AbstractMockitoMethodProxy.java',
- 'org/mockito/internal/creation/AcrossJVMSerializationFeature.java',
- 'org/mockito/internal/creation/CglibMockMaker.java',
- 'org/mockito/internal/creation/DelegatingMockitoMethodProxy.java',
- 'org/mockito/internal/creation/MethodInterceptorFilter.java',
- 'org/mockito/internal/creation/MockitoMethodProxy.java',
- 'org/mockito/internal/creation/SerializableMockitoMethodProxy.java',
- 'org/mockito/internal/invocation/realmethod/FilteredCGLIBProxyRealMethod.java',
- 'org/mockito/internal/invocation/realmethod/CGLIBProxyRealMethod.java',
- 'org/mockito/internal/invocation/realmethod/HasCGLIBMethodProxy.java'
- }
+ tasks.withType(AbstractArchiveTask) {
+ preserveFileTimestamps = false
+ reproducibleFileOrder = true
}
+
+ apply plugin: 'checkstyle'
+ checkstyle {
+ configFile = rootProject.file('config/checkstyle/checkstyle.xml')
+ }
+}
+
+configurations {
+ testUtil //TODO move to separate project
}
dependencies {
- targetCompile project(':hamcrest')
- targetCompile project(':objenesis')
- targetCompile project(path: ':junit', configuration: 'target')
+ compile libraries.bytebuddy, libraries.bytebuddyagent
- hostCompile project(':hamcrest')
- hostCompile project(':objenesis')
- hostCompile project(path: ':junit', configuration: 'host')
- hostCompile 'org.apache.ant:ant:1.8.0'
+ compileOnly libraries.junit4, libraries.hamcrest, libraries.opentest4j
+ compile libraries.objenesis
+
+ testCompile libraries.assertj
+
+ //putting 'provided' dependencies on test compile and runtime classpath
+ testCompileOnly configurations.compileOnly
+ testRuntime configurations.compileOnly
+
+ testUtil sourceSets.test.output
+
+ signature 'org.codehaus.mojo.signature:java18:1.0@signature'
+ signature 'net.sf.androidscents.signature:android-api-level-24:7.0_r2@signature'
}
-task targetJar(type: Jar) {
- from sourceSets.target.output
- dependsOn targetClasses
- baseName "mockito"
- classifier "target"
+animalsniffer {
+ sourceSets = [sourceSets.main]
+ annotation = 'org.mockito.internal.SuppressSignatureCheck'
}
-task hostJar(type: Jar) {
- from sourceSets.host.output
- dependsOn hostClasses
- baseName "mockito"
- classifier "host"
+spotless {
+ // We run the check separately on CI, so don't run this by default
+ enforceCheck = false
+
+ java {
+ licenseHeaderFile rootProject.file('config/spotless/spotless.header')
+
+ customLazyGroovy('google-java-format') {
+ com.google.googlejavaformat.java.JavaFormatterOptions options = new com.google.googlejavaformat.java.JavaFormatterOptions.Builder()
+ .style(com.google.googlejavaformat.java.JavaFormatterOptions.Style.AOSP)
+ .formatJavadoc(false)
+ .build()
+ com.google.googlejavaformat.java.Formatter formatter = new com.google.googlejavaformat.java.Formatter(options)
+ return { source -> formatter.formatSource(source) }
+ }
+
+ // This test contains emulation of same-line stubbings. The formatter would put them on a separate line.
+ targetExclude 'src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java'
+ }
}
-artifacts {
- host hostJar
- target targetJar
+
+//workaround for #1444, delete when Shipkit bug is fixed
+subprojects {
+ eclipse {
+ project {
+ name = rootProject.name + '-' + project.name
+ }
+ }
+
+ afterEvaluate {
+ def lib = publishing.publications.javaLibrary
+ if(lib && !lib.artifactId.startsWith("mockito-")) {
+ lib.artifactId = "mockito-" + lib.artifactId
+ }
+ }
}
+//end workaround
diff --git a/patches/FieldSetter.patch b/patches/FieldSetter.patch
new file mode 100644
index 0000000..759c26e
--- /dev/null
+++ b/patches/FieldSetter.patch
@@ -0,0 +1,74 @@
+diff --git a/src/main/java/org/mockito/internal/util/reflection/AccessibilityChanger.java b/src/main/java/org/mockito/internal/util/reflection/AccessibilityChanger.java
+new file mode 100644
+index 0000000..9d1b756
+--- /dev/null
++++ b/src/main/java/org/mockito/internal/util/reflection/AccessibilityChanger.java
+@@ -0,0 +1,32 @@
++/*
++ * Copyright (c) 2007 Mockito contributors
++ * This program is made available under the terms of the MIT License.
++ */
++package org.mockito.internal.util.reflection;
++
++import java.lang.reflect.AccessibleObject;
++
++class AccessibilityChanger {
++
++ private Boolean wasAccessible = null;
++
++ /**
++ * safely disables access
++ */
++ public void safelyDisableAccess(AccessibleObject accessibleObject) {
++ assert wasAccessible != null : "accessibility info shall not be null";
++ try {
++ accessibleObject.setAccessible(wasAccessible);
++ } catch (Throwable t) {
++ //ignore
++ }
++ }
++
++ /**
++ * changes the accessibleObject accessibility and returns true if accessibility was changed
++ */
++ public void enableAccess(AccessibleObject accessibleObject) {
++ wasAccessible = accessibleObject.isAccessible();
++ accessibleObject.setAccessible(true);
++ }
++}
+diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldSetter.java b/src/main/java/org/mockito/internal/util/reflection/FieldSetter.java
+new file mode 100644
+index 0000000..35b1210
+--- /dev/null
++++ b/src/main/java/org/mockito/internal/util/reflection/FieldSetter.java
+@@ -0,0 +1,30 @@
++/*
++ * Copyright (c) 2007 Mockito contributors
++ * This program is made available under the terms of the MIT License.
++ */
++package org.mockito.internal.util.reflection;
++
++import java.lang.reflect.Field;
++
++/** Do not use. To be removed after last usage is gone. */
++@Deprecated
++public class FieldSetter {
++
++ private FieldSetter(){}
++
++ /** Do not use. To be removed after last usage is gone. */
++ @Deprecated
++ public static void setField(Object target, Field field,Object value) {
++ AccessibilityChanger changer = new AccessibilityChanger();
++ changer.enableAccess(field);
++ try {
++ field.set(target, value);
++ } catch (IllegalAccessException e) {
++ throw new RuntimeException("Access not authorized on field '" + field + "' of object '" + target + "' with value: '" + value + "'", e);
++ } catch (IllegalArgumentException e) {
++ throw new RuntimeException("Wrong argument on field '" + field + "' of object '" + target + "' with value: '" + value + "', \n" +
++ "reason : " + e.getMessage(), e);
++ }
++ changer.safelyDisableAccess(field);
++ }
++}
diff --git a/patches/GenericMetadataSupport.patch b/patches/GenericMetadataSupport.patch
new file mode 100644
index 0000000..6bcc64a
--- /dev/null
+++ b/patches/GenericMetadataSupport.patch
@@ -0,0 +1,13 @@
+diff --git a/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java b/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java
+index ef64c5bb6..c7edd9cea 100644
+--- a/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java
++++ b/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java
+@@ -91,7 +91,7 @@ public abstract class GenericMetadataSupport {
+
+ Class<?> rawType = extractRawTypeOf(typeToRegister);
+ typesToRegister.add(rawType.getGenericSuperclass());
+- typesToRegister.addAll(Arrays.asList(rawType.getGenericInterfaces()));
++ Collections.addAll(typesToRegister, rawType.getGenericInterfaces());
+ }
+ }
+
diff --git a/patches/remove_opentest4j.patch b/patches/remove_opentest4j.patch
new file mode 100644
index 0000000..c8fd3f2
--- /dev/null
+++ b/patches/remove_opentest4j.patch
@@ -0,0 +1,38 @@
+diff --git a/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java b/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java
+index 2810520..6589c5a 100644
+--- a/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java
++++ b/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java
+@@ -7,30 +7,13 @@ package org.mockito.exceptions.verification.opentest4j;
+ import static org.mockito.internal.util.StringUtil.removeFirstLine;
+
+ import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
+-import org.opentest4j.AssertionFailedError;
++import org.mockito.exceptions.base.MockitoAssertionError;
+
+-public class ArgumentsAreDifferent extends AssertionFailedError {
+
+- private static final long serialVersionUID = 1L;
+- private final String message;
+- private final StackTraceElement[] unfilteredStackTrace;
++public class ArgumentsAreDifferent extends MockitoAssertionError {
+
+ public ArgumentsAreDifferent(String message, String wanted, String actual) {
+- super(message, wanted, actual);
+- this.message = message;
+-
+- unfilteredStackTrace = getStackTrace();
+- ConditionalStackTraceFilter filter = new ConditionalStackTraceFilter();
+- filter.filter(this);
+- }
+-
+- @Override
+- public String getMessage() {
+- return message;
+- }
+-
+- public StackTraceElement[] getUnfilteredStackTrace() {
+- return unfilteredStackTrace;
++ super(message);
+ }
+
+ @Override
diff --git a/post_update.sh b/post_update.sh
new file mode 100644
index 0000000..86089b2
--- /dev/null
+++ b/post_update.sh
@@ -0,0 +1,41 @@
+#!/bin/bash
+
+# $1 Path to the new version.
+# $2 Path to the old version.
+
+excludes=(
+.checkstyle
+.editorconfig
+.gitattributes
+.github/
+.gitignore
+README.md
+SECURITY.md
+check_reproducibility.sh
+config/
+doc/
+gradle.properties
+gradle/
+gradlew
+gradlew.bat
+src/conf/
+src/javadoc/
+subprojects/androidTest/
+subprojects/deprecatedPluginsTest/
+subprojects/errorprone/
+subprojects/extTest/
+subprojects/groovyTest/
+subprojects/junit-jupiter/
+subprojects/junitJupiterExtensionTest/
+subprojects/junitJupiterInlineMockMakerExtensionTest/
+subprojects/junitJupiterParallelTest/
+subprojects/kotlinReleaseCoroutinesTest/
+subprojects/kotlinTest/
+subprojects/memory-test/
+subprojects/module-test/
+subprojects/osgi-test/
+)
+
+for remove in ${excludes[@]}; do
+ rm -rf "$1/$remove"
+done
diff --git a/settings.gradle.kts b/settings.gradle.kts
new file mode 100644
index 0000000..cdaa0e6
--- /dev/null
+++ b/settings.gradle.kts
@@ -0,0 +1,61 @@
+plugins {
+ id("com.gradle.enterprise").version("3.3.4")
+}
+
+include("deprecatedPluginsTest",
+ "inline",
+ "extTest",
+ "groovyTest",
+ "kotlinTest",
+ "kotlinReleaseCoroutinesTest",
+ "android",
+ "junit-jupiter",
+ "junitJupiterExtensionTest",
+ "junitJupiterInlineMockMakerExtensionTest",
+ "module-test",
+ "memory-test",
+ "errorprone",
+ "junitJupiterParallelTest",
+ "osgi-test")
+
+if (System.getenv("ANDROID_SDK_ROOT") != null || File(".local.properties").exists()) {
+ include("androidTest")
+} else {
+ logger.info("Not including android test project due to missing SDK configuration")
+}
+
+rootProject.name = "mockito"
+
+val koltinBuildScriptProject = hashSetOf("junitJupiterExtensionTest", "junitJupiterInlineMockMakerExtensionTest")
+
+fun buildFileExtensionFor(projectName: String) =
+ if (projectName in koltinBuildScriptProject) ".gradle.kts" else ".gradle"
+
+fun buildFileFor(projectName: String) =
+ "$projectName${buildFileExtensionFor(projectName)}"
+
+rootProject.children.forEach { project ->
+ val projectDirName = "subprojects/${project.name}"
+ project.projectDir = File(settingsDir, projectDirName)
+ project.buildFileName = buildFileFor(project.name)
+ require(project.projectDir.isDirectory) {
+ "Project directory ${project.projectDir} for project ${project.name} does not exist."
+ }
+ require(project.buildFile.isFile) {
+ "Build file ${project.buildFile} for project ${project.name} does not exist."
+ }
+}
+
+//Posting Build scans to https://scans.gradle.com
+gradleEnterprise {
+ buildScan {
+ termsOfServiceUrl = "https://gradle.com/terms-of-service"
+ termsOfServiceAgree = "yes"
+ }
+}
+
+buildCache {
+ local {
+ isEnabled = !System.getenv().containsKey("CI")
+ }
+}
diff --git a/src/main/java/org/mockito/AdditionalAnswers.java b/src/main/java/org/mockito/AdditionalAnswers.java
index 214eaa5..c7d2683 100644
--- a/src/main/java/org/mockito/AdditionalAnswers.java
+++ b/src/main/java/org/mockito/AdditionalAnswers.java
@@ -4,6 +4,8 @@
*/
package org.mockito;
+import static org.mockito.internal.stubbing.answers.AnswerFunctionalInterfaces.toAnswer;
+
import java.util.Collection;
import org.mockito.internal.stubbing.answers.AnswersWithDelay;
@@ -16,13 +18,13 @@
import org.mockito.stubbing.Answer3;
import org.mockito.stubbing.Answer4;
import org.mockito.stubbing.Answer5;
+import org.mockito.stubbing.Answer6;
import org.mockito.stubbing.VoidAnswer1;
import org.mockito.stubbing.VoidAnswer2;
import org.mockito.stubbing.VoidAnswer3;
import org.mockito.stubbing.VoidAnswer4;
import org.mockito.stubbing.VoidAnswer5;
-
-import static org.mockito.internal.stubbing.answers.AnswerFunctionalInterfaces.toAnswer;
+import org.mockito.stubbing.VoidAnswer6;
/**
* Additional answers provides factory methods for answers.
@@ -37,7 +39,7 @@
* @since 1.9.5
*/
@SuppressWarnings("unchecked")
-public class AdditionalAnswers {
+public final class AdditionalAnswers {
/**
* Returns the first parameter of an invocation.
*
@@ -274,7 +276,7 @@
* This feature suffers from the same drawback as the spy.
* The mock will call the delegate if you use regular when().then() stubbing style.
* Since the real implementation is called this might have some side effects.
- * Therefore you should to use the doReturn|Throw|Answer|CallRealMethod stubbing style. Example:
+ * Therefore you should use the doReturn|Throw|Answer|CallRealMethod stubbing style. Example:
*
* <pre class="code"><code class="java">
* List listWithDelegate = mock(List.class, AdditionalAnswers.delegatesTo(awesomeList));
@@ -306,7 +308,7 @@
* when(mock.foo()).thenReturn(1, 2, 3);
*
* //is equivalent to:
- * when(mock.foo()).thenAnswer(new ReturnsElementsOf(Arrays.asList(1, 2, 3)));
+ * when(mock.foo()).thenAnswer(AdditionalAnswers.returnsElementsOf(Arrays.asList(1, 2, 3)));
* </code></pre>
*
* @param elements The collection of elements to return.
@@ -488,4 +490,45 @@
public static <A, B, C, D, E> Answer<Void> answerVoid(VoidAnswer5<A, B, C, D, E> answer) {
return toAnswer(answer);
}
+
+ /**
+ * Creates an answer from a functional interface - allows for a strongly typed answer to be created
+ * idiomatically in Java 8
+ *
+ * @param answer interface to the answer - which is expected to return something
+ * @param <T> return type
+ * @param <A> input parameter type 1
+ * @param <B> input parameter type 2
+ * @param <C> input parameter type 3
+ * @param <D> input parameter type 4
+ * @param <E> input parameter type 5
+ * @param <F> input parameter type 6
+ * @return the answer object to use
+ * @since 2.26.0
+ */
+ @Incubating
+ public static <T, A, B, C, D, E, F> Answer<T> answer(Answer6<T, A, B, C, D, E, F> answer) {
+ return toAnswer(answer);
+ }
+
+ /**
+ * Creates an answer from a functional interface - allows for a strongly typed answer to be created
+ * idiomatically in Java 8
+ *
+ * @param answer interface to the answer - a void method
+ * @param <A> input parameter type 1
+ * @param <B> input parameter type 2
+ * @param <C> input parameter type 3
+ * @param <D> input parameter type 4
+ * @param <E> input parameter type 5
+ * @param <F> input parameter type 6
+ * @return the answer object to use
+ * @since 2.26.0
+ */
+ @Incubating
+ public static <A, B, C, D, E, F> Answer<Void> answerVoid(VoidAnswer6<A, B, C, D, E, F> answer) {
+ return toAnswer(answer);
+ }
+
+ private AdditionalAnswers() {}
}
diff --git a/src/main/java/org/mockito/AdditionalMatchers.java b/src/main/java/org/mockito/AdditionalMatchers.java
index 8f6d11c..16f5ed8 100644
--- a/src/main/java/org/mockito/AdditionalMatchers.java
+++ b/src/main/java/org/mockito/AdditionalMatchers.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito;
import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
@@ -39,7 +38,7 @@
* Scroll down to see all methods - full list of matchers.
*/
@SuppressWarnings("ALL")
-public class AdditionalMatchers {
+public final class AdditionalMatchers {
/**
* argument greater than or equal the given value.
@@ -1055,4 +1054,6 @@
private static void reportMatcher(ArgumentMatcher<?> matcher) {
mockingProgress().getArgumentMatcherStorage().reportMatcher(matcher);
}
+
+ private AdditionalMatchers() {}
}
diff --git a/src/main/java/org/mockito/Answers.java b/src/main/java/org/mockito/Answers.java
index 1ba50d9..2c844f5 100644
--- a/src/main/java/org/mockito/Answers.java
+++ b/src/main/java/org/mockito/Answers.java
@@ -5,11 +5,11 @@
package org.mockito;
import org.mockito.internal.stubbing.answers.CallsRealMethods;
-import org.mockito.internal.stubbing.defaultanswers.TriesToReturnSelf;
import org.mockito.internal.stubbing.defaultanswers.GloballyConfiguredAnswer;
import org.mockito.internal.stubbing.defaultanswers.ReturnsDeepStubs;
import org.mockito.internal.stubbing.defaultanswers.ReturnsMocks;
import org.mockito.internal.stubbing.defaultanswers.ReturnsSmartNulls;
+import org.mockito.internal.stubbing.defaultanswers.TriesToReturnSelf;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
@@ -24,7 +24,7 @@
* </code></pre>
* <b>This is not the full list</b> of Answers available in Mockito. Some interesting answers can be found in org.mockito.stubbing.answers package.
*/
-public enum Answers implements Answer<Object>{
+public enum Answers implements Answer<Object> {
/**
* The default configured answer of every mock.
*
@@ -52,7 +52,6 @@
*/
RETURNS_MOCKS(new ReturnsMocks()),
-
/**
* An answer that returns <strong>deep stubs</strong> (not mocks).
*
@@ -78,8 +77,7 @@
*
* @see org.mockito.Mockito#RETURNS_SELF
*/
- RETURNS_SELF(new TriesToReturnSelf())
- ;
+ RETURNS_SELF(new TriesToReturnSelf());
private final Answer<Object> implementation;
@@ -96,6 +94,7 @@
return this;
}
+ @Override
public Object answer(InvocationOnMock invocation) throws Throwable {
return implementation.answer(invocation);
}
diff --git a/src/main/java/org/mockito/ArgumentCaptor.java b/src/main/java/org/mockito/ArgumentCaptor.java
index 7011c92..f027de5 100644
--- a/src/main/java/org/mockito/ArgumentCaptor.java
+++ b/src/main/java/org/mockito/ArgumentCaptor.java
@@ -40,7 +40,7 @@
*
* <p>
* In a way ArgumentCaptor is related to custom argument matchers (see javadoc for {@link ArgumentMatcher} class).
- * Both techniques can be used for making sure certain arguments where passed to mocks.
+ * Both techniques can be used for making sure certain arguments were passed to mocks.
* However, ArgumentCaptor may be a better fit if:
* <ul>
* <li>custom argument matcher is not likely to be reused</li>
@@ -59,9 +59,9 @@
* @see Captor
* @since 1.8.0
*/
+@CheckReturnValue
public class ArgumentCaptor<T> {
-
private final CapturingMatcher<T> capturingMatcher = new CapturingMatcher<T>();
private final Class<? extends T> clazz;
@@ -80,7 +80,7 @@
* @return null or default values
*/
public T capture() {
- Mockito.argThat(capturingMatcher);
+ T ignored = Mockito.argThat(capturingMatcher);
return defaultValue(clazz);
}
@@ -145,7 +145,7 @@
* @param <U> Type of object captured by the newly built ArgumentCaptor
* @return A new ArgumentCaptor
*/
- public static <U,S extends U> ArgumentCaptor<U> forClass(Class<S> clazz) {
+ public static <U, S extends U> ArgumentCaptor<U> forClass(Class<S> clazz) {
return new ArgumentCaptor<U>(clazz);
}
}
diff --git a/src/main/java/org/mockito/ArgumentMatcher.java b/src/main/java/org/mockito/ArgumentMatcher.java
index a1e27c9..f51d7e5 100644
--- a/src/main/java/org/mockito/ArgumentMatcher.java
+++ b/src/main/java/org/mockito/ArgumentMatcher.java
@@ -61,7 +61,7 @@
*
* List mock = mock(List.class);
*
- * when(mock.addAll(argThat(new ListOfTwoElements))).thenReturn(true);
+ * when(mock.addAll(argThat(new ListOfTwoElements()))).thenReturn(true);
*
* mock.addAll(Arrays.asList("one", "two"));
*
diff --git a/src/main/java/org/mockito/ArgumentMatchers.java b/src/main/java/org/mockito/ArgumentMatchers.java
index 4a6c84d..7e90362 100644
--- a/src/main/java/org/mockito/ArgumentMatchers.java
+++ b/src/main/java/org/mockito/ArgumentMatchers.java
@@ -4,6 +4,9 @@
*/
package org.mockito;
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+import static org.mockito.internal.util.Primitives.defaultValue;
+
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
@@ -12,6 +15,7 @@
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;
+
import org.mockito.internal.matchers.Any;
import org.mockito.internal.matchers.Contains;
import org.mockito.internal.matchers.EndsWith;
@@ -25,9 +29,6 @@
import org.mockito.internal.matchers.apachecommons.ReflectionEquals;
import org.mockito.internal.util.Primitives;
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-import static org.mockito.internal.util.Primitives.defaultValue;
-
/**
* Allow flexible verification or stubbing. See also {@link AdditionalMatchers}.
*
@@ -111,6 +112,7 @@
*
* @see AdditionalMatchers
*/
+@CheckReturnValue
@SuppressWarnings("unchecked")
public class ArgumentMatchers {
@@ -120,7 +122,7 @@
* <p>
* See examples in javadoc for {@link ArgumentMatchers} class
*
- * This is an alias of: {@link #anyObject()} and {@link #any(java.lang.Class)}
+ * This is an alias of: {@link #anyObject()}
* </p>
*
* <p>
@@ -149,7 +151,7 @@
* Matches anything, including <code>null</code>.
*
* <p>
- * This is an alias of: {@link #any()} and {@link #any(java.lang.Class)}.
+ * This is an alias of: {@link #any()}.
* See examples in javadoc for {@link ArgumentMatchers} class.
* </p>
*
@@ -158,7 +160,8 @@
* @see #any(Class)
* @see #notNull()
* @see #notNull(Class)
- * @deprecated This will be removed in Mockito 3.0 (which will be java 8 only)
+ * @deprecated This will be removed in Mockito 4.0 This method is only used for generic
+ * friendliness to avoid casting, this is not anymore needed in Java 8.
*/
@Deprecated
public static <T> T anyObject() {
@@ -179,7 +182,7 @@
* <p>
* Since Mockito 2.1.0, only allow non-null instance of <code></code>, thus <code>null</code> is not anymore a valid value.
* As reference are nullable, the suggested API to <strong>match</strong> <code>null</code>
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -256,7 +259,7 @@
*/
@Deprecated
public static <T> T anyVararg() {
- any();
+ Object ignored = any();
return null;
}
@@ -266,7 +269,7 @@
* <p>
* Since Mockito 2.1.0, only allow valued <code>Boolean</code>, thus <code>null</code> is not anymore a valid value.
* As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -289,7 +292,7 @@
* <p>
* Since Mockito 2.1.0, only allow valued <code>Byte</code>, thus <code>null</code> is not anymore a valid value.
* As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -312,7 +315,7 @@
* <p>
* Since Mockito 2.1.0, only allow valued <code>Character</code>, thus <code>null</code> is not anymore a valid value.
* As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -335,7 +338,7 @@
* <p>
* Since Mockito 2.1.0, only allow valued <code>Integer</code>, thus <code>null</code> is not anymore a valid value.
* As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -358,7 +361,7 @@
* <p>
* Since Mockito 2.1.0, only allow valued <code>Long</code>, thus <code>null</code> is not anymore a valid value.
* As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -381,7 +384,7 @@
* <p>
* Since Mockito 2.1.0, only allow valued <code>Float</code>, thus <code>null</code> is not anymore a valid value.
* As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -404,7 +407,7 @@
* <p>
* Since Mockito 2.1.0, only allow valued <code>Double</code>, thus <code>null</code> is not anymore a valid value.
* As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -427,7 +430,7 @@
* <p>
* Since Mockito 2.1.0, only allow valued <code>Short</code>, thus <code>null</code> is not anymore a valid value.
* As primitive wrappers are nullable, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -450,7 +453,7 @@
* <p>
* Since Mockito 2.1.0, only allow non-null <code>String</code>.
* As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -473,7 +476,7 @@
* <p>
* Since Mockito 2.1.0, only allow non-null <code>List</code>.
* As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -505,7 +508,7 @@
* <p>
* Since Mockito 2.1.0, only allow non-null <code>List</code>.
* As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -518,9 +521,10 @@
* @see #anyList()
* @see #isNull()
* @see #isNull(Class)
- * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
+ * @deprecated With Java 8 this method will be removed in Mockito 4.0. This method is only used for generic
* friendliness to avoid casting, this is not anymore needed in Java 8.
*/
+ @Deprecated
public static <T> List<T> anyListOf(Class<T> clazz) {
return anyList();
}
@@ -531,7 +535,7 @@
* <p>
* Since Mockito 2.1.0, only allow non-null <code>Set</code>.
* As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -565,7 +569,7 @@
* <p>
* Since Mockito 2.1.0, only allow non-null <code>Set</code>.
* As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -578,9 +582,10 @@
* @see #anySet()
* @see #isNull()
* @see #isNull(Class)
- * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
+ * @deprecated With Java 8 this method will be removed in Mockito 4.0. This method is only used for generic
* friendliness to avoid casting, this is not anymore needed in Java 8.
*/
+ @Deprecated
public static <T> Set<T> anySetOf(Class<T> clazz) {
return anySet();
}
@@ -591,7 +596,7 @@
* <p>
* Since Mockito 2.1.0, only allow non-null <code>Map</code>.
* As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -625,7 +630,7 @@
* <p>
* Since Mockito 2.1.0, only allow non-null <code>Map</code>.
* As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -639,9 +644,10 @@
* @see #anyMap()
* @see #isNull()
* @see #isNull(Class)
- * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
+ * @deprecated With Java 8 this method will be removed in Mockito 4.0. This method is only used for generic
* friendliness to avoid casting, this is not anymore needed in Java 8.
*/
+ @Deprecated
public static <K, V> Map<K, V> anyMapOf(Class<K> keyClazz, Class<V> valueClazz) {
return anyMap();
}
@@ -652,7 +658,7 @@
* <p>
* Since Mockito 2.1.0, only allow non-null <code>Collection</code>.
* As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code>
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -686,7 +692,7 @@
* <p>
* Since Mockito 2.1.0, only allow non-null <code>Collection</code>.
* As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code>
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -699,9 +705,10 @@
* @see #anyCollection()
* @see #isNull()
* @see #isNull(Class)
- * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
+ * @deprecated With Java 8 this method will be removed in Mockito 4.0. This method is only used for generic
* friendliness to avoid casting, this is not anymore needed in Java 8.
*/
+ @Deprecated
public static <T> Collection<T> anyCollectionOf(Class<T> clazz) {
return anyCollection();
}
@@ -712,7 +719,7 @@
* <p>
* Since Mockito 2.1.0, only allow non-null <code>Iterable</code>.
* As this is a nullable reference, the suggested API to <strong>match</strong> <code>null</code>
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -747,7 +754,7 @@
* <p>
* Since Mockito 2.1.0, only allow non-null <code>String</code>.
* As strings are nullable reference, the suggested API to <strong>match</strong> <code>null</code> wrapper
- * would be {@link #isNull()}. We felt this change would make tests harness much safer that it was with Mockito
+ * would be {@link #isNull()}. We felt this change would make test harnesses much safer than they were with Mockito
* 1.x.
* </p>
*
@@ -761,15 +768,14 @@
* @see #isNull()
* @see #isNull(Class)
* @since 2.1.0
- * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
+ * @deprecated With Java 8 this method will be removed in Mockito 4.0. This method is only used for generic
* friendliness to avoid casting, this is not anymore needed in Java 8.
*/
+ @Deprecated
public static <T> Iterable<T> anyIterableOf(Class<T> clazz) {
return anyIterable();
}
-
-
/**
* <code>boolean</code> argument that is equal to the given value.
*
@@ -900,8 +906,7 @@
*/
public static <T> T eq(T value) {
reportMatcher(new Equals(value));
- if (value == null)
- return null;
+ if (value == null) return null;
return (T) Primitives.defaultValue(value.getClass());
}
@@ -947,8 +952,9 @@
*/
public static <T> T same(T value) {
reportMatcher(new Same(value));
- if (value == null)
+ if (value == null) {
return null;
+ }
return (T) Primitives.defaultValue(value.getClass());
}
@@ -985,9 +991,10 @@
* @see #isNull()
* @see #isNotNull()
* @see #isNotNull(Class)
- * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
+ * @deprecated With Java 8 this method will be removed in Mockito 4.0. This method is only used for generic
* friendliness to avoid casting, this is not anymore needed in Java 8.
*/
+ @Deprecated
public static <T> T isNull(Class<T> clazz) {
return isNull();
}
@@ -1028,9 +1035,10 @@
* @see #isNotNull()
* @see #isNull()
* @see #isNull(Class)
- * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
+ * @deprecated With Java 8 this method will be removed in Mockito 4.0. This method is only used for generic
* friendliness to avoid casting, this is not anymore needed in Java 8.
*/
+ @Deprecated
public static <T> T notNull(Class<T> clazz) {
return notNull();
}
@@ -1069,14 +1077,14 @@
*
* @param clazz Type to avoid casting
* @return <code>null</code>.
- * @deprecated With Java 8 this method will be removed in Mockito 3.0. This method is only used for generic
+ * @deprecated With Java 8 this method will be removed in Mockito 4.0. This method is only used for generic
* friendliness to avoid casting, this is not anymore needed in Java 8.
*/
+ @Deprecated
public static <T> T isNotNull(Class<T> clazz) {
return notNull(clazz);
}
-
/**
* Argument that is either <code>null</code> or of the given type.
*
@@ -1089,7 +1097,7 @@
*/
public static <T> T nullable(Class<T> clazz) {
AdditionalMatchers.or(isNull(), isA(clazz));
- return (T) Primitives.defaultValue(clazz);
+ return Primitives.defaultValue(clazz);
}
/**
diff --git a/src/main/java/org/mockito/BDDMockito.java b/src/main/java/org/mockito/BDDMockito.java
index 9090fa8..1f249b4 100644
--- a/src/main/java/org/mockito/BDDMockito.java
+++ b/src/main/java/org/mockito/BDDMockito.java
@@ -13,7 +13,7 @@
* Behavior Driven Development style of writing tests uses <b>//given //when //then</b> comments as fundamental parts of your test methods.
* This is exactly how we write our tests and we warmly encourage you to do so!
* <p>
- * Start learning about BDD here: <a href="http://en.wikipedia.org/wiki/Behavior_Driven_Development">http://en.wikipedia.org/wiki/Behavior_Driven_Development</a>
+ * Start learning about BDD here: <a href="https://en.wikipedia.org/wiki/Behavior-driven_development">https://en.wikipedia.org/wiki/Behavior-driven_development</a>
* <p>
* The problem is that current stubbing api with canonical role of <b>when</b> word does not integrate nicely with <b>//given //when //then</b> comments.
* It's because stubbing belongs to <b>given</b> component of the test and not to the <b>when</b> component of the test.
@@ -127,9 +127,12 @@
* See original {@link OngoingStubbing#thenThrow(Class, Class[])}
* @since 2.1.0
*/
- // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array creation
- @SuppressWarnings ({"unchecked", "varargs"})
- BDDMyOngoingStubbing<T> willThrow(Class<? extends Throwable> throwableType, Class<? extends Throwable>... throwableTypes);
+ // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array
+ // creation
+ @SuppressWarnings({"unchecked", "varargs"})
+ BDDMyOngoingStubbing<T> willThrow(
+ Class<? extends Throwable> throwableType,
+ Class<? extends Throwable>... throwableTypes);
/**
* See original {@link OngoingStubbing#thenCallRealMethod()}
@@ -176,8 +179,11 @@
return new BDDOngoingStubbingImpl<T>(mockitoOngoingStubbing.thenThrow(throwableType));
}
- public BDDMyOngoingStubbing<T> willThrow(Class<? extends Throwable> throwableType, Class<? extends Throwable>... throwableTypes) {
- return new BDDOngoingStubbingImpl<T>(mockitoOngoingStubbing.thenThrow(throwableType, throwableTypes));
+ public BDDMyOngoingStubbing<T> willThrow(
+ Class<? extends Throwable> throwableType,
+ Class<? extends Throwable>... throwableTypes) {
+ return new BDDOngoingStubbingImpl<T>(
+ mockitoOngoingStubbing.thenThrow(throwableType, throwableTypes));
}
public BDDMyOngoingStubbing<T> willCallRealMethod() {
@@ -251,7 +257,9 @@
/**
* @see #verifyZeroInteractions(Object...)
* @since 2.1.0
+ * @deprecated Since 3.0.1. Please migrate your code to {@link #shouldHaveNoInteractions()}
*/
+ @Deprecated
void shouldHaveZeroInteractions();
/**
@@ -259,6 +267,12 @@
* @since 2.1.0
*/
void shouldHaveNoMoreInteractions();
+
+ /**
+ * @see #verifyNoInteractions(Object...)
+ * @since 3.0.1
+ */
+ void shouldHaveNoInteractions();
}
private static class ThenImpl<T> implements Then<T> {
@@ -316,6 +330,14 @@
public void shouldHaveNoMoreInteractions() {
verifyNoMoreInteractions(mock);
}
+
+ /**
+ * @see #verifyNoInteractions(Object...)
+ * @since 3.0.1
+ */
+ public void shouldHaveNoInteractions() {
+ verifyNoInteractions(mock);
+ }
}
/**
@@ -338,7 +360,7 @@
/**
* See original {@link Stubber#doNothing()}.
*
- * This method will be removed in version 3.0.0
+ * This method will be removed in version 4.0.0
*
* @since 1.8.0
* @deprecated as of 2.1.0 please use {@link #willDoNothing()} instead
@@ -381,8 +403,10 @@
* See original {@link Stubber#doThrow(Class, Class[])}
* @since 2.1.0
*/
- @SuppressWarnings ({"unchecked", "varargs"})
- BDDStubber willThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown);
+ @SuppressWarnings({"unchecked", "varargs"})
+ BDDStubber willThrow(
+ Class<? extends Throwable> toBeThrown,
+ Class<? extends Throwable>... nextToBeThrown);
/**
* See original {@link Stubber#doCallRealMethod()}
@@ -434,7 +458,8 @@
}
public BDDStubber willReturn(Object toBeReturned, Object... nextToBeReturned) {
- return new BDDStubberImpl(mockitoStubber.doReturn(toBeReturned).doReturn(nextToBeReturned));
+ return new BDDStubberImpl(
+ mockitoStubber.doReturn(toBeReturned).doReturn(nextToBeReturned));
}
public BDDStubber willThrow(Throwable... toBeThrown) {
@@ -445,7 +470,9 @@
return new BDDStubberImpl(mockitoStubber.doThrow(toBeThrown));
}
- public BDDStubber willThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
+ public BDDStubber willThrow(
+ Class<? extends Throwable> toBeThrown,
+ Class<? extends Throwable>... nextToBeThrown) {
return new BDDStubberImpl(mockitoStubber.doThrow(toBeThrown, nextToBeThrown));
}
@@ -474,7 +501,8 @@
* see original {@link Mockito#doThrow(Class)}
* @since 1.9.0
*/
- public static BDDStubber willThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... throwableTypes) {
+ public static BDDStubber willThrow(
+ Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... throwableTypes) {
return new BDDStubberImpl(Mockito.doThrow(toBeThrown, throwableTypes));
}
diff --git a/src/main/java/org/mockito/Captor.java b/src/main/java/org/mockito/Captor.java
index 225bf70..0de9f72 100644
--- a/src/main/java/org/mockito/Captor.java
+++ b/src/main/java/org/mockito/Captor.java
@@ -4,7 +4,11 @@
*/
package org.mockito;
-import java.lang.annotation.*;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
/**
* Allows shorthand {@link org.mockito.ArgumentCaptor} creation on fields.
@@ -15,9 +19,16 @@
*
* @Captor ArgumentCaptor<AsyncCallback<Foo>> captor;
*
+ * private AutoCloseable closeable;
+ *
* @Before
- * public void init(){
- * MockitoAnnotations.initMocks(this);
+ * public void open() {
+ * closeable = MockitoAnnotations.openMocks(this);
+ * }
+ *
+ * @After
+ * public void release() throws Exception {
+ * closeable.close();
* }
*
* @Test public void shouldDoSomethingUseful() {
diff --git a/src/main/java/org/mockito/CheckReturnValue.java b/src/main/java/org/mockito/CheckReturnValue.java
index 0498c14..935b320 100644
--- a/src/main/java/org/mockito/CheckReturnValue.java
+++ b/src/main/java/org/mockito/CheckReturnValue.java
@@ -9,7 +9,6 @@
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
-
/**
* This annotation is not supposed to be used by Mockito end-users. Instead, we
* use it to annotate methods for Static Analysis tools, including FindBugs and ErrorProne.
@@ -18,15 +17,9 @@
* This annotation is public, because we have to use it in multiple packages.
*
* @see <a href="https://github.com/findbugsproject/findbugs/blob/264ae7baf890d2b347d91805c90057062b5dcb1e/findbugs/src/java/edu/umd/cs/findbugs/detect/BuildCheckReturnAnnotationDatabase.java#L120">Findbugs source code</a>
- * @see <a href="http://errorprone.info/bugpattern/CheckReturnValue">ErrorProne check</a>
+ * @see <a href="https://errorprone.info/bugpattern/CheckReturnValue">ErrorProne check</a>
* @since 2.11.4
*/
-@Target({
- ElementType.CONSTRUCTOR,
- ElementType.METHOD,
- ElementType.PACKAGE,
- ElementType.TYPE
-})
+@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PACKAGE, ElementType.TYPE})
@Retention(RetentionPolicy.CLASS)
-public @interface CheckReturnValue {
-}
+public @interface CheckReturnValue {}
diff --git a/src/main/java/org/mockito/InOrder.java b/src/main/java/org/mockito/InOrder.java
index 56beafe..02ea019 100644
--- a/src/main/java/org/mockito/InOrder.java
+++ b/src/main/java/org/mockito/InOrder.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito;
import org.mockito.verification.VerificationMode;
@@ -63,7 +62,6 @@
*/
<T> T verify(T mock, VerificationMode mode);
-
/**
* Verifies that no more interactions happened <b>in order</b>.
* Different from {@link Mockito#verifyNoMoreInteractions(Object...)} because the order of verification matters.
diff --git a/src/main/java/org/mockito/Incubating.java b/src/main/java/org/mockito/Incubating.java
index 294cfc5..adf011a 100644
--- a/src/main/java/org/mockito/Incubating.java
+++ b/src/main/java/org/mockito/Incubating.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito;
import java.lang.annotation.Documented;
@@ -26,5 +25,4 @@
*/
@Retention(RetentionPolicy.RUNTIME)
@Documented
-public @interface Incubating {
-}
+public @interface Incubating {}
diff --git a/src/main/java/org/mockito/InjectMocks.java b/src/main/java/org/mockito/InjectMocks.java
index 0430524..6ed02ab 100644
--- a/src/main/java/org/mockito/InjectMocks.java
+++ b/src/main/java/org/mockito/InjectMocks.java
@@ -4,15 +4,15 @@
*/
package org.mockito;
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import org.mockito.junit.MockitoJUnitRunner;
-import static java.lang.annotation.ElementType.FIELD;
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
/**
* Mark a field on which injection should be performed.
*
@@ -22,7 +22,7 @@
* </ul>
* <p>
* Mockito will try to inject mocks only either by constructor injection,
- * setter injection, or property injection in order and as described below.
+ * property injection or setter injection in order and as described below.
* If any of the following strategy fail, then Mockito <strong>won't report failure</strong>;
* i.e. you will have to provide dependencies yourself.
* <ol>
@@ -39,7 +39,7 @@
* then, if there is several property of the same type, by the match of the property name and the mock name.
* <p><u>Note 1:</u> If you have properties with the same type (or same erasure), it's better to name all @Mock
* annotated fields with the matching properties, otherwise Mockito might get confused and injection won't happen.</p>
- * <p><u>Note 2:</u> If @InjectMocks instance wasn't initialized before and have a no-arg constructor,
+ * <p><u>Note 2:</u> If @InjectMocks instance wasn't initialized before and has a no-arg constructor,
* then it will be initialized with this constructor.</p></li>
*
* <li><strong>Field injection</strong>; mocks will first be resolved by type (if a single type match
@@ -71,8 +71,14 @@
*
* public class SampleBaseTestCase {
*
- * @Before public void initMocks() {
- * MockitoAnnotations.initMocks(this);
+ * private AutoCloseable closeable;
+ *
+ * @Before public void openMocks() {
+ * closeable = MockitoAnnotations.openMocks(this);
+ * }
+ *
+ * @After public void releaseMocks() throws Exception {
+ * closeable.close();
* }
* }
* </code></pre>
@@ -83,13 +89,13 @@
* a parameterized constructor only or a no-arg constructor only, or both.
* All these constructors can be package protected, protected or private, however
* <u>Mockito cannot instantiate inner classes, local classes, abstract classes and of course interfaces.</u>
- * <u>Beware of private nest static classes too.</u>
+ * <u>Beware of private nested static classes too.</u>
*
* <p>The same stands for setters or fields, they can be declared with private
* visibility, Mockito will see them through reflection.
* However fields that are static or final will be ignored.</p>
*
- * <p>So on the field that needs injection, for example constructor injection will happen here :</p>
+ * <p>So on the field that needs injection, for example constructor injection will happen here:</p>
* <pre class="code"><code class="java">
* public class ArticleManager {
* ArticleManager(ArticleCalculator calculator, ArticleDatabase database) {
@@ -98,7 +104,7 @@
* }
* </code></pre>
*
- * <p>Property setter injection will happen here :</p>
+ * <p>Property setter injection will happen here:</p>
* <pre class="code"><code class="java">
* public class ArticleManager {
* // no-arg constructor
@@ -112,7 +118,7 @@
* }
* </code></pre>
*
- * <p>Field injection will be used here :</p>
+ * <p>Field injection will be used here:</p>
* <pre class="code"><code class="java">
* public class ArticleManager {
* private ArticleDatabase database;
@@ -141,11 +147,11 @@
* </p>
*
* <p>
- * <strong><code>MockitoAnnotations.initMocks(this)</code></strong> method has to be called to initialize annotated objects.
- * In above example, <code>initMocks()</code> is called in @Before (JUnit4) method of test's base class.
- * For JUnit3 <code>initMocks()</code> can go to <code>setup()</code> method of a base class.
- * <strong>Instead</strong> you can also put initMocks() in your JUnit runner (@RunWith) or use the built-in
- * {@link MockitoJUnitRunner}.
+ * <strong><code>MockitoAnnotations.openMocks(this)</code></strong> method has to be called to initialize annotated objects.
+ * In above example, <code>openMocks()</code> is called in @Before (JUnit4) method of test's base class.
+ * For JUnit3 <code>openMocks()</code> can go to <code>setup()</code> method of a base class.
+ * <strong>Instead</strong> you can also put openMocks() in your JUnit runner (@RunWith) or use the built-in
+ * {@link MockitoJUnitRunner}. Also, make sure to release any mocks after disposing your test class with a corresponding hook.
* </p>
*
* <p>
@@ -155,7 +161,7 @@
*
* @see Mock
* @see Spy
- * @see MockitoAnnotations#initMocks(Object)
+ * @see MockitoAnnotations#openMocks(Object)
* @see MockitoJUnitRunner
* @since 1.8.3
*/
diff --git a/src/main/java/org/mockito/Matchers.java b/src/main/java/org/mockito/Matchers.java
index f6d07bc..f5e70bb 100644
--- a/src/main/java/org/mockito/Matchers.java
+++ b/src/main/java/org/mockito/Matchers.java
@@ -6,8 +6,7 @@
/**
* @deprecated Use {@link ArgumentMatchers}. This class is now deprecated in order to avoid a name clash with Hamcrest
- * <code>org.hamcrest.Matchers</code> class. This class will likely be removed in version 3.0.
+ * <code>org.hamcrest.Matchers</code> class. This class will likely be removed in version 4.0.
*/
@Deprecated
-public class Matchers extends ArgumentMatchers {
-}
+public class Matchers extends ArgumentMatchers {}
diff --git a/src/main/java/org/mockito/Mock.java b/src/main/java/org/mockito/Mock.java
index 909432f..8b81320 100644
--- a/src/main/java/org/mockito/Mock.java
+++ b/src/main/java/org/mockito/Mock.java
@@ -4,15 +4,16 @@
*/
package org.mockito;
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import org.mockito.junit.MockitoJUnitRunner;
-
-import static java.lang.annotation.ElementType.FIELD;
-import static java.lang.annotation.ElementType.PARAMETER;
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
+import org.mockito.stubbing.Answer;
/**
* Mark a field as a mock.
@@ -22,6 +23,7 @@
* <li>Minimizes repetitive mock creation code.</li>
* <li>Makes the test class more readable.</li>
* <li>Makes the verification error easier to read because the <b>field name</b> is used to identify the mock.</li>
+ * <li>Automatically detects static mocks of type {@link MockedStatic} and infers the static mock type of the type parameter.</li>
* </ul>
*
* <pre class="code"><code class="java">
@@ -30,7 +32,7 @@
* @Mock private ArticleCalculator calculator;
* @Mock(name = "database") private ArticleDatabase dbMock;
* @Mock(answer = RETURNS_MOCKS) private UserProvider userProvider;
- * @Mock(extraInterfaces = {Queue.class, Observer.class}) private articleMonitor;
+ * @Mock(extraInterfaces = {Queue.class, Observer.class}) private ArticleMonitor articleMonitor;
* @Mock(stubOnly = true) private Logger logger;
*
* private ArticleManager manager;
@@ -42,24 +44,30 @@
*
* public class SampleBaseTestCase {
*
- * @Before public void initMocks() {
- * MockitoAnnotations.initMocks(this);
+ * private AutoCloseable closeable;
+ *
+ * @Before public void openMocks() {
+ * closeable = MockitoAnnotations.openMocks(this);
+ * }
+ *
+ * @After public void releaseMocks() throws Exception {
+ * closeable.close();
* }
* }
* </code></pre>
*
* <p>
- * <strong><code>MockitoAnnotations.initMocks(this)</code></strong> method has to be called to initialize annotated objects.
- * In above example, <code>initMocks()</code> is called in @Before (JUnit4) method of test's base class.
- * For JUnit3 <code>initMocks()</code> can go to <code>setup()</code> method of a base class.
- * <strong>Instead</strong> you can also put initMocks() in your JUnit runner (@RunWith) or use the built-in
- * {@link MockitoJUnitRunner}.
+ * <strong><code>MockitoAnnotations.openMocks(this)</code></strong> method has to be called to initialize annotated objects.
+ * In above example, <code>openMocks()</code> is called in @Before (JUnit4) method of test's base class.
+ * For JUnit3 <code>openMocks()</code> can go to <code>setup()</code> method of a base class.
+ * <strong>Instead</strong> you can also put openMocks() in your JUnit runner (@RunWith) or use the built-in
+ * {@link MockitoJUnitRunner}. Also, make sure to release any mocks after disposing your test class with a corresponding hook.
* </p>
*
* @see Mockito#mock(Class)
* @see Spy
* @see InjectMocks
- * @see MockitoAnnotations#initMocks(Object)
+ * @see MockitoAnnotations#openMocks(Object)
* @see MockitoJUnitRunner
*/
@Target({FIELD, PARAMETER})
@@ -67,13 +75,41 @@
@Documented
public @interface Mock {
+ /**
+ * Mock will have custom answer, see {@link MockSettings#defaultAnswer(Answer)}.
+ * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+ */
Answers answer() default Answers.RETURNS_DEFAULTS;
+ /**
+ * Mock will be 'stubOnly', see {@link MockSettings#stubOnly()}.
+ * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+ */
boolean stubOnly() default false;
+ /**
+ * Mock will have custom name (shown in verification errors), see {@link MockSettings#name(String)}.
+ * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+ */
String name() default "";
+ /**
+ * Mock will have extra interfaces, see {@link MockSettings#extraInterfaces(Class[])}.
+ * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+ */
Class<?>[] extraInterfaces() default {};
+ /**
+ * Mock will be serializable, see {@link MockSettings#serializable()}.
+ * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+ */
boolean serializable() default false;
+
+ /**
+ * Mock will be lenient, see {@link MockSettings#lenient()}.
+ * For examples how to use 'Mock' annotation and parameters see {@link Mock}.
+ *
+ * @since 2.23.3
+ */
+ boolean lenient() default false;
}
diff --git a/src/main/java/org/mockito/MockSettings.java b/src/main/java/org/mockito/MockSettings.java
index c79c243..a1fdb50 100644
--- a/src/main/java/org/mockito/MockSettings.java
+++ b/src/main/java/org/mockito/MockSettings.java
@@ -4,19 +4,20 @@
*/
package org.mockito;
+import java.io.Serializable;
+
import org.mockito.exceptions.misusing.PotentialStubbingProblem;
import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
import org.mockito.invocation.InvocationFactory;
import org.mockito.invocation.MockHandler;
import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.StubbingLookupListener;
import org.mockito.listeners.VerificationStartedListener;
import org.mockito.mock.MockCreationSettings;
import org.mockito.mock.SerializableMode;
import org.mockito.quality.Strictness;
import org.mockito.stubbing.Answer;
-import java.io.Serializable;
-
/**
* Allows mock creation with additional mock settings.
* <p/>
@@ -43,6 +44,7 @@
* Firstly, to make it easy to add another mock setting when the demand comes.
* Secondly, to enable combining together different mock settings without introducing zillions of overloaded mock() methods.
*/
+@NotExtensible
public interface MockSettings extends Serializable {
/**
@@ -204,6 +206,24 @@
MockSettings verboseLogging();
/**
+ * Add stubbing lookup listener to the mock object.
+ *
+ * Multiple listeners may be added and they will be notified orderly.
+ *
+ * For use cases and more info see {@link StubbingLookupListener}.
+ *
+ * Example:
+ * <pre class="code"><code class="java">
+ * List mockWithListener = mock(List.class, withSettings().stubbingLookupListeners(new YourStubbingLookupListener()));
+ * </code></pre>
+ *
+ * @param listeners The stubbing lookup listeners to add. May not be null.
+ * @return settings instance so that you can fluently specify other settings
+ * @since 2.24.6
+ */
+ MockSettings stubbingLookupListeners(StubbingLookupListener... listeners);
+
+ /**
* Registers a listener for method invocations on this mock. The listener is
* notified every time a method on this mock is called.
* <p>
@@ -321,6 +341,21 @@
<T> MockCreationSettings<T> build(Class<T> typeToMock);
/**
+ * Creates immutable view of mock settings used later by Mockito, for use within a static mocking.
+ * Framework integrators can use this method to create instances of creation settings
+ * and use them in advanced use cases, for example to create invocations with {@link InvocationFactory},
+ * or to implement custom {@link MockHandler}.
+ * Since {@link MockCreationSettings} is {@link NotExtensible}, Mockito public API needs a creation method for this type.
+ *
+ * @param classToMock class to mock
+ * @param <T> type to mock
+ * @return immutable view of mock settings
+ * @since 2.10.0
+ */
+ @Incubating
+ <T> MockCreationSettings<T> buildStatic(Class<T> classToMock);
+
+ /**
* Lenient mocks bypass "strict stubbing" validation (see {@link Strictness#STRICT_STUBS}).
* When mock is declared as lenient none of its stubbings will be checked for potential stubbing problems such as
* 'unnecessary stubbing' ({@link UnnecessaryStubbingException}) or for 'stubbing argument mismatch' {@link PotentialStubbingProblem}.
diff --git a/src/main/java/org/mockito/MockedConstruction.java b/src/main/java/org/mockito/MockedConstruction.java
new file mode 100644
index 0000000..c00fb02
--- /dev/null
+++ b/src/main/java/org/mockito/MockedConstruction.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import java.lang.reflect.Constructor;
+import java.util.List;
+
+/**
+ * Represents a mock of any object construction of the represented type. Within the scope of the
+ * mocked construction, the invocation of any interceptor will generate a mock which will be
+ * prepared as specified when generating this scope. The mock can also be received via this
+ * instance.
+ * <p>
+ * If the {@link Mock} annotation is used on fields or method parameters of this type, a mocked
+ * construction is created instead of a regular mock. The mocked construction is activated and
+ * released upon completing any relevant test.
+ *
+ * @param <T> The type for which the construction is being mocked.
+ */
+@Incubating
+public interface MockedConstruction<T> extends ScopedMock {
+
+ List<T> constructed();
+
+ interface Context {
+
+ int getCount();
+
+ Constructor<?> constructor();
+
+ List<?> arguments();
+ }
+
+ interface MockInitializer<T> {
+
+ void prepare(T mock, Context context) throws Throwable;
+ }
+}
diff --git a/src/main/java/org/mockito/MockedStatic.java b/src/main/java/org/mockito/MockedStatic.java
new file mode 100644
index 0000000..fbf011f
--- /dev/null
+++ b/src/main/java/org/mockito/MockedStatic.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static org.mockito.Mockito.times;
+
+import org.mockito.stubbing.OngoingStubbing;
+import org.mockito.verification.VerificationMode;
+
+/**
+ * Represents an active mock of a type's static methods. The mocking only affects the thread
+ * on which this static mock was created and it is not safe to use this object from another
+ * thread. The static mock is released when this object's {@link MockedStatic#close()} method
+ * is invoked. If this object is never closed, the static mock will remain active on the
+ * initiating thread. It is therefore recommended to create this object within a try-with-resources
+ * statement unless when managed explicitly, for example by using a JUnit rule or extension.
+ * <p>
+ * If the {@link Mock} annotation is used on fields or method parameters of this type, a static mock
+ * is created instead of a regular mock. The static mock is activated and released upon completing any
+ * relevant test.
+ *
+ * @param <T> The type being mocked.
+ */
+@Incubating
+public interface MockedStatic<T> extends ScopedMock {
+
+ /**
+ * See {@link Mockito#when(Object)}.
+ */
+ <S> OngoingStubbing<S> when(Verification verification);
+
+ /**
+ * See {@link Mockito#verify(Object)}.
+ */
+ default void verify(Verification verification) {
+ verify(verification, times(1));
+ }
+
+ /**
+ * See {@link Mockito#verify(Object, VerificationMode)}.
+ *
+ * @deprecated Please use {@link MockedStatic#verify(Verification, VerificationMode) instead
+ */
+ @Deprecated
+ void verify(VerificationMode mode, Verification verification);
+
+ /**
+ * See {@link Mockito#verify(Object, VerificationMode)}.
+ */
+ void verify(Verification verification, VerificationMode mode);
+
+ /**
+ * See {@link Mockito#reset(Object[])}.
+ */
+ void reset();
+
+ /**
+ * See {@link Mockito#clearInvocations(Object[])}.
+ */
+ void clearInvocations();
+
+ /**
+ * {@link Mockito#verifyNoMoreInteractions(Object...)}.
+ */
+ void verifyNoMoreInteractions();
+
+ /**
+ * See {@link Mockito#verifyNoInteractions(Object...)}.
+ */
+ void verifyNoInteractions();
+
+ interface Verification {
+
+ void apply() throws Throwable;
+ }
+}
diff --git a/src/main/java/org/mockito/MockingDetails.java b/src/main/java/org/mockito/MockingDetails.java
index 126b48e..be7dc63 100644
--- a/src/main/java/org/mockito/MockingDetails.java
+++ b/src/main/java/org/mockito/MockingDetails.java
@@ -4,14 +4,14 @@
*/
package org.mockito;
+import java.util.Collection;
+
import org.mockito.invocation.Invocation;
import org.mockito.invocation.MockHandler;
import org.mockito.mock.MockCreationSettings;
import org.mockito.quality.MockitoHint;
import org.mockito.stubbing.Stubbing;
-import java.util.Collection;
-
/**
* Provides mocking information.
* For example, you can identify whether a particular object is either a mock or a spy.
diff --git a/src/main/java/org/mockito/Mockito.java b/src/main/java/org/mockito/Mockito.java
index 4058340..184cc14 100644
--- a/src/main/java/org/mockito/Mockito.java
+++ b/src/main/java/org/mockito/Mockito.java
@@ -29,24 +29,19 @@
import org.mockito.session.MockitoSessionBuilder;
import org.mockito.session.MockitoSessionLogger;
import org.mockito.stubbing.Answer;
-import org.mockito.stubbing.Answer1;
import org.mockito.stubbing.LenientStubber;
import org.mockito.stubbing.OngoingStubbing;
import org.mockito.stubbing.Stubber;
-import org.mockito.stubbing.Stubbing;
-import org.mockito.stubbing.VoidAnswer1;
-import org.mockito.verification.After;
-import org.mockito.verification.Timeout;
-import org.mockito.verification.VerificationAfterDelay;
-import org.mockito.verification.VerificationMode;
-import org.mockito.verification.VerificationWithTimeout;
+import org.mockito.verification.*;
+
+import java.util.function.Function;
/**
* <p align="left"><img src="logo.png" srcset="logo@2x.png 2x" alt="Mockito logo"/></p>
* The Mockito library enables mock creation, verification and stubbing.
*
* <p>
- * This javadoc content is also available on the <a href="http://mockito.org">http://mockito.org</a> web page.
+ * This javadoc content is also available on the <a href="https://site.mockito.org/">https://site.mockito.org/</a> web page.
* All documentation is kept in javadocs because it guarantees consistency between what's on the web and what's in the source code.
* It allows access to documentation straight from the IDE even if you work offline.
* It motivates Mockito developers to keep documentation up-to-date with the code that they write,
@@ -105,12 +100,15 @@
* <a href="#45">45. New JUnit Jupiter (JUnit5+) extension</a><br/>
* <a href="#46">46. New <code>Mockito.lenient()</code> and <code>MockSettings.lenient()</code> methods (Since 2.20.0)</a><br/>
* <a href="#47">47. New API for clearing mock state in inline mocking (Since 2.25.0)</a><br/>
+ * <a href="#48">48. New API for mocking static methods (Since 3.4.0)</a><br/>
+ * <a href="#49">49. New API for mocking object construction (Since 3.5.0)</a><br/>
+ * <a href="#50">50. Avoiding code generation when restricting mocks to interfaces (Since 3.12.2)</a><br/>
* </b>
*
* <h3 id="0">0. <a class="meaningful_link" href="#mockito2" name="mockito2">Migrating to Mockito 2</a></h3>
*
* In order to continue improving Mockito and further improve the unit testing experience, we want you to upgrade to 2.1.0!
- * Mockito follows <a href="http://semver.org/">semantic versioning</a> and contains breaking changes only on major version upgrades.
+ * Mockito follows <a href="https://semver.org/">semantic versioning</a> and contains breaking changes only on major version upgrades.
* In the lifecycle of a library, breaking changes are necessary
* to roll out a set of brand new features that alter the existing behavior or even change the API.
* For a comprehensive guide on the new release including incompatible changes,
@@ -124,7 +122,7 @@
*
* <pre class="code"><code>
* repositories {
- * jcenter()
+ * mavenCentral()
* }
* dependencies {
* testCompile "org.mockito:mockito-core:+"
@@ -146,7 +144,7 @@
*
* <pre class="code"><code>
* repositories {
- * jcenter()
+ * mavenCentral()
* }
* dependencies {
* testCompile "org.mockito:mockito-inline:+"
@@ -208,7 +206,7 @@
*
* //Although it is possible to verify a stubbed invocation, usually <b>it's just redundant</b>
* //If your code cares what get(0) returns, then something else breaks (often even before verify() gets executed).
- * //If your code doesn't care what get(0) returns, then it should not be stubbed. Not convinced? See <a href="http://monkeyisland.pl/2008/04/26/asking-and-telling">here</a>.
+ * //If your code doesn't care what get(0) returns, then it should not be stubbed.
* verify(mockedList).get(0);
* </code></pre>
*
@@ -243,7 +241,7 @@
* when(mockedList.get(anyInt())).thenReturn("element");
*
* //stubbing using custom matcher (let's say isValid() returns your own matcher implementation):
- * when(mockedList.contains(argThat(isValid()))).thenReturn("element");
+ * when(mockedList.contains(argThat(isValid()))).thenReturn(true);
*
* //following prints "element"
* System.out.println(mockedList.get(999));
@@ -275,7 +273,7 @@
* If you are using argument matchers, <b>all arguments</b> have to be provided
* by matchers.
* <p>
- The following example shows verification but the same applies to stubbing:
+ * The following example shows verification but the same applies to stubbing:
*
* <pre class="code"><code class="java">
* verify(mock).someMethod(anyInt(), anyString(), <b>eq("third argument")</b>);
@@ -320,6 +318,7 @@
* verify(mockedList, never()).add("never happened");
*
* //verification using atLeast()/atMost()
+ * verify(mockedList, atMostOnce()).add("once");
* verify(mockedList, atLeastOnce()).add("three times");
* verify(mockedList, atLeast(2)).add("three times");
* verify(mockedList, atMost(5)).add("three times");
@@ -358,7 +357,7 @@
* //create an inOrder verifier for a single mock
* InOrder inOrder = inOrder(singleMock);
*
- * //following will make sure that add is first called with "was added first, then with "was added second"
+ * //following will make sure that add is first called with "was added first", then with "was added second"
* inOrder.verify(singleMock).add("was added first");
* inOrder.verify(singleMock).add("was added second");
*
@@ -427,8 +426,7 @@
* Some users who did a lot of classic, expect-run-verify mocking tend to use <code>verifyNoMoreInteractions()</code> very often, even in every test method.
* <code>verifyNoMoreInteractions()</code> is not recommended to use in every test method.
* <code>verifyNoMoreInteractions()</code> is a handy assertion from the interaction testing toolkit. Use it only when it's relevant.
- * Abusing it leads to <strong>overspecified</strong>, <strong>less maintainable</strong> tests. You can find further reading
- * <a href="http://monkeyisland.pl/2008/07/12/should-i-worry-about-the-unexpected/">here</a>.
+ * Abusing it leads to <strong>overspecified</strong>, <strong>less maintainable</strong> tests.
*
* <p>
* See also {@link Mockito#never()} - it is more explicit and
@@ -455,16 +453,20 @@
* @Mock private UserProvider userProvider;
*
* private ArticleManager manager;
+ *
+ * @org.junit.jupiter.api.Test
+ * void testSomethingInJunit5(@Mock ArticleDatabase database) {
* </code></pre>
*
* <b>Important!</b> This needs to be somewhere in the base class or a test
* runner:
*
* <pre class="code"><code class="java">
- * MockitoAnnotations.initMocks(testClass);
+ * MockitoAnnotations.openMocks(testClass);
* </code></pre>
*
* You can use built-in runner: {@link MockitoJUnitRunner} or a rule: {@link MockitoRule}.
+ * For JUnit5 tests, refer to the JUnit5 extension described in <a href="#45">section 45</a>.
* <p>
* Read more here: {@link MockitoAnnotations}
*
@@ -598,8 +600,7 @@
* <b>Before the release 1.8</b>, Mockito spies were not real partial mocks.
* The reason was we thought partial mock is a code smell.
* At some point we found legitimate use cases for partial mocks
- * (3rd party interfaces, interim refactoring of legacy code, the full article is
- * <a href="http://monkeyisland.pl/2009/01/13/subclass-and-override-vs-partial-mocking-vs-refactoring">here</a>)
+ * (3rd party interfaces, interim refactoring of legacy code).
* <p>
*
* <pre class="code"><code class="java">
@@ -694,7 +695,7 @@
* Also it may reduce defect localization because if stubbed method was not called then no argument is captured.
* <p>
* In a way ArgumentCaptor is related to custom argument matchers (see javadoc for {@link ArgumentMatcher} class).
- * Both techniques can be used for making sure certain arguments where passed to mocks.
+ * Both techniques can be used for making sure certain arguments were passed to mocks.
* However, ArgumentCaptor may be a better fit if:
* <ul>
* <li>custom argument matcher is not likely to be reused</li>
@@ -708,8 +709,7 @@
* <h3 id="16">16. <a class="meaningful_link" href="#partial_mocks" name="partial_mocks">Real partial mocks</a> (Since 1.8.0)</h3>
*
* Finally, after many internal debates & discussions on the mailing list, partial mock support was added to Mockito.
- * Previously we considered partial mocks as code smells. However, we found a legitimate use case for partial mocks - more reading:
- * <a href="http://monkeyisland.pl/2009/01/13/subclass-and-override-vs-partial-mocking-vs-refactoring">here</a>
+ * Previously we considered partial mocks as code smells. However, we found a legitimate use case for partial mocks.
* <p>
* <b>Before release 1.8</b> <code>spy()</code> was not producing real partial mocks and it was confusing for some users.
* Read more about spying: <a href="#13">here</a> or in javadoc for {@link Mockito#spy(Object)} method.
@@ -771,7 +771,7 @@
* <a href="https://github.com/mockito/mockito/wiki/FAQ">https://github.com/mockito/mockito/wiki/FAQ</a>
* <p>
* In case of questions you may also post to mockito mailing list:
- * <a href="http://groups.google.com/group/mockito">http://groups.google.com/group/mockito</a>
+ * <a href="https://groups.google.com/group/mockito">https://groups.google.com/group/mockito</a>
* <p>
* Next, you should know that Mockito validates if you use it correctly <b>all the time</b>.
* However, there's a gotcha so please read the javadoc for {@link Mockito#validateMockitoUsage()}
@@ -784,7 +784,7 @@
* Behavior Driven Development style of writing tests uses <b>//given //when //then</b> comments as fundamental parts of your test methods.
* This is exactly how we write our tests and we warmly encourage you to do so!
* <p>
- * Start learning about BDD here: <a href="http://en.wikipedia.org/wiki/Behavior_Driven_Development">http://en.wikipedia.org/wiki/Behavior_Driven_Development</a>
+ * Start learning about BDD here: <a href="https://en.wikipedia.org/wiki/Behavior-driven_development">https://en.wikipedia.org/wiki/Behavior-driven_development</a>
* <p>
* The problem is that current stubbing api with canonical role of <b>when</b> word does not integrate nicely with <b>//given //when //then</b> comments.
* It's because stubbing belongs to <b>given</b> component of the test and not to the <b>when</b> component of the test.
@@ -827,7 +827,7 @@
* List serializableMock = mock(List.class, withSettings().serializable());
* </code></pre>
* <p>
- * The mock can be serialized assuming all the normal <a href='http://java.sun.com/j2se/1.5.0/docs/api/java/io/Serializable.html'>
+ * The mock can be serialized assuming all the normal <a href='https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html'>
* serialization requirements</a> are met by the class.
* <p>
* Making a real object spy serializable is a bit more effort as the spy(...) method does not have an overloaded version
@@ -864,7 +864,7 @@
* should only use partial mocks as a last resort. See point 16 about partial mocks.
*
* <p>
- * All new annotations are <b>*only*</b> processed on {@link MockitoAnnotations#initMocks(Object)}.
+ * All new annotations are <b>*only*</b> processed on {@link MockitoAnnotations#openMocks(Object)}.
* Just like for @{@link Mock} annotation you can use the built-in runner: {@link MockitoJUnitRunner} or rule:
* {@link MockitoRule}.
* <p>
@@ -908,7 +908,7 @@
* Mockito will now try to instantiate @{@link Spy} and will instantiate @{@link InjectMocks} fields
* using <b>constructor</b> injection, <b>setter</b> injection, or <b>field</b> injection.
* <p>
- * To take advantage of this feature you need to use {@link MockitoAnnotations#initMocks(Object)}, {@link MockitoJUnitRunner}
+ * To take advantage of this feature you need to use {@link MockitoAnnotations#openMocks(Object)}, {@link MockitoJUnitRunner}
* or {@link MockitoRule}.
* <p>
* Read more about available tricks and the rules of injection in the javadoc for {@link InjectMocks}
@@ -1101,7 +1101,7 @@
*
* Mockito introduces serialization across classloader.
*
- * Like with any other form of serialization, all types in the mock hierarchy have to serializable, inclusing answers.
+ * Like with any other form of serialization, all types in the mock hierarchy have to serializable, including answers.
* As this serialization mode require considerably more work, this is an opt-in setting.
*
* <pre class="code"><code class="java">
@@ -1145,7 +1145,7 @@
*
* <ul>
* <li>Annotating the JUnit test class with a <code>@{@link org.junit.runner.RunWith}({@link MockitoJUnitRunner}.class)</code></li>
- * <li>Invoking <code>{@link MockitoAnnotations#initMocks(Object)}</code> in the <code>@{@link org.junit.Before}</code> method</li>
+ * <li>Invoking <code>{@link MockitoAnnotations#openMocks(Object)}</code> in the <code>@{@link org.junit.Before}</code> method</li>
* </ul>
*
* Now you can choose to use a rule :
@@ -1361,7 +1361,7 @@
* </li>
* <li>This mock maker has been designed around Java Agent runtime attachment ; this require a compatible JVM,
* that is part of the JDK (or Java 9 VM). When running on a non-JDK VM prior to Java 9, it is however possible to
- * manually add the <a href="http://bytebuddy.net">Byte Buddy Java agent jar</a> using the <code>-javaagent</code>
+ * manually add the <a href="https://bytebuddy.net">Byte Buddy Java agent jar</a> using the <code>-javaagent</code>
* parameter upon starting the JVM.
* </li>
* </ul>
@@ -1375,9 +1375,11 @@
*
* To quickly find out how "stricter" Mockito can make you more productive and get your tests cleaner, see:
* <ul>
- * <li>Strict stubbing with JUnit Rules - {@link MockitoRule#strictness(Strictness)} with {@link Strictness#STRICT_STUBS}</li>
- * <li>Strict stubbing with JUnit Runner - {@link MockitoJUnitRunner.StrictStubs}</li>
- * <li>Strict stubbing if you cannot use runner/rule (like TestNG) - {@link MockitoSession}</li>
+ * <li>Strict stubbing with JUnit4 Rules - {@link MockitoRule#strictness(Strictness)} with {@link Strictness#STRICT_STUBS}</li>
+ * <li>Strict stubbing with JUnit4 Runner - {@link MockitoJUnitRunner.Strict}</li>
+ * <li>Strict stubbing with JUnit5 Extension - <code>org.mockito.junit.jupiter.MockitoExtension</code></li>
+ * <li>Strict stubbing with TestNG Listener <a href="https://github.com/mockito/mockito-testng">MockitoTestNGListener</a></li>
+ * <li>Strict stubbing if you cannot use runner/rule - {@link MockitoSession}</li>
* <li>Unnecessary stubbing detection with {@link MockitoJUnitRunner}</li>
* <li>Stubbing argument mismatch warnings, documented in {@link MockitoHint}</li>
* </ul>
@@ -1501,7 +1503,7 @@
*
* <h3 id="44">44. <a class="meaningful_link" href="#mockito_instantiator_provider_deprecation" name="mockito_instantiator_provider_deprecation">
* Deprecated <code>org.mockito.plugins.InstantiatorProvider</code> as it was leaking internal API. it was
- * replaced by <code>org.mockito.plugins.InstantiatorProvider2 (Since 2.15.4)</a></h3>
+ * replaced by <code>org.mockito.plugins.InstantiatorProvider2 (Since 2.15.4)</code></a></h3>
*
* <p>{@link org.mockito.plugins.InstantiatorProvider} returned an internal API. Hence it was deprecated and replaced
* by {@link org.mockito.plugins.InstantiatorProvider2}. Old {@link org.mockito.plugins.InstantiatorProvider
@@ -1510,7 +1512,7 @@
* <h3 id="45">45. <a class="meaningful_link" href="#junit5_mockito" name="junit5_mockito">New JUnit Jupiter (JUnit5+) extension</a></h3>
*
* For integration with JUnit Jupiter (JUnit5+), use the `org.mockito:mockito-junit-jupiter` artifact.
- * For more information about the usage of the integration, see <a href="http://javadoc.io/page/org.mockito/mockito-junit-jupiter/latest/org/mockito/junit/jupiter/MockitoExtension.html">the JavaDoc of <code>MockitoExtension</code></a>.
+ * For more information about the usage of the integration, see <a href="https://javadoc.io/doc/org.mockito/mockito-junit-jupiter/latest/org/mockito/junit/jupiter/MockitoExtension.html">the JavaDoc of <code>MockitoExtension</code></a>.
*
* <h3 id="46">46. <a class="meaningful_link" href="#mockito_lenient" name="mockito_lenient">
* New <code>Mockito.lenient()</code> and <code>MockSettings.lenient()</code> methods (Since 2.20.0)</a></h3>
@@ -1542,7 +1544,67 @@
* Hence, we introduced a new API to explicitly clear mock state (only make sense in inline mocking!).
* See example usage in {@link MockitoFramework#clearInlineMocks()}.
* If you have feedback or a better idea how to solve the problem please reach out.
+ *
+ *
+ * <h3 id="48">48. <a class="meaningful_link" href="#static_mocks" name="static_mocks">Mocking static methods</a> (since 3.4.0)</h3>
+ *
+ * When using the <a href="#0.2">inline mock maker</a>, it is possible to mock static method invocations within the current
+ * thread and a user-defined scope. This way, Mockito assures that concurrently and sequentially running tests do not interfere.
+ *
+ * To make sure a static mock remains temporary, it is recommended to define the scope within a try-with-resources construct.
+ * In the following example, the <code>Foo</code> type's static method would return <code>foo</code> unless mocked:
+ *
+ * <pre class="code"><code class="java">
+ * assertEquals("foo", Foo.method());
+ * try (MockedStatic<Foo> mocked = mockStatic(Foo.class)) {
+ * mocked.when(Foo::method).thenReturn("bar");
+ * assertEquals("bar", Foo.method());
+ * mocked.verify(Foo::method);
+ * }
+ * assertEquals("foo", Foo.method());
+ * </code></pre>
+ *
+ * Due to the defined scope of the static mock, it returns to its original behavior once the scope is released. To define mock
+ * behavior and to verify static method invocations, use the <code>MockedStatic</code> that is returned.
+ * <p>
+ *
+ * <h3 id="49">49. <a class="meaningful_link" href="#mocked_construction" name="mocked_construction">Mocking object construction</a> (since 3.5.0)</h3>
+ *
+ * When using the <a href="#0.2">inline mock maker</a>, it is possible to generate mocks on constructor invocations within the current
+ * thread and a user-defined scope. This way, Mockito assures that concurrently and sequentially running tests do not interfere.
+ *
+ * To make sure a constructor mocks remain temporary, it is recommended to define the scope within a try-with-resources construct.
+ * In the following example, the <code>Foo</code> type's construction would generate a mock:
+ *
+ * <pre class="code"><code class="java">
+ * assertEquals("foo", new Foo().method());
+ * try (MockedConstruction<Foo> mocked = mockConstruction(Foo.class)) {
+ * Foo foo = new Foo();
+ * when(foo.method()).thenReturn("bar");
+ * assertEquals("bar", foo.method());
+ * verify(foo).method();
+ * }
+ * assertEquals("foo", new Foo().method());
+ * </code></pre>
+ *
+ * Due to the defined scope of the mocked construction, object construction returns to its original behavior once the scope is
+ * released. To define mock behavior and to verify method invocations, use the <code>MockedConstruction</code> that is returned.
+ * <p>
+ *
+ * <h3 id="50">50. <a class="meaningful_link" href="#proxy_mock_maker" name="mocked_construction">Avoiding code generation when only interfaces are mocked</a> (since 3.12.2)</h3>
+ *
+ * The JVM offers the {@link java.lang.reflect.Proxy} facility for creating dynamic proxies of interface types. For most applications, Mockito
+ * must be capable of mocking classes as supported by the default mock maker, or even final classes, as supported by the inline mock maker. To
+ * create such mocks, Mockito requires to setup diverse JVM facilities and must apply code generation. If only interfaces are supposed to be
+ * mocked, one can however choose to use a {@link org.mockito.internal.creation.proxy.ProxyMockMaker} that is based on the {@link java.lang.reflect.Proxy}
+ * API which avoids diverse overhead of the other mock makers but also limits mocking to interfaces.
+ *
+ * This mock maker can be activated explicitly by the mockito extension mechanism, just create in the classpath a file
+ * <code>/mockito-extensions/org.mockito.plugins.MockMaker</code> containing the value <code>mock-maker-proxy</code>.
+ *
+ * <p>
*/
+@CheckReturnValue
@SuppressWarnings("unchecked")
public class Mockito extends ArgumentMatchers {
@@ -1573,7 +1635,7 @@
* <code>ReturnsSmartNulls</code> first tries to return ordinary values (zeros, empty collections, empty string, etc.)
* then it tries to return SmartNull. If the return type is final then plain <code>null</code> is returned.
* <p>
- * <code>ReturnsSmartNulls</code> will be probably the default return values strategy in Mockito 3.0.0
+ * <code>ReturnsSmartNulls</code> will be probably the default return values strategy in Mockito 4.0.0
* <p>
* Example:
* <pre class="code"><code class="java">
@@ -1694,6 +1756,7 @@
/**
* Optional <code>Answer</code> to be used with {@link Mockito#mock(Class, Answer)}
+ *
* <p>
* {@link Answer} can be used to define the return values of unstubbed invocations.
* <p>
@@ -1725,8 +1788,11 @@
* </code></pre>
*
* <p>
- * <u>Note:</u> Stubbing partial mocks using <code>when(mock.getSomething()).thenReturn(fakeValue)</code>
+ * <u>Note 1:</u> Stubbing partial mocks using <code>when(mock.getSomething()).thenReturn(fakeValue)</code>
* syntax will call the real method. For partial mock it's recommended to use <code>doReturn</code> syntax.
+ * <p>
+ * <u>Note 2:</u> If the mock is serialized then deserialized, then this answer will not be able to understand
+ * generics metadata.
*/
public static final Answer<Object> CALLS_REAL_METHODS = Answers.CALLS_REAL_METHODS;
@@ -1809,7 +1875,6 @@
* @param classToMock class or interface to mock
* @return mock object
*/
- @CheckReturnValue
public static <T> T mock(Class<T> classToMock) {
return mock(classToMock, withSettings());
}
@@ -1829,11 +1894,8 @@
* @param name of the mock
* @return mock object
*/
- @CheckReturnValue
public static <T> T mock(Class<T> classToMock, String name) {
- return mock(classToMock, withSettings()
- .name(name)
- .defaultAnswer(RETURNS_DEFAULTS));
+ return mock(classToMock, withSettings().name(name).defaultAnswer(RETURNS_DEFAULTS));
}
/**
@@ -1848,7 +1910,6 @@
* @return A {@link org.mockito.MockingDetails} instance.
* @since 1.9.5
*/
- @CheckReturnValue
public static MockingDetails mockingDetails(Object toInspect) {
return MOCKITO_CORE.mockingDetails(toInspect);
}
@@ -1872,7 +1933,6 @@
*
* @return mock object
*/
- @CheckReturnValue
public static <T> T mock(Class<T> classToMock, Answer defaultAnswer) {
return mock(classToMock, withSettings().defaultAnswer(defaultAnswer));
}
@@ -1900,7 +1960,6 @@
* @param mockSettings additional mock settings
* @return mock object
*/
- @CheckReturnValue
public static <T> T mock(Class<T> classToMock, MockSettings mockSettings) {
return MOCKITO_CORE.mock(classToMock, mockSettings);
}
@@ -1984,11 +2043,10 @@
* to spy on
* @return a spy of the real object
*/
- @CheckReturnValue
public static <T> T spy(T object) {
- return MOCKITO_CORE.mock((Class<T>) object.getClass(), withSettings()
- .spiedInstance(object)
- .defaultAnswer(CALLS_REAL_METHODS));
+ return MOCKITO_CORE.mock(
+ (Class<T>) object.getClass(),
+ withSettings().spiedInstance(object).defaultAnswer(CALLS_REAL_METHODS));
}
/**
@@ -2019,11 +2077,235 @@
* @since 1.10.12
*/
@Incubating
- @CheckReturnValue
public static <T> T spy(Class<T> classToSpy) {
- return MOCKITO_CORE.mock(classToSpy, withSettings()
- .useConstructor()
- .defaultAnswer(CALLS_REAL_METHODS));
+ return MOCKITO_CORE.mock(
+ classToSpy, withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
+ }
+
+ /**
+ * Creates a thread-local mock controller for all static methods of the given class or interface.
+ * The returned object's {@link MockedStatic#close()} method must be called upon completing the
+ * test or the mock will remain active on the current thread.
+ * <p>
+ * <b>Note</b>: We recommend against mocking static methods of classes in the standard library or
+ * classes used by custom class loaders used to executed the block with the mocked class. A mock
+ * maker might forbid mocking static methods of know classes that are known to cause problems.
+ * Also, if a static method is a JVM-intrinsic, it cannot typically be mocked even if not
+ * explicitly forbidden.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock class or interface of which static mocks should be mocked.
+ * @return mock controller
+ */
+ @Incubating
+ public static <T> MockedStatic<T> mockStatic(Class<T> classToMock) {
+ return mockStatic(classToMock, withSettings());
+ }
+
+ /**
+ * Creates a thread-local mock controller for all static methods of the given class or interface.
+ * The returned object's {@link MockedStatic#close()} method must be called upon completing the
+ * test or the mock will remain active on the current thread.
+ * <p>
+ * <b>Note</b>: We recommend against mocking static methods of classes in the standard library or
+ * classes used by custom class loaders used to executed the block with the mocked class. A mock
+ * maker might forbid mocking static methods of know classes that are known to cause problems.
+ * Also, if a static method is a JVM-intrinsic, it cannot typically be mocked even if not
+ * explicitly forbidden.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock class or interface of which static mocks should be mocked.
+ * @param defaultAnswer the default answer when invoking static methods.
+ * @return mock controller
+ */
+ @Incubating
+ public static <T> MockedStatic<T> mockStatic(Class<T> classToMock, Answer defaultAnswer) {
+ return mockStatic(classToMock, withSettings().defaultAnswer(defaultAnswer));
+ }
+
+ /**
+ * Creates a thread-local mock controller for all static methods of the given class or interface.
+ * The returned object's {@link MockedStatic#close()} method must be called upon completing the
+ * test or the mock will remain active on the current thread.
+ * <p>
+ * <b>Note</b>: We recommend against mocking static methods of classes in the standard library or
+ * classes used by custom class loaders used to executed the block with the mocked class. A mock
+ * maker might forbid mocking static methods of know classes that are known to cause problems.
+ * Also, if a static method is a JVM-intrinsic, it cannot typically be mocked even if not
+ * explicitly forbidden.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock class or interface of which static mocks should be mocked.
+ * @param name the name of the mock to use in error messages.
+ * @return mock controller
+ */
+ @Incubating
+ public static <T> MockedStatic<T> mockStatic(Class<T> classToMock, String name) {
+ return mockStatic(classToMock, withSettings().name(name));
+ }
+
+ /**
+ * Creates a thread-local mock controller for all static methods of the given class or interface.
+ * The returned object's {@link MockedStatic#close()} method must be called upon completing the
+ * test or the mock will remain active on the current thread.
+ * <p>
+ * <b>Note</b>: We recommend against mocking static methods of classes in the standard library or
+ * classes used by custom class loaders used to executed the block with the mocked class. A mock
+ * maker might forbid mocking static methods of know classes that are known to cause problems.
+ * Also, if a static method is a JVM-intrinsic, it cannot typically be mocked even if not
+ * explicitly forbidden.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock class or interface of which static mocks should be mocked.
+ * @param mockSettings the settings to use where only name and default answer are considered.
+ * @return mock controller
+ */
+ @Incubating
+ public static <T> MockedStatic<T> mockStatic(Class<T> classToMock, MockSettings mockSettings) {
+ return MOCKITO_CORE.mockStatic(classToMock, mockSettings);
+ }
+
+ /**
+ * Creates a thread-local mock controller for all constructions of the given class.
+ * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+ * test or the mock will remain active on the current thread.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock non-abstract class of which constructions should be mocked.
+ * @param defaultAnswer the default answer for the first created mock.
+ * @param additionalAnswers the default answer for all additional mocks. For any access mocks, the
+ * last answer is used. If this array is empty, the {@code defaultAnswer} is used.
+ * @return mock controller
+ */
+ @Incubating
+ public static <T> MockedConstruction<T> mockConstructionWithAnswer(
+ Class<T> classToMock, Answer defaultAnswer, Answer... additionalAnswers) {
+ return mockConstruction(
+ classToMock,
+ context -> {
+ if (context.getCount() == 1 || additionalAnswers.length == 0) {
+ return withSettings().defaultAnswer(defaultAnswer);
+ } else if (context.getCount() >= additionalAnswers.length) {
+ return withSettings()
+ .defaultAnswer(additionalAnswers[additionalAnswers.length - 1]);
+ } else {
+ return withSettings()
+ .defaultAnswer(additionalAnswers[context.getCount() - 2]);
+ }
+ },
+ (mock, context) -> {});
+ }
+
+ /**
+ * Creates a thread-local mock controller for all constructions of the given class.
+ * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+ * test or the mock will remain active on the current thread.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock non-abstract class of which constructions should be mocked.
+ * @return mock controller
+ */
+ @Incubating
+ public static <T> MockedConstruction<T> mockConstruction(Class<T> classToMock) {
+ return mockConstruction(classToMock, index -> withSettings(), (mock, context) -> {});
+ }
+
+ /**
+ * Creates a thread-local mock controller for all constructions of the given class.
+ * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+ * test or the mock will remain active on the current thread.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock non-abstract class of which constructions should be mocked.
+ * @param mockInitializer a callback to prepare a mock's methods after its instantiation.
+ * @return mock controller
+ */
+ @Incubating
+ public static <T> MockedConstruction<T> mockConstruction(
+ Class<T> classToMock, MockedConstruction.MockInitializer<T> mockInitializer) {
+ return mockConstruction(classToMock, withSettings(), mockInitializer);
+ }
+
+ /**
+ * Creates a thread-local mock controller for all constructions of the given class.
+ * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+ * test or the mock will remain active on the current thread.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock non-abstract class of which constructions should be mocked.
+ * @param mockSettings the mock settings to use.
+ * @return mock controller
+ */
+ @Incubating
+ public static <T> MockedConstruction<T> mockConstruction(
+ Class<T> classToMock, MockSettings mockSettings) {
+ return mockConstruction(classToMock, context -> mockSettings);
+ }
+
+ /**
+ * Creates a thread-local mock controller for all constructions of the given class.
+ * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+ * test or the mock will remain active on the current thread.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock non-abstract class of which constructions should be mocked.
+ * @param mockSettingsFactory the mock settings to use.
+ * @return mock controller
+ */
+ @Incubating
+ public static <T> MockedConstruction<T> mockConstruction(
+ Class<T> classToMock,
+ Function<MockedConstruction.Context, MockSettings> mockSettingsFactory) {
+ return mockConstruction(classToMock, mockSettingsFactory, (mock, context) -> {});
+ }
+
+ /**
+ * Creates a thread-local mock controller for all constructions of the given class.
+ * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+ * test or the mock will remain active on the current thread.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock non-abstract class of which constructions should be mocked.
+ * @param mockSettings the settings to use.
+ * @param mockInitializer a callback to prepare a mock's methods after its instantiation.
+ * @return mock controller
+ */
+ @Incubating
+ public static <T> MockedConstruction<T> mockConstruction(
+ Class<T> classToMock,
+ MockSettings mockSettings,
+ MockedConstruction.MockInitializer<T> mockInitializer) {
+ return mockConstruction(classToMock, index -> mockSettings, mockInitializer);
+ }
+
+ /**
+ * Creates a thread-local mock controller for all constructions of the given class.
+ * The returned object's {@link MockedConstruction#close()} method must be called upon completing the
+ * test or the mock will remain active on the current thread.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param classToMock non-abstract class of which constructions should be mocked.
+ * @param mockSettingsFactory a function to create settings to use.
+ * @param mockInitializer a callback to prepare a mock's methods after its instantiation.
+ * @return mock controller
+ */
+ @Incubating
+ public static <T> MockedConstruction<T> mockConstruction(
+ Class<T> classToMock,
+ Function<MockedConstruction.Context, MockSettings> mockSettingsFactory,
+ MockedConstruction.MockInitializer<T> mockInitializer) {
+ return MOCKITO_CORE.mockConstruction(classToMock, mockSettingsFactory, mockInitializer);
}
/**
@@ -2079,7 +2361,6 @@
* Let's say you've stubbed <code>foo.bar()</code>.
* If your code cares what <code>foo.bar()</code> returns then something else breaks(often before even <code>verify()</code> gets executed).
* If your code doesn't care what <code>get(0)</code> returns then it should not be stubbed.
- * Not convinced? See <a href="http://monkeyisland.pl/2008/04/26/asking-and-telling">here</a>.
*
* <p>
* See examples in javadoc for {@link Mockito} class
@@ -2087,7 +2368,6 @@
* @return OngoingStubbing object used to stub fluently.
* <strong>Do not</strong> create a reference to this returned object.
*/
- @CheckReturnValue
public static <T> OngoingStubbing<T> when(T methodCall) {
return MOCKITO_CORE.when(methodCall);
}
@@ -2110,8 +2390,7 @@
* Although it is possible to verify a stubbed invocation, usually <b>it's just redundant</b>.
* Let's say you've stubbed <code>foo.bar()</code>.
* If your code cares what <code>foo.bar()</code> returns then something else breaks(often before even <code>verify()</code> gets executed).
- * If your code doesn't care what <code>get(0)</code> returns then it should not be stubbed.
- * Not convinced? See <a href="http://monkeyisland.pl/2008/04/26/asking-and-telling">here</a>.
+ * If your code doesn't care what <code>foo.bar()</code> returns then it should not be stubbed.
*
* <p>
* See examples in javadoc for {@link Mockito} class
@@ -2119,7 +2398,6 @@
* @param mock to be verified
* @return mock object itself
*/
- @CheckReturnValue
public static <T> T verify(T mock) {
return MOCKITO_CORE.verify(mock, times(1));
}
@@ -2146,7 +2424,6 @@
*
* @return mock object itself
*/
- @CheckReturnValue
public static <T> T verify(T mock, VerificationMode mode) {
return MOCKITO_CORE.verify(mock, mode);
}
@@ -2177,11 +2454,22 @@
* @param <T> The Type of the mocks
* @param mocks to be reset
*/
- public static <T> void reset(T ... mocks) {
+ public static <T> void reset(T... mocks) {
MOCKITO_CORE.reset(mocks);
}
/**
+ * Clears all mocks, type caches and instrumentations.
+ * <p>
+ * By clearing Mockito's state, previously created mocks might begin to malfunction. This option can be used if
+ * Mockito's caches take up too much space or if the inline mock maker's instrumentation is causing performance
+ * issues in code where mocks are no longer used. Normally, you would not need to use this option.
+ */
+ public static void clearAllCaches() {
+ MOCKITO_CORE.clearAllCaches();
+ }
+
+ /**
* Use this method in order to only clear invocations, when stubbing is non-trivial. Use-cases can be:
* <ul>
* <li>You are using a dependency injection framework to inject your mocks.</li>
@@ -2192,7 +2480,7 @@
* @param <T> The type of the mocks
* @param mocks The mocks to clear the invocations for
*/
- public static <T> void clearInvocations(T ... mocks) {
+ public static <T> void clearInvocations(T... mocks) {
MOCKITO_CORE.clearInvocations(mocks);
}
@@ -2213,8 +2501,7 @@
* Some users who did a lot of classic, expect-run-verify mocking tend to use <code>verifyNoMoreInteractions()</code> very often, even in every test method.
* <code>verifyNoMoreInteractions()</code> is not recommended to use in every test method.
* <code>verifyNoMoreInteractions()</code> is a handy assertion from the interaction testing toolkit. Use it only when it's relevant.
- * Abusing it leads to overspecified, less maintainable tests. You can find further reading
- * <a href="http://monkeyisland.pl/2008/07/12/should-i-worry-about-the-unexpected/">here</a>.
+ * Abusing it leads to overspecified, less maintainable tests.
* <p>
* This method will also detect unverified invocations that occurred before the test method,
* for example: in <code>setUp()</code>, <code>@Before</code> method or in constructor.
@@ -2249,12 +2536,34 @@
* This method has the same behavior as {@link #verifyNoMoreInteractions(Object...)}.
*
* @param mocks to be verified
+ * @deprecated Since 3.0.1. Please migrate your code to {@link #verifyNoInteractions(Object...)}
*/
+ @Deprecated
public static void verifyZeroInteractions(Object... mocks) {
MOCKITO_CORE.verifyNoMoreInteractions(mocks);
}
/**
+ * Verifies that no interactions happened on given mocks.
+ * <pre class="code"><code class="java">
+ * verifyNoInteractions(mockOne, mockTwo);
+ * </code></pre>
+ * This method will also detect invocations
+ * that occurred before the test method, for example: in <code>setUp()</code>, <code>@Before</code> method or in constructor.
+ * Consider writing nice code that makes interactions only in test methods.
+ * <p>
+ * See also {@link Mockito#never()} - it is more explicit and communicates the intent well.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @param mocks to be verified
+ * @since 3.0.1
+ */
+ public static void verifyNoInteractions(Object... mocks) {
+ MOCKITO_CORE.verifyNoInteractions(mocks);
+ }
+
+ /**
* Use <code>doThrow()</code> when you want to stub the void method with an exception.
* <p>
* Stubbing voids requires different approach from {@link Mockito#when(Object)} because the compiler
@@ -2269,7 +2578,6 @@
* @param toBeThrown to be thrown when the stubbed method is called
* @return stubber - to select a method for stubbing
*/
- @CheckReturnValue
public static Stubber doThrow(Throwable... toBeThrown) {
return MOCKITO_CORE.stubber().doThrow(toBeThrown);
}
@@ -2292,7 +2600,6 @@
* @return stubber - to select a method for stubbing
* @since 2.1.0
*/
- @CheckReturnValue
public static Stubber doThrow(Class<? extends Throwable> toBeThrown) {
return MOCKITO_CORE.stubber().doThrow(toBeThrown);
}
@@ -2317,14 +2624,14 @@
* @return stubber - to select a method for stubbing
* @since 2.1.0
*/
- // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array creation
- @SuppressWarnings ({"unchecked", "varargs"})
- @CheckReturnValue
- public static Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... toBeThrownNext) {
+ // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array
+ // creation
+ @SuppressWarnings({"unchecked", "varargs"})
+ public static Stubber doThrow(
+ Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... toBeThrownNext) {
return MOCKITO_CORE.stubber().doThrow(toBeThrown, toBeThrownNext);
}
-
/**
* Use <code>doCallRealMethod()</code> when you want to call the real implementation of a method.
* <p>
@@ -2356,7 +2663,6 @@
* @return stubber - to select a method for stubbing
* @since 1.9.5
*/
- @CheckReturnValue
public static Stubber doCallRealMethod() {
return MOCKITO_CORE.stubber().doCallRealMethod();
}
@@ -2383,7 +2689,6 @@
* @param answer to answer when the stubbed method is called
* @return stubber - to select a method for stubbing
*/
- @CheckReturnValue
public static Stubber doAnswer(Answer answer) {
return MOCKITO_CORE.stubber().doAnswer(answer);
}
@@ -2426,7 +2731,6 @@
*
* @return stubber - to select a method for stubbing
*/
- @CheckReturnValue
public static Stubber doNothing() {
return MOCKITO_CORE.stubber().doNothing();
}
@@ -2477,7 +2781,6 @@
* @param toBeReturned to be returned when the stubbed method is called
* @return stubber - to select a method for stubbing
*/
- @CheckReturnValue
public static Stubber doReturn(Object toBeReturned) {
return MOCKITO_CORE.stubber().doReturn(toBeReturned);
}
@@ -2532,7 +2835,6 @@
* @since 2.1.0
*/
@SuppressWarnings({"unchecked", "varargs"})
- @CheckReturnValue
public static Stubber doReturn(Object toBeReturned, Object... toBeReturnedNext) {
return MOCKITO_CORE.stubber().doReturn(toBeReturned, toBeReturnedNext);
}
@@ -2554,9 +2856,9 @@
* <p>
* <code>InOrder</code> verification is 'greedy', but you will hardly ever notice it.
* If you want to find out more, read
- * <a href="https://github.com/mockito/mockito/wiki/Greedy-algorithm-of-verfication-InOrder">this wiki page</a>.
+ * <a href="https://github.com/mockito/mockito/wiki/Greedy-algorithm-of-verification-InOrder">this wiki page</a>.
* <p>
- * As of Mockito 1.8.4 you can verifyNoMoreInvocations() in order-sensitive way. Read more: {@link InOrder#verifyNoMoreInteractions()}
+ * As of Mockito 1.8.4 you can verifyNoMoreInteractions() in order-sensitive way. Read more: {@link InOrder#verifyNoMoreInteractions()}
* <p>
* See examples in javadoc for {@link Mockito} class
*
@@ -2564,7 +2866,6 @@
*
* @return InOrder object to be used to verify in order
*/
- @CheckReturnValue
public static InOrder inOrder(Object... mocks) {
return MOCKITO_CORE.inOrder(mocks);
}
@@ -2665,7 +2966,6 @@
*
* @return verification mode
*/
- @CheckReturnValue
public static VerificationMode times(int wantedNumberOfInvocations) {
return VerificationModeFactory.times(wantedNumberOfInvocations);
}
@@ -2687,7 +2987,6 @@
*
* @return verification mode
*/
- @CheckReturnValue
public static VerificationMode never() {
return times(0);
}
@@ -2703,7 +3002,6 @@
*
* @return verification mode
*/
- @CheckReturnValue
public static VerificationMode atLeastOnce() {
return VerificationModeFactory.atLeastOnce();
}
@@ -2720,12 +3018,26 @@
*
* @return verification mode
*/
- @CheckReturnValue
public static VerificationMode atLeast(int minNumberOfInvocations) {
return VerificationModeFactory.atLeast(minNumberOfInvocations);
}
/**
+ * Allows at-most-once verification. E.g:
+ * <pre class="code"><code class="java">
+ * verify(mock, atMostOnce()).someMethod("some arg");
+ * </code></pre>
+ * Alias to <code>atMost(1)</code>.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @return verification mode
+ */
+ public static VerificationMode atMostOnce() {
+ return VerificationModeFactory.atMostOnce();
+ }
+
+ /**
* Allows at-most-x verification. E.g:
* <pre class="code"><code class="java">
* verify(mock, atMost(3)).someMethod("some arg");
@@ -2737,7 +3049,6 @@
*
* @return verification mode
*/
- @CheckReturnValue
public static VerificationMode atMost(int maxNumberOfInvocations) {
return VerificationModeFactory.atMost(maxNumberOfInvocations);
}
@@ -2755,9 +3066,8 @@
* @param wantedNumberOfInvocations number of invocations to verify
* @return verification mode
*/
- @CheckReturnValue
- public static VerificationMode calls( int wantedNumberOfInvocations ){
- return VerificationModeFactory.calls( wantedNumberOfInvocations );
+ public static VerificationMode calls(int wantedNumberOfInvocations) {
+ return VerificationModeFactory.calls(wantedNumberOfInvocations);
}
/**
@@ -2766,7 +3076,7 @@
* verify(mock, only()).someMethod();
* //above is a shorthand for following 2 lines of code:
* verify(mock).someMethod();
- * verifyNoMoreInvocations(mock);
+ * verifyNoMoreInteractions(mock);
* </code></pre>
*
* <p>
@@ -2776,20 +3086,18 @@
*
* @return verification mode
*/
- @CheckReturnValue
public static VerificationMode only() {
return VerificationModeFactory.only();
}
/**
- * Verification will be triggered after given amount of millis, allowing testing of async code.
+ * Verification will be triggered over and over until the given amount of millis, allowing testing of async code.
* Useful when interactions with the mock object did not happened yet.
- * Extensive use of after() method can be a code smell - there are better ways of testing concurrent code.
+ * Extensive use of {@code timeout()} method can be a code smell - there are better ways of testing concurrent code.
* <p>
* See also {@link #after(long)} method for testing async code.
* Differences between {@code timeout()} and {@code after} are explained in Javadoc for {@link #after(long)}.
- * <p>
- * Extensive use of {@code timeout()} method can be a code smell - there are better ways of testing concurrent code.
+ *
* <pre class="code"><code class="java">
* //passes when someMethod() is called no later than within 100 ms
* //exits immediately when verification is satisfied (e.g. may not wait full 100 ms)
@@ -2810,7 +3118,6 @@
*
* @return object that allows fluent specification of the verification (times(x), atLeast(y), etc.)
*/
- @CheckReturnValue
public static VerificationWithTimeout timeout(long millis) {
return new Timeout(millis, VerificationModeFactory.times(1));
}
@@ -2818,7 +3125,7 @@
/**
* Verification will be triggered after given amount of millis, allowing testing of async code.
* Useful when interactions with the mock object did not happened yet.
- * Extensive use of after() method can be a code smell - there are better ways of testing concurrent code.
+ * Extensive use of {@code after()} method can be a code smell - there are better ways of testing concurrent code.
* <p>
* Not yet implemented to work with InOrder verification.
* <p>
@@ -2866,7 +3173,6 @@
*
* @return object that allows fluent specification of the verification
*/
- @CheckReturnValue
public static VerificationAfterDelay after(long millis) {
return new After(millis, VerificationModeFactory.times(1));
}
@@ -2874,7 +3180,7 @@
/**
* First of all, in case of any trouble, I encourage you to read the Mockito FAQ: <a href="https://github.com/mockito/mockito/wiki/FAQ">https://github.com/mockito/mockito/wiki/FAQ</a>
* <p>
- * In case of questions you may also post to mockito mailing list: <a href="http://groups.google.com/group/mockito">http://groups.google.com/group/mockito</a>
+ * In case of questions you may also post to mockito mailing list: <a href="https://groups.google.com/group/mockito">https://groups.google.com/group/mockito</a>
* <p>
* <code>validateMockitoUsage()</code> <b>explicitly validates</b> the framework state to detect invalid use of Mockito.
* However, this feature is optional <b>because Mockito validates the usage all the time...</b> but there is a gotcha so read on.
@@ -2950,7 +3256,6 @@
*
* @return mock settings instance with defaults.
*/
- @CheckReturnValue
public static MockSettings withSettings() {
return new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS);
}
@@ -2964,7 +3269,6 @@
* @return verification mode
* @since 2.1.0
*/
- @CheckReturnValue
public static VerificationMode description(String description) {
return times(1).description(description);
}
@@ -2974,7 +3278,6 @@
* An instance of {@code MockingDetails} can be retrieved via {@link #mockingDetails(Object)}.
*/
@Deprecated
- @CheckReturnValue
static MockitoDebugger debug() {
return new MockitoDebuggerImpl();
}
@@ -2985,7 +3288,6 @@
* @since 2.1.0
*/
@Incubating
- @CheckReturnValue
public static MockitoFramework framework() {
return new DefaultMockitoFramework();
}
@@ -2999,7 +3301,6 @@
* @since 2.7.0
*/
@Incubating
- @CheckReturnValue
public static MockitoSessionBuilder mockitoSession() {
return new DefaultMockitoSessionBuilder();
}
diff --git a/src/main/java/org/mockito/MockitoAnnotations.java b/src/main/java/org/mockito/MockitoAnnotations.java
index 518a36f..1672422 100644
--- a/src/main/java/org/mockito/MockitoAnnotations.java
+++ b/src/main/java/org/mockito/MockitoAnnotations.java
@@ -2,16 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito;
+import static org.mockito.internal.util.StringUtil.join;
+
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.configuration.GlobalConfiguration;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.plugins.AnnotationEngine;
/**
- * MockitoAnnotations.initMocks(this); initializes fields annotated with Mockito annotations.
+ * MockitoAnnotations.openMocks(this); initializes fields annotated with Mockito annotations.
* See also {@link MockitoSession} which not only initializes mocks
* but also adds extra validation for cleaner tests!
* <p>
@@ -38,34 +39,74 @@
*
* public class SampleBaseTestCase {
*
- * @Before public void initMocks() {
- * MockitoAnnotations.initMocks(this);
+ * private AutoCloseable closeable;
+ *
+ * @Before public void openMocks() {
+ * closeable = MockitoAnnotations.openMocks(this);
+ * }
+ *
+ * @After public void releaseMocks() throws Exception {
+ * closeable.close();
* }
* }
* </code></pre>
* <p>
* Read also about other annotations @{@link Spy}, @{@link Captor}, @{@link InjectMocks}
* <p>
- * <b><code>MockitoAnnotations.initMocks(this)</code></b> method has to called to initialize annotated fields.
+ * <b><code>MockitoAnnotations.openMocks(this)</code></b> method has to be called to initialize annotated fields.
* <p>
- * In above example, <code>initMocks()</code> is called in @Before (JUnit4) method of test's base class.
- * For JUnit3 <code>initMocks()</code> can go to <code>setup()</code> method of a base class.
- * You can also put initMocks() in your JUnit runner (@RunWith) or use built-in runner: {@link MockitoJUnitRunner}
+ * In above example, <code>openMocks()</code> is called in @Before (JUnit4) method of test's base class.
+ * For JUnit3 <code>openMocks()</code> can go to <code>setup()</code> method of a base class.
+ * You can also put openMocks() in your JUnit runner (@RunWith) or use built-in runner: {@link MockitoJUnitRunner}.
+ * If static method mocks are used, it is required to close the initialization. Additionally, if using third-party
+ * mock-makers, other life-cycles might be handled by the open-release routine.
*/
-public class MockitoAnnotations {
+public final class MockitoAnnotations {
/**
* Initializes objects annotated with Mockito annotations for given testClass:
* @{@link org.mockito.Mock}, @{@link Spy}, @{@link Captor}, @{@link InjectMocks}
* <p>
* See examples in javadoc for {@link MockitoAnnotations} class.
+ *
+ * @return A closable to close when completing any tests in {@code testClass}.
*/
- public static void initMocks(Object testClass) {
+ public static AutoCloseable openMocks(Object testClass) {
if (testClass == null) {
- throw new MockitoException("testClass cannot be null. For info how to use @Mock annotations see examples in javadoc for MockitoAnnotations class");
+ throw new MockitoException(
+ "testClass cannot be null. For info how to use @Mock annotations see examples in javadoc for MockitoAnnotations class");
}
- AnnotationEngine annotationEngine = new GlobalConfiguration().tryGetPluginAnnotationEngine();
- annotationEngine.process(testClass.getClass(), testClass);
+ AnnotationEngine annotationEngine =
+ new GlobalConfiguration().tryGetPluginAnnotationEngine();
+ return annotationEngine.process(testClass.getClass(), testClass);
}
+
+ /**
+ * Initializes objects annotated with Mockito annotations for given testClass:
+ * @{@link org.mockito.Mock}, @{@link Spy}, @{@link Captor}, @{@link InjectMocks}
+ * <p>
+ * See examples in javadoc for {@link MockitoAnnotations} class.
+ *
+ * @deprecated Use {@link MockitoAnnotations#openMocks(Object)} instead.
+ * This method is equivalent to {@code openMocks(testClass).close()}.
+ * The close method should however only be called after completed usage of {@code testClass}.
+ * If using static-mocks or custom {@link org.mockito.plugins.MockMaker}s, using this method might
+ * cause misbehavior of mocks injected into the test class.
+ */
+ @Deprecated
+ public static void initMocks(Object testClass) {
+ try {
+ openMocks(testClass).close();
+ } catch (Exception e) {
+ throw new MockitoException(
+ join(
+ "Failed to release mocks",
+ "",
+ "This should not happen unless you are using a third-party mock maker"),
+ e);
+ }
+ }
+
+ private MockitoAnnotations() {}
}
diff --git a/src/main/java/org/mockito/MockitoDebugger.java b/src/main/java/org/mockito/MockitoDebugger.java
index 90c7e9a..7ee2229 100644
--- a/src/main/java/org/mockito/MockitoDebugger.java
+++ b/src/main/java/org/mockito/MockitoDebugger.java
@@ -16,5 +16,5 @@
* An instance of {@code MockingDetails} can be retrieved via {@link Mockito#mockingDetails(Object)}.
*/
@Deprecated
- String printInvocations(Object ... mocks);
+ String printInvocations(Object... mocks);
}
diff --git a/src/main/java/org/mockito/MockitoFramework.java b/src/main/java/org/mockito/MockitoFramework.java
index 58cd4b6..da03ef4 100644
--- a/src/main/java/org/mockito/MockitoFramework.java
+++ b/src/main/java/org/mockito/MockitoFramework.java
@@ -20,6 +20,7 @@
* @since 2.1.0
*/
@Incubating
+@NotExtensible
public interface MockitoFramework {
/**
diff --git a/src/main/java/org/mockito/MockitoSession.java b/src/main/java/org/mockito/MockitoSession.java
index 9e820f2..c7989be 100644
--- a/src/main/java/org/mockito/MockitoSession.java
+++ b/src/main/java/org/mockito/MockitoSession.java
@@ -27,7 +27,6 @@
* otherwise {@link UnfinishedMockingSessionException} is triggered when the next session is created.
* <p>
* {@code MockitoSession} is useful when you cannot use {@link MockitoJUnitRunner} or {@link MockitoRule}.
- * For example, you work with TestNG instead of JUnit.
* Another example is when different JUnit runner is in use (Jukito, Springockito)
* and it cannot be combined with Mockito's own runner.
* <p>
@@ -67,18 +66,18 @@
* <p>
* Why to use {@code MockitoSession}?
* What's the difference between {@code MockitoSession}, {@link MockitoJUnitRunner}, {@link MockitoRule}
- * and traditional {@link MockitoAnnotations#initMocks(Object)}?
+ * and traditional {@link MockitoAnnotations#openMocks(Object)}?
* <p>
* Great questions!
* There is no need to use {@code MockitoSession} if you already use {@link MockitoJUnitRunner} or {@link MockitoRule}.
* If you are JUnit user who does not leverage Mockito rule or runner we strongly recommend to do so.
* Both the runner and the rule support strict stubbing which can really help driving cleaner tests.
* See {@link MockitoJUnitRunner.StrictStubs} and {@link MockitoRule#strictness(Strictness)}.
- * If you cannot use Mockito's JUnit support (for example, you are on TestNG) {@code MockitoSession} exactly is for you!
+ * If you cannot use Mockito's JUnit support {@code MockitoSession} exactly is for you!
* You can automatically take advantage of strict stubbing ({@link Strictness}),
* automatic initialization of annotated mocks ({@link MockitoAnnotations}),
* and extra validation ({@link Mockito#validateMockitoUsage()}).
- * If you use Mockito annotations with {@link MockitoAnnotations#initMocks(Object)}
+ * If you use Mockito annotations with {@link MockitoAnnotations#openMocks(Object)}
* but not Mockito runner/rule please try out Mockito's JUnit support (runner or rule) or
* start using {@code MockitoSession}. You'll get cleaner tests and better productivity.
* <p>
@@ -88,6 +87,7 @@
* @since 2.7.0
*/
@Incubating
+@NotExtensible
public interface MockitoSession {
/**
diff --git a/src/main/java/org/mockito/NotExtensible.java b/src/main/java/org/mockito/NotExtensible.java
index de67a0a..39191ac 100644
--- a/src/main/java/org/mockito/NotExtensible.java
+++ b/src/main/java/org/mockito/NotExtensible.java
@@ -26,5 +26,4 @@
*/
@Retention(RetentionPolicy.RUNTIME)
@Documented
-public @interface NotExtensible {
-}
+public @interface NotExtensible {}
diff --git a/src/main/java/org/mockito/ScopedMock.java b/src/main/java/org/mockito/ScopedMock.java
new file mode 100644
index 0000000..3ef0d9b
--- /dev/null
+++ b/src/main/java/org/mockito/ScopedMock.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+/**
+ * Represents a mock with a thread-local explicit scope. Scoped mocks must be closed by the entity
+ * that activates the scoped mock.
+ */
+@Incubating
+public interface ScopedMock extends AutoCloseable {
+
+ /**
+ * Checks if this mock is closed.
+ *
+ * @return {@code true} if this mock is closed.
+ */
+ boolean isClosed();
+
+ /**
+ * Closes this scoped mock and throws an exception if already closed.
+ */
+ @Override
+ void close();
+
+ /**
+ * Releases this scoped mock and is non-operational if already released.
+ */
+ void closeOnDemand();
+}
diff --git a/src/main/java/org/mockito/Spy.java b/src/main/java/org/mockito/Spy.java
index 6bb4609..aa485a3 100644
--- a/src/main/java/org/mockito/Spy.java
+++ b/src/main/java/org/mockito/Spy.java
@@ -6,9 +6,11 @@
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
+
import org.mockito.junit.MockitoJUnitRunner;
/**
@@ -23,9 +25,14 @@
* @Spy Foo spyOnFoo = new Foo("argument");
* //Instance for spying is created by mockito via reflection (only default constructors supported):
* @Spy Bar spyOnBar;
+ * private AutoCloseable closeable;
* @Before
- * public void init(){
- * MockitoAnnotations.initMocks(this);
+ * public void init() {
+ * closeable = MockitoAnnotations.openMocks(this);
+ * }
+ * @After
+ * public void release() throws Exception {
+ * closeable.close();
* }
* ...
* }
@@ -82,12 +89,13 @@
* </ol>
*
* <p>
- * <strong>One last warning :</strong> if you call <code>MockitoAnnotations.initMocks(this)</code> in a
+ * <strong>One last warning :</strong> if you call <code>MockitoAnnotations.openMocks(this)</code> in a
* super class <strong>constructor</strong> then this will not work. It is because fields
* in subclass are only instantiated after super class constructor has returned.
* It's better to use @Before.
- * <strong>Instead</strong> you can also put initMocks() in your JUnit runner (@RunWith) or use the built-in
- * {@link MockitoJUnitRunner}.
+ * <strong>Instead</strong> you can also put openMocks() in your JUnit runner (@RunWith) or use the built-in
+ * {@link MockitoJUnitRunner}. Also, make sure to release any mocks after disposing your test class with a
+ * corresponding hook.
* </p>
*
* <p>Note that the spy won't have any annotations of the spied type, because CGLIB won't rewrite them.
@@ -96,11 +104,11 @@
* @see Mockito#spy(Object)
* @see Mock
* @see InjectMocks
- * @see MockitoAnnotations#initMocks(Object)
+ * @see MockitoAnnotations#openMocks(Object)
* @see MockitoJUnitRunner
* @since 1.8.3
*/
@Retention(RUNTIME)
@Target(FIELD)
@Documented
-public @interface Spy { }
+public @interface Spy {}
diff --git a/src/main/java/org/mockito/configuration/AnnotationEngine.java b/src/main/java/org/mockito/configuration/AnnotationEngine.java
index 40ff352..8978781 100644
--- a/src/main/java/org/mockito/configuration/AnnotationEngine.java
+++ b/src/main/java/org/mockito/configuration/AnnotationEngine.java
@@ -9,7 +9,7 @@
/**
* Configures mock creation logic behind @Mock, @Captor and @Spy annotations
* <p>
- * If you are interested then see implementations or source code of {@link MockitoAnnotations#initMocks(Object)}
+ * If you are interested then see implementations or source code of {@link MockitoAnnotations#openMocks(Object)}
*
* <p>This interface can be used to configure a different annotation engine through
* {@link org.mockito.configuration.IMockitoConfiguration}, however this mechanism is being superseded by the new
@@ -19,10 +19,9 @@
* Note that if it exists on the classpath both a class <code>org.mockito.configuration.MockitoConfiguration</code>
* and a file <code>mockito-extensions/org.mockito.plugins.AnnotationEngine</code> then the implementation of
* <code>org.mockito.configuration.MockitoConfiguration</code> will be chosen instead of the one in the file.
-
+ *
* @deprecated Please use {@link org.mockito.plugins.AnnotationEngine} instead,
- * this interface will probably be removed in mockito 3.
+ * this interface will probably be removed in mockito 4.
*/
@Deprecated
-public interface AnnotationEngine extends org.mockito.plugins.AnnotationEngine {
-}
+public interface AnnotationEngine extends org.mockito.plugins.AnnotationEngine {}
diff --git a/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java b/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java
index cad13e7..2d749c2 100644
--- a/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java
+++ b/src/main/java/org/mockito/configuration/DefaultMockitoConfiguration.java
@@ -17,6 +17,7 @@
*/
public class DefaultMockitoConfiguration implements IMockitoConfiguration {
+ @Override
public Answer<Object> getDefaultAnswer() {
return new ReturnsEmptyValues();
}
@@ -31,6 +32,7 @@
/* (non-Javadoc)
* @see org.mockito.configuration.IMockitoConfiguration#cleansStackTrace()
*/
+ @Override
public boolean cleansStackTrace() {
return true;
}
@@ -38,9 +40,8 @@
/* (non-Javadoc)
* @see org.mockito.configuration.IMockitoConfiguration#enableClassCache()
*/
+ @Override
public boolean enableClassCache() {
return true;
}
-
-
}
diff --git a/src/main/java/org/mockito/configuration/IMockitoConfiguration.java b/src/main/java/org/mockito/configuration/IMockitoConfiguration.java
index 2c2da56..f9690de 100644
--- a/src/main/java/org/mockito/configuration/IMockitoConfiguration.java
+++ b/src/main/java/org/mockito/configuration/IMockitoConfiguration.java
@@ -57,7 +57,7 @@
* See javadoc for {@link IMockitoConfiguration}
*
* @deprecated Please use the extension mechanism {@link org.mockito.plugins.AnnotationEngine} instead,
- * this method will probably be removed in mockito 3.
+ * this method will probably be removed in mockito 4.
*/
@Deprecated
AnnotationEngine getAnnotationEngine();
diff --git a/src/main/java/org/mockito/creation/instance/InstantiationException.java b/src/main/java/org/mockito/creation/instance/InstantiationException.java
index 1cfbaba..34548d5 100644
--- a/src/main/java/org/mockito/creation/instance/InstantiationException.java
+++ b/src/main/java/org/mockito/creation/instance/InstantiationException.java
@@ -14,6 +14,13 @@
public class InstantiationException extends MockitoException {
/**
+ * @since 3.5.0
+ */
+ public InstantiationException(String message) {
+ super(message);
+ }
+
+ /**
* @since 2.15.4
*/
public InstantiationException(String message, Throwable cause) {
diff --git a/src/main/java/org/mockito/creation/instance/Instantiator.java b/src/main/java/org/mockito/creation/instance/Instantiator.java
index 9ce37b5..a60ec75 100644
--- a/src/main/java/org/mockito/creation/instance/Instantiator.java
+++ b/src/main/java/org/mockito/creation/instance/Instantiator.java
@@ -17,6 +17,5 @@
*
* @since 2.15.4
*/
- <T> T newInstance(Class<T> cls) throws InstantiationException;
-
+ <T> T newInstance(Class<T> cls);
}
diff --git a/src/main/java/org/mockito/exceptions/base/MockitoAssertionError.java b/src/main/java/org/mockito/exceptions/base/MockitoAssertionError.java
index 491ff40..5e463c7 100644
--- a/src/main/java/org/mockito/exceptions/base/MockitoAssertionError.java
+++ b/src/main/java/org/mockito/exceptions/base/MockitoAssertionError.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.base;
import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
@@ -47,6 +46,18 @@
unfilteredStackTrace = error.getUnfilteredStackTrace();
}
+ /**
+ * Creates a copy of the given assertion error with the custom failure message prepended.
+ * @param error The assertion error to copy
+ * @param message The custom message to prepend
+ * @since 3.3.13
+ */
+ public MockitoAssertionError(AssertionError error, String message) {
+ super(message + "\n" + error.getMessage());
+ unfilteredStackTrace = error.getStackTrace();
+ super.setStackTrace(unfilteredStackTrace);
+ }
+
public StackTraceElement[] getUnfilteredStackTrace() {
return unfilteredStackTrace;
}
diff --git a/src/main/java/org/mockito/exceptions/base/MockitoException.java b/src/main/java/org/mockito/exceptions/base/MockitoException.java
index d774702..9293870 100644
--- a/src/main/java/org/mockito/exceptions/base/MockitoException.java
+++ b/src/main/java/org/mockito/exceptions/base/MockitoException.java
@@ -2,12 +2,10 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.base;
import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
-
/**
* Raised by mockito to emit an error either due to Mockito, or due to the User.
* All exception classes that inherit from this class will have the stack trace filtered.
diff --git a/src/main/java/org/mockito/exceptions/base/MockitoInitializationException.java b/src/main/java/org/mockito/exceptions/base/MockitoInitializationException.java
index 019fe0b..e4d986d 100644
--- a/src/main/java/org/mockito/exceptions/base/MockitoInitializationException.java
+++ b/src/main/java/org/mockito/exceptions/base/MockitoInitializationException.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.base;
public class MockitoInitializationException extends RuntimeException {
diff --git a/src/main/java/org/mockito/exceptions/base/MockitoSerializationIssue.java b/src/main/java/org/mockito/exceptions/base/MockitoSerializationIssue.java
index 458b56d..eae6851 100644
--- a/src/main/java/org/mockito/exceptions/base/MockitoSerializationIssue.java
+++ b/src/main/java/org/mockito/exceptions/base/MockitoSerializationIssue.java
@@ -2,13 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.base;
-import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
-
import java.io.ObjectStreamException;
+import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
+
/**
* Raised by mockito to emit an error either due to Mockito, or due to the User.
*
diff --git a/src/main/java/org/mockito/exceptions/misusing/CannotVerifyStubOnlyMock.java b/src/main/java/org/mockito/exceptions/misusing/CannotVerifyStubOnlyMock.java
index 2c8a656..6fa9a55 100644
--- a/src/main/java/org/mockito/exceptions/misusing/CannotVerifyStubOnlyMock.java
+++ b/src/main/java/org/mockito/exceptions/misusing/CannotVerifyStubOnlyMock.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.misusing;
import org.mockito.exceptions.base.MockitoException;
diff --git a/src/main/java/org/mockito/exceptions/misusing/FriendlyReminderException.java b/src/main/java/org/mockito/exceptions/misusing/FriendlyReminderException.java
index 57d8015..a161e8f 100644
--- a/src/main/java/org/mockito/exceptions/misusing/FriendlyReminderException.java
+++ b/src/main/java/org/mockito/exceptions/misusing/FriendlyReminderException.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.misusing;
import org.mockito.exceptions.base.MockitoException;
diff --git a/src/main/java/org/mockito/exceptions/misusing/InvalidUseOfMatchersException.java b/src/main/java/org/mockito/exceptions/misusing/InvalidUseOfMatchersException.java
index a6a17ee..c6e574d 100644
--- a/src/main/java/org/mockito/exceptions/misusing/InvalidUseOfMatchersException.java
+++ b/src/main/java/org/mockito/exceptions/misusing/InvalidUseOfMatchersException.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.misusing;
import org.mockito.exceptions.base.MockitoException;
diff --git a/src/main/java/org/mockito/exceptions/misusing/MissingMethodInvocationException.java b/src/main/java/org/mockito/exceptions/misusing/MissingMethodInvocationException.java
index ae77fb0..45db3f4 100644
--- a/src/main/java/org/mockito/exceptions/misusing/MissingMethodInvocationException.java
+++ b/src/main/java/org/mockito/exceptions/misusing/MissingMethodInvocationException.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.misusing;
import org.mockito.exceptions.base.MockitoException;
diff --git a/src/main/java/org/mockito/exceptions/misusing/NotAMockException.java b/src/main/java/org/mockito/exceptions/misusing/NotAMockException.java
index d4fb917..541f197 100644
--- a/src/main/java/org/mockito/exceptions/misusing/NotAMockException.java
+++ b/src/main/java/org/mockito/exceptions/misusing/NotAMockException.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.misusing;
import org.mockito.exceptions.base.MockitoException;
diff --git a/src/main/java/org/mockito/exceptions/misusing/NullInsteadOfMockException.java b/src/main/java/org/mockito/exceptions/misusing/NullInsteadOfMockException.java
index 5225f7c..1d1f91d 100644
--- a/src/main/java/org/mockito/exceptions/misusing/NullInsteadOfMockException.java
+++ b/src/main/java/org/mockito/exceptions/misusing/NullInsteadOfMockException.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.misusing;
import org.mockito.exceptions.base.MockitoException;
diff --git a/src/main/java/org/mockito/exceptions/misusing/UnfinishedStubbingException.java b/src/main/java/org/mockito/exceptions/misusing/UnfinishedStubbingException.java
index 3085161..c24ae43 100644
--- a/src/main/java/org/mockito/exceptions/misusing/UnfinishedStubbingException.java
+++ b/src/main/java/org/mockito/exceptions/misusing/UnfinishedStubbingException.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.misusing;
import org.mockito.exceptions.base.MockitoException;
diff --git a/src/main/java/org/mockito/exceptions/misusing/UnfinishedVerificationException.java b/src/main/java/org/mockito/exceptions/misusing/UnfinishedVerificationException.java
index 323c1f6..078cc23 100644
--- a/src/main/java/org/mockito/exceptions/misusing/UnfinishedVerificationException.java
+++ b/src/main/java/org/mockito/exceptions/misusing/UnfinishedVerificationException.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.misusing;
import org.mockito.exceptions.base.MockitoException;
diff --git a/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java b/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java
index 2d4605b..6078437 100644
--- a/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java
+++ b/src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java
@@ -33,10 +33,11 @@
* when(translator.translate("one")).thenReturn("jeden"); // <- stubbing realized during code execution
* when(translator.translate("two")).thenReturn("dwa"); // <- stubbing never realized
* ...
+ * </code>
* </pre>
* Notice that one of the stubbed methods were never realized in the code under test, during test execution.
* The stray stubbing might be an oversight of the developer, the artifact of copy-paste
- * or the effect not understanding the test/code.
+ * or the effect of not understanding the test/code.
* Either way, the developer ends up with unnecessary test code.
* In order to keep the codebase clean & maintainable it is necessary to remove unnecessary code.
* Otherwise tests are harder to read and reason about.
diff --git a/src/main/java/org/mockito/exceptions/verification/ArgumentsAreDifferent.java b/src/main/java/org/mockito/exceptions/verification/ArgumentsAreDifferent.java
index a44cc6f..ac572f4 100644
--- a/src/main/java/org/mockito/exceptions/verification/ArgumentsAreDifferent.java
+++ b/src/main/java/org/mockito/exceptions/verification/ArgumentsAreDifferent.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.verification;
import static org.mockito.internal.util.StringUtil.removeFirstLine;
@@ -17,8 +16,21 @@
super(message);
}
+ /**
+ * Three-arg constructor for compatibility with ExceptionFactory's three-arg
+ * create method. This implementation simply ignores the second and third
+ * arguments.
+ *
+ * @param message
+ * @param wanted ignored
+ * @param actual ignored
+ */
+ public ArgumentsAreDifferent(String message, String wanted, String actual) {
+ this(message);
+ }
+
@Override
- public String toString() {
- return removeFirstLine(super.toString());
+ public String getMessage() {
+ return removeFirstLine(super.getMessage());
}
}
diff --git a/src/main/java/org/mockito/exceptions/verification/MoreThanAllowedActualInvocations.java b/src/main/java/org/mockito/exceptions/verification/MoreThanAllowedActualInvocations.java
index c3c0ed4..7d3ac5a 100644
--- a/src/main/java/org/mockito/exceptions/verification/MoreThanAllowedActualInvocations.java
+++ b/src/main/java/org/mockito/exceptions/verification/MoreThanAllowedActualInvocations.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.verification;
import org.mockito.exceptions.base.MockitoAssertionError;
diff --git a/src/main/java/org/mockito/exceptions/verification/NeverWantedButInvoked.java b/src/main/java/org/mockito/exceptions/verification/NeverWantedButInvoked.java
index e8e3ba9..d126102 100644
--- a/src/main/java/org/mockito/exceptions/verification/NeverWantedButInvoked.java
+++ b/src/main/java/org/mockito/exceptions/verification/NeverWantedButInvoked.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.verification;
import org.mockito.exceptions.base.MockitoAssertionError;
diff --git a/src/main/java/org/mockito/exceptions/verification/NoInteractionsWanted.java b/src/main/java/org/mockito/exceptions/verification/NoInteractionsWanted.java
index 9dccf3b..0b45a86 100644
--- a/src/main/java/org/mockito/exceptions/verification/NoInteractionsWanted.java
+++ b/src/main/java/org/mockito/exceptions/verification/NoInteractionsWanted.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.verification;
import org.mockito.exceptions.base.MockitoAssertionError;
diff --git a/src/main/java/org/mockito/exceptions/verification/TooFewActualInvocations.java b/src/main/java/org/mockito/exceptions/verification/TooFewActualInvocations.java
new file mode 100644
index 0000000..5ffbb2f
--- /dev/null
+++ b/src/main/java/org/mockito/exceptions/verification/TooFewActualInvocations.java
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.exceptions.verification;
+
+/**
+ * @since 2.27.5
+ */
+public class TooFewActualInvocations extends TooLittleActualInvocations {
+
+ private static final long serialVersionUID = 1L;
+
+ public TooFewActualInvocations(String message) {
+ super(message);
+ }
+}
diff --git a/src/main/java/org/mockito/exceptions/verification/TooLittleActualInvocations.java b/src/main/java/org/mockito/exceptions/verification/TooLittleActualInvocations.java
index d47a440..39bd30f 100644
--- a/src/main/java/org/mockito/exceptions/verification/TooLittleActualInvocations.java
+++ b/src/main/java/org/mockito/exceptions/verification/TooLittleActualInvocations.java
@@ -2,11 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.verification;
import org.mockito.exceptions.base.MockitoAssertionError;
+/**
+ * @deprecated as of 2.27.5. Please use {@link TooFewActualInvocations} instead.
+ * @see TooFewActualInvocations
+ */
+@Deprecated
public class TooLittleActualInvocations extends MockitoAssertionError {
private static final long serialVersionUID = 1L;
diff --git a/src/main/java/org/mockito/exceptions/verification/TooManyActualInvocations.java b/src/main/java/org/mockito/exceptions/verification/TooManyActualInvocations.java
index e29ec7a..b121508 100644
--- a/src/main/java/org/mockito/exceptions/verification/TooManyActualInvocations.java
+++ b/src/main/java/org/mockito/exceptions/verification/TooManyActualInvocations.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.verification;
import org.mockito.exceptions.base.MockitoAssertionError;
diff --git a/src/main/java/org/mockito/exceptions/verification/VerificationInOrderFailure.java b/src/main/java/org/mockito/exceptions/verification/VerificationInOrderFailure.java
index d27c30c..c2b9632 100644
--- a/src/main/java/org/mockito/exceptions/verification/VerificationInOrderFailure.java
+++ b/src/main/java/org/mockito/exceptions/verification/VerificationInOrderFailure.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.verification;
import org.mockito.exceptions.base.MockitoAssertionError;
diff --git a/src/main/java/org/mockito/exceptions/verification/WantedButNotInvoked.java b/src/main/java/org/mockito/exceptions/verification/WantedButNotInvoked.java
index e791d56..ddf5998 100644
--- a/src/main/java/org/mockito/exceptions/verification/WantedButNotInvoked.java
+++ b/src/main/java/org/mockito/exceptions/verification/WantedButNotInvoked.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.verification;
import static org.mockito.internal.util.StringUtil.removeFirstLine;
diff --git a/src/main/java/org/mockito/exceptions/verification/junit/ArgumentsAreDifferent.java b/src/main/java/org/mockito/exceptions/verification/junit/ArgumentsAreDifferent.java
index 32bf882..94da89d 100644
--- a/src/main/java/org/mockito/exceptions/verification/junit/ArgumentsAreDifferent.java
+++ b/src/main/java/org/mockito/exceptions/verification/junit/ArgumentsAreDifferent.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.verification.junit;
import static org.mockito.internal.util.StringUtil.removeFirstLine;
@@ -10,7 +9,6 @@
import junit.framework.ComparisonFailure;
import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
-
public class ArgumentsAreDifferent extends ComparisonFailure {
private static final long serialVersionUID = 1L;
diff --git a/src/main/java/org/mockito/exceptions/verification/junit/package-info.java b/src/main/java/org/mockito/exceptions/verification/junit/package-info.java
index 4542d34..ad4ab77 100644
--- a/src/main/java/org/mockito/exceptions/verification/junit/package-info.java
+++ b/src/main/java/org/mockito/exceptions/verification/junit/package-info.java
@@ -4,6 +4,9 @@
*/
/**
- * JUnit integration to provide better support for junit runners in IDEs.
+ * JUnit integration to provide better support for JUnit 4 and
+ * earlier in IDEs.
+ *
+ * @see org.mockito.exceptions.verification.opentest4j
*/
package org.mockito.exceptions.verification.junit;
diff --git a/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java b/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java
new file mode 100644
index 0000000..6589c5a
--- /dev/null
+++ b/src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.exceptions.verification.opentest4j;
+
+import static org.mockito.internal.util.StringUtil.removeFirstLine;
+
+import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
+import org.mockito.exceptions.base.MockitoAssertionError;
+
+
+public class ArgumentsAreDifferent extends MockitoAssertionError {
+
+ public ArgumentsAreDifferent(String message, String wanted, String actual) {
+ super(message);
+ }
+
+ @Override
+ public String toString() {
+ return removeFirstLine(super.toString());
+ }
+}
diff --git a/src/main/java/org/mockito/exceptions/verification/opentest4j/package-info.java b/src/main/java/org/mockito/exceptions/verification/opentest4j/package-info.java
new file mode 100644
index 0000000..2e84ddd
--- /dev/null
+++ b/src/main/java/org/mockito/exceptions/verification/opentest4j/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+/**
+ * Integration to provide better support for IDEs that support OpenTest4J.
+ *
+ * @see org.mocktio.exceptions.verification.junit
+ * @see org.mocktio.exceptions.verification.junit4
+ */
+package org.mockito.exceptions.verification.opentest4j;
diff --git a/src/main/java/org/mockito/hamcrest/MockitoHamcrest.java b/src/main/java/org/mockito/hamcrest/MockitoHamcrest.java
index 5f55d22..b8ebf8f 100644
--- a/src/main/java/org/mockito/hamcrest/MockitoHamcrest.java
+++ b/src/main/java/org/mockito/hamcrest/MockitoHamcrest.java
@@ -4,14 +4,14 @@
*/
package org.mockito.hamcrest;
-import org.hamcrest.Matcher;
-import org.mockito.ArgumentMatcher;
-import org.mockito.internal.hamcrest.HamcrestArgumentMatcher;
-
import static org.mockito.internal.hamcrest.MatcherGenericTypeExtractor.genericTypeOfMatcher;
import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
import static org.mockito.internal.util.Primitives.defaultValue;
+import org.hamcrest.Matcher;
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.hamcrest.HamcrestArgumentMatcher;
+
/**
* Allows matching arguments with hamcrest matchers.
* <b>Requires</b> <a href="http://hamcrest.org/JavaHamcrest/">hamcrest</a> on classpath,
@@ -45,7 +45,7 @@
*
* @since 2.1.0
*/
-public class MockitoHamcrest {
+public final class MockitoHamcrest {
/**
* Allows matching arguments with hamcrest matchers.
@@ -59,7 +59,7 @@
@SuppressWarnings("unchecked")
public static <T> T argThat(Matcher<T> matcher) {
reportMatcher(matcher);
- return (T) defaultValue(genericTypeOfMatcher(matcher.getClass()));
+ return (T) defaultValue(genericTypeOfMatcher(matcher.getClass()));
}
/**
@@ -175,6 +175,10 @@
}
private static <T> void reportMatcher(Matcher<T> matcher) {
- mockingProgress().getArgumentMatcherStorage().reportMatcher(new HamcrestArgumentMatcher<T>(matcher));
+ mockingProgress()
+ .getArgumentMatcherStorage()
+ .reportMatcher(new HamcrestArgumentMatcher<T>(matcher));
}
+
+ private MockitoHamcrest() {}
}
diff --git a/src/main/java/org/mockito/internal/InOrderImpl.java b/src/main/java/org/mockito/internal/InOrderImpl.java
index 5b0af9c..af852e4 100644
--- a/src/main/java/org/mockito/internal/InOrderImpl.java
+++ b/src/main/java/org/mockito/internal/InOrderImpl.java
@@ -2,25 +2,28 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal;
+import static org.mockito.internal.exceptions.Reporter.inOrderRequiresFamiliarMock;
+
+import java.util.ArrayList;
+import java.util.List;
+
import org.mockito.InOrder;
+import org.mockito.MockingDetails;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.verification.InOrderContextImpl;
import org.mockito.internal.verification.InOrderWrapper;
import org.mockito.internal.verification.VerificationModeFactory;
+import org.mockito.internal.verification.VerificationWrapper;
+import org.mockito.internal.verification.VerificationWrapperInOrderWrapper;
import org.mockito.internal.verification.api.InOrderContext;
import org.mockito.internal.verification.api.VerificationInOrderMode;
import org.mockito.invocation.Invocation;
import org.mockito.verification.VerificationMode;
-import org.mockito.internal.verification.VerificationWrapper;
-import org.mockito.internal.verification.VerificationWrapperInOrderWrapper;
-import static org.mockito.internal.exceptions.Reporter.inOrderRequiresFamiliarMock;
-
-import java.util.LinkedList;
-import java.util.List;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.internal.exceptions.Reporter.*;
/**
* Allows verifying in order. This class should not be exposed, hence default access.
@@ -28,7 +31,7 @@
public class InOrderImpl implements InOrder, InOrderContext {
private final MockitoCore mockitoCore = new MockitoCore();
- private final List<Object> mocksToBeVerifiedInOrder = new LinkedList<Object>();
+ private final List<Object> mocksToBeVerifiedInOrder = new ArrayList<>();
private final InOrderContext inOrderContext = new InOrderContextImpl();
public List<Object> getMocksToBeVerifiedInOrder() {
@@ -39,30 +42,58 @@
this.mocksToBeVerifiedInOrder.addAll(mocksToBeVerifiedInOrder);
}
+ @Override
public <T> T verify(T mock) {
return this.verify(mock, VerificationModeFactory.times(1));
}
+ @Override
public <T> T verify(T mock, VerificationMode mode) {
- if (!mocksToBeVerifiedInOrder.contains(mock)) {
+ if (mock == null) {
+ throw nullPassedToVerify();
+ }
+ MockingDetails mockingDetails = mockingDetails(mock);
+ if (!mockingDetails.isMock()) {
+ throw notAMockPassedToVerify(mock.getClass());
+ }
+ if (!this.objectIsMockToBeVerified(mock)) {
throw inOrderRequiresFamiliarMock();
}
if (mode instanceof VerificationWrapper) {
- return mockitoCore.verify(mock, new VerificationWrapperInOrderWrapper((VerificationWrapper) mode, this));
- } else if (!(mode instanceof VerificationInOrderMode)) {
- throw new MockitoException(mode.getClass().getSimpleName() + " is not implemented to work with InOrder");
+ return mockitoCore.verify(
+ mock, new VerificationWrapperInOrderWrapper((VerificationWrapper) mode, this));
+ } else if (!(mode instanceof VerificationInOrderMode)) {
+ throw new MockitoException(
+ mode.getClass().getSimpleName() + " is not implemented to work with InOrder");
}
return mockitoCore.verify(mock, new InOrderWrapper((VerificationInOrderMode) mode, this));
}
+ // We can't use `this.mocksToBeVerifiedInOrder.contains`, since that in turn calls `.equals` on
+ // the mock. Since mocks can be spies and spies get their real equals method calls called, the
+ // result is that Mockito incorrectly would register an invocation on a mock. This normally
+ // wouldn't be a problem, unless the user explicitly verifies that no interactions are performed
+ // on the mock, which would start to fail for the equals invocation.
+ private boolean objectIsMockToBeVerified(Object mock) {
+ for (Object inOrderMock : this.mocksToBeVerifiedInOrder) {
+ if (inOrderMock == mock) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
public boolean isVerified(Invocation i) {
return inOrderContext.isVerified(i);
}
+ @Override
public void markVerified(Invocation i) {
inOrderContext.markVerified(i);
}
+ @Override
public void verifyNoMoreInteractions() {
mockitoCore.verifyNoMoreInteractionsInOrder(mocksToBeVerifiedInOrder, this);
}
diff --git a/src/main/java/org/mockito/internal/InternalMockHandler.java b/src/main/java/org/mockito/internal/InternalMockHandler.java
index 40ebd24..2fd9549 100644
--- a/src/main/java/org/mockito/internal/InternalMockHandler.java
+++ b/src/main/java/org/mockito/internal/InternalMockHandler.java
@@ -14,7 +14,7 @@
* Since this class is internal, e.g. it resides in "org.mockito.internal" package,
* Mockito team can change it without the need for major version release of Mockito.
* <p>
- * This interface was deprecated in Mockito 2.10.0 and will be deleted in Mockito 3.0.
+ * This interface was deprecated in Mockito 2.10.0 and will be deleted in Mockito 4.0.
*/
@Deprecated
public interface InternalMockHandler<T> extends MockHandler {}
diff --git a/src/main/java/org/mockito/internal/MockedConstructionImpl.java b/src/main/java/org/mockito/internal/MockedConstructionImpl.java
new file mode 100644
index 0000000..47bd808
--- /dev/null
+++ b/src/main/java/org/mockito/internal/MockedConstructionImpl.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal;
+
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.mockito.MockedConstruction;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.debugging.LocationImpl;
+import org.mockito.invocation.Location;
+import org.mockito.plugins.MockMaker;
+
+public final class MockedConstructionImpl<T> implements MockedConstruction<T> {
+
+ private final MockMaker.ConstructionMockControl<T> control;
+
+ private boolean closed;
+
+ private final Location location = new LocationImpl();
+
+ protected MockedConstructionImpl(MockMaker.ConstructionMockControl<T> control) {
+ this.control = control;
+ }
+
+ @Override
+ public List<T> constructed() {
+ return Collections.unmodifiableList(control.getMocks());
+ }
+
+ @Override
+ public boolean isClosed() {
+ return closed;
+ }
+
+ @Override
+ public void close() {
+ assertNotClosed();
+
+ closed = true;
+ control.disable();
+ }
+
+ @Override
+ public void closeOnDemand() {
+ if (!closed) {
+ close();
+ }
+ }
+
+ private void assertNotClosed() {
+ if (closed) {
+ throw new MockitoException(
+ join(
+ "The static mock created at",
+ location.toString(),
+ "is already resolved and cannot longer be used"));
+ }
+ }
+}
diff --git a/src/main/java/org/mockito/internal/MockedStaticImpl.java b/src/main/java/org/mockito/internal/MockedStaticImpl.java
new file mode 100644
index 0000000..2b7ca0a
--- /dev/null
+++ b/src/main/java/org/mockito/internal/MockedStaticImpl.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal;
+
+import static org.mockito.internal.exceptions.Reporter.missingMethodInvocation;
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+import static org.mockito.internal.util.MockUtil.getInvocationContainer;
+import static org.mockito.internal.util.MockUtil.resetMock;
+import static org.mockito.internal.util.StringUtil.join;
+import static org.mockito.internal.verification.VerificationModeFactory.noInteractions;
+import static org.mockito.internal.verification.VerificationModeFactory.noMoreInteractions;
+
+import org.mockito.MockedStatic;
+import org.mockito.MockingDetails;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoAssertionError;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.debugging.LocationImpl;
+import org.mockito.internal.listeners.VerificationStartedNotifier;
+import org.mockito.internal.progress.MockingProgress;
+import org.mockito.internal.stubbing.InvocationContainerImpl;
+import org.mockito.internal.verification.MockAwareVerificationMode;
+import org.mockito.internal.verification.VerificationDataImpl;
+import org.mockito.invocation.Location;
+import org.mockito.invocation.MockHandler;
+import org.mockito.plugins.MockMaker;
+import org.mockito.stubbing.OngoingStubbing;
+import org.mockito.verification.VerificationMode;
+
+public final class MockedStaticImpl<T> implements MockedStatic<T> {
+
+ private final MockMaker.StaticMockControl<T> control;
+
+ private boolean closed;
+
+ private final Location location = new LocationImpl();
+
+ protected MockedStaticImpl(MockMaker.StaticMockControl<T> control) {
+ this.control = control;
+ }
+
+ @Override
+ public <S> OngoingStubbing<S> when(Verification verification) {
+ assertNotClosed();
+
+ try {
+ verification.apply();
+ } catch (Throwable ignored) {
+ }
+
+ MockingProgress mockingProgress = mockingProgress();
+ mockingProgress.stubbingStarted();
+ @SuppressWarnings("unchecked")
+ OngoingStubbing<S> stubbing = (OngoingStubbing<S>) mockingProgress.pullOngoingStubbing();
+ if (stubbing == null) {
+ mockingProgress.reset();
+ throw missingMethodInvocation();
+ }
+ return stubbing;
+ }
+
+ @Override
+ public void verify(VerificationMode mode, Verification verification) {
+ verify(verification, mode);
+ }
+
+ @Override
+ public void verify(Verification verification, VerificationMode mode) {
+ assertNotClosed();
+
+ MockingDetails mockingDetails = Mockito.mockingDetails(control.getType());
+ MockHandler handler = mockingDetails.getMockHandler();
+
+ VerificationStartedNotifier.notifyVerificationStarted(
+ handler.getMockSettings().getVerificationStartedListeners(), mockingDetails);
+
+ MockingProgress mockingProgress = mockingProgress();
+ VerificationMode actualMode = mockingProgress.maybeVerifyLazily(mode);
+ mockingProgress.verificationStarted(
+ new MockAwareVerificationMode(
+ control.getType(), actualMode, mockingProgress.verificationListeners()));
+
+ try {
+ verification.apply();
+ } catch (MockitoException | MockitoAssertionError e) {
+ throw e;
+ } catch (Throwable t) {
+ throw new MockitoException(
+ join(
+ "An unexpected error occurred while verifying a static stub",
+ "",
+ "To correctly verify a stub, invoke a single static method of "
+ + control.getType().getName()
+ + " in the provided lambda.",
+ "For example, if a method 'sample' was defined, provide a lambda or anonymous class containing the code",
+ "",
+ "() -> " + control.getType().getSimpleName() + ".sample()",
+ "or",
+ control.getType().getSimpleName() + "::sample"),
+ t);
+ }
+ }
+
+ @Override
+ public void reset() {
+ assertNotClosed();
+
+ MockingProgress mockingProgress = mockingProgress();
+ mockingProgress.validateState();
+ mockingProgress.reset();
+ mockingProgress.resetOngoingStubbing();
+
+ resetMock(control.getType());
+ }
+
+ @Override
+ public void clearInvocations() {
+ assertNotClosed();
+
+ MockingProgress mockingProgress = mockingProgress();
+ mockingProgress.validateState();
+ mockingProgress.reset();
+ mockingProgress.resetOngoingStubbing();
+
+ getInvocationContainer(control.getType()).clearInvocations();
+ }
+
+ @Override
+ public void verifyNoMoreInteractions() {
+ assertNotClosed();
+
+ mockingProgress().validateState();
+ InvocationContainerImpl invocations = getInvocationContainer(control.getType());
+ VerificationDataImpl data = new VerificationDataImpl(invocations, null);
+ noMoreInteractions().verify(data);
+ }
+
+ @Override
+ public void verifyNoInteractions() {
+ assertNotClosed();
+
+ mockingProgress().validateState();
+ InvocationContainerImpl invocations = getInvocationContainer(control.getType());
+ VerificationDataImpl data = new VerificationDataImpl(invocations, null);
+ noInteractions().verify(data);
+ }
+
+ @Override
+ public boolean isClosed() {
+ return closed;
+ }
+
+ @Override
+ public void close() {
+ assertNotClosed();
+
+ closed = true;
+ control.disable();
+ }
+
+ @Override
+ public void closeOnDemand() {
+ if (!closed) {
+ close();
+ }
+ }
+
+ private void assertNotClosed() {
+ if (closed) {
+ throw new MockitoException(
+ join(
+ "The static mock created at",
+ location.toString(),
+ "is already resolved and cannot longer be used"));
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "static mock for " + control.getType().getName();
+ }
+}
diff --git a/src/main/java/org/mockito/internal/MockitoCore.java b/src/main/java/org/mockito/internal/MockitoCore.java
index 68b580a..47480fa 100644
--- a/src/main/java/org/mockito/internal/MockitoCore.java
+++ b/src/main/java/org/mockito/internal/MockitoCore.java
@@ -4,37 +4,6 @@
*/
package org.mockito.internal;
-import org.mockito.InOrder;
-import org.mockito.MockSettings;
-import org.mockito.MockingDetails;
-import org.mockito.exceptions.misusing.NotAMockException;
-import org.mockito.internal.creation.MockSettingsImpl;
-import org.mockito.internal.invocation.finder.VerifiableInvocationsFinder;
-import org.mockito.internal.listeners.VerificationStartedNotifier;
-import org.mockito.internal.progress.MockingProgress;
-import org.mockito.internal.stubbing.DefaultLenientStubber;
-import org.mockito.internal.stubbing.InvocationContainerImpl;
-import org.mockito.internal.stubbing.OngoingStubbingImpl;
-import org.mockito.internal.stubbing.StubberImpl;
-import org.mockito.internal.util.DefaultMockingDetails;
-import org.mockito.internal.verification.MockAwareVerificationMode;
-import org.mockito.internal.verification.VerificationDataImpl;
-import org.mockito.internal.verification.VerificationModeFactory;
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.internal.verification.api.VerificationDataInOrder;
-import org.mockito.internal.verification.api.VerificationDataInOrderImpl;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.quality.Strictness;
-import org.mockito.stubbing.LenientStubber;
-import org.mockito.stubbing.OngoingStubbing;
-import org.mockito.stubbing.Stubber;
-import org.mockito.verification.VerificationMode;
-
-import java.util.Arrays;
-import java.util.List;
-
import static org.mockito.internal.exceptions.Reporter.missingMethodInvocation;
import static org.mockito.internal.exceptions.Reporter.mocksHaveToBePassedToVerifyNoMoreInteractions;
import static org.mockito.internal.exceptions.Reporter.mocksHaveToBePassedWhenCreatingInOrder;
@@ -46,13 +15,55 @@
import static org.mockito.internal.exceptions.Reporter.nullPassedWhenCreatingInOrder;
import static org.mockito.internal.exceptions.Reporter.stubPassedToVerify;
import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+import static org.mockito.internal.util.MockUtil.createConstructionMock;
import static org.mockito.internal.util.MockUtil.createMock;
+import static org.mockito.internal.util.MockUtil.createStaticMock;
import static org.mockito.internal.util.MockUtil.getInvocationContainer;
+import static org.mockito.internal.util.MockUtil.getMockHandler;
import static org.mockito.internal.util.MockUtil.isMock;
import static org.mockito.internal.util.MockUtil.resetMock;
import static org.mockito.internal.util.MockUtil.typeMockabilityOf;
+import static org.mockito.internal.verification.VerificationModeFactory.noInteractions;
import static org.mockito.internal.verification.VerificationModeFactory.noMoreInteractions;
+import java.util.Arrays;
+import java.util.List;
+import org.mockito.InOrder;
+import org.mockito.MockSettings;
+import org.mockito.MockedConstruction;
+import org.mockito.MockedStatic;
+import org.mockito.MockingDetails;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.internal.invocation.finder.VerifiableInvocationsFinder;
+import org.mockito.internal.listeners.VerificationStartedNotifier;
+import org.mockito.internal.progress.MockingProgress;
+import org.mockito.internal.stubbing.DefaultLenientStubber;
+import org.mockito.internal.stubbing.InvocationContainerImpl;
+import org.mockito.internal.stubbing.OngoingStubbingImpl;
+import org.mockito.internal.stubbing.StubberImpl;
+import org.mockito.internal.util.DefaultMockingDetails;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.internal.verification.MockAwareVerificationMode;
+import org.mockito.internal.verification.VerificationDataImpl;
+import org.mockito.internal.verification.VerificationModeFactory;
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.internal.verification.api.VerificationDataInOrder;
+import org.mockito.internal.verification.api.VerificationDataInOrderImpl;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.MockMaker;
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.LenientStubber;
+import org.mockito.stubbing.OngoingStubbing;
+import org.mockito.stubbing.Stubber;
+import org.mockito.verification.VerificationMode;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+
@SuppressWarnings("unchecked")
public class MockitoCore {
@@ -61,16 +72,59 @@
}
public <T> T mock(Class<T> typeToMock, MockSettings settings) {
- if (!MockSettingsImpl.class.isInstance(settings)) {
- throw new IllegalArgumentException("Unexpected implementation of '" + settings.getClass().getCanonicalName() + "'\n" + "At the moment, you cannot provide your own implementations of that class.");
+ if (!(settings instanceof MockSettingsImpl)) {
+ throw new IllegalArgumentException(
+ "Unexpected implementation of '"
+ + settings.getClass().getCanonicalName()
+ + "'\n"
+ + "At the moment, you cannot provide your own implementations of that class.");
}
- MockSettingsImpl impl = MockSettingsImpl.class.cast(settings);
+ MockSettingsImpl impl = (MockSettingsImpl) settings;
MockCreationSettings<T> creationSettings = impl.build(typeToMock);
T mock = createMock(creationSettings);
mockingProgress().mockingStarted(mock, creationSettings);
return mock;
}
+ public <T> MockedStatic<T> mockStatic(Class<T> classToMock, MockSettings settings) {
+ if (!MockSettingsImpl.class.isInstance(settings)) {
+ throw new IllegalArgumentException(
+ "Unexpected implementation of '"
+ + settings.getClass().getCanonicalName()
+ + "'\n"
+ + "At the moment, you cannot provide your own implementations of that class.");
+ }
+ MockSettingsImpl impl = MockSettingsImpl.class.cast(settings);
+ MockCreationSettings<T> creationSettings = impl.buildStatic(classToMock);
+ MockMaker.StaticMockControl<T> control = createStaticMock(classToMock, creationSettings);
+ control.enable();
+ mockingProgress().mockingStarted(classToMock, creationSettings);
+ return new MockedStaticImpl<>(control);
+ }
+
+ public <T> MockedConstruction<T> mockConstruction(
+ Class<T> typeToMock,
+ Function<MockedConstruction.Context, ? extends MockSettings> settingsFactory,
+ MockedConstruction.MockInitializer<T> mockInitializer) {
+ Function<MockedConstruction.Context, MockCreationSettings<T>> creationSettings =
+ context -> {
+ MockSettings value = settingsFactory.apply(context);
+ if (!MockSettingsImpl.class.isInstance(value)) {
+ throw new IllegalArgumentException(
+ "Unexpected implementation of '"
+ + value.getClass().getCanonicalName()
+ + "'\n"
+ + "At the moment, you cannot provide your own implementations of that class.");
+ }
+ MockSettingsImpl impl = MockSettingsImpl.class.cast(value);
+ return impl.build(typeToMock);
+ };
+ MockMaker.ConstructionMockControl<T> control =
+ createConstructionMock(typeToMock, creationSettings, mockInitializer);
+ control.enable();
+ return new MockedConstructionImpl<>(control);
+ }
+
public <T> OngoingStubbing<T> when(T methodCall) {
MockingProgress mockingProgress = mockingProgress();
mockingProgress.stubbingStarted();
@@ -91,16 +145,19 @@
if (!mockingDetails.isMock()) {
throw notAMockPassedToVerify(mock.getClass());
}
+ assertNotStubOnlyMock(mock);
MockHandler handler = mockingDetails.getMockHandler();
- if (handler.getMockSettings().isStubOnly()) {
- throw stubPassedToVerify();
- }
- mock = (T) VerificationStartedNotifier.notifyVerificationStarted(
- handler.getMockSettings().getVerificationStartedListeners(), mockingDetails);
+ mock =
+ (T)
+ VerificationStartedNotifier.notifyVerificationStarted(
+ handler.getMockSettings().getVerificationStartedListeners(),
+ mockingDetails);
MockingProgress mockingProgress = mockingProgress();
VerificationMode actualMode = mockingProgress.maybeVerifyLazily(mode);
- mockingProgress.verificationStarted(new MockAwareVerificationMode(mock, actualMode, mockingProgress.verificationListeners()));
+ mockingProgress.verificationStarted(
+ new MockAwareVerificationMode(
+ mock, actualMode, mockingProgress.verificationListeners()));
return mock;
}
@@ -135,6 +192,7 @@
throw nullPassedToVerifyNoMoreInteractions();
}
InvocationContainerImpl invocations = getInvocationContainer(mock);
+ assertNotStubOnlyMock(mock);
VerificationDataImpl data = new VerificationDataImpl(invocations, null);
noMoreInteractions().verify(data);
} catch (NotAMockException e) {
@@ -143,9 +201,29 @@
}
}
+ public void verifyNoInteractions(Object... mocks) {
+ assertMocksNotEmpty(mocks);
+ mockingProgress().validateState();
+ for (Object mock : mocks) {
+ try {
+ if (mock == null) {
+ throw nullPassedToVerifyNoMoreInteractions();
+ }
+ InvocationContainerImpl invocations = getInvocationContainer(mock);
+ assertNotStubOnlyMock(mock);
+ VerificationDataImpl data = new VerificationDataImpl(invocations, null);
+ noInteractions().verify(data);
+ } catch (NotAMockException e) {
+ throw notAMockPassedToVerifyNoMoreInteractions();
+ }
+ }
+ }
+
public void verifyNoMoreInteractionsInOrder(List<Object> mocks, InOrderContext inOrderContext) {
mockingProgress().validateState();
- VerificationDataInOrder data = new VerificationDataInOrderImpl(inOrderContext, VerifiableInvocationsFinder.find(mocks), null);
+ VerificationDataInOrder data =
+ new VerificationDataInOrderImpl(
+ inOrderContext, VerifiableInvocationsFinder.find(mocks), null);
VerificationModeFactory.noMoreInteractions().verifyInOrder(data);
}
@@ -155,6 +233,12 @@
}
}
+ private void assertNotStubOnlyMock(Object mock) {
+ if (getMockHandler(mock).getMockSettings().isStubOnly()) {
+ throw stubPassedToVerify(mock);
+ }
+ }
+
public InOrder inOrder(Object... mocks) {
if (mocks == null || mocks.length == 0) {
throw mocksHaveToBePassedWhenCreatingInOrder();
@@ -166,6 +250,7 @@
if (!isMock(mock)) {
throw notAMockPassedWhenCreatingInOrder();
}
+ assertNotStubOnlyMock(mock);
}
return new InOrderImpl(Arrays.asList(mocks));
}
@@ -191,7 +276,8 @@
* @return last invocation
*/
public Invocation getLastInvocation() {
- OngoingStubbingImpl ongoingStubbing = ((OngoingStubbingImpl) mockingProgress().pullOngoingStubbing());
+ OngoingStubbingImpl ongoingStubbing =
+ ((OngoingStubbingImpl) mockingProgress().pullOngoingStubbing());
List<Invocation> allInvocations = ongoingStubbing.getRegisteredInvocations();
return allInvocations.get(allInvocations.size() - 1);
}
@@ -216,4 +302,8 @@
public LenientStubber lenient() {
return new DefaultLenientStubber();
}
+
+ public void clearAllCaches() {
+ MockUtil.clearAllCaches();
+ }
}
diff --git a/src/main/java/org/mockito/internal/SuppressSignatureCheck.java b/src/main/java/org/mockito/internal/SuppressSignatureCheck.java
new file mode 100644
index 0000000..2a47d00
--- /dev/null
+++ b/src/main/java/org/mockito/internal/SuppressSignatureCheck.java
@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.CLASS)
+@Documented
+public @interface SuppressSignatureCheck {}
diff --git a/src/main/java/org/mockito/internal/configuration/CaptorAnnotationProcessor.java b/src/main/java/org/mockito/internal/configuration/CaptorAnnotationProcessor.java
index 0ccbfbc..600583b 100644
--- a/src/main/java/org/mockito/internal/configuration/CaptorAnnotationProcessor.java
+++ b/src/main/java/org/mockito/internal/configuration/CaptorAnnotationProcessor.java
@@ -4,23 +4,27 @@
*/
package org.mockito.internal.configuration;
+import java.lang.reflect.Field;
+
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.util.reflection.GenericMaster;
-import java.lang.reflect.Field;
-
/**
* Instantiate {@link ArgumentCaptor} a field annotated by @Captor.
*/
public class CaptorAnnotationProcessor implements FieldAnnotationProcessor<Captor> {
+ @Override
public Object process(Captor annotation, Field field) {
Class<?> type = field.getType();
if (!ArgumentCaptor.class.isAssignableFrom(type)) {
- throw new MockitoException("@Captor field must be of the type ArgumentCaptor.\n" + "Field: '"
- + field.getName() + "' has wrong type\n"
- + "For info how to use @Captor annotations see examples in javadoc for MockitoAnnotations class.");
+ throw new MockitoException(
+ "@Captor field must be of the type ArgumentCaptor.\n"
+ + "Field: '"
+ + field.getName()
+ + "' has wrong type\n"
+ + "For info how to use @Captor annotations see examples in javadoc for MockitoAnnotations class.");
}
Class<?> cls = new GenericMaster().getGenericType(field);
return ArgumentCaptor.forClass(cls);
diff --git a/src/main/java/org/mockito/internal/configuration/ClassPathLoader.java b/src/main/java/org/mockito/internal/configuration/ClassPathLoader.java
index 67b2040..0f031ee 100644
--- a/src/main/java/org/mockito/internal/configuration/ClassPathLoader.java
+++ b/src/main/java/org/mockito/internal/configuration/ClassPathLoader.java
@@ -8,7 +8,6 @@
import org.mockito.exceptions.misusing.MockitoConfigurationException;
import org.mockito.plugins.MockMaker;
-
/**
* Loads configuration or extension points available in the classpath.
*
@@ -47,7 +46,8 @@
*/
public class ClassPathLoader {
- public static final String MOCKITO_CONFIGURATION_CLASS_NAME = "org.mockito.configuration.MockitoConfiguration";
+ public static final String MOCKITO_CONFIGURATION_CLASS_NAME =
+ "org.mockito.configuration.MockitoConfiguration";
/**
* @return configuration loaded from classpath or null
@@ -59,16 +59,24 @@
try {
configClass = Class.forName(MOCKITO_CONFIGURATION_CLASS_NAME);
} catch (ClassNotFoundException e) {
- //that's ok, it means there is no global config, using default one.
+ // that's ok, it means there is no global config, using default one.
return null;
}
try {
- return (IMockitoConfiguration) configClass.newInstance();
+ return (IMockitoConfiguration) configClass.getDeclaredConstructor().newInstance();
} catch (ClassCastException e) {
- throw new MockitoConfigurationException("MockitoConfiguration class must implement " + IMockitoConfiguration.class.getName() + " interface.", e);
+ throw new MockitoConfigurationException(
+ "MockitoConfiguration class must implement "
+ + IMockitoConfiguration.class.getName()
+ + " interface.",
+ e);
} catch (Exception e) {
- throw new MockitoConfigurationException("Unable to instantiate " + MOCKITO_CONFIGURATION_CLASS_NAME +" class. Does it have a safe, no-arg constructor?", e);
+ throw new MockitoConfigurationException(
+ "Unable to instantiate "
+ + MOCKITO_CONFIGURATION_CLASS_NAME
+ + " class. Does it have a safe, no-arg constructor?",
+ e);
}
}
}
diff --git a/src/main/java/org/mockito/internal/configuration/DefaultInjectionEngine.java b/src/main/java/org/mockito/internal/configuration/DefaultInjectionEngine.java
index e5e98a1..f6b3595 100644
--- a/src/main/java/org/mockito/internal/configuration/DefaultInjectionEngine.java
+++ b/src/main/java/org/mockito/internal/configuration/DefaultInjectionEngine.java
@@ -16,7 +16,8 @@
*/
public class DefaultInjectionEngine {
- public void injectMocksOnFields(Set<Field> needingInjection, Set<Object> mocks, Object testClassInstance) {
+ public void injectMocksOnFields(
+ Set<Field> needingInjection, Set<Object> mocks, Object testClassInstance) {
MockInjection.onFields(needingInjection, testClassInstance)
.withMocks(mocks)
.tryConstructorInjection()
@@ -24,5 +25,4 @@
.handleSpyAnnotation()
.apply();
}
-
}
diff --git a/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java b/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java
index 4ac027a..8f8e037 100644
--- a/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java
+++ b/src/main/java/org/mockito/internal/configuration/GlobalConfiguration.java
@@ -5,6 +5,7 @@
package org.mockito.internal.configuration;
import java.io.Serializable;
+
import org.mockito.configuration.AnnotationEngine;
import org.mockito.configuration.DefaultMockitoConfiguration;
import org.mockito.configuration.IMockitoConfiguration;
@@ -17,15 +18,16 @@
public class GlobalConfiguration implements IMockitoConfiguration, Serializable {
private static final long serialVersionUID = -2860353062105505938L;
- private static final ThreadLocal<IMockitoConfiguration> GLOBAL_CONFIGURATION = new ThreadLocal<IMockitoConfiguration>();
+ private static final ThreadLocal<IMockitoConfiguration> GLOBAL_CONFIGURATION =
+ new ThreadLocal<>();
- //back door for testing
+ // back door for testing
IMockitoConfiguration getIt() {
return GLOBAL_CONFIGURATION.get();
}
public GlobalConfiguration() {
- //Configuration should be loaded only once but I cannot really test it
+ // Configuration should be loaded only once but I cannot really test it
if (GLOBAL_CONFIGURATION.get() == null) {
GLOBAL_CONFIGURATION.set(createConfig());
}
@@ -57,16 +59,17 @@
return configuration.getAnnotationEngine();
}
-
-
+ @Override
public boolean cleansStackTrace() {
return GLOBAL_CONFIGURATION.get().cleansStackTrace();
}
+ @Override
public boolean enableClassCache() {
return GLOBAL_CONFIGURATION.get().enableClassCache();
}
+ @Override
public Answer<Object> getDefaultAnswer() {
return GLOBAL_CONFIGURATION.get().getDefaultAnswer();
}
diff --git a/src/main/java/org/mockito/internal/configuration/IndependentAnnotationEngine.java b/src/main/java/org/mockito/internal/configuration/IndependentAnnotationEngine.java
index d78476a..06f2d29 100644
--- a/src/main/java/org/mockito/internal/configuration/IndependentAnnotationEngine.java
+++ b/src/main/java/org/mockito/internal/configuration/IndependentAnnotationEngine.java
@@ -4,18 +4,23 @@
*/
package org.mockito.internal.configuration;
+import static org.mockito.internal.exceptions.Reporter.moreThanOneAnnotationNotAllowed;
+
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
+import java.util.ArrayList;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
+
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.mockito.ScopedMock;
import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.plugins.AnnotationEngine;
-
-import static org.mockito.internal.exceptions.Reporter.moreThanOneAnnotationNotAllowed;
-import static org.mockito.internal.util.reflection.FieldSetter.setField;
+import org.mockito.plugins.MemberAccessor;
/**
* Initializes fields annotated with @{@link org.mockito.Mock} or @{@link org.mockito.Captor}.
@@ -26,8 +31,10 @@
* @see MockitoAnnotations
*/
@SuppressWarnings("unchecked")
-public class IndependentAnnotationEngine implements AnnotationEngine, org.mockito.configuration.AnnotationEngine {
- private final Map<Class<? extends Annotation>, FieldAnnotationProcessor<?>> annotationProcessorMap = new HashMap<Class<? extends Annotation>, FieldAnnotationProcessor<?>>();
+public class IndependentAnnotationEngine
+ implements AnnotationEngine, org.mockito.configuration.AnnotationEngine {
+ private final Map<Class<? extends Annotation>, FieldAnnotationProcessor<?>>
+ annotationProcessorMap = new HashMap<>();
public IndependentAnnotationEngine() {
registerAnnotationProcessor(Mock.class, new MockAnnotationProcessor());
@@ -40,38 +47,58 @@
private <A extends Annotation> FieldAnnotationProcessor<A> forAnnotation(A annotation) {
if (annotationProcessorMap.containsKey(annotation.annotationType())) {
- return (FieldAnnotationProcessor<A>) annotationProcessorMap.get(annotation.annotationType());
+ return (FieldAnnotationProcessor<A>)
+ annotationProcessorMap.get(annotation.annotationType());
}
return new FieldAnnotationProcessor<A>() {
+ @Override
public Object process(A annotation, Field field) {
return null;
}
};
}
- private <A extends Annotation> void registerAnnotationProcessor(Class<A> annotationClass, FieldAnnotationProcessor<A> fieldAnnotationProcessor) {
+ private <A extends Annotation> void registerAnnotationProcessor(
+ Class<A> annotationClass, FieldAnnotationProcessor<A> fieldAnnotationProcessor) {
annotationProcessorMap.put(annotationClass, fieldAnnotationProcessor);
}
@Override
- public void process(Class<?> clazz, Object testInstance) {
+ public AutoCloseable process(Class<?> clazz, Object testInstance) {
+ List<ScopedMock> scopedMocks = new ArrayList<>();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
boolean alreadyAssigned = false;
- for(Annotation annotation : field.getAnnotations()) {
+ for (Annotation annotation : field.getAnnotations()) {
Object mock = createMockFor(annotation, field);
+ if (mock instanceof ScopedMock) {
+ scopedMocks.add((ScopedMock) mock);
+ }
if (mock != null) {
throwIfAlreadyAssigned(field, alreadyAssigned);
alreadyAssigned = true;
+ final MemberAccessor accessor = Plugins.getMemberAccessor();
try {
- setField(testInstance, field,mock);
+ accessor.set(field, testInstance, mock);
} catch (Exception e) {
- throw new MockitoException("Problems setting field " + field.getName() + " annotated with "
- + annotation, e);
+ for (ScopedMock scopedMock : scopedMocks) {
+ scopedMock.close();
+ }
+ throw new MockitoException(
+ "Problems setting field "
+ + field.getName()
+ + " annotated with "
+ + annotation,
+ e);
}
}
}
}
+ return () -> {
+ for (ScopedMock scopedMock : scopedMocks) {
+ scopedMock.closeOnDemand();
+ }
+ };
}
void throwIfAlreadyAssigned(Field field, boolean alreadyAssigned) {
@@ -79,5 +106,4 @@
throw moreThanOneAnnotationNotAllowed(field.getName());
}
}
-
}
diff --git a/src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java b/src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java
index 6cb5fb1..513d7c9 100644
--- a/src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java
+++ b/src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java
@@ -4,20 +4,25 @@
*/
package org.mockito.internal.configuration;
+import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;
+
import java.lang.reflect.Field;
+import java.util.ArrayList;
import java.util.HashSet;
+import java.util.List;
import java.util.Set;
+
import org.mockito.MockitoAnnotations;
+import org.mockito.ScopedMock;
import org.mockito.internal.configuration.injection.scanner.InjectMocksScanner;
import org.mockito.internal.configuration.injection.scanner.MockScanner;
import org.mockito.plugins.AnnotationEngine;
-import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;
-
/**
* See {@link MockitoAnnotations}
*/
-public class InjectingAnnotationEngine implements AnnotationEngine, org.mockito.configuration.AnnotationEngine {
+public class InjectingAnnotationEngine
+ implements AnnotationEngine, org.mockito.configuration.AnnotationEngine {
private final AnnotationEngine delegate = new IndependentAnnotationEngine();
private final AnnotationEngine spyAnnotationEngine = new SpyAnnotationEngine();
@@ -37,31 +42,57 @@
*
* @see org.mockito.plugins.AnnotationEngine#process(Class, Object)
*/
- public void process(Class<?> clazz, Object testInstance) {
- processIndependentAnnotations(testInstance.getClass(), testInstance);
- processInjectMocks(testInstance.getClass(), testInstance);
+ @Override
+ public AutoCloseable process(Class<?> clazz, Object testInstance) {
+ List<AutoCloseable> closeables = new ArrayList<>();
+ closeables.addAll(processIndependentAnnotations(testInstance.getClass(), testInstance));
+ closeables.addAll(processInjectMocks(testInstance.getClass(), testInstance));
+ return () -> {
+ for (AutoCloseable closeable : closeables) {
+ closeable.close();
+ }
+ };
}
- private void processInjectMocks(final Class<?> clazz, final Object testInstance) {
+ private List<AutoCloseable> processInjectMocks(
+ final Class<?> clazz, final Object testInstance) {
+ List<AutoCloseable> closeables = new ArrayList<>();
Class<?> classContext = clazz;
while (classContext != Object.class) {
- injectMocks(testInstance);
+ closeables.add(injectCloseableMocks(testInstance));
classContext = classContext.getSuperclass();
}
+ return closeables;
}
- private void processIndependentAnnotations(final Class<?> clazz, final Object testInstance) {
+ private List<AutoCloseable> processIndependentAnnotations(
+ final Class<?> clazz, final Object testInstance) {
+ List<AutoCloseable> closeables = new ArrayList<>();
Class<?> classContext = clazz;
while (classContext != Object.class) {
- //this will create @Mocks, @Captors, etc:
- delegate.process(classContext, testInstance);
- //this will create @Spies:
- spyAnnotationEngine.process(classContext, testInstance);
+ // this will create @Mocks, @Captors, etc:
+ closeables.add(delegate.process(classContext, testInstance));
+ // this will create @Spies:
+ closeables.add(spyAnnotationEngine.process(classContext, testInstance));
classContext = classContext.getSuperclass();
}
+ return closeables;
}
+ /**
+ * Required by PowerMockito and retained to avoid API breakage despite being internal API.
+ *
+ * @deprecated Use {@link InjectingAnnotationEngine#injectCloseableMocks(Object)}.
+ */
+ @Deprecated
+ public void injectMocks(Object testClassInstance) {
+ try {
+ injectCloseableMocks(testClassInstance).close();
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
/**
* Initializes mock/spies dependencies for objects annotated with
@@ -72,9 +103,9 @@
* @param testClassInstance
* Test class, usually <code>this</code>
*/
- public void injectMocks(final Object testClassInstance) {
+ private AutoCloseable injectCloseableMocks(final Object testClassInstance) {
Class<?> clazz = testClassInstance.getClass();
- Set<Field> mockDependentFields = new HashSet<Field>();
+ Set<Field> mockDependentFields = new HashSet<>();
Set<Object> mocks = newMockSafeHashSet();
while (clazz != Object.class) {
@@ -84,11 +115,21 @@
clazz = clazz.getSuperclass();
}
- new DefaultInjectionEngine().injectMocksOnFields(mockDependentFields, mocks, testClassInstance);
+ new DefaultInjectionEngine()
+ .injectMocksOnFields(mockDependentFields, mocks, testClassInstance);
+
+ return () -> {
+ for (Object mock : mocks) {
+ if (mock instanceof ScopedMock) {
+ ((ScopedMock) mock).closeOnDemand();
+ }
+ }
+ };
}
- protected void onInjection(Object testClassInstance, Class<?> clazz, Set<Field> mockDependentFields, Set<Object> mocks) {
-
- }
-
+ protected void onInjection(
+ Object testClassInstance,
+ Class<?> clazz,
+ Set<Field> mockDependentFields,
+ Set<Object> mocks) {}
}
diff --git a/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java b/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java
index 91086d2..e48291e 100644
--- a/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java
+++ b/src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java
@@ -4,11 +4,19 @@
*/
package org.mockito.internal.configuration;
-import org.mockito.Mock;
-import org.mockito.MockSettings;
-import org.mockito.Mockito;
+import static org.mockito.internal.util.StringUtil.join;
import java.lang.reflect.Field;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+import org.mockito.Mock;
+import org.mockito.MockSettings;
+import org.mockito.MockedConstruction;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.util.Supplier;
/**
* Instantiates a mock on a field annotated by {@link Mock}
@@ -16,10 +24,12 @@
public class MockAnnotationProcessor implements FieldAnnotationProcessor<Mock> {
@Override
public Object process(Mock annotation, Field field) {
- return processAnnotationForMock(annotation, field.getType(), field.getName());
+ return processAnnotationForMock(
+ annotation, field.getType(), field::getGenericType, field.getName());
}
- public static Object processAnnotationForMock(Mock annotation, Class<?> type, String name) {
+ public static Object processAnnotationForMock(
+ Mock annotation, Class<?> type, Supplier<Type> genericType, String name) {
MockSettings mockSettings = Mockito.withSettings();
if (annotation.extraInterfaces().length > 0) { // never null
mockSettings.extraInterfaces(annotation.extraInterfaces());
@@ -29,15 +39,53 @@
} else {
mockSettings.name(annotation.name());
}
- if(annotation.serializable()){
+ if (annotation.serializable()) {
mockSettings.serializable();
}
- if(annotation.stubOnly()){
+ if (annotation.stubOnly()) {
mockSettings.stubOnly();
}
+ if (annotation.lenient()) {
+ mockSettings.lenient();
+ }
// see @Mock answer default value
mockSettings.defaultAnswer(annotation.answer());
- return Mockito.mock(type, mockSettings);
+
+ if (type == MockedStatic.class) {
+ return Mockito.mockStatic(
+ inferParameterizedType(
+ genericType.get(), name, MockedStatic.class.getSimpleName()),
+ mockSettings);
+ } else if (type == MockedConstruction.class) {
+ return Mockito.mockConstruction(
+ inferParameterizedType(
+ genericType.get(), name, MockedConstruction.class.getSimpleName()),
+ mockSettings);
+ } else {
+ return Mockito.mock(type, mockSettings);
+ }
+ }
+
+ static Class<?> inferParameterizedType(Type type, String name, String sort) {
+ if (type instanceof ParameterizedType) {
+ ParameterizedType parameterizedType = (ParameterizedType) type;
+ Type[] arguments = parameterizedType.getActualTypeArguments();
+ if (arguments.length == 1) {
+ if (arguments[0] instanceof Class<?>) {
+ return (Class<?>) arguments[0];
+ }
+ }
+ }
+ throw new MockitoException(
+ join(
+ "Mockito cannot infer a static mock from a raw type for " + name,
+ "",
+ "Instead of @Mock " + sort + " you need to specify a parameterized type",
+ "For example, if you would like to mock Sample.class, specify",
+ "",
+ "@Mock " + sort + "<Sample>",
+ "",
+ "as the type parameter. If the type is itself parameterized, it should be specified as raw type."));
}
}
diff --git a/src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java b/src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java
index 92d045d..2540311 100644
--- a/src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java
+++ b/src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java
@@ -4,11 +4,17 @@
*/
package org.mockito.internal.configuration;
+import static org.mockito.Mockito.CALLS_REAL_METHODS;
+import static org.mockito.Mockito.withSettings;
+import static org.mockito.internal.exceptions.Reporter.unsupportedCombinationOfAnnotations;
+import static org.mockito.internal.util.StringUtil.join;
+
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
+
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
@@ -16,13 +22,10 @@
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.util.MockUtil;
import org.mockito.plugins.AnnotationEngine;
-
-import static org.mockito.Mockito.CALLS_REAL_METHODS;
-import static org.mockito.Mockito.withSettings;
-import static org.mockito.internal.exceptions.Reporter.unsupportedCombinationOfAnnotations;
-import static org.mockito.internal.util.StringUtil.join;
+import org.mockito.plugins.MemberAccessor;
/**
* Process fields annotated with @Spy.
@@ -43,73 +46,87 @@
* <p>This engine will fail, if the field is also annotated with incompatible Mockito annotations.
*/
@SuppressWarnings({"unchecked"})
-public class SpyAnnotationEngine implements AnnotationEngine, org.mockito.configuration.AnnotationEngine {
+public class SpyAnnotationEngine
+ implements AnnotationEngine, org.mockito.configuration.AnnotationEngine {
@Override
- public void process(Class<?> context, Object testInstance) {
+ public AutoCloseable process(Class<?> context, Object testInstance) {
Field[] fields = context.getDeclaredFields();
+ MemberAccessor accessor = Plugins.getMemberAccessor();
for (Field field : fields) {
- if (field.isAnnotationPresent(Spy.class) && !field.isAnnotationPresent(InjectMocks.class)) {
+ if (field.isAnnotationPresent(Spy.class)
+ && !field.isAnnotationPresent(InjectMocks.class)) {
assertNoIncompatibleAnnotations(Spy.class, field, Mock.class, Captor.class);
- field.setAccessible(true);
Object instance;
try {
- instance = field.get(testInstance);
+ instance = accessor.get(field, testInstance);
if (MockUtil.isMock(instance)) {
// instance has been spied earlier
- // for example happens when MockitoAnnotations.initMocks is called two times.
+ // for example happens when MockitoAnnotations.openMocks is called two
+ // times.
Mockito.reset(instance);
} else if (instance != null) {
- field.set(testInstance, spyInstance(field, instance));
+ accessor.set(field, testInstance, spyInstance(field, instance));
} else {
- field.set(testInstance, spyNewInstance(testInstance, field));
+ accessor.set(field, testInstance, spyNewInstance(testInstance, field));
}
} catch (Exception e) {
- throw new MockitoException("Unable to initialize @Spy annotated field '" + field.getName() + "'.\n" + e.getMessage(), e);
+ throw new MockitoException(
+ "Unable to initialize @Spy annotated field '"
+ + field.getName()
+ + "'.\n"
+ + e.getMessage(),
+ e);
}
}
}
+ return new NoAction();
}
private static Object spyInstance(Field field, Object instance) {
- return Mockito.mock(instance.getClass(),
- withSettings().spiedInstance(instance)
- .defaultAnswer(CALLS_REAL_METHODS)
- .name(field.getName()));
+ return Mockito.mock(
+ instance.getClass(),
+ withSettings()
+ .spiedInstance(instance)
+ .defaultAnswer(CALLS_REAL_METHODS)
+ .name(field.getName()));
}
private static Object spyNewInstance(Object testInstance, Field field)
throws InstantiationException, IllegalAccessException, InvocationTargetException {
- MockSettings settings = withSettings().defaultAnswer(CALLS_REAL_METHODS)
- .name(field.getName());
+ MockSettings settings =
+ withSettings().defaultAnswer(CALLS_REAL_METHODS).name(field.getName());
Class<?> type = field.getType();
if (type.isInterface()) {
return Mockito.mock(type, settings.useConstructor());
}
int modifiers = type.getModifiers();
if (typeIsPrivateAbstractInnerClass(type, modifiers)) {
- throw new MockitoException(join("@Spy annotation can't initialize private abstract inner classes.",
- " inner class: '" + type.getSimpleName() + "'",
- " outer class: '" + type.getEnclosingClass().getSimpleName() + "'",
- "",
- "You should augment the visibility of this inner class"));
+ throw new MockitoException(
+ join(
+ "@Spy annotation can't initialize private abstract inner classes.",
+ " inner class: '" + type.getSimpleName() + "'",
+ " outer class: '" + type.getEnclosingClass().getSimpleName() + "'",
+ "",
+ "You should augment the visibility of this inner class"));
}
if (typeIsNonStaticInnerClass(type, modifiers)) {
Class<?> enclosing = type.getEnclosingClass();
if (!enclosing.isInstance(testInstance)) {
- throw new MockitoException(join("@Spy annotation can only initialize inner classes declared in the test.",
- " inner class: '" + type.getSimpleName() + "'",
- " outer class: '" + enclosing.getSimpleName() + "'",
- ""));
+ throw new MockitoException(
+ join(
+ "@Spy annotation can only initialize inner classes declared in the test.",
+ " inner class: '" + type.getSimpleName() + "'",
+ " outer class: '" + enclosing.getSimpleName() + "'",
+ ""));
}
- return Mockito.mock(type, settings.useConstructor()
- .outerInstance(testInstance));
+ return Mockito.mock(type, settings.useConstructor().outerInstance(testInstance));
}
Constructor<?> constructor = noArgConstructorOf(type);
if (Modifier.isPrivate(constructor.getModifiers())) {
- constructor.setAccessible(true);
- return Mockito.mock(type, settings.spiedInstance(constructor.newInstance()));
+ MemberAccessor accessor = Plugins.getMemberAccessor();
+ return Mockito.mock(type, settings.spiedInstance(accessor.newInstance(constructor)));
} else {
return Mockito.mock(type, settings.useConstructor());
}
@@ -120,7 +137,11 @@
try {
constructor = type.getDeclaredConstructor();
} catch (NoSuchMethodException e) {
- throw new MockitoException("Please ensure that the type '" + type.getSimpleName() + "' has a no-arg constructor.");
+ throw new MockitoException(
+ "Please ensure that the type '"
+ + type.getSimpleName()
+ + "' has a no-arg constructor.",
+ e);
}
return constructor;
}
@@ -130,17 +151,20 @@
}
private static boolean typeIsPrivateAbstractInnerClass(Class<?> type, int modifiers) {
- return Modifier.isPrivate(modifiers) && Modifier.isAbstract(modifiers) && type.getEnclosingClass() != null;
+ return Modifier.isPrivate(modifiers)
+ && Modifier.isAbstract(modifiers)
+ && type.getEnclosingClass() != null;
}
- //TODO duplicated elsewhere
- private static void assertNoIncompatibleAnnotations(Class<? extends Annotation> annotation,
- Field field,
- Class<? extends Annotation>... undesiredAnnotations) {
+ // TODO duplicated elsewhere
+ private static void assertNoIncompatibleAnnotations(
+ Class<? extends Annotation> annotation,
+ Field field,
+ Class<? extends Annotation>... undesiredAnnotations) {
for (Class<? extends Annotation> u : undesiredAnnotations) {
if (field.isAnnotationPresent(u)) {
- throw unsupportedCombinationOfAnnotations(annotation.getSimpleName(),
- u.getSimpleName());
+ throw unsupportedCombinationOfAnnotations(
+ annotation.getSimpleName(), u.getSimpleName());
}
}
}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/ConstructorInjection.java b/src/main/java/org/mockito/internal/configuration/injection/ConstructorInjection.java
index ffece34..f1577d7 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/ConstructorInjection.java
+++ b/src/main/java/org/mockito/internal/configuration/injection/ConstructorInjection.java
@@ -2,14 +2,8 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.configuration.injection;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.reflection.FieldInitializationReport;
-import org.mockito.internal.util.reflection.FieldInitializer;
-import org.mockito.internal.util.reflection.FieldInitializer.ConstructorArgumentResolver;
-
import static org.mockito.internal.exceptions.Reporter.fieldInitialisationThrewException;
import java.lang.reflect.Field;
@@ -18,6 +12,11 @@
import java.util.List;
import java.util.Set;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.util.reflection.FieldInitializationReport;
+import org.mockito.internal.util.reflection.FieldInitializer;
+import org.mockito.internal.util.reflection.FieldInitializer.ConstructorArgumentResolver;
+
/**
* Injection strategy based on constructor.
*
@@ -38,23 +37,25 @@
*/
public class ConstructorInjection extends MockInjectionStrategy {
- public ConstructorInjection() { }
+ public ConstructorInjection() {}
+ @Override
public boolean processInjection(Field field, Object fieldOwner, Set<Object> mockCandidates) {
try {
- SimpleArgumentResolver simpleArgumentResolver = new SimpleArgumentResolver(mockCandidates);
- FieldInitializationReport report = new FieldInitializer(fieldOwner, field, simpleArgumentResolver).initialize();
+ SimpleArgumentResolver simpleArgumentResolver =
+ new SimpleArgumentResolver(mockCandidates);
+ FieldInitializationReport report =
+ new FieldInitializer(fieldOwner, field, simpleArgumentResolver).initialize();
return report.fieldWasInitializedUsingContructorArgs();
} catch (MockitoException e) {
- if(e.getCause() instanceof InvocationTargetException) {
+ if (e.getCause() instanceof InvocationTargetException) {
Throwable realCause = e.getCause().getCause();
throw fieldInitialisationThrewException(field, realCause);
}
// other causes should be fine
return false;
}
-
}
/**
@@ -67,8 +68,9 @@
this.objects = objects;
}
+ @Override
public Object[] resolveTypeInstances(Class<?>... argTypes) {
- List<Object> argumentInstances = new ArrayList<Object>(argTypes.length);
+ List<Object> argumentInstances = new ArrayList<>(argTypes.length);
for (Class<?> argType : argTypes) {
argumentInstances.add(objectThatIsAssignableFrom(argType));
}
@@ -77,10 +79,11 @@
private Object objectThatIsAssignableFrom(Class<?> argType) {
for (Object object : objects) {
- if(argType.isAssignableFrom(object.getClass())) return object;
+ if (argType.isAssignableFrom(object.getClass())) {
+ return object;
+ }
}
return null;
}
}
-
}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/MockInjection.java b/src/main/java/org/mockito/internal/configuration/injection/MockInjection.java
index ef5312c..342391e 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/MockInjection.java
+++ b/src/main/java/org/mockito/internal/configuration/injection/MockInjection.java
@@ -2,27 +2,23 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.configuration.injection;
+import static org.mockito.internal.util.Checks.checkItemsNotNull;
+import static org.mockito.internal.util.Checks.checkNotNull;
+import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;
+
import java.lang.reflect.Field;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
-import static org.mockito.internal.util.Checks.checkItemsNotNull;
-import static org.mockito.internal.util.Checks.checkNotNull;
-import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;
-
/**
* Internal injection configuration utility.
*
- * <p>
- * Allow the user of this class to configure the way the injection of mocks will happen.
- * </p>
- *
+ * <p>Allow the user of this class to configure the way the injection of mocks will happen.
*/
-public class MockInjection {
+public final class MockInjection {
/**
* Create a new configuration setup for a field
@@ -52,7 +48,7 @@
* Ongoing configuration of the mock injector.
*/
public static class OngoingMockInjection {
- private final Set<Field> fields = new HashSet<Field>();
+ private final Set<Field> fields = new HashSet<>();
private final Set<Object> mocks = newMockSafeHashSet();
private final Object fieldOwner;
private final MockInjectionStrategy injectionStrategies = MockInjectionStrategy.nop();
@@ -94,4 +90,6 @@
}
}
}
+
+ private MockInjection() {}
}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/MockInjectionStrategy.java b/src/main/java/org/mockito/internal/configuration/injection/MockInjectionStrategy.java
index 5b56eb0..1ce4c05 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/MockInjectionStrategy.java
+++ b/src/main/java/org/mockito/internal/configuration/injection/MockInjectionStrategy.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.configuration.injection;
import java.lang.reflect.Field;
@@ -18,13 +17,14 @@
*/
public static MockInjectionStrategy nop() {
return new MockInjectionStrategy() {
- protected boolean processInjection(Field field, Object fieldOwner, Set<Object> mockCandidates) {
+ @Override
+ protected boolean processInjection(
+ Field field, Object fieldOwner, Set<Object> mockCandidates) {
return false;
}
};
}
-
private MockInjectionStrategy nextStrategy;
/**
@@ -38,7 +38,7 @@
* @return The passed strategy instance to allow chaining.
*/
public MockInjectionStrategy thenTry(MockInjectionStrategy strategy) {
- if(nextStrategy != null) {
+ if (nextStrategy != null) {
nextStrategy.thenTry(strategy);
} else {
nextStrategy = strategy;
@@ -65,7 +65,7 @@
* @return <code>true</code> if successful, <code>false</code> otherwise.
*/
public boolean process(Field onField, Object fieldOwnedBy, Set<Object> mockCandidates) {
- if(processInjection(onField, fieldOwnedBy, mockCandidates)) {
+ if (processInjection(onField, fieldOwnedBy, mockCandidates)) {
return true;
}
return relayProcessToNextStrategy(onField, fieldOwnedBy, mockCandidates);
@@ -83,9 +83,11 @@
* @param mockCandidates Pool of mocks to inject.
* @return <code>true</code> if injection occurred, <code>false</code> otherwise
*/
- protected abstract boolean processInjection(Field field, Object fieldOwner, Set<Object> mockCandidates);
+ protected abstract boolean processInjection(
+ Field field, Object fieldOwner, Set<Object> mockCandidates);
- private boolean relayProcessToNextStrategy(Field field, Object fieldOwner, Set<Object> mockCandidates) {
+ private boolean relayProcessToNextStrategy(
+ Field field, Object fieldOwner, Set<Object> mockCandidates) {
return nextStrategy != null && nextStrategy.process(field, fieldOwner, mockCandidates);
}
}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java b/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java
index 2d74197..06e340e 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java
+++ b/src/main/java/org/mockito/internal/configuration/injection/PropertyAndSetterInjection.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.configuration.injection;
import static org.mockito.internal.exceptions.Reporter.cannotInitializeForInjectMocksAnnotation;
@@ -65,25 +64,33 @@
private final MockCandidateFilter mockCandidateFilter =
new TypeBasedCandidateFilter(
- new NameBasedCandidateFilter(
- new TerminalMockCandidateFilter()));
+ new NameBasedCandidateFilter(new TerminalMockCandidateFilter()));
- private final ListUtil.Filter<Field> notFinalOrStatic = new ListUtil.Filter<Field>() {
- public boolean isOut(Field object) {
- return Modifier.isFinal(object.getModifiers()) || Modifier.isStatic(object.getModifiers());
- }
- };
+ private final ListUtil.Filter<Field> notFinalOrStatic =
+ new ListUtil.Filter<Field>() {
+ @Override
+ public boolean isOut(Field object) {
+ return Modifier.isFinal(object.getModifiers())
+ || Modifier.isStatic(object.getModifiers());
+ }
+ };
-
- public boolean processInjection(Field injectMocksField, Object injectMocksFieldOwner, Set<Object> mockCandidates) {
- FieldInitializationReport report = initializeInjectMocksField(injectMocksField, injectMocksFieldOwner);
+ @Override
+ public boolean processInjection(
+ Field injectMocksField, Object injectMocksFieldOwner, Set<Object> mockCandidates) {
+ FieldInitializationReport report =
+ initializeInjectMocksField(injectMocksField, injectMocksFieldOwner);
// for each field in the class hierarchy
boolean injectionOccurred = false;
Class<?> fieldClass = report.fieldClass();
Object fieldInstanceNeedingInjection = report.fieldInstance();
while (fieldClass != Object.class) {
- injectionOccurred |= injectMockCandidates(fieldClass, fieldInstanceNeedingInjection, newMockSafeHashSet(mockCandidates));
+ injectionOccurred |=
+ injectMockCandidates(
+ fieldClass,
+ fieldInstanceNeedingInjection,
+ newMockSafeHashSet(mockCandidates));
fieldClass = fieldClass.getSuperclass();
}
return injectionOccurred;
@@ -93,33 +100,42 @@
try {
return new FieldInitializer(fieldOwner, field).initialize();
} catch (MockitoException e) {
- if(e.getCause() instanceof InvocationTargetException) {
+ if (e.getCause() instanceof InvocationTargetException) {
Throwable realCause = e.getCause().getCause();
throw fieldInitialisationThrewException(field, realCause);
}
- throw cannotInitializeForInjectMocksAnnotation(field.getName(),e.getMessage());
+ throw cannotInitializeForInjectMocksAnnotation(field.getName(), e.getMessage());
}
}
-
- private boolean injectMockCandidates(Class<?> awaitingInjectionClazz, Object injectee, Set<Object> mocks) {
+ private boolean injectMockCandidates(
+ Class<?> awaitingInjectionClazz, Object injectee, Set<Object> mocks) {
boolean injectionOccurred;
- List<Field> orderedCandidateInjecteeFields = orderedInstanceFieldsFrom(awaitingInjectionClazz);
+ List<Field> orderedCandidateInjecteeFields =
+ orderedInstanceFieldsFrom(awaitingInjectionClazz);
// pass 1
- injectionOccurred = injectMockCandidatesOnFields(mocks, injectee, false, orderedCandidateInjecteeFields);
+ injectionOccurred =
+ injectMockCandidatesOnFields(
+ mocks, injectee, false, orderedCandidateInjecteeFields);
// pass 2
- injectionOccurred |= injectMockCandidatesOnFields(mocks, injectee, injectionOccurred, orderedCandidateInjecteeFields);
+ injectionOccurred |=
+ injectMockCandidatesOnFields(
+ mocks, injectee, injectionOccurred, orderedCandidateInjecteeFields);
return injectionOccurred;
}
- private boolean injectMockCandidatesOnFields(Set<Object> mocks,
- Object injectee,
- boolean injectionOccurred,
- List<Field> orderedCandidateInjecteeFields) {
+ private boolean injectMockCandidatesOnFields(
+ Set<Object> mocks,
+ Object injectee,
+ boolean injectionOccurred,
+ List<Field> orderedCandidateInjecteeFields) {
for (Iterator<Field> it = orderedCandidateInjecteeFields.iterator(); it.hasNext(); ) {
Field candidateField = it.next();
- Object injected = mockCandidateFilter.filterCandidate(mocks, candidateField, orderedCandidateInjecteeFields, injectee)
- .thenInject();
+ Object injected =
+ mockCandidateFilter
+ .filterCandidate(
+ mocks, candidateField, orderedCandidateInjecteeFields, injectee)
+ .thenInject();
if (injected != null) {
injectionOccurred |= true;
mocks.remove(injected);
diff --git a/src/main/java/org/mockito/internal/configuration/injection/SpyOnInjectedFieldsHandler.java b/src/main/java/org/mockito/internal/configuration/injection/SpyOnInjectedFieldsHandler.java
index 3dc0351..73f3004 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/SpyOnInjectedFieldsHandler.java
+++ b/src/main/java/org/mockito/internal/configuration/injection/SpyOnInjectedFieldsHandler.java
@@ -2,20 +2,20 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.configuration.injection;
-import org.mockito.Mockito;
-import org.mockito.Spy;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.internal.util.reflection.FieldReader;
+import static org.mockito.Mockito.withSettings;
import java.lang.reflect.Field;
import java.util.Set;
-import static org.mockito.Mockito.withSettings;
-import static org.mockito.internal.util.reflection.FieldSetter.setField;
+import org.mockito.Mockito;
+import org.mockito.Spy;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.internal.util.reflection.FieldReader;
+import org.mockito.plugins.MemberAccessor;
/**
* Handler for field annotated with @InjectMocks and @Spy.
@@ -27,24 +27,29 @@
*/
public class SpyOnInjectedFieldsHandler extends MockInjectionStrategy {
+ private final MemberAccessor accessor = Plugins.getMemberAccessor();
+
@Override
protected boolean processInjection(Field field, Object fieldOwner, Set<Object> mockCandidates) {
FieldReader fieldReader = new FieldReader(fieldOwner, field);
- // TODO refoctor : code duplicated in SpyAnnotationEngine
- if(!fieldReader.isNull() && field.isAnnotationPresent(Spy.class)) {
+ // TODO refactor : code duplicated in SpyAnnotationEngine
+ if (!fieldReader.isNull() && field.isAnnotationPresent(Spy.class)) {
try {
Object instance = fieldReader.read();
if (MockUtil.isMock(instance)) {
// A. instance has been spied earlier
- // B. protect against multiple use of MockitoAnnotations.initMocks()
+ // B. protect against multiple use of MockitoAnnotations.openMocks()
Mockito.reset(instance);
} else {
- Object mock = Mockito.mock(instance.getClass(), withSettings()
- .spiedInstance(instance)
- .defaultAnswer(Mockito.CALLS_REAL_METHODS)
- .name(field.getName()));
- setField(fieldOwner, field, mock);
+ Object mock =
+ Mockito.mock(
+ instance.getClass(),
+ withSettings()
+ .spiedInstance(instance)
+ .defaultAnswer(Mockito.CALLS_REAL_METHODS)
+ .name(field.getName()));
+ accessor.set(field, fieldOwner, mock);
}
} catch (Exception e) {
throw new MockitoException("Problems initiating spied field " + field.getName(), e);
diff --git a/src/main/java/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java b/src/main/java/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java
index 454d3be..470a42f 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java
+++ b/src/main/java/org/mockito/internal/configuration/injection/filter/MockCandidateFilter.java
@@ -13,6 +13,5 @@
Collection<Object> mocks,
Field candidateFieldToBeInjected,
List<Field> allRemainingCandidateFields,
- Object injectee
- );
+ Object injectee);
}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java b/src/main/java/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java
index dc50e9d..125b959 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java
+++ b/src/main/java/org/mockito/internal/configuration/injection/filter/NameBasedCandidateFilter.java
@@ -18,27 +18,32 @@
this.next = next;
}
- public OngoingInjector filterCandidate(final Collection<Object> mocks,
- final Field candidateFieldToBeInjected,
- final List<Field> allRemainingCandidateFields,
- final Object injectee) {
+ @Override
+ public OngoingInjector filterCandidate(
+ final Collection<Object> mocks,
+ final Field candidateFieldToBeInjected,
+ final List<Field> allRemainingCandidateFields,
+ final Object injectee) {
if (mocks.size() == 1
- && anotherCandidateMatchesMockName(mocks, candidateFieldToBeInjected, allRemainingCandidateFields)) {
+ && anotherCandidateMatchesMockName(
+ mocks, candidateFieldToBeInjected, allRemainingCandidateFields)) {
return OngoingInjector.nop;
}
- return next.filterCandidate(tooMany(mocks) ? selectMatchingName(mocks, candidateFieldToBeInjected) : mocks,
- candidateFieldToBeInjected,
- allRemainingCandidateFields,
- injectee);
+ return next.filterCandidate(
+ tooMany(mocks) ? selectMatchingName(mocks, candidateFieldToBeInjected) : mocks,
+ candidateFieldToBeInjected,
+ allRemainingCandidateFields,
+ injectee);
}
private boolean tooMany(Collection<Object> mocks) {
return mocks.size() > 1;
}
- private List<Object> selectMatchingName(Collection<Object> mocks, Field candidateFieldToBeInjected) {
- List<Object> mockNameMatches = new ArrayList<Object>();
+ private List<Object> selectMatchingName(
+ Collection<Object> mocks, Field candidateFieldToBeInjected) {
+ List<Object> mockNameMatches = new ArrayList<>();
for (Object mock : mocks) {
if (candidateFieldToBeInjected.getName().equals(getMockName(mock).toString())) {
mockNameMatches.add(mock);
@@ -56,9 +61,10 @@
* whenever we find a field that does match its name with the mock
* name, we should take that field instead.
*/
- private boolean anotherCandidateMatchesMockName(final Collection<Object> mocks,
- final Field candidateFieldToBeInjected,
- final List<Field> allRemainingCandidateFields) {
+ private boolean anotherCandidateMatchesMockName(
+ final Collection<Object> mocks,
+ final Field candidateFieldToBeInjected,
+ final List<Field> allRemainingCandidateFields) {
String mockName = getMockName(mocks.iterator().next()).toString();
for (Field otherCandidateField : allRemainingCandidateFields) {
diff --git a/src/main/java/org/mockito/internal/configuration/injection/filter/OngoingInjector.java b/src/main/java/org/mockito/internal/configuration/injection/filter/OngoingInjector.java
index 4550e1f..a10d041 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/filter/OngoingInjector.java
+++ b/src/main/java/org/mockito/internal/configuration/injection/filter/OngoingInjector.java
@@ -23,9 +23,11 @@
/**
* Injector that will do nothing, and will return <code>null</code> as no mocks will be injected
*/
- OngoingInjector nop = new OngoingInjector() {
- public Object thenInject() {
- return null;
- }
- };
+ OngoingInjector nop =
+ new OngoingInjector() {
+ @Override
+ public Object thenInject() {
+ return null;
+ }
+ };
}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/filter/TerminalMockCandidateFilter.java b/src/main/java/org/mockito/internal/configuration/injection/filter/TerminalMockCandidateFilter.java
index 3a66c7e..ec9dadc 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/filter/TerminalMockCandidateFilter.java
+++ b/src/main/java/org/mockito/internal/configuration/injection/filter/TerminalMockCandidateFilter.java
@@ -4,14 +4,15 @@
*/
package org.mockito.internal.configuration.injection.filter;
-import org.mockito.internal.util.reflection.BeanPropertySetter;
+import static org.mockito.internal.exceptions.Reporter.cannotInjectDependency;
import java.lang.reflect.Field;
import java.util.Collection;
import java.util.List;
-import static org.mockito.internal.exceptions.Reporter.cannotInjectDependency;
-import static org.mockito.internal.util.reflection.FieldSetter.setField;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.util.reflection.BeanPropertySetter;
+import org.mockito.plugins.MemberAccessor;
/**
* This node returns an actual injecter which will be either :
@@ -22,28 +23,29 @@
* </ul>
*/
public class TerminalMockCandidateFilter implements MockCandidateFilter {
- public OngoingInjector filterCandidate(final Collection<Object> mocks,
- final Field candidateFieldToBeInjected,
- final List<Field> allRemainingCandidateFields,
- final Object injectee) {
- if(mocks.size() == 1) {
+ @Override
+ public OngoingInjector filterCandidate(
+ final Collection<Object> mocks,
+ final Field candidateFieldToBeInjected,
+ final List<Field> allRemainingCandidateFields,
+ final Object injectee) {
+ if (mocks.size() == 1) {
final Object matchingMock = mocks.iterator().next();
- return new OngoingInjector() {
- public Object thenInject() {
- try {
- if (!new BeanPropertySetter(injectee, candidateFieldToBeInjected).set(matchingMock)) {
- setField(injectee, candidateFieldToBeInjected,matchingMock);
- }
- } catch (RuntimeException e) {
- throw cannotInjectDependency(candidateFieldToBeInjected, matchingMock, e);
+ MemberAccessor accessor = Plugins.getMemberAccessor();
+ return () -> {
+ try {
+ if (!new BeanPropertySetter(injectee, candidateFieldToBeInjected)
+ .set(matchingMock)) {
+ accessor.set(candidateFieldToBeInjected, injectee, matchingMock);
}
- return matchingMock;
+ } catch (RuntimeException | IllegalAccessException e) {
+ throw cannotInjectDependency(candidateFieldToBeInjected, matchingMock, e);
}
+ return matchingMock;
};
}
return OngoingInjector.nop;
-
}
}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java b/src/main/java/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java
index 7284399..9ba0fba 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java
+++ b/src/main/java/org/mockito/internal/configuration/injection/filter/TypeBasedCandidateFilter.java
@@ -17,17 +17,20 @@
this.next = next;
}
- public OngoingInjector filterCandidate(final Collection<Object> mocks,
- final Field candidateFieldToBeInjected,
- final List<Field> allRemainingCandidateFields,
- final Object injectee) {
- List<Object> mockTypeMatches = new ArrayList<Object>();
+ @Override
+ public OngoingInjector filterCandidate(
+ final Collection<Object> mocks,
+ final Field candidateFieldToBeInjected,
+ final List<Field> allRemainingCandidateFields,
+ final Object injectee) {
+ List<Object> mockTypeMatches = new ArrayList<>();
for (Object mock : mocks) {
if (candidateFieldToBeInjected.getType().isAssignableFrom(mock.getClass())) {
mockTypeMatches.add(mock);
}
}
- return next.filterCandidate(mockTypeMatches, candidateFieldToBeInjected, allRemainingCandidateFields, injectee);
+ return next.filterCandidate(
+ mockTypeMatches, candidateFieldToBeInjected, allRemainingCandidateFields, injectee);
}
}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/scanner/InjectMocksScanner.java b/src/main/java/org/mockito/internal/configuration/injection/scanner/InjectMocksScanner.java
index 57d5113..b206f18 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/scanner/InjectMocksScanner.java
+++ b/src/main/java/org/mockito/internal/configuration/injection/scanner/InjectMocksScanner.java
@@ -4,10 +4,6 @@
*/
package org.mockito.internal.configuration.injection.scanner;
-import org.mockito.Captor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-
import static org.mockito.internal.exceptions.Reporter.unsupportedCombinationOfAnnotations;
import java.lang.annotation.Annotation;
@@ -15,6 +11,10 @@
import java.util.HashSet;
import java.util.Set;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
/**
* Scan field for injection.
*/
@@ -30,7 +30,6 @@
this.clazz = clazz;
}
-
/**
* Add the fields annotated by @{@link InjectMocks}
*
@@ -47,7 +46,7 @@
*/
@SuppressWarnings("unchecked")
private Set<Field> scan() {
- Set<Field> mockDependentFields = new HashSet<Field>();
+ Set<Field> mockDependentFields = new HashSet<>();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
if (null != field.getAnnotation(InjectMocks.class)) {
@@ -59,10 +58,12 @@
return mockDependentFields;
}
- private static void assertNoAnnotations(Field field, Class<? extends Annotation>... annotations) {
+ private static void assertNoAnnotations(
+ Field field, Class<? extends Annotation>... annotations) {
for (Class<? extends Annotation> annotation : annotations) {
if (field.isAnnotationPresent(annotation)) {
- throw unsupportedCombinationOfAnnotations(annotation.getSimpleName(), InjectMocks.class.getSimpleName());
+ throw unsupportedCombinationOfAnnotations(
+ annotation.getSimpleName(), InjectMocks.class.getSimpleName());
}
}
}
diff --git a/src/main/java/org/mockito/internal/configuration/injection/scanner/MockScanner.java b/src/main/java/org/mockito/internal/configuration/injection/scanner/MockScanner.java
index 1d567fe..9798444 100644
--- a/src/main/java/org/mockito/internal/configuration/injection/scanner/MockScanner.java
+++ b/src/main/java/org/mockito/internal/configuration/injection/scanner/MockScanner.java
@@ -4,15 +4,15 @@
*/
package org.mockito.internal.configuration.injection.scanner;
-import org.mockito.Mock;
-import org.mockito.Spy;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.internal.util.reflection.FieldReader;
+import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;
import java.lang.reflect.Field;
import java.util.Set;
-import static org.mockito.internal.util.collections.Sets.newMockSafeHashSet;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.internal.util.reflection.FieldReader;
/**
* Scan mocks, and prepare them if needed.
@@ -80,7 +80,6 @@
}
private boolean isMockOrSpy(Object instance) {
- return MockUtil.isMock(instance)
- || MockUtil.isSpy(instance);
+ return MockUtil.isMock(instance) || MockUtil.isSpy(instance);
}
}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java b/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
index f80e7c4..559a90d 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
@@ -4,40 +4,63 @@
*/
package org.mockito.internal.configuration.plugins;
+import java.util.HashMap;
+import java.util.Map;
import org.mockito.internal.creation.instance.InstantiatorProvider2Adapter;
import org.mockito.plugins.AnnotationEngine;
import org.mockito.plugins.InstantiatorProvider;
import org.mockito.plugins.InstantiatorProvider2;
+import org.mockito.plugins.MemberAccessor;
import org.mockito.plugins.MockMaker;
+import org.mockito.plugins.MockitoLogger;
import org.mockito.plugins.MockitoPlugins;
import org.mockito.plugins.PluginSwitch;
import org.mockito.plugins.StackTraceCleanerProvider;
-import java.util.HashMap;
-import java.util.Map;
-
class DefaultMockitoPlugins implements MockitoPlugins {
- private final static Map<String, String> DEFAULT_PLUGINS = new HashMap<String, String>();
+ private static final Map<String, String> DEFAULT_PLUGINS = new HashMap<>();
static final String INLINE_ALIAS = "mock-maker-inline";
+ static final String PROXY_ALIAS = "mock-maker-proxy";
+ static final String MODULE_ALIAS = "member-accessor-module";
static {
- //Keep the mapping: plugin interface name -> plugin implementation class name
+ // Keep the mapping: plugin interface name -> plugin implementation class name
DEFAULT_PLUGINS.put(PluginSwitch.class.getName(), DefaultPluginSwitch.class.getName());
- DEFAULT_PLUGINS.put(MockMaker.class.getName(), "org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker");
- DEFAULT_PLUGINS.put(StackTraceCleanerProvider.class.getName(), "org.mockito.internal.exceptions.stacktrace.DefaultStackTraceCleanerProvider");
- DEFAULT_PLUGINS.put(InstantiatorProvider2.class.getName(), "org.mockito.internal.creation.instance.DefaultInstantiatorProvider");
- DEFAULT_PLUGINS.put(AnnotationEngine.class.getName(), "org.mockito.internal.configuration.InjectingAnnotationEngine");
- DEFAULT_PLUGINS.put(INLINE_ALIAS, "org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker");
+ DEFAULT_PLUGINS.put(
+ MockMaker.class.getName(),
+ "org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker");
+ DEFAULT_PLUGINS.put(
+ StackTraceCleanerProvider.class.getName(),
+ "org.mockito.internal.exceptions.stacktrace.DefaultStackTraceCleanerProvider");
+ DEFAULT_PLUGINS.put(
+ InstantiatorProvider2.class.getName(),
+ "org.mockito.internal.creation.instance.DefaultInstantiatorProvider");
+ DEFAULT_PLUGINS.put(
+ AnnotationEngine.class.getName(),
+ "org.mockito.internal.configuration.InjectingAnnotationEngine");
+ DEFAULT_PLUGINS.put(
+ INLINE_ALIAS, "org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker");
+ DEFAULT_PLUGINS.put(PROXY_ALIAS, "org.mockito.internal.creation.proxy.ProxyMockMaker");
+ DEFAULT_PLUGINS.put(
+ MockitoLogger.class.getName(), "org.mockito.internal.util.ConsoleMockitoLogger");
+ DEFAULT_PLUGINS.put(
+ MemberAccessor.class.getName(),
+ "org.mockito.internal.util.reflection.ReflectionMemberAccessor");
+ DEFAULT_PLUGINS.put(
+ MODULE_ALIAS, "org.mockito.internal.util.reflection.ModuleMemberAccessor");
}
@Override
public <T> T getDefaultPlugin(Class<T> pluginType) {
if (pluginType == InstantiatorProvider.class) {
- //the implementation class is not configured via map so that we can reduce duplication
- //(ensure that we are adapting the currently configured default implementation for InstantiatorProvider2)
+ // the implementation class is not configured via map so that we can reduce duplication
+ // (ensure that we are adapting the currently configured default implementation for
+ // InstantiatorProvider2)
String className = DEFAULT_PLUGINS.get(InstantiatorProvider2.class.getName());
- return pluginType.cast(new InstantiatorProvider2Adapter(create(InstantiatorProvider2.class, className)));
+ return pluginType.cast(
+ new InstantiatorProvider2Adapter(
+ create(InstantiatorProvider2.class, className)));
} else {
String className = DEFAULT_PLUGINS.get(pluginType.getName());
return create(pluginType, className);
@@ -54,20 +77,25 @@
private <T> T create(Class<T> pluginType, String className) {
if (className == null) {
throw new IllegalStateException(
- "No default implementation for requested Mockito plugin type: " + pluginType.getName() + "\n"
- + "Is this a valid Mockito plugin type? If yes, please report this problem to Mockito team.\n"
- + "Otherwise, please check if you are passing valid plugin type.\n"
- + "Examples of valid plugin types: MockMaker, StackTraceCleanerProvider.");
+ "No default implementation for requested Mockito plugin type: "
+ + pluginType.getName()
+ + "\n"
+ + "Is this a valid Mockito plugin type? If yes, please report this problem to Mockito team.\n"
+ + "Otherwise, please check if you are passing valid plugin type.\n"
+ + "Examples of valid plugin types: MockMaker, StackTraceCleanerProvider.");
}
try {
// Default implementation. Use our own ClassLoader instead of the context
// ClassLoader, as the default implementation is assumed to be part of
// Mockito and may not be available via the context ClassLoader.
- return pluginType.cast(Class.forName(className).newInstance());
+ return pluginType.cast(Class.forName(className).getDeclaredConstructor().newInstance());
} catch (Exception e) {
- throw new IllegalStateException("Internal problem occurred, please report it. " +
- "Mockito is unable to load the default implementation of class that is a part of Mockito distribution. " +
- "Failed to load " + pluginType, e);
+ throw new IllegalStateException(
+ "Internal problem occurred, please report it. "
+ + "Mockito is unable to load the default implementation of class that is a part of Mockito distribution. "
+ + "Failed to load "
+ + pluginType,
+ e);
}
}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/DefaultPluginSwitch.java b/src/main/java/org/mockito/internal/configuration/plugins/DefaultPluginSwitch.java
index e332cd9..61fded6 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/DefaultPluginSwitch.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/DefaultPluginSwitch.java
@@ -7,6 +7,7 @@
import org.mockito.plugins.PluginSwitch;
class DefaultPluginSwitch implements PluginSwitch {
+ @Override
public boolean isEnabled(String pluginClassName) {
return true;
}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginFileReader.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginFileReader.java
index a71a144..c1e2cbb 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginFileReader.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/PluginFileReader.java
@@ -4,14 +4,14 @@
*/
package org.mockito.internal.configuration.plugins;
-import org.mockito.internal.util.io.IOUtil;
-
import java.io.InputStream;
+import org.mockito.internal.util.io.IOUtil;
+
class PluginFileReader {
String readPluginClass(InputStream input) {
- for(String line: IOUtil.readLines(input)) {
+ for (String line : IOUtil.readLines(input)) {
String stripped = stripCommentAndWhitespace(line);
if (stripped.length() > 0) {
return stripped;
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginFinder.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginFinder.java
index 258da72..3ca2ac5 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginFinder.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/PluginFinder.java
@@ -4,13 +4,15 @@
*/
package org.mockito.internal.configuration.plugins;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.util.io.IOUtil;
import org.mockito.plugins.PluginSwitch;
-import java.io.InputStream;
-import java.net.URL;
-
class PluginFinder {
private final PluginSwitch pluginSwitch;
@@ -26,20 +28,47 @@
s = resource.openStream();
String pluginClassName = new PluginFileReader().readPluginClass(s);
if (pluginClassName == null) {
- //For backwards compatibility
- //If the resource does not have plugin class name we're ignoring it
+ // For backwards compatibility
+ // If the resource does not have plugin class name we're ignoring it
continue;
}
if (!pluginSwitch.isEnabled(pluginClassName)) {
continue;
}
return pluginClassName;
- } catch(Exception e) {
- throw new MockitoException("Problems reading plugin implementation from: " + resource, e);
+ } catch (Exception e) {
+ throw new MockitoException(
+ "Problems reading plugin implementation from: " + resource, e);
} finally {
IOUtil.closeQuietly(s);
}
}
return null;
}
+
+ List<String> findPluginClasses(Iterable<URL> resources) {
+ List<String> pluginClassNames = new ArrayList<>();
+ for (URL resource : resources) {
+ InputStream s = null;
+ try {
+ s = resource.openStream();
+ String pluginClassName = new PluginFileReader().readPluginClass(s);
+ if (pluginClassName == null) {
+ // For backwards compatibility
+ // If the resource does not have plugin class name we're ignoring it
+ continue;
+ }
+ if (!pluginSwitch.isEnabled(pluginClassName)) {
+ continue;
+ }
+ pluginClassNames.add(pluginClassName);
+ } catch (Exception e) {
+ throw new MockitoException(
+ "Problems reading plugin implementation from: " + resource, e);
+ } finally {
+ IOUtil.closeQuietly(s);
+ }
+ }
+ return pluginClassNames;
+ }
}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java
index 0e28d91..a88f0cc 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java
@@ -4,20 +4,23 @@
*/
package org.mockito.internal.configuration.plugins;
-import org.mockito.internal.util.collections.Iterables;
-import org.mockito.plugins.PluginSwitch;
-
import java.io.IOException;
import java.net.URL;
+import java.util.ArrayList;
import java.util.Enumeration;
+import java.util.List;
+import java.util.Set;
+
+import org.mockito.internal.util.collections.Iterables;
+import org.mockito.plugins.PluginSwitch;
class PluginInitializer {
private final PluginSwitch pluginSwitch;
- private final String alias;
+ private final Set<String> alias;
private final DefaultMockitoPlugins plugins;
- PluginInitializer(PluginSwitch pluginSwitch, String alias, DefaultMockitoPlugins plugins) {
+ PluginInitializer(PluginSwitch pluginSwitch, Set<String> alias, DefaultMockitoPlugins plugins) {
this.pluginSwitch = pluginSwitch;
this.alias = alias;
this.plugins = plugins;
@@ -40,19 +43,52 @@
}
try {
- String classOrAlias = new PluginFinder(pluginSwitch).findPluginClass(Iterables.toIterable(resources));
+ String classOrAlias =
+ new PluginFinder(pluginSwitch).findPluginClass(Iterables.toIterable(resources));
if (classOrAlias != null) {
- if (classOrAlias.equals(alias)) {
- classOrAlias = plugins.getDefaultPluginClass(alias);
+ if (alias.contains(classOrAlias)) {
+ classOrAlias = plugins.getDefaultPluginClass(classOrAlias);
}
Class<?> pluginClass = loader.loadClass(classOrAlias);
- Object plugin = pluginClass.newInstance();
+ Object plugin = pluginClass.getDeclaredConstructor().newInstance();
return service.cast(plugin);
}
return null;
} catch (Exception e) {
throw new IllegalStateException(
- "Failed to load " + service + " implementation declared in " + resources, e);
+ "Failed to load " + service + " implementation declared in " + resources, e);
+ }
+ }
+
+ public <T> List<T> loadImpls(Class<T> service) {
+ ClassLoader loader = Thread.currentThread().getContextClassLoader();
+ if (loader == null) {
+ loader = ClassLoader.getSystemClassLoader();
+ }
+ Enumeration<URL> resources;
+ try {
+ resources = loader.getResources("mockito-extensions/" + service.getName());
+ } catch (IOException e) {
+ throw new IllegalStateException("Failed to load " + service, e);
+ }
+
+ try {
+ List<String> classesOrAliases =
+ new PluginFinder(pluginSwitch)
+ .findPluginClasses(Iterables.toIterable(resources));
+ List<T> impls = new ArrayList<>();
+ for (String classOrAlias : classesOrAliases) {
+ if (alias.contains(classOrAlias)) {
+ classOrAlias = plugins.getDefaultPluginClass(classOrAlias);
+ }
+ Class<?> pluginClass = loader.loadClass(classOrAlias);
+ Object plugin = pluginClass.getDeclaredConstructor().newInstance();
+ impls.add(service.cast(plugin));
+ }
+ return impls;
+ } catch (Exception e) {
+ throw new IllegalStateException(
+ "Failed to load " + service + " implementation declared in " + resources, e);
}
}
}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java
index a230d0c..3f33dff 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/PluginLoader.java
@@ -4,11 +4,15 @@
*/
package org.mockito.internal.configuration.plugins;
-import org.mockito.plugins.PluginSwitch;
-
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+
+import org.mockito.plugins.PluginSwitch;
class PluginLoader {
@@ -21,19 +25,25 @@
}
PluginLoader(PluginSwitch pluginSwitch) {
- this(new DefaultMockitoPlugins(), new PluginInitializer(pluginSwitch, null, new DefaultMockitoPlugins()));
+ this(
+ new DefaultMockitoPlugins(),
+ new PluginInitializer(
+ pluginSwitch, Collections.emptySet(), new DefaultMockitoPlugins()));
}
/**
- * @deprecated Let's avoid adding more aliases. It complicates the API.
- * Instead of an alias, we can use fully qualified class name of the alternative implementation.
- * <p>
* Adds an alias for a class name to this plugin loader. Instead of the fully qualified type name,
- * the alias can be used as a convenience name for a known plugin.
+ * the alias can be used as a convenience name for a known plugin. This avoids exposing API that is
+ * explicitly marked as <i>internal</i> through the package name. Without such aliases, we would need
+ * to make internal packages part of the API, not by code but by configuration file.
*/
- @Deprecated
- PluginLoader(PluginSwitch pluginSwitch, String alias) {
- this(new DefaultMockitoPlugins(), new PluginInitializer(pluginSwitch, alias, new DefaultMockitoPlugins()));
+ PluginLoader(PluginSwitch pluginSwitch, String... alias) {
+ this(
+ new DefaultMockitoPlugins(),
+ new PluginInitializer(
+ pluginSwitch,
+ new HashSet<>(Arrays.asList(alias)),
+ new DefaultMockitoPlugins()));
}
/**
@@ -52,9 +62,11 @@
* @return An object of either {@code preferredPluginType} or {@code alternatePluginType}
*/
@SuppressWarnings("unchecked")
- <PreferredType, AlternateType> Object loadPlugin(final Class<PreferredType> preferredPluginType, final Class<AlternateType> alternatePluginType) {
+ <PreferredT, AlternateType> Object loadPlugin(
+ final Class<PreferredT> preferredPluginType,
+ final Class<AlternateType> alternatePluginType) {
try {
- PreferredType preferredPlugin = initializer.loadImpl(preferredPluginType);
+ PreferredT preferredPlugin = initializer.loadImpl(preferredPluginType);
if (preferredPlugin != null) {
return preferredPlugin;
} else if (alternatePluginType != null) {
@@ -66,14 +78,50 @@
return plugins.getDefaultPlugin(preferredPluginType);
} catch (final Throwable t) {
- return Proxy.newProxyInstance(preferredPluginType.getClassLoader(),
- new Class<?>[]{preferredPluginType},
- new InvocationHandler() {
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- throw new IllegalStateException("Could not initialize plugin: " + preferredPluginType + " (alternate: " + alternatePluginType + ")", t);
- }
- });
+ return Proxy.newProxyInstance(
+ preferredPluginType.getClassLoader(),
+ new Class<?>[] {preferredPluginType},
+ new InvocationHandler() {
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args)
+ throws Throwable {
+ throw new IllegalStateException(
+ "Could not initialize plugin: "
+ + preferredPluginType
+ + " (alternate: "
+ + alternatePluginType
+ + ")",
+ t);
+ }
+ });
+ }
+ }
+
+ /**
+ * Scans the classpath for given {@code pluginType} and returns a list of its instances.
+ *
+ * @return An list of {@code pluginType} or an empty list if none was found.
+ */
+ @SuppressWarnings("unchecked")
+ <T> List<T> loadPlugins(final Class<T> pluginType) {
+ try {
+ return initializer.loadImpls(pluginType);
+ } catch (final Throwable t) {
+ return Collections.singletonList(
+ (T)
+ Proxy.newProxyInstance(
+ pluginType.getClassLoader(),
+ new Class<?>[] {pluginType},
+ new InvocationHandler() {
+ @Override
+ public Object invoke(
+ Object proxy, Method method, Object[] args)
+ throws Throwable {
+ throw new IllegalStateException(
+ "Could not initialize plugin: " + pluginType,
+ t);
+ }
+ }));
}
}
}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
index 02e5d66..3bec0bf 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
@@ -4,32 +4,52 @@
*/
package org.mockito.internal.configuration.plugins;
+import java.util.List;
import org.mockito.internal.creation.instance.InstantiatorProviderAdapter;
import org.mockito.plugins.AnnotationEngine;
import org.mockito.plugins.InstantiatorProvider;
import org.mockito.plugins.InstantiatorProvider2;
+import org.mockito.plugins.MemberAccessor;
import org.mockito.plugins.MockMaker;
+import org.mockito.plugins.MockResolver;
+import org.mockito.plugins.MockitoLogger;
import org.mockito.plugins.PluginSwitch;
import org.mockito.plugins.StackTraceCleanerProvider;
class PluginRegistry {
- private final PluginSwitch pluginSwitch = new PluginLoader(new DefaultPluginSwitch())
- .loadPlugin(PluginSwitch.class);
+ private final PluginSwitch pluginSwitch =
+ new PluginLoader(new DefaultPluginSwitch()).loadPlugin(PluginSwitch.class);
- private final MockMaker mockMaker = new PluginLoader(pluginSwitch, DefaultMockitoPlugins.INLINE_ALIAS)
- .loadPlugin(MockMaker.class);
+ private final MockMaker mockMaker =
+ new PluginLoader(
+ pluginSwitch,
+ DefaultMockitoPlugins.INLINE_ALIAS,
+ DefaultMockitoPlugins.PROXY_ALIAS)
+ .loadPlugin(MockMaker.class);
- private final StackTraceCleanerProvider stackTraceCleanerProvider = new PluginLoader(pluginSwitch)
- .loadPlugin(StackTraceCleanerProvider.class);
+ private final MemberAccessor memberAccessor =
+ new PluginLoader(pluginSwitch, DefaultMockitoPlugins.MODULE_ALIAS)
+ .loadPlugin(MemberAccessor.class);
+
+ private final StackTraceCleanerProvider stackTraceCleanerProvider =
+ new PluginLoader(pluginSwitch).loadPlugin(StackTraceCleanerProvider.class);
private final InstantiatorProvider2 instantiatorProvider;
- private AnnotationEngine annotationEngine = new PluginLoader(pluginSwitch)
- .loadPlugin(AnnotationEngine.class);
+ private final AnnotationEngine annotationEngine =
+ new PluginLoader(pluginSwitch).loadPlugin(AnnotationEngine.class);
+
+ private final MockitoLogger mockitoLogger =
+ new PluginLoader(pluginSwitch).loadPlugin(MockitoLogger.class);
+
+ private final List<MockResolver> mockResolvers =
+ new PluginLoader(pluginSwitch).loadPlugins(MockResolver.class);
PluginRegistry() {
- Object impl = new PluginLoader(pluginSwitch).loadPlugin(InstantiatorProvider2.class, InstantiatorProvider.class);
+ Object impl =
+ new PluginLoader(pluginSwitch)
+ .loadPlugin(InstantiatorProvider2.class, InstantiatorProvider.class);
if (impl instanceof InstantiatorProvider) {
instantiatorProvider = new InstantiatorProviderAdapter((InstantiatorProvider) impl);
} else {
@@ -41,7 +61,7 @@
* The implementation of the stack trace cleaner
*/
StackTraceCleanerProvider getStackTraceCleanerProvider() {
- //TODO we should throw some sensible exception if this is null.
+ // TODO we should throw some sensible exception if this is null.
return stackTraceCleanerProvider;
}
@@ -56,6 +76,16 @@
}
/**
+ * Returns the implementation of the member accessor available for the current runtime.
+ *
+ * <p>Returns {@link org.mockito.internal.util.reflection.ReflectionMemberAccessor} if no
+ * {@link org.mockito.plugins.MockMaker} extension exists or is visible in the current classpath.</p>
+ */
+ MemberAccessor getMemberAccessor() {
+ return memberAccessor;
+ }
+
+ /**
* Returns the instantiator provider available for the current runtime.
*
* <p>Returns {@link org.mockito.internal.creation.instance.DefaultInstantiatorProvider} if no
@@ -75,4 +105,23 @@
AnnotationEngine getAnnotationEngine() {
return annotationEngine;
}
+
+ /**
+ * Returns the logger available for the current runtime.
+ *
+ * <p>Returns {@link org.mockito.internal.util.ConsoleMockitoLogger} if no
+ * {@link org.mockito.plugins.MockitoLogger} extension exists or is visible in the current classpath.</p>
+ */
+ MockitoLogger getMockitoLogger() {
+ return mockitoLogger;
+ }
+
+ /**
+ * Returns a list of available mock resolvers if any.
+ *
+ * @return A list of available mock resolvers or an empty list if none are registered.
+ */
+ List<MockResolver> getMockResolvers() {
+ return mockResolvers;
+ }
}
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java b/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
index f65fe89..dc6646b 100644
--- a/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
+++ b/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
@@ -4,16 +4,18 @@
*/
package org.mockito.internal.configuration.plugins;
+import java.util.List;
import org.mockito.plugins.AnnotationEngine;
import org.mockito.plugins.InstantiatorProvider2;
+import org.mockito.plugins.MemberAccessor;
import org.mockito.plugins.MockMaker;
+import org.mockito.plugins.MockResolver;
+import org.mockito.plugins.MockitoLogger;
import org.mockito.plugins.MockitoPlugins;
import org.mockito.plugins.StackTraceCleanerProvider;
-/**
- * Access to Mockito behavior that can be reconfigured by plugins
- */
-public class Plugins {
+/** Access to Mockito behavior that can be reconfigured by plugins */
+public final class Plugins {
private static final PluginRegistry registry = new PluginRegistry();
@@ -35,6 +37,16 @@
}
/**
+ * Returns the implementation of the member accessor available for the current runtime.
+ *
+ * <p>Returns default member accessor if no
+ * {@link org.mockito.plugins.MemberAccessor} extension exists or is visible in the current classpath.</p>
+ */
+ public static MemberAccessor getMemberAccessor() {
+ return registry.getMemberAccessor();
+ }
+
+ /**
* Returns the instantiator provider available for the current runtime.
*
* <p>Returns {@link org.mockito.internal.creation.instance.DefaultInstantiatorProvider} if no
@@ -42,7 +54,7 @@
* current classpath.</p>
*/
public static InstantiatorProvider2 getInstantiatorProvider() {
- return registry.getInstantiatorProvider();
+ return registry.getInstantiatorProvider();
}
/**
@@ -56,9 +68,30 @@
}
/**
+ * Returns the logger available for the current runtime.
+ *
+ * <p>Returns {@link org.mockito.internal.util.ConsoleMockitoLogger} if no
+ * {@link org.mockito.plugins.MockitoLogger} extension exists or is visible in the current classpath.</p>
+ */
+ public static MockitoLogger getMockitoLogger() {
+ return registry.getMockitoLogger();
+ }
+
+ /**
+ * Returns a list of available mock resolvers if any.
+ *
+ * @return A list of available mock resolvers or an empty list if none are registered.
+ */
+ public static List<MockResolver> getMockResolvers() {
+ return registry.getMockResolvers();
+ }
+
+ /**
* @return instance of mockito plugins type
*/
public static MockitoPlugins getPlugins() {
return new DefaultMockitoPlugins();
}
+
+ private Plugins() {}
}
diff --git a/src/main/java/org/mockito/internal/creation/DelegatingMethod.java b/src/main/java/org/mockito/internal/creation/DelegatingMethod.java
index 0844471..bb947ba 100644
--- a/src/main/java/org/mockito/internal/creation/DelegatingMethod.java
+++ b/src/main/java/org/mockito/internal/creation/DelegatingMethod.java
@@ -4,11 +4,11 @@
*/
package org.mockito.internal.creation;
-import org.mockito.internal.invocation.MockitoMethod;
-
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
+import org.mockito.internal.invocation.MockitoMethod;
+
public class DelegatingMethod implements MockitoMethod {
private final Method method;
@@ -20,30 +20,37 @@
this.parameterTypes = SuspendMethod.trimSuspendParameterTypes(method.getParameterTypes());
}
+ @Override
public Class<?>[] getExceptionTypes() {
return method.getExceptionTypes();
}
+ @Override
public Method getJavaMethod() {
return method;
}
+ @Override
public String getName() {
return method.getName();
}
+ @Override
public Class<?>[] getParameterTypes() {
return parameterTypes;
}
+ @Override
public Class<?> getReturnType() {
return method.getReturnType();
}
+ @Override
public boolean isVarArgs() {
return method.isVarArgs();
}
+ @Override
public boolean isAbstract() {
return (method.getModifiers() & Modifier.ABSTRACT) != 0;
}
diff --git a/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java b/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
index ca67730..3aa746c 100644
--- a/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
+++ b/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
@@ -4,36 +4,40 @@
*/
package org.mockito.internal.creation;
+import static java.util.Arrays.asList;
+
+import static org.mockito.internal.exceptions.Reporter.defaultAnswerDoesNotAcceptNullParameter;
+import static org.mockito.internal.exceptions.Reporter.extraInterfacesAcceptsOnlyInterfaces;
+import static org.mockito.internal.exceptions.Reporter.extraInterfacesDoesNotAcceptNullParameters;
+import static org.mockito.internal.exceptions.Reporter.extraInterfacesRequiresAtLeastOneInterface;
+import static org.mockito.internal.exceptions.Reporter.methodDoesNotAcceptParameter;
+import static org.mockito.internal.exceptions.Reporter.requiresAtLeastOneListener;
+import static org.mockito.internal.util.collections.Sets.newSet;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
import org.mockito.MockSettings;
+import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.creation.settings.CreationSettings;
import org.mockito.internal.debugging.VerboseMockInvocationLogger;
import org.mockito.internal.util.Checks;
import org.mockito.internal.util.MockCreationValidator;
import org.mockito.internal.util.MockNameImpl;
import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.StubbingLookupListener;
import org.mockito.listeners.VerificationStartedListener;
import org.mockito.mock.MockCreationSettings;
import org.mockito.mock.MockName;
import org.mockito.mock.SerializableMode;
import org.mockito.stubbing.Answer;
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import static org.mockito.internal.exceptions.Reporter.defaultAnswerDoesNotAcceptNullParameter;
-import static org.mockito.internal.exceptions.Reporter.extraInterfacesAcceptsOnlyInterfaces;
-import static org.mockito.internal.exceptions.Reporter.extraInterfacesDoesNotAcceptNullParameters;
-import static org.mockito.internal.exceptions.Reporter.extraInterfacesRequiresAtLeastOneInterface;
-import static org.mockito.internal.exceptions.Reporter.invocationListenersRequiresAtLeastOneListener;
-import static org.mockito.internal.exceptions.Reporter.methodDoesNotAcceptParameter;
-import static org.mockito.internal.util.collections.Sets.newSet;
-
@SuppressWarnings("unchecked")
-public class MockSettingsImpl<T> extends CreationSettings<T> implements MockSettings, MockCreationSettings<T> {
+public class MockSettingsImpl<T> extends CreationSettings<T>
+ implements MockSettings, MockCreationSettings<T> {
private static final long serialVersionUID = 4475297236197939569L;
private boolean useConstructor;
@@ -117,9 +121,10 @@
@Override
public MockSettings useConstructor(Object... constructorArgs) {
- Checks.checkNotNull(constructorArgs,
- "constructorArgs",
- "If you need to pass null, please cast it to the right type, e.g.: useConstructor((String) null)");
+ Checks.checkNotNull(
+ constructorArgs,
+ "constructorArgs",
+ "If you need to pass null, please cast it to the right type, e.g.: useConstructor((String) null)");
this.useConstructor = true;
this.constructorArgs = constructorArgs;
return this;
@@ -152,9 +157,9 @@
if (outerClassInstance == null) {
return constructorArgs;
}
- List<Object> resultArgs = new ArrayList<Object>(constructorArgs.length + 1);
+ List<Object> resultArgs = new ArrayList<>(constructorArgs.length + 1);
resultArgs.add(outerClassInstance);
- resultArgs.addAll(Arrays.asList(constructorArgs));
+ resultArgs.addAll(asList(constructorArgs));
return resultArgs.toArray(new Object[constructorArgs.length + 1]);
}
@@ -173,17 +178,23 @@
@Override
public MockSettings invocationListeners(InvocationListener... listeners) {
- if (listeners == null || listeners.length == 0) {
- throw invocationListenersRequiresAtLeastOneListener();
- }
addListeners(listeners, invocationListeners, "invocationListeners");
return this;
}
- private static <T> void addListeners(T[] listeners, List<T> container, String method) {
+ @Override
+ public MockSettings stubbingLookupListeners(StubbingLookupListener... listeners) {
+ addListeners(listeners, stubbingLookupListeners, "stubbingLookupListeners");
+ return this;
+ }
+
+ static <T> void addListeners(T[] listeners, List<T> container, String method) {
if (listeners == null) {
throw methodDoesNotAcceptParameter(method, "null vararg array.");
}
+ if (listeners.length == 0) {
+ throw requiresAtLeastOneListener(method);
+ }
for (T listener : listeners) {
if (listener == null) {
throw methodDoesNotAcceptParameter(method, "null listeners.");
@@ -207,13 +218,8 @@
return false;
}
- @Override
- public List<InvocationListener> getInvocationListeners() {
- return this.invocationListeners;
- }
-
public boolean hasInvocationListeners() {
- return !invocationListeners.isEmpty();
+ return !getInvocationListeners().isEmpty();
}
@Override
@@ -222,8 +228,13 @@
}
@Override
- public <T> MockCreationSettings<T> build(Class<T> typeToMock) {
- return validatedSettings(typeToMock, (CreationSettings<T>) this);
+ public <T2> MockCreationSettings<T2> build(Class<T2> typeToMock) {
+ return validatedSettings(typeToMock, (CreationSettings<T2>) this);
+ }
+
+ @Override
+ public <T2> MockCreationSettings<T2> buildStatic(Class<T2> classToMock) {
+ return validatedStaticSettings(classToMock, (CreationSettings<T2>) this);
}
@Override
@@ -232,34 +243,56 @@
return this;
}
- private static <T> CreationSettings<T> validatedSettings(Class<T> typeToMock, CreationSettings<T> source) {
+ private static <T> CreationSettings<T> validatedSettings(
+ Class<T> typeToMock, CreationSettings<T> source) {
MockCreationValidator validator = new MockCreationValidator();
validator.validateType(typeToMock);
validator.validateExtraInterfaces(typeToMock, source.getExtraInterfaces());
validator.validateMockedType(typeToMock, source.getSpiedInstance());
- //TODO SF - add this validation and also add missing coverage
-// validator.validateDelegatedInstance(classToMock, settings.getDelegatedInstance());
+ // TODO SF - add this validation and also add missing coverage
+ // validator.validateDelegatedInstance(classToMock, settings.getDelegatedInstance());
validator.validateConstructorUse(source.isUsingConstructor(), source.getSerializableMode());
- //TODO SF - I don't think we really need CreationSettings type
- //TODO do we really need to copy the entire settings every time we create mock object? it does not seem necessary.
+ // TODO SF - I don't think we really need CreationSettings type
+ // TODO do we really need to copy the entire settings every time we create mock object? it
+ // does not seem necessary.
CreationSettings<T> settings = new CreationSettings<T>(source);
- settings.setMockName(new MockNameImpl(source.getName(), typeToMock));
+ settings.setMockName(new MockNameImpl(source.getName(), typeToMock, false));
settings.setTypeToMock(typeToMock);
settings.setExtraInterfaces(prepareExtraInterfaces(source));
return settings;
}
+ private static <T> CreationSettings<T> validatedStaticSettings(
+ Class<T> classToMock, CreationSettings<T> source) {
+
+ if (classToMock.isPrimitive()) {
+ throw new MockitoException(
+ "Cannot create static mock of primitive type " + classToMock);
+ }
+ if (!source.getExtraInterfaces().isEmpty()) {
+ throw new MockitoException(
+ "Cannot specify additional interfaces for static mock of " + classToMock);
+ }
+ if (source.getSpiedInstance() != null) {
+ throw new MockitoException(
+ "Cannot specify spied instance for static mock of " + classToMock);
+ }
+
+ CreationSettings<T> settings = new CreationSettings<T>(source);
+ settings.setMockName(new MockNameImpl(source.getName(), classToMock, true));
+ settings.setTypeToMock(classToMock);
+ return settings;
+ }
+
private static Set<Class<?>> prepareExtraInterfaces(CreationSettings settings) {
- Set<Class<?>> interfaces = new HashSet<Class<?>>(settings.getExtraInterfaces());
- if(settings.isSerializable()) {
+ Set<Class<?>> interfaces = new HashSet<>(settings.getExtraInterfaces());
+ if (settings.isSerializable()) {
interfaces.add(Serializable.class);
}
return interfaces;
}
-
}
-
diff --git a/src/main/java/org/mockito/internal/creation/SuspendMethod.java b/src/main/java/org/mockito/internal/creation/SuspendMethod.java
index 42ceac6..1bb6e0a 100644
--- a/src/main/java/org/mockito/internal/creation/SuspendMethod.java
+++ b/src/main/java/org/mockito/internal/creation/SuspendMethod.java
@@ -10,14 +10,16 @@
* Utilities for Kotlin Continuation-Passing-Style suspending function, detecting and trimming last hidden parameter.
* See <a href="https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-informal.md#continuation-passing-style">Design docs for details</a>.
*/
-public class SuspendMethod {
- private static final String KOTLIN_EXPERIMENTAL_CONTINUATION = "kotlin.coroutines.experimental.Continuation";
+public final class SuspendMethod {
+ private static final String KOTLIN_EXPERIMENTAL_CONTINUATION =
+ "kotlin.coroutines.experimental.Continuation";
private static final String KOTLIN_CONTINUATION = "kotlin.coroutines.Continuation";
public static Class<?>[] trimSuspendParameterTypes(Class<?>[] parameterTypes) {
int n = parameterTypes.length;
- if (n > 0 && isContinuationType(parameterTypes[n - 1]))
+ if (n > 0 && isContinuationType(parameterTypes[n - 1])) {
return Arrays.copyOf(parameterTypes, n - 1);
+ }
return parameterTypes;
}
@@ -25,4 +27,6 @@
String name = parameterType.getName();
return name.equals(KOTLIN_CONTINUATION) || name.equals(KOTLIN_EXPERIMENTAL_CONTINUATION);
}
+
+ private SuspendMethod() {}
}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyCrossClassLoaderSerializationSupport.java b/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyCrossClassLoaderSerializationSupport.java
index f63731c..41efec4 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyCrossClassLoaderSerializationSupport.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyCrossClassLoaderSerializationSupport.java
@@ -2,9 +2,25 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.creation.bytebuddy;
+import static org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.ForWriteReplace;
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamClass;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+import java.lang.reflect.Field;
+import java.util.Set;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
import org.mockito.Incubating;
import org.mockito.exceptions.base.MockitoSerializationIssue;
import org.mockito.internal.configuration.plugins.Plugins;
@@ -13,16 +29,7 @@
import org.mockito.mock.MockCreationSettings;
import org.mockito.mock.MockName;
import org.mockito.mock.SerializableMode;
-
-import java.io.*;
-import java.lang.reflect.Field;
-import java.util.Set;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-
-import static org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.ForWriteReplace;
-import static org.mockito.internal.util.StringUtil.join;
-import static org.mockito.internal.util.reflection.FieldSetter.setField;
+import org.mockito.plugins.MemberAccessor;
/**
* This is responsible for serializing a mock, it is enabled if the mock is implementing {@link Serializable}.
@@ -115,12 +122,16 @@
return new CrossClassLoaderSerializationProxy(mockitoMock);
} catch (IOException ioe) {
MockName mockName = MockUtil.getMockName(mockitoMock);
- String mockedType = MockUtil.getMockSettings(mockitoMock).getTypeToMock().getCanonicalName();
- throw new MockitoSerializationIssue(join(
- "The mock '" + mockName + "' of type '" + mockedType + "'",
- "The Java Standard Serialization reported an '" + ioe.getClass().getSimpleName() + "' saying :",
- " " + ioe.getMessage()
- ), ioe);
+ String mockedType =
+ MockUtil.getMockSettings(mockitoMock).getTypeToMock().getCanonicalName();
+ throw new MockitoSerializationIssue(
+ join(
+ "The mock '" + mockName + "' of type '" + mockedType + "'",
+ "The Java Standard Serialization reported an '"
+ + ioe.getClass().getSimpleName()
+ + "' saying :",
+ " " + ioe.getMessage()),
+ ioe);
} finally {
// unmark
mockReplacementCompleted();
@@ -128,17 +139,14 @@
}
}
-
private void mockReplacementCompleted() {
instanceLocalCurrentlySerializingFlag = false;
}
-
private void mockReplacementStarted() {
instanceLocalCurrentlySerializingFlag = true;
}
-
private boolean mockIsCurrentlyBeingReplaced() {
return instanceLocalCurrentlySerializingFlag;
}
@@ -193,10 +201,12 @@
* @return A deserialized instance of the Mockito mock.
* @throws java.io.ObjectStreamException
*/
+ @SuppressWarnings("BanSerializableRead")
private Object readResolve() throws ObjectStreamException {
try {
ByteArrayInputStream bis = new ByteArrayInputStream(serializedMock);
- ObjectInputStream objectInputStream = new MockitoMockObjectInputStream(bis, typeToMock, extraInterfaces);
+ ObjectInputStream objectInputStream =
+ new MockitoMockObjectInputStream(bis, typeToMock, extraInterfaces);
Object deserializedMock = objectInputStream.readObject();
@@ -205,22 +215,25 @@
return deserializedMock;
} catch (IOException ioe) {
- throw new MockitoSerializationIssue(join(
- "Mockito mock cannot be deserialized to a mock of '" + typeToMock.getCanonicalName() + "'. The error was :",
- " " + ioe.getMessage(),
- "If you are unsure what is the reason of this exception, feel free to contact us on the mailing list."
- ), ioe);
+ throw new MockitoSerializationIssue(
+ join(
+ "Mockito mock cannot be deserialized to a mock of '"
+ + typeToMock.getCanonicalName()
+ + "'. The error was :",
+ " " + ioe.getMessage(),
+ "If you are unsure what is the reason of this exception, feel free to contact us on the mailing list."),
+ ioe);
} catch (ClassNotFoundException cce) {
- throw new MockitoSerializationIssue(join(
- "A class couldn't be found while deserializing a Mockito mock, you should check your classpath. The error was :",
- " " + cce.getMessage(),
- "If you are still unsure what is the reason of this exception, feel free to contact us on the mailing list."
- ), cce);
+ throw new MockitoSerializationIssue(
+ join(
+ "A class couldn't be found while deserializing a Mockito mock, you should check your classpath. The error was :",
+ " " + cce.getMessage(),
+ "If you are still unsure what is the reason of this exception, feel free to contact us on the mailing list."),
+ cce);
}
}
}
-
/**
* Special Mockito aware <code>ObjectInputStream</code> that will resolve the Mockito proxy class.
* <p/>
@@ -241,7 +254,9 @@
private final Class<?> typeToMock;
private final Set<Class<?>> extraInterfaces;
- public MockitoMockObjectInputStream(InputStream in, Class<?> typeToMock, Set<Class<?>> extraInterfaces) throws IOException {
+ public MockitoMockObjectInputStream(
+ InputStream in, Class<?> typeToMock, Set<Class<?>> extraInterfaces)
+ throws IOException {
super(in);
this.typeToMock = typeToMock;
this.extraInterfaces = extraInterfaces;
@@ -261,7 +276,9 @@
* @throws ClassNotFoundException
*/
@Override
- protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
+ @SuppressWarnings("BanSerializableRead")
+ protected Class<?> resolveClass(ObjectStreamClass desc)
+ throws IOException, ClassNotFoundException {
if (notMarkedAsAMockitoMock(readObject())) {
return super.resolveClass(desc);
}
@@ -269,20 +286,24 @@
// create the Mockito mock class before it can even be deserialized
try {
@SuppressWarnings("unchecked")
- Class<?> proxyClass = ((ClassCreatingMockMaker) Plugins.getMockMaker()).createMockType(
- new CreationSettings()
- .setTypeToMock(typeToMock)
- .setExtraInterfaces(extraInterfaces)
- .setSerializableMode(SerializableMode.ACROSS_CLASSLOADERS));
+ Class<?> proxyClass =
+ ((ClassCreatingMockMaker) Plugins.getMockMaker())
+ .createMockType(
+ new CreationSettings()
+ .setTypeToMock(typeToMock)
+ .setExtraInterfaces(extraInterfaces)
+ .setSerializableMode(
+ SerializableMode.ACROSS_CLASSLOADERS));
hackClassNameToMatchNewlyCreatedClass(desc, proxyClass);
return proxyClass;
} catch (ClassCastException cce) {
- throw new MockitoSerializationIssue(join(
- "A Byte Buddy-generated mock cannot be deserialized into a non-Byte Buddy generated mock class",
- "",
- "The mock maker in use was: " + Plugins.getMockMaker().getClass()
- ), cce);
+ throw new MockitoSerializationIssue(
+ join(
+ "A Byte Buddy-generated mock cannot be deserialized into a non-Byte Buddy generated mock class",
+ "",
+ "The mock maker in use was: " + Plugins.getMockMaker().getClass()),
+ cce);
}
}
@@ -304,17 +325,25 @@
* @param proxyClass The proxy class whose name will be applied.
* @throws java.io.InvalidObjectException
*/
- private void hackClassNameToMatchNewlyCreatedClass(ObjectStreamClass descInstance, Class<?> proxyClass) throws ObjectStreamException {
+ private void hackClassNameToMatchNewlyCreatedClass(
+ ObjectStreamClass descInstance, Class<?> proxyClass) throws ObjectStreamException {
try {
+ MemberAccessor accessor = Plugins.getMemberAccessor();
Field classNameField = descInstance.getClass().getDeclaredField("name");
- setField(descInstance, classNameField,proxyClass.getCanonicalName());
+ try {
+ accessor.set(classNameField, descInstance, proxyClass.getCanonicalName());
+ } catch (IllegalAccessException e) {
+ throw new MockitoSerializationIssue(
+ "Access to " + classNameField + " was denied", e);
+ }
} catch (NoSuchFieldException nsfe) {
- throw new MockitoSerializationIssue(join(
- "Wow, the class 'ObjectStreamClass' in the JDK don't have the field 'name',",
- "this is definitely a bug in our code as it means the JDK team changed a few internal things.",
- "",
- "Please report an issue with the JDK used, a code sample and a link to download the JDK would be welcome."
- ), nsfe);
+ throw new MockitoSerializationIssue(
+ join(
+ "Wow, the class 'ObjectStreamClass' in the JDK don't have the field 'name',",
+ "this is definitely a bug in our code as it means the JDK team changed a few internal things.",
+ "",
+ "Please report an issue with the JDK used, a code sample and a link to download the JDK would be welcome."),
+ nsfe);
}
}
@@ -329,7 +358,6 @@
}
}
-
/**
* Special Mockito aware <code>ObjectOutputStream</code>.
* <p/>
@@ -375,7 +403,6 @@
}
}
-
/**
* Simple interface that hold a correct <code>writeReplace</code> signature that can be seen by an
* <code>ObjectOutputStream</code>.
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java b/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java
index 3b124dc..35c379c 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java
@@ -5,9 +5,14 @@
package org.mockito.internal.creation.bytebuddy;
import org.mockito.Incubating;
+import org.mockito.MockedConstruction;
+import org.mockito.internal.exceptions.Reporter;
import org.mockito.invocation.MockHandler;
import org.mockito.mock.MockCreationSettings;
+import java.util.Optional;
+import java.util.function.Function;
+
/**
* ByteBuddy MockMaker.
*
@@ -18,31 +23,71 @@
* The programmatic API could look like {@code mock(Final.class, withSettings().finalClasses())}.
*/
public class ByteBuddyMockMaker implements ClassCreatingMockMaker {
- private ClassCreatingMockMaker defaultByteBuddyMockMaker = new SubclassByteBuddyMockMaker();
+ private final SubclassByteBuddyMockMaker subclassByteBuddyMockMaker;
+
+ public ByteBuddyMockMaker() {
+ try {
+ subclassByteBuddyMockMaker = new SubclassByteBuddyMockMaker();
+ } catch (NoClassDefFoundError e) {
+ Reporter.missingByteBuddyDependency(e);
+ throw e;
+ }
+ }
+
+ ByteBuddyMockMaker(SubclassByteBuddyMockMaker subclassByteBuddyMockMaker) {
+ this.subclassByteBuddyMockMaker = subclassByteBuddyMockMaker;
+ }
@Override
public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
- return defaultByteBuddyMockMaker.createMock(settings, handler);
+ return subclassByteBuddyMockMaker.createMock(settings, handler);
+ }
+
+ @Override
+ public <T> Optional<T> createSpy(
+ MockCreationSettings<T> settings, MockHandler handler, T object) {
+ return subclassByteBuddyMockMaker.createSpy(settings, handler, object);
}
@Override
public <T> Class<? extends T> createMockType(MockCreationSettings<T> creationSettings) {
- return defaultByteBuddyMockMaker.createMockType(creationSettings);
+ return subclassByteBuddyMockMaker.createMockType(creationSettings);
}
@Override
public MockHandler getHandler(Object mock) {
- return defaultByteBuddyMockMaker.getHandler(mock);
+ return subclassByteBuddyMockMaker.getHandler(mock);
}
@Override
public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
- defaultByteBuddyMockMaker.resetMock(mock, newHandler, settings);
+ subclassByteBuddyMockMaker.resetMock(mock, newHandler, settings);
}
@Override
@Incubating
public TypeMockability isTypeMockable(Class<?> type) {
- return defaultByteBuddyMockMaker.isTypeMockable(type);
+ return subclassByteBuddyMockMaker.isTypeMockable(type);
+ }
+
+ @Override
+ public <T> StaticMockControl<T> createStaticMock(
+ Class<T> type, MockCreationSettings<T> settings, MockHandler handler) {
+ return subclassByteBuddyMockMaker.createStaticMock(type, settings, handler);
+ }
+
+ @Override
+ public <T> ConstructionMockControl<T> createConstructionMock(
+ Class<T> type,
+ Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory,
+ Function<MockedConstruction.Context, MockHandler<T>> handlerFactory,
+ MockedConstruction.MockInitializer<T> mockInitializer) {
+ return subclassByteBuddyMockMaker.createConstructionMock(
+ type, settingsFactory, handlerFactory, mockInitializer);
+ }
+
+ @Override
+ public void clearAllCaches() {
+ subclassByteBuddyMockMaker.clearAllCaches();
}
}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/BytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/BytecodeGenerator.java
index a131c04..392392d 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/BytecodeGenerator.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/BytecodeGenerator.java
@@ -7,4 +7,10 @@
public interface BytecodeGenerator {
<T> Class<? extends T> mockClass(MockFeatures<T> features);
+
+ void mockClassConstruction(Class<?> type);
+
+ void mockClassStatic(Class<?> type);
+
+ default void clearAllCaches() {}
}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/ConstructionCallback.java b/src/main/java/org/mockito/internal/creation/bytebuddy/ConstructionCallback.java
new file mode 100644
index 0000000..ac8ecc4
--- /dev/null
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/ConstructionCallback.java
@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+public interface ConstructionCallback {
+
+ Object apply(Class<?> type, Object object, Object[] arguments, String[] parameterTypeNames);
+}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java
index dfe2061..92593de 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java
@@ -4,310 +4,99 @@
*/
package org.mockito.internal.creation.bytebuddy;
-import net.bytebuddy.agent.ByteBuddyAgent;
import org.mockito.Incubating;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.base.MockitoInitializationException;
-import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.MockedConstruction;
import org.mockito.creation.instance.Instantiator;
-import org.mockito.internal.util.Platform;
-import org.mockito.internal.util.concurrent.WeakConcurrentMap;
+import org.mockito.internal.exceptions.Reporter;
import org.mockito.invocation.MockHandler;
import org.mockito.mock.MockCreationSettings;
import org.mockito.plugins.InlineMockMaker;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.lang.instrument.Instrumentation;
-import java.lang.reflect.Modifier;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
-import java.util.jar.JarOutputStream;
+import java.util.Optional;
+import java.util.function.Function;
-import static org.mockito.internal.creation.bytebuddy.InlineBytecodeGenerator.EXCLUDES;
-import static org.mockito.internal.util.StringUtil.join;
-
-/**
- * Agent and subclass based mock maker.
- * <p>
- * This mock maker which uses a combination of the Java instrumentation API and sub-classing rather than creating
- * a new sub-class to create a mock. This way, it becomes possible to mock final types and methods. This mock
- * maker <strong>must to be activated explicitly</strong> for supporting mocking final types and methods:
- * <p>
- * <p>
- * This mock maker can be activated by creating the file <code>/mockito-extensions/org.mockito.plugins.MockMaker</code>
- * containing the text <code>mock-maker-inline</code> or <code>org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker</code>.
- * <p>
- * <p>
- * This mock maker will make a best effort to avoid subclass creation when creating a mock. Otherwise it will use the
- * <code>org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker</code> to create the mock class. That means
- * that the following condition is true
- * <p>
- * <pre class="code"><code class="java">
- * class Foo { }
- * assert mock(Foo.class).getClass() == Foo.class;
- * </pre></code>
- * <p>
- * unless any of the following conditions is met, in such case the mock maker <em>fall backs</em> to the
- * the creation of a subclass.
- * <p>
- * <ul>
- * <li>the type to mock is an abstract class.</li>
- * <li>the mock is set to require additional interfaces.</li>
- * <li>the mock is <a href="#20">explicitly set to support serialization</a>.</li>
- * </ul>
- * <p>
- * <p>
- * Some type of the JDK cannot be mocked, this includes <code>Class</code>, <code>String</code>, and wrapper types.
- * <p>
- * <p>
- * Nevertheless, final methods of such types are mocked when using the inlining mock maker. Mocking final types and enums
- * does however remain impossible when explicitly requiring serialization support or when adding ancillary interfaces.
- * <p>
- * <p>
- * Important behavioral changes when using inline-mocks:
- * <ul>
- * <li>Mockito is capable of mocking package-private methods even if they are defined in different packages than
- * the mocked type. Mockito voluntarily never mocks package-visible methods within <code>java.*</code> packages.</li>
- * <li>Additionally to final types, Mockito can now mock types that are not visible for extension; such types
- * include private types in a protected package.</li>
- * <li>Mockito can no longer mock <code>native</code> methods. Inline mocks require byte code manipulation of a
- * method where native methods do not offer any byte code to manipulate.</li>
- * <li>Mockito cannot longer strip <code>synchronized</code> modifiers from mocked instances.</li>
- * </ul>
- * <p>
- * <p>
- * Note that inline mocks require a Java agent to be attached. Mockito will attempt an attachment of a Java agent upon
- * loading the mock maker for creating inline mocks. Such runtime attachment is only possible when using a JVM that
- * is part of a JDK or when using a Java 9 VM. When running on a non-JDK VM prior to Java 9, it is however possible to
- * manually add the <a href="http://bytebuddy.net">Byte Buddy Java agent jar</a> using the <code>-javaagent</code>
- * parameter upon starting the JVM. Furthermore, the inlining mock maker requires the VM to support class retransformation
- * (also known as HotSwap). All major VM distributions such as HotSpot (OpenJDK), J9 (IBM/Websphere) or Zing (Azul)
- * support this feature.
- */
@Incubating
-public class InlineByteBuddyMockMaker implements ClassCreatingMockMaker, InlineMockMaker {
-
- private static final Instrumentation INSTRUMENTATION;
-
- private static final Throwable INITIALIZATION_ERROR;
-
- static {
- Instrumentation instrumentation;
- Throwable initializationError = null;
- try {
- try {
- instrumentation = ByteBuddyAgent.install();
- if (!instrumentation.isRetransformClassesSupported()) {
- throw new IllegalStateException(join(
- "Byte Buddy requires retransformation for creating inline mocks. This feature is unavailable on the current VM.",
- "",
- "You cannot use this mock maker on this VM"));
- }
- File boot = File.createTempFile("mockitoboot", ".jar");
- boot.deleteOnExit();
- JarOutputStream outputStream = new JarOutputStream(new FileOutputStream(boot));
- try {
- String source = "org/mockito/internal/creation/bytebuddy/MockMethodDispatcher";
- InputStream inputStream = InlineByteBuddyMockMaker.class.getClassLoader().getResourceAsStream(source + ".raw");
- if (inputStream == null) {
- throw new IllegalStateException(join(
- "The MockMethodDispatcher class file is not locatable: " + source + ".raw",
- "",
- "The class loader responsible for looking up the resource: " + InlineByteBuddyMockMaker.class.getClassLoader()
- ));
- }
- outputStream.putNextEntry(new JarEntry(source + ".class"));
- try {
- int length;
- byte[] buffer = new byte[1024];
- while ((length = inputStream.read(buffer)) != -1) {
- outputStream.write(buffer, 0, length);
- }
- } finally {
- inputStream.close();
- }
- outputStream.closeEntry();
- } finally {
- outputStream.close();
- }
- instrumentation.appendToBootstrapClassLoaderSearch(new JarFile(boot));
- try {
- Class<?> dispatcher = Class.forName("org.mockito.internal.creation.bytebuddy.MockMethodDispatcher");
- if (dispatcher.getClassLoader() != null) {
- throw new IllegalStateException(join(
- "The MockMethodDispatcher must not be loaded manually but must be injected into the bootstrap class loader.",
- "",
- "The dispatcher class was already loaded by: " + dispatcher.getClassLoader()));
- }
- } catch (ClassNotFoundException cnfe) {
- throw new IllegalStateException(join(
- "Mockito failed to inject the MockMethodDispatcher class into the bootstrap class loader",
- "",
- "It seems like your current VM does not support the instrumentation API correctly."), cnfe);
- }
- } catch (IOException ioe) {
- throw new IllegalStateException(join(
- "Mockito could not self-attach a Java agent to the current VM. This feature is required for inline mocking.",
- "This error occured due to an I/O error during the creation of this agent: " + ioe,
- "",
- "Potentially, the current VM does not support the instrumentation API correctly"), ioe);
- }
- } catch (Throwable throwable) {
- instrumentation = null;
- initializationError = throwable;
- }
- INSTRUMENTATION = instrumentation;
- INITIALIZATION_ERROR = initializationError;
- }
-
- private final BytecodeGenerator bytecodeGenerator;
-
- private final WeakConcurrentMap<Object, MockMethodInterceptor> mocks = new WeakConcurrentMap.WithInlinedExpunction<Object, MockMethodInterceptor>();
+public class InlineByteBuddyMockMaker
+ implements ClassCreatingMockMaker, InlineMockMaker, Instantiator {
+ private final InlineDelegateByteBuddyMockMaker inlineDelegateByteBuddyMockMaker;
public InlineByteBuddyMockMaker() {
- if (INITIALIZATION_ERROR != null) {
- throw new MockitoInitializationException(join(
- "Could not initialize inline Byte Buddy mock maker. (This mock maker is not supported on Android.)",
- "",
- Platform.describe()), INITIALIZATION_ERROR);
+ try {
+ inlineDelegateByteBuddyMockMaker = new InlineDelegateByteBuddyMockMaker();
+ } catch (NoClassDefFoundError e) {
+ Reporter.missingByteBuddyDependency(e);
+ throw e;
}
- bytecodeGenerator = new TypeCachingBytecodeGenerator(new InlineBytecodeGenerator(INSTRUMENTATION, mocks), true);
+ }
+
+ InlineByteBuddyMockMaker(InlineDelegateByteBuddyMockMaker inlineDelegateByteBuddyMockMaker) {
+ this.inlineDelegateByteBuddyMockMaker = inlineDelegateByteBuddyMockMaker;
}
@Override
- public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
- Class<? extends T> type = createMockType(settings);
-
- Instantiator instantiator = Plugins.getInstantiatorProvider().getInstantiator(settings);
- try {
- T instance = instantiator.newInstance(type);
- MockMethodInterceptor mockMethodInterceptor = new MockMethodInterceptor(handler, settings);
- mocks.put(instance, mockMethodInterceptor);
- if (instance instanceof MockAccess) {
- ((MockAccess) instance).setMockitoInterceptor(mockMethodInterceptor);
- }
- return instance;
- } catch (org.mockito.creation.instance.InstantiationException e) {
- throw new MockitoException("Unable to create mock instance of type '" + type.getSimpleName() + "'", e);
- }
+ public <T> T newInstance(Class<T> cls) {
+ return inlineDelegateByteBuddyMockMaker.newInstance(cls);
}
@Override
public <T> Class<? extends T> createMockType(MockCreationSettings<T> settings) {
- try {
- return bytecodeGenerator.mockClass(MockFeatures.withMockFeatures(
- settings.getTypeToMock(),
- settings.getExtraInterfaces(),
- settings.getSerializableMode(),
- settings.isStripAnnotations()
- ));
- } catch (Exception bytecodeGenerationFailed) {
- throw prettifyFailure(settings, bytecodeGenerationFailed);
- }
- }
-
- private <T> RuntimeException prettifyFailure(MockCreationSettings<T> mockFeatures, Exception generationFailed) {
- if (mockFeatures.getTypeToMock().isArray()) {
- throw new MockitoException(join(
- "Arrays cannot be mocked: " + mockFeatures.getTypeToMock() + ".",
- ""
- ), generationFailed);
- }
- if (Modifier.isFinal(mockFeatures.getTypeToMock().getModifiers())) {
- throw new MockitoException(join(
- "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
- "Can not mock final classes with the following settings :",
- " - explicit serialization (e.g. withSettings().serializable())",
- " - extra interfaces (e.g. withSettings().extraInterfaces(...))",
- "",
- "You are seeing this disclaimer because Mockito is configured to create inlined mocks.",
- "You can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.",
- "",
- "Underlying exception : " + generationFailed
- ), generationFailed);
- }
- if (Modifier.isPrivate(mockFeatures.getTypeToMock().getModifiers())) {
- throw new MockitoException(join(
- "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
- "Most likely it is a private class that is not visible by Mockito",
- "",
- "You are seeing this disclaimer because Mockito is configured to create inlined mocks.",
- "You can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.",
- ""
- ), generationFailed);
- }
- throw new MockitoException(join(
- "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
- "",
- "If you're not sure why you're getting this error, please report to the mailing list.",
- "",
- Platform.warnForVM(
- "IBM J9 VM", "Early IBM virtual machine are known to have issues with Mockito, please upgrade to an up-to-date version.\n",
- "Hotspot", Platform.isJava8BelowUpdate45() ? "Java 8 early builds have bugs that were addressed in Java 1.8.0_45, please update your JDK!\n" : ""
- ),
- Platform.describe(),
- "",
- "You are seeing this disclaimer because Mockito is configured to create inlined mocks.",
- "You can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.",
- "",
- "Underlying exception : " + generationFailed
- ), generationFailed);
- }
-
- @Override
- public MockHandler getHandler(Object mock) {
- MockMethodInterceptor interceptor = mocks.get(mock);
- if (interceptor == null) {
- return null;
- } else {
- return interceptor.handler;
- }
- }
-
- @Override
- public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
- MockMethodInterceptor mockMethodInterceptor = new MockMethodInterceptor(newHandler, settings);
- mocks.put(mock, mockMethodInterceptor);
- if (mock instanceof MockAccess) {
- ((MockAccess) mock).setMockitoInterceptor(mockMethodInterceptor);
- }
+ return inlineDelegateByteBuddyMockMaker.createMockType(settings);
}
@Override
public void clearMock(Object mock) {
- mocks.remove(mock);
+ inlineDelegateByteBuddyMockMaker.clearMock(mock);
}
@Override
public void clearAllMocks() {
- mocks.clear();
+ inlineDelegateByteBuddyMockMaker.clearAllMocks();
}
@Override
- public TypeMockability isTypeMockable(final Class<?> type) {
- return new TypeMockability() {
- @Override
- public boolean mockable() {
- return INSTRUMENTATION.isModifiableClass(type) && !EXCLUDES.contains(type);
- }
-
- @Override
- public String nonMockableReason() {
- if (mockable()) {
- return "";
- }
- if (type.isPrimitive()) {
- return "primitive type";
- }
- if (EXCLUDES.contains(type)) {
- return "Cannot mock wrapper types, String.class or Class.class";
- }
- return "VM does not not support modification of given type";
- }
- };
+ public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
+ return inlineDelegateByteBuddyMockMaker.createMock(settings, handler);
}
+ @Override
+ public <T> Optional<T> createSpy(
+ MockCreationSettings<T> settings, MockHandler handler, T instance) {
+ return inlineDelegateByteBuddyMockMaker.createSpy(settings, handler, instance);
+ }
+
+ @Override
+ public MockHandler getHandler(Object mock) {
+ return inlineDelegateByteBuddyMockMaker.getHandler(mock);
+ }
+
+ @Override
+ public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
+ inlineDelegateByteBuddyMockMaker.resetMock(mock, newHandler, settings);
+ }
+
+ @Override
+ public TypeMockability isTypeMockable(Class<?> type) {
+ return inlineDelegateByteBuddyMockMaker.isTypeMockable(type);
+ }
+
+ @Override
+ public <T> StaticMockControl<T> createStaticMock(
+ Class<T> type, MockCreationSettings<T> settings, MockHandler handler) {
+ return inlineDelegateByteBuddyMockMaker.createStaticMock(type, settings, handler);
+ }
+
+ @Override
+ public <T> ConstructionMockControl<T> createConstructionMock(
+ Class<T> type,
+ Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory,
+ Function<MockedConstruction.Context, MockHandler<T>> handlerFactory,
+ MockedConstruction.MockInitializer<T> mockInitializer) {
+ return inlineDelegateByteBuddyMockMaker.createConstructionMock(
+ type, settingsFactory, handlerFactory, mockInitializer);
+ }
+
+ @Override
+ public void clearAllCaches() {
+ inlineDelegateByteBuddyMockMaker.clearAllCaches();
+ }
}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java
index 64139c2..077bf97 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java
@@ -20,85 +20,151 @@
import net.bytebuddy.implementation.Implementation;
import net.bytebuddy.jar.asm.ClassVisitor;
import net.bytebuddy.jar.asm.MethodVisitor;
-import net.bytebuddy.jar.asm.Opcodes;
import net.bytebuddy.matcher.ElementMatchers;
import net.bytebuddy.pool.TypePool;
import net.bytebuddy.utility.OpenedClassReader;
import net.bytebuddy.utility.RandomString;
import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.SuppressSignatureCheck;
+import org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher;
+import org.mockito.internal.util.concurrent.DetachedThreadLocal;
import org.mockito.internal.util.concurrent.WeakConcurrentMap;
import org.mockito.internal.util.concurrent.WeakConcurrentSet;
import org.mockito.mock.SerializableMode;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;
+import java.lang.instrument.UnmodifiableClassException;
+import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.security.ProtectionDomain;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.*;
+import java.util.function.Predicate;
import static net.bytebuddy.implementation.MethodDelegation.withDefaultConfiguration;
import static net.bytebuddy.implementation.bind.annotation.TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFixedValue.OfConstant.of;
import static net.bytebuddy.matcher.ElementMatchers.*;
import static org.mockito.internal.util.StringUtil.join;
+@SuppressSignatureCheck
public class InlineBytecodeGenerator implements BytecodeGenerator, ClassFileTransformer {
private static final String PRELOAD = "org.mockito.inline.preload";
@SuppressWarnings("unchecked")
- static final Set<Class<?>> EXCLUDES = new HashSet<Class<?>>(Arrays.asList(Class.class,
- Boolean.class,
- Byte.class,
- Short.class,
- Character.class,
- Integer.class,
- Long.class,
- Float.class,
- Double.class,
- String.class));
+ static final Set<Class<?>> EXCLUDES =
+ new HashSet<Class<?>>(
+ Arrays.asList(
+ Class.class,
+ Boolean.class,
+ Byte.class,
+ Short.class,
+ Character.class,
+ Integer.class,
+ Long.class,
+ Float.class,
+ Double.class,
+ String.class));
private final Instrumentation instrumentation;
private final ByteBuddy byteBuddy;
- private final WeakConcurrentSet<Class<?>> mocked;
+ private final WeakConcurrentSet<Class<?>> mocked, flatMocked;
private final BytecodeGenerator subclassEngine;
private final AsmVisitorWrapper mockTransformer;
+ private final Method getModule, canRead, redefineModule;
+
private volatile Throwable lastException;
- public InlineBytecodeGenerator(Instrumentation instrumentation, WeakConcurrentMap<Object, MockMethodInterceptor> mocks) {
+ public InlineBytecodeGenerator(
+ Instrumentation instrumentation,
+ WeakConcurrentMap<Object, MockMethodInterceptor> mocks,
+ DetachedThreadLocal<Map<Class<?>, MockMethodInterceptor>> mockedStatics,
+ Predicate<Class<?>> isMockConstruction,
+ ConstructionCallback onConstruction) {
preload();
this.instrumentation = instrumentation;
- byteBuddy = new ByteBuddy()
- .with(TypeValidation.DISABLED)
- .with(Implementation.Context.Disabled.Factory.INSTANCE)
- .with(MethodGraph.Compiler.ForDeclaredMethods.INSTANCE);
- mocked = new WeakConcurrentSet<Class<?>>(WeakConcurrentSet.Cleaner.INLINE);
+ byteBuddy =
+ new ByteBuddy()
+ .with(TypeValidation.DISABLED)
+ .with(Implementation.Context.Disabled.Factory.INSTANCE)
+ .with(MethodGraph.Compiler.ForDeclaredMethods.INSTANCE)
+ .ignore(isSynthetic().and(not(isConstructor())).or(isDefaultFinalizer()));
+ mocked = new WeakConcurrentSet<>(WeakConcurrentSet.Cleaner.INLINE);
+ flatMocked = new WeakConcurrentSet<>(WeakConcurrentSet.Cleaner.INLINE);
String identifier = RandomString.make();
- subclassEngine = new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(withDefaultConfiguration()
- .withBinders(of(MockMethodAdvice.Identifier.class, identifier))
- .to(MockMethodAdvice.ForReadObject.class), isAbstract().or(isNative()).or(isToString())), false);
- mockTransformer = new AsmVisitorWrapper.ForDeclaredMethods()
- .method(isVirtual()
- .and(not(isBridge().or(isHashCode()).or(isEquals()).or(isDefaultFinalizer())))
- .and(not(isDeclaredBy(nameStartsWith("java.")).<MethodDescription>and(isPackagePrivate()))),
- Advice.withCustomMapping()
- .bind(MockMethodAdvice.Identifier.class, identifier)
- .to(MockMethodAdvice.class))
- .method(isHashCode(),
- Advice.withCustomMapping()
- .bind(MockMethodAdvice.Identifier.class, identifier)
- .to(MockMethodAdvice.ForHashCode.class))
- .method(isEquals(),
- Advice.withCustomMapping()
- .bind(MockMethodAdvice.Identifier.class, identifier)
- .to(MockMethodAdvice.ForEquals.class));
- MockMethodDispatcher.set(identifier, new MockMethodAdvice(mocks, identifier));
+ subclassEngine =
+ new TypeCachingBytecodeGenerator(
+ new SubclassBytecodeGenerator(
+ withDefaultConfiguration()
+ .withBinders(
+ of(MockMethodAdvice.Identifier.class, identifier))
+ .to(MockMethodAdvice.ForReadObject.class),
+ isAbstract().or(isNative()).or(isToString())),
+ false);
+ mockTransformer =
+ new AsmVisitorWrapper.ForDeclaredMethods()
+ .method(
+ isVirtual()
+ .and(
+ not(
+ isBridge()
+ .or(isHashCode())
+ .or(isEquals())
+ .or(isDefaultFinalizer())))
+ .and(
+ not(
+ isDeclaredBy(nameStartsWith("java."))
+ .<MethodDescription>and(
+ isPackagePrivate()))),
+ Advice.withCustomMapping()
+ .bind(MockMethodAdvice.Identifier.class, identifier)
+ .to(MockMethodAdvice.class))
+ .method(
+ isStatic(),
+ Advice.withCustomMapping()
+ .bind(MockMethodAdvice.Identifier.class, identifier)
+ .to(MockMethodAdvice.ForStatic.class))
+ .constructor(any(), new MockMethodAdvice.ConstructorShortcut(identifier))
+ .method(
+ isHashCode(),
+ Advice.withCustomMapping()
+ .bind(MockMethodAdvice.Identifier.class, identifier)
+ .to(MockMethodAdvice.ForHashCode.class))
+ .method(
+ isEquals(),
+ Advice.withCustomMapping()
+ .bind(MockMethodAdvice.Identifier.class, identifier)
+ .to(MockMethodAdvice.ForEquals.class));
+ Method getModule, canRead, redefineModule;
+ try {
+ getModule = Class.class.getMethod("getModule");
+ canRead = getModule.getReturnType().getMethod("canRead", getModule.getReturnType());
+ redefineModule =
+ Instrumentation.class.getMethod(
+ "redefineModule",
+ getModule.getReturnType(),
+ Set.class,
+ Map.class,
+ Map.class,
+ Set.class,
+ Map.class);
+ } catch (Exception ignored) {
+ getModule = null;
+ canRead = null;
+ redefineModule = null;
+ }
+ this.getModule = getModule;
+ this.canRead = canRead;
+ this.redefineModule = redefineModule;
+ MockMethodDispatcher.set(
+ identifier,
+ new MockMethodAdvice(
+ mocks, mockedStatics, identifier, isMockConstruction, onConstruction));
instrumentation.addTransformer(this, true);
}
@@ -119,7 +185,8 @@
private static void preload() {
String preloads = System.getProperty(PRELOAD);
if (preloads == null) {
- preloads = "java.lang.WeakPairMap,java.lang.WeakPairMap$Pair,java.lang.WeakPairMap$Pair$Weak";
+ preloads =
+ "java.lang.WeakPairMap,java.lang.WeakPairMap$Pair,java.lang.WeakPairMap$Pair$Weak";
}
for (String preload : preloads.split(",")) {
try {
@@ -131,89 +198,200 @@
@Override
public <T> Class<? extends T> mockClass(MockFeatures<T> features) {
- boolean subclassingRequired = !features.interfaces.isEmpty()
- || features.serializableMode != SerializableMode.NONE
- || Modifier.isAbstract(features.mockedType.getModifiers());
+ boolean subclassingRequired =
+ !features.interfaces.isEmpty()
+ || features.serializableMode != SerializableMode.NONE
+ || Modifier.isAbstract(features.mockedType.getModifiers());
checkSupportedCombination(subclassingRequired, features);
+ Set<Class<?>> types = new HashSet<>();
+ types.add(features.mockedType);
+ types.addAll(features.interfaces);
+
synchronized (this) {
- triggerRetransformation(features);
+ triggerRetransformation(types, false);
}
- return subclassingRequired ?
- subclassEngine.mockClass(features) :
- features.mockedType;
+ return subclassingRequired ? subclassEngine.mockClass(features) : features.mockedType;
}
- private <T> void triggerRetransformation(MockFeatures<T> features) {
- Set<Class<?>> types = new HashSet<Class<?>>();
- Class<?> type = features.mockedType;
- do {
- if (mocked.add(type)) {
- types.add(type);
- addInterfaces(types, type.getInterfaces());
+ @Override
+ public synchronized void mockClassStatic(Class<?> type) {
+ triggerRetransformation(Collections.singleton(type), true);
+ }
+
+ @Override
+ public synchronized void mockClassConstruction(Class<?> type) {
+ triggerRetransformation(Collections.singleton(type), false);
+ }
+
+ private static void assureInitialization(Class<?> type) {
+ try {
+ Class.forName(type.getName(), true, type.getClassLoader());
+ } catch (ExceptionInInitializerError e) {
+ throw new MockitoException(
+ "Cannot instrument "
+ + type
+ + " because it or one of its supertypes could not be initialized",
+ e.getException());
+ } catch (Throwable ignored) {
+ }
+ }
+
+ private <T> void triggerRetransformation(Set<Class<?>> types, boolean flat) {
+ Set<Class<?>> targets = new HashSet<Class<?>>();
+
+ try {
+ for (Class<?> type : types) {
+ if (flat) {
+ if (!mocked.contains(type) && flatMocked.add(type)) {
+ assureInitialization(type);
+ targets.add(type);
+ }
+ } else {
+ do {
+ if (mocked.add(type)) {
+ assureInitialization(type);
+ if (!flatMocked.remove(type)) {
+ targets.add(type);
+ }
+ addInterfaces(targets, type.getInterfaces());
+ }
+ type = type.getSuperclass();
+ } while (type != null);
+ }
}
- type = type.getSuperclass();
- } while (type != null);
- if (!types.isEmpty()) {
+ } catch (Throwable t) {
+ for (Class<?> target : targets) {
+ mocked.remove(target);
+ flatMocked.remove(target);
+ }
+ throw t;
+ }
+
+ if (!targets.isEmpty()) {
try {
- instrumentation.retransformClasses(types.toArray(new Class<?>[types.size()]));
+ assureCanReadMockito(targets);
+ instrumentation.retransformClasses(targets.toArray(new Class<?>[targets.size()]));
Throwable throwable = lastException;
if (throwable != null) {
- throw new IllegalStateException(join("Byte Buddy could not instrument all classes within the mock's type hierarchy",
- "",
- "This problem should never occur for javac-compiled classes. This problem has been observed for classes that are:",
- " - Compiled by older versions of scalac",
- " - Classes that are part of the Android distribution"), throwable);
+ throw new IllegalStateException(
+ join(
+ "Byte Buddy could not instrument all classes within the mock's type hierarchy",
+ "",
+ "This problem should never occur for javac-compiled classes. This problem has been observed for classes that are:",
+ " - Compiled by older versions of scalac",
+ " - Classes that are part of the Android distribution"),
+ throwable);
}
} catch (Exception exception) {
- for (Class<?> failed : types) {
+ for (Class<?> failed : targets) {
mocked.remove(failed);
+ flatMocked.remove(failed);
}
- throw new MockitoException("Could not modify all classes " + types, exception);
+ throw new MockitoException("Could not modify all classes " + targets, exception);
} finally {
lastException = null;
}
}
}
- private <T> void checkSupportedCombination(boolean subclassingRequired, MockFeatures<T> features) {
+ private void assureCanReadMockito(Set<Class<?>> types) {
+ if (redefineModule == null) {
+ return;
+ }
+ Set<Object> modules = new HashSet<Object>();
+ try {
+ Object target =
+ getModule.invoke(
+ Class.forName(
+ "org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher",
+ false,
+ null));
+ for (Class<?> type : types) {
+ Object module = getModule.invoke(type);
+ if (!modules.contains(module) && !(Boolean) canRead.invoke(module, target)) {
+ modules.add(module);
+ }
+ }
+ for (Object module : modules) {
+ redefineModule.invoke(
+ instrumentation,
+ module,
+ Collections.singleton(target),
+ Collections.emptyMap(),
+ Collections.emptyMap(),
+ Collections.emptySet(),
+ Collections.emptyMap());
+ }
+ } catch (Exception e) {
+ throw new IllegalStateException(
+ join(
+ "Could not adjust module graph to make the mock instance dispatcher visible to some classes",
+ "",
+ "At least one of those modules: "
+ + modules
+ + " is not reading the unnamed module of the bootstrap loader",
+ "Without such a read edge, the classes that are redefined to become mocks cannot access the mock dispatcher.",
+ "To circumvent this, Mockito attempted to add a read edge to this module what failed for an unexpected reason"),
+ e);
+ }
+ }
+
+ private <T> void checkSupportedCombination(
+ boolean subclassingRequired, MockFeatures<T> features) {
if (subclassingRequired
&& !features.mockedType.isArray()
&& !features.mockedType.isPrimitive()
- && Modifier.isFinal(features.mockedType.getModifiers())) {
- throw new MockitoException("Unsupported settings with this type '" + features.mockedType.getName() + "'");
+ && (Modifier.isFinal(features.mockedType.getModifiers())
+ || TypeSupport.INSTANCE.isSealed(features.mockedType)
+ || features.interfaces.stream().anyMatch(TypeSupport.INSTANCE::isSealed))) {
+ throw new MockitoException(
+ "Unsupported settings with this type '" + features.mockedType.getName() + "'");
}
}
private void addInterfaces(Set<Class<?>> types, Class<?>[] interfaces) {
for (Class<?> type : interfaces) {
if (mocked.add(type)) {
- types.add(type);
+ if (!flatMocked.remove(type)) {
+ types.add(type);
+ }
addInterfaces(types, type.getInterfaces());
}
}
}
@Override
- public byte[] transform(ClassLoader loader,
- String className,
- Class<?> classBeingRedefined,
- ProtectionDomain protectionDomain,
- byte[] classfileBuffer) {
+ public byte[] transform(
+ ClassLoader loader,
+ String className,
+ Class<?> classBeingRedefined,
+ ProtectionDomain protectionDomain,
+ byte[] classfileBuffer) {
if (classBeingRedefined == null
- || !mocked.contains(classBeingRedefined)
- || EXCLUDES.contains(classBeingRedefined)) {
+ || !mocked.contains(classBeingRedefined)
+ && !flatMocked.contains(classBeingRedefined)
+ || EXCLUDES.contains(classBeingRedefined)) {
return null;
} else {
try {
- return byteBuddy.redefine(classBeingRedefined, ClassFileLocator.Simple.of(classBeingRedefined.getName(), classfileBuffer))
- // Note: The VM erases parameter meta data from the provided class file (bug). We just add this information manually.
- .visit(new ParameterWritingVisitorWrapper(classBeingRedefined))
- .visit(mockTransformer)
- .make()
- .getBytes();
+ return byteBuddy
+ .redefine(
+ classBeingRedefined,
+ // new ClassFileLocator.Compound(
+ ClassFileLocator.Simple.of(
+ classBeingRedefined.getName(), classfileBuffer)
+ // ,ClassFileLocator.ForClassLoader.ofSystemLoader()
+ // )
+ )
+ // Note: The VM erases parameter meta data from the provided class file
+ // (bug). We just add this information manually.
+ .visit(new ParameterWritingVisitorWrapper(classBeingRedefined))
+ .visit(mockTransformer)
+ .make()
+ .getBytes();
} catch (Throwable throwable) {
lastException = throwable;
return null;
@@ -221,6 +399,28 @@
}
}
+ @Override
+ public synchronized void clearAllCaches() {
+ Set<Class<?>> types = new HashSet<>();
+ mocked.forEach(types::add);
+ if (types.isEmpty()) {
+ return;
+ }
+ mocked.clear();
+ flatMocked.clear();
+ try {
+ instrumentation.retransformClasses(types.toArray(new Class<?>[0]));
+ } catch (UnmodifiableClassException e) {
+ throw new MockitoException(
+ join(
+ "Failed to reset mocks.",
+ "",
+ "This should not influence the working of Mockito.",
+ "But if the reset intends to remove mocking code to improve performance, it is still impacted."),
+ e);
+ }
+ }
+
private static class ParameterWritingVisitorWrapper extends AsmVisitorWrapper.AbstractBase {
private final Class<?> type;
@@ -230,16 +430,18 @@
}
@Override
- public ClassVisitor wrap(TypeDescription instrumentedType,
- ClassVisitor classVisitor,
- Implementation.Context implementationContext,
- TypePool typePool,
- FieldList<FieldDescription.InDefinedShape> fields,
- MethodList<?> methods,
- int writerFlags,
- int readerFlags) {
+ public ClassVisitor wrap(
+ TypeDescription instrumentedType,
+ ClassVisitor classVisitor,
+ Implementation.Context implementationContext,
+ TypePool typePool,
+ FieldList<FieldDescription.InDefinedShape> fields,
+ MethodList<?> methods,
+ int writerFlags,
+ int readerFlags) {
return implementationContext.getClassFileVersion().isAtLeast(ClassFileVersion.JAVA_V8)
- ? new ParameterAddingClassVisitor(classVisitor, new TypeDescription.ForLoadedType(type))
+ ? new ParameterAddingClassVisitor(
+ classVisitor, new TypeDescription.ForLoadedType(type))
: classVisitor;
}
@@ -253,14 +455,26 @@
}
@Override
- public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
- MethodVisitor methodVisitor = super.visitMethod(access, name, desc, signature, exceptions);
- MethodList<?> methodList = typeDescription.getDeclaredMethods().filter((name.equals(MethodDescription.CONSTRUCTOR_INTERNAL_NAME)
- ? isConstructor()
- : ElementMatchers.<MethodDescription>named(name)).and(hasDescriptor(desc)));
- if (methodList.size() == 1 && methodList.getOnly().getParameters().hasExplicitMetaData()) {
- for (ParameterDescription parameterDescription : methodList.getOnly().getParameters()) {
- methodVisitor.visitParameter(parameterDescription.getName(), parameterDescription.getModifiers());
+ public MethodVisitor visitMethod(
+ int access, String name, String desc, String signature, String[] exceptions) {
+ MethodVisitor methodVisitor =
+ super.visitMethod(access, name, desc, signature, exceptions);
+ MethodList<?> methodList =
+ typeDescription
+ .getDeclaredMethods()
+ .filter(
+ (name.equals(MethodDescription.CONSTRUCTOR_INTERNAL_NAME)
+ ? isConstructor()
+ : ElementMatchers.<MethodDescription>named(
+ name))
+ .and(hasDescriptor(desc)));
+ if (methodList.size() == 1
+ && methodList.getOnly().getParameters().hasExplicitMetaData()) {
+ for (ParameterDescription parameterDescription :
+ methodList.getOnly().getParameters()) {
+ methodVisitor.visitParameter(
+ parameterDescription.getName(),
+ parameterDescription.getModifiers());
}
return new MethodParameterStrippingMethodVisitor(methodVisitor);
} else {
@@ -272,7 +486,7 @@
private static class MethodParameterStrippingMethodVisitor extends MethodVisitor {
public MethodParameterStrippingMethodVisitor(MethodVisitor mv) {
- super(Opcodes.ASM5, mv);
+ super(OpenedClassReader.ASM_API, mv);
}
@Override
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java
new file mode 100644
index 0000000..7178927
--- /dev/null
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java
@@ -0,0 +1,881 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import net.bytebuddy.agent.ByteBuddyAgent;
+import org.mockito.Incubating;
+import org.mockito.MockedConstruction;
+import org.mockito.creation.instance.InstantiationException;
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.base.MockitoInitializationException;
+import org.mockito.exceptions.misusing.MockitoConfigurationException;
+import org.mockito.internal.SuppressSignatureCheck;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.instance.ConstructorInstantiator;
+import org.mockito.internal.util.Platform;
+import org.mockito.internal.util.concurrent.DetachedThreadLocal;
+import org.mockito.internal.util.concurrent.WeakConcurrentMap;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.InlineMockMaker;
+import org.mockito.plugins.MemberAccessor;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.instrument.Instrumentation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Modifier;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarOutputStream;
+
+import static org.mockito.internal.creation.bytebuddy.InlineBytecodeGenerator.EXCLUDES;
+import static org.mockito.internal.util.StringUtil.join;
+
+/**
+ * Agent and subclass based mock maker.
+ * <p>
+ * This mock maker which uses a combination of the Java instrumentation API and sub-classing rather than creating
+ * a new sub-class to create a mock. This way, it becomes possible to mock final types and methods. This mock
+ * maker <strong>must to be activated explicitly</strong> for supporting mocking final types and methods:
+ * <p>
+ * <p>
+ * This mock maker can be activated by creating the file <code>/mockito-extensions/org.mockito.plugins.MockMaker</code>
+ * containing the text <code>mock-maker-inline</code> or <code>org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker</code>.
+ * <p>
+ * <p>
+ * This mock maker will make a best effort to avoid subclass creation when creating a mock. Otherwise it will use the
+ * <code>org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker</code> to create the mock class. That means
+ * that the following condition is true
+ * <p>
+ * <pre class="code"><code class="java">
+ * class Foo { }
+ * assert mock(Foo.class).getClass() == Foo.class;
+ * </pre></code>
+ * <p>
+ * unless any of the following conditions is met, in such case the mock maker <em>fall backs</em> to the
+ * the creation of a subclass.
+ * <p>
+ * <ul>
+ * <li>the type to mock is an abstract class.</li>
+ * <li>the mock is set to require additional interfaces.</li>
+ * <li>the mock is <a href="#20">explicitly set to support serialization</a>.</li>
+ * </ul>
+ * <p>
+ * <p>
+ * Some type of the JDK cannot be mocked, this includes <code>Class</code>, <code>String</code>, and wrapper types.
+ * <p>
+ * <p>
+ * Nevertheless, final methods of such types are mocked when using the inlining mock maker. Mocking final types and enums
+ * does however remain impossible when explicitly requiring serialization support or when adding ancillary interfaces.
+ * <p>
+ * <p>
+ * Important behavioral changes when using inline-mocks:
+ * <ul>
+ * <li>Mockito is capable of mocking package-private methods even if they are defined in different packages than
+ * the mocked type. Mockito voluntarily never mocks package-visible methods within <code>java.*</code> packages.</li>
+ * <li>Additionally to final types, Mockito can now mock types that are not visible for extension; such types
+ * include private types in a protected package.</li>
+ * <li>Mockito can no longer mock <code>native</code> methods. Inline mocks require byte code manipulation of a
+ * method where native methods do not offer any byte code to manipulate.</li>
+ * <li>Mockito cannot longer strip <code>synchronized</code> modifiers from mocked instances.</li>
+ * </ul>
+ * <p>
+ * <p>
+ * Note that inline mocks require a Java agent to be attached. Mockito will attempt an attachment of a Java agent upon
+ * loading the mock maker for creating inline mocks. Such runtime attachment is only possible when using a JVM that
+ * is part of a JDK or when using a Java 9 VM. When running on a non-JDK VM prior to Java 9, it is however possible to
+ * manually add the <a href="https://bytebuddy.net">Byte Buddy Java agent jar</a> using the <code>-javaagent</code>
+ * parameter upon starting the JVM. Furthermore, the inlining mock maker requires the VM to support class retransformation
+ * (also known as HotSwap). All major VM distributions such as HotSpot (OpenJDK), J9 (IBM/Websphere) or Zing (Azul)
+ * support this feature.
+ */
+@Incubating
+@SuppressSignatureCheck
+class InlineDelegateByteBuddyMockMaker
+ implements ClassCreatingMockMaker, InlineMockMaker, Instantiator {
+
+ private static final Instrumentation INSTRUMENTATION;
+
+ private static final Throwable INITIALIZATION_ERROR;
+
+ static {
+ Instrumentation instrumentation;
+ Throwable initializationError = null;
+ try {
+ try {
+ instrumentation = ByteBuddyAgent.install();
+ if (!instrumentation.isRetransformClassesSupported()) {
+ throw new IllegalStateException(
+ join(
+ "Byte Buddy requires retransformation for creating inline mocks. This feature is unavailable on the current VM.",
+ "",
+ "You cannot use this mock maker on this VM"));
+ }
+ File boot = File.createTempFile("mockitoboot", ".jar");
+ boot.deleteOnExit();
+ JarOutputStream outputStream = new JarOutputStream(new FileOutputStream(boot));
+ try {
+ String source =
+ "org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher";
+ InputStream inputStream =
+ InlineDelegateByteBuddyMockMaker.class
+ .getClassLoader()
+ .getResourceAsStream(source + ".raw");
+ if (inputStream == null) {
+ throw new IllegalStateException(
+ join(
+ "The MockMethodDispatcher class file is not locatable: "
+ + source
+ + ".raw",
+ "",
+ "The class loader responsible for looking up the resource: "
+ + InlineDelegateByteBuddyMockMaker.class
+ .getClassLoader()));
+ }
+ outputStream.putNextEntry(new JarEntry(source + ".class"));
+ try {
+ int length;
+ byte[] buffer = new byte[1024];
+ while ((length = inputStream.read(buffer)) != -1) {
+ outputStream.write(buffer, 0, length);
+ }
+ } finally {
+ inputStream.close();
+ }
+ outputStream.closeEntry();
+ } finally {
+ outputStream.close();
+ }
+ try (JarFile jarfile = new JarFile(boot)) {
+ instrumentation.appendToBootstrapClassLoaderSearch(jarfile);
+ }
+ try {
+ Class.forName(
+ "org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher",
+ false,
+ null);
+ } catch (ClassNotFoundException cnfe) {
+ throw new IllegalStateException(
+ join(
+ "Mockito failed to inject the MockMethodDispatcher class into the bootstrap class loader",
+ "",
+ "It seems like your current VM does not support the instrumentation API correctly."),
+ cnfe);
+ }
+ } catch (IOException ioe) {
+ throw new IllegalStateException(
+ join(
+ "Mockito could not self-attach a Java agent to the current VM. This feature is required for inline mocking.",
+ "This error occured due to an I/O error during the creation of this agent: "
+ + ioe,
+ "",
+ "Potentially, the current VM does not support the instrumentation API correctly"),
+ ioe);
+ }
+ } catch (Throwable throwable) {
+ instrumentation = null;
+ initializationError = throwable;
+ }
+ INSTRUMENTATION = instrumentation;
+ INITIALIZATION_ERROR = initializationError;
+ }
+
+ private final BytecodeGenerator bytecodeGenerator;
+
+ private final WeakConcurrentMap<Object, MockMethodInterceptor> mocks =
+ new WeakConcurrentMap.WithInlinedExpunction<Object, MockMethodInterceptor>();
+
+ private final DetachedThreadLocal<Map<Class<?>, MockMethodInterceptor>> mockedStatics =
+ new DetachedThreadLocal<>(DetachedThreadLocal.Cleaner.INLINE);
+
+ private final DetachedThreadLocal<Map<Class<?>, BiConsumer<Object, MockedConstruction.Context>>>
+ mockedConstruction = new DetachedThreadLocal<>(DetachedThreadLocal.Cleaner.INLINE);
+
+ private final ThreadLocal<Boolean> mockitoConstruction = ThreadLocal.withInitial(() -> false);
+
+ private final ThreadLocal<Object> currentSpied = new ThreadLocal<>();
+
+ InlineDelegateByteBuddyMockMaker() {
+ if (INITIALIZATION_ERROR != null) {
+ String detail;
+ if (System.getProperty("java.specification.vendor", "")
+ .toLowerCase()
+ .contains("android")) {
+ detail =
+ "It appears as if you are trying to run this mock maker on Android which does not support the instrumentation API.";
+ } else {
+ try {
+ if (INITIALIZATION_ERROR instanceof NoClassDefFoundError
+ && INITIALIZATION_ERROR.getMessage() != null
+ && INITIALIZATION_ERROR
+ .getMessage()
+ .startsWith("net/bytebuddy/agent/")) {
+ detail =
+ join(
+ "It seems like you are running Mockito with an incomplete or inconsistent class path. Byte Buddy Agent could not be loaded.",
+ "",
+ "Byte Buddy Agent is available on Maven Central as 'net.bytebuddy:byte-buddy-agent' with the module name 'net.bytebuddy.agent'.",
+ "Normally, your IDE or build tool (such as Maven or Gradle) should take care of your class path completion but ");
+ } else if (Class.forName("javax.tools.ToolProvider")
+ .getMethod("getSystemJavaCompiler")
+ .invoke(null)
+ == null) {
+ detail =
+ "It appears as if you are running on a JRE. Either install a JDK or add JNA to the class path.";
+ } else {
+ detail =
+ "It appears as if your JDK does not supply a working agent attachment mechanism.";
+ }
+ } catch (Throwable ignored) {
+ detail =
+ "It appears as if you are running an incomplete JVM installation that might not support all tooling APIs";
+ }
+ }
+ throw new MockitoInitializationException(
+ join(
+ "Could not initialize inline Byte Buddy mock maker.",
+ "",
+ detail,
+ Platform.describe()),
+ INITIALIZATION_ERROR);
+ }
+
+ ThreadLocal<Class<?>> currentConstruction = new ThreadLocal<>();
+ ThreadLocal<Boolean> isSuspended = ThreadLocal.withInitial(() -> false);
+ Predicate<Class<?>> isMockConstruction =
+ type -> {
+ if (isSuspended.get()) {
+ return false;
+ } else if (mockitoConstruction.get() || currentConstruction.get() != null) {
+ return true;
+ }
+ Map<Class<?>, ?> interceptors = mockedConstruction.get();
+ if (interceptors != null && interceptors.containsKey(type)) {
+ currentConstruction.set(type);
+ return true;
+ } else {
+ return false;
+ }
+ };
+ ConstructionCallback onConstruction =
+ (type, object, arguments, parameterTypeNames) -> {
+ if (mockitoConstruction.get()) {
+ Object spy = currentSpied.get();
+ if (spy == null) {
+ return null;
+ } else if (type.isInstance(spy)) {
+ return spy;
+ } else {
+ isSuspended.set(true);
+ try {
+ // Unexpected construction of non-spied object
+ throw new MockitoException(
+ "Unexpected spy for "
+ + type.getName()
+ + " on instance of "
+ + object.getClass().getName(),
+ object instanceof Throwable ? (Throwable) object : null);
+ } finally {
+ isSuspended.set(false);
+ }
+ }
+ } else if (currentConstruction.get() != type) {
+ return null;
+ }
+ currentConstruction.remove();
+ isSuspended.set(true);
+ try {
+ Map<Class<?>, BiConsumer<Object, MockedConstruction.Context>> interceptors =
+ mockedConstruction.get();
+ if (interceptors != null) {
+ BiConsumer<Object, MockedConstruction.Context> interceptor =
+ interceptors.get(type);
+ if (interceptor != null) {
+ interceptor.accept(
+ object,
+ new InlineConstructionMockContext(
+ arguments, object.getClass(), parameterTypeNames));
+ }
+ }
+ } finally {
+ isSuspended.set(false);
+ }
+ return null;
+ };
+
+ bytecodeGenerator =
+ new TypeCachingBytecodeGenerator(
+ new InlineBytecodeGenerator(
+ INSTRUMENTATION,
+ mocks,
+ mockedStatics,
+ isMockConstruction,
+ onConstruction),
+ true);
+ }
+
+ @Override
+ public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
+ return doCreateMock(settings, handler, false);
+ }
+
+ @Override
+ public <T> Optional<T> createSpy(
+ MockCreationSettings<T> settings, MockHandler handler, T object) {
+ if (object == null) {
+ throw new MockitoConfigurationException("Spy instance must not be null");
+ }
+ currentSpied.set(object);
+ try {
+ return Optional.ofNullable(doCreateMock(settings, handler, true));
+ } finally {
+ currentSpied.remove();
+ }
+ }
+
+ private <T> T doCreateMock(
+ MockCreationSettings<T> settings,
+ MockHandler handler,
+ boolean nullOnNonInlineConstruction) {
+ Class<? extends T> type = createMockType(settings);
+
+ try {
+ T instance;
+ if (settings.isUsingConstructor()) {
+ instance =
+ new ConstructorInstantiator(
+ settings.getOuterClassInstance() != null,
+ settings.getConstructorArgs())
+ .newInstance(type);
+ } else {
+ try {
+ // We attempt to use the "native" mock maker first that avoids
+ // Objenesis and Unsafe
+ instance = newInstance(type);
+ } catch (InstantiationException ignored) {
+ if (nullOnNonInlineConstruction) {
+ return null;
+ }
+ Instantiator instantiator =
+ Plugins.getInstantiatorProvider().getInstantiator(settings);
+ instance = instantiator.newInstance(type);
+ }
+ }
+ MockMethodInterceptor mockMethodInterceptor =
+ new MockMethodInterceptor(handler, settings);
+ mocks.put(instance, mockMethodInterceptor);
+ if (instance instanceof MockAccess) {
+ ((MockAccess) instance).setMockitoInterceptor(mockMethodInterceptor);
+ }
+ return instance;
+ } catch (InstantiationException e) {
+ throw new MockitoException(
+ "Unable to create mock instance of type '" + type.getSimpleName() + "'", e);
+ }
+ }
+
+ @Override
+ public <T> Class<? extends T> createMockType(MockCreationSettings<T> settings) {
+ try {
+ return bytecodeGenerator.mockClass(
+ MockFeatures.withMockFeatures(
+ settings.getTypeToMock(),
+ settings.getExtraInterfaces(),
+ settings.getSerializableMode(),
+ settings.isStripAnnotations(),
+ settings.getDefaultAnswer()));
+ } catch (Exception bytecodeGenerationFailed) {
+ throw prettifyFailure(settings, bytecodeGenerationFailed);
+ }
+ }
+
+ private <T> RuntimeException prettifyFailure(
+ MockCreationSettings<T> mockFeatures, Exception generationFailed) {
+ if (mockFeatures.getTypeToMock().isArray()) {
+ throw new MockitoException(
+ join("Arrays cannot be mocked: " + mockFeatures.getTypeToMock() + ".", ""),
+ generationFailed);
+ }
+ if (Modifier.isFinal(mockFeatures.getTypeToMock().getModifiers())) {
+ throw new MockitoException(
+ join(
+ "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
+ "Can not mock final classes with the following settings :",
+ " - explicit serialization (e.g. withSettings().serializable())",
+ " - extra interfaces (e.g. withSettings().extraInterfaces(...))",
+ "",
+ "You are seeing this disclaimer because Mockito is configured to create inlined mocks.",
+ "You can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.",
+ "",
+ "Underlying exception : " + generationFailed),
+ generationFailed);
+ }
+ if (Modifier.isPrivate(mockFeatures.getTypeToMock().getModifiers())) {
+ throw new MockitoException(
+ join(
+ "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
+ "Most likely it is a private class that is not visible by Mockito",
+ "",
+ "You are seeing this disclaimer because Mockito is configured to create inlined mocks.",
+ "You can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.",
+ ""),
+ generationFailed);
+ }
+ throw new MockitoException(
+ join(
+ "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
+ "",
+ "If you're not sure why you're getting this error, please report to the mailing list.",
+ "",
+ Platform.warnForVM(
+ "IBM J9 VM",
+ "Early IBM virtual machine are known to have issues with Mockito, please upgrade to an up-to-date version.\n",
+ "Hotspot",
+ Platform.isJava8BelowUpdate45()
+ ? "Java 8 early builds have bugs that were addressed in Java 1.8.0_45, please update your JDK!\n"
+ : ""),
+ Platform.describe(),
+ "",
+ "You are seeing this disclaimer because Mockito is configured to create inlined mocks.",
+ "You can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.",
+ "",
+ "Underlying exception : " + generationFailed),
+ generationFailed);
+ }
+
+ @Override
+ public MockHandler getHandler(Object mock) {
+ MockMethodInterceptor interceptor;
+ if (mock instanceof Class<?>) {
+ Map<Class<?>, MockMethodInterceptor> interceptors = mockedStatics.get();
+ interceptor = interceptors != null ? interceptors.get(mock) : null;
+ } else {
+ interceptor = mocks.get(mock);
+ }
+ if (interceptor == null) {
+ return null;
+ } else {
+ return interceptor.handler;
+ }
+ }
+
+ @Override
+ public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
+ MockMethodInterceptor mockMethodInterceptor =
+ new MockMethodInterceptor(newHandler, settings);
+ if (mock instanceof Class<?>) {
+ Map<Class<?>, MockMethodInterceptor> interceptors = mockedStatics.get();
+ if (interceptors == null || !interceptors.containsKey(mock)) {
+ throw new MockitoException(
+ "Cannot reset "
+ + mock
+ + " which is not currently registered as a static mock");
+ }
+ interceptors.put((Class<?>) mock, mockMethodInterceptor);
+ } else {
+ if (!mocks.containsKey(mock)) {
+ throw new MockitoException(
+ "Cannot reset " + mock + " which is not currently registered as a mock");
+ }
+ mocks.put(mock, mockMethodInterceptor);
+ if (mock instanceof MockAccess) {
+ ((MockAccess) mock).setMockitoInterceptor(mockMethodInterceptor);
+ }
+ }
+ }
+
+ @Override
+ public void clearAllCaches() {
+ clearAllMocks();
+ bytecodeGenerator.clearAllCaches();
+ }
+
+ @Override
+ public void clearMock(Object mock) {
+ if (mock instanceof Class<?>) {
+ for (Map<Class<?>, ?> entry : mockedStatics.getBackingMap().target.values()) {
+ entry.remove(mock);
+ }
+ } else {
+ mocks.remove(mock);
+ }
+ }
+
+ @Override
+ public void clearAllMocks() {
+ mockedStatics.getBackingMap().clear();
+ mocks.clear();
+ }
+
+ @Override
+ public TypeMockability isTypeMockable(final Class<?> type) {
+ return new TypeMockability() {
+ @Override
+ public boolean mockable() {
+ return INSTRUMENTATION.isModifiableClass(type) && !EXCLUDES.contains(type);
+ }
+
+ @Override
+ public String nonMockableReason() {
+ if (mockable()) {
+ return "";
+ }
+ if (type.isPrimitive()) {
+ return "primitive type";
+ }
+ if (EXCLUDES.contains(type)) {
+ return "Cannot mock wrapper types, String.class or Class.class";
+ }
+ return "VM does not support modification of given type";
+ }
+ };
+ }
+
+ @Override
+ public <T> StaticMockControl<T> createStaticMock(
+ Class<T> type, MockCreationSettings<T> settings, MockHandler handler) {
+ if (type == ConcurrentHashMap.class) {
+ throw new MockitoException(
+ "It is not possible to mock static methods of ConcurrentHashMap "
+ + "to avoid infinitive loops within Mockito's implementation of static mock handling");
+ } else if (type == Thread.class
+ || type == System.class
+ || type == Arrays.class
+ || ClassLoader.class.isAssignableFrom(type)) {
+ throw new MockitoException(
+ "It is not possible to mock static methods of "
+ + type.getName()
+ + " to avoid interfering with class loading what leads to infinite loops");
+ }
+
+ bytecodeGenerator.mockClassStatic(type);
+
+ Map<Class<?>, MockMethodInterceptor> interceptors = mockedStatics.get();
+ if (interceptors == null) {
+ interceptors = new WeakHashMap<>();
+ mockedStatics.set(interceptors);
+ }
+
+ return new InlineStaticMockControl<>(type, interceptors, settings, handler);
+ }
+
+ @Override
+ public <T> ConstructionMockControl<T> createConstructionMock(
+ Class<T> type,
+ Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory,
+ Function<MockedConstruction.Context, MockHandler<T>> handlerFactory,
+ MockedConstruction.MockInitializer<T> mockInitializer) {
+ if (type == Object.class) {
+ throw new MockitoException(
+ "It is not possible to mock construction of the Object class "
+ + "to avoid inference with default object constructor chains");
+ } else if (type.isPrimitive() || Modifier.isAbstract(type.getModifiers())) {
+ throw new MockitoException(
+ "It is not possible to construct primitive types or abstract types: "
+ + type.getName());
+ }
+
+ bytecodeGenerator.mockClassConstruction(type);
+
+ Map<Class<?>, BiConsumer<Object, MockedConstruction.Context>> interceptors =
+ mockedConstruction.get();
+ if (interceptors == null) {
+ interceptors = new WeakHashMap<>();
+ mockedConstruction.set(interceptors);
+ }
+
+ return new InlineConstructionMockControl<>(
+ type, settingsFactory, handlerFactory, mockInitializer, interceptors);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public <T> T newInstance(Class<T> cls) throws InstantiationException {
+ Constructor<?>[] constructors = cls.getDeclaredConstructors();
+ if (constructors.length == 0) {
+ throw new InstantiationException(cls.getName() + " does not define a constructor");
+ }
+ Constructor<?> selected = constructors[0];
+ for (Constructor<?> constructor : constructors) {
+ if (Modifier.isPublic(constructor.getModifiers())) {
+ selected = constructor;
+ break;
+ }
+ }
+ Class<?>[] types = selected.getParameterTypes();
+ Object[] arguments = new Object[types.length];
+ int index = 0;
+ for (Class<?> type : types) {
+ arguments[index++] = makeStandardArgument(type);
+ }
+ MemberAccessor accessor = Plugins.getMemberAccessor();
+ try {
+ return (T)
+ accessor.newInstance(
+ selected,
+ callback -> {
+ mockitoConstruction.set(true);
+ try {
+ return callback.newInstance();
+ } finally {
+ mockitoConstruction.set(false);
+ }
+ },
+ arguments);
+ } catch (Exception e) {
+ throw new InstantiationException("Could not instantiate " + cls.getName(), e);
+ }
+ }
+
+ private Object makeStandardArgument(Class<?> type) {
+ if (type == boolean.class) {
+ return false;
+ } else if (type == byte.class) {
+ return (byte) 0;
+ } else if (type == short.class) {
+ return (short) 0;
+ } else if (type == char.class) {
+ return (char) 0;
+ } else if (type == int.class) {
+ return 0;
+ } else if (type == long.class) {
+ return 0L;
+ } else if (type == float.class) {
+ return 0f;
+ } else if (type == double.class) {
+ return 0d;
+ } else {
+ return null;
+ }
+ }
+
+ private static class InlineStaticMockControl<T> implements StaticMockControl<T> {
+
+ private final Class<T> type;
+
+ private final Map<Class<?>, MockMethodInterceptor> interceptors;
+
+ private final MockCreationSettings<T> settings;
+
+ private final MockHandler handler;
+
+ private InlineStaticMockControl(
+ Class<T> type,
+ Map<Class<?>, MockMethodInterceptor> interceptors,
+ MockCreationSettings<T> settings,
+ MockHandler handler) {
+ this.type = type;
+ this.interceptors = interceptors;
+ this.settings = settings;
+ this.handler = handler;
+ }
+
+ @Override
+ public Class<T> getType() {
+ return type;
+ }
+
+ @Override
+ public void enable() {
+ if (interceptors.putIfAbsent(type, new MockMethodInterceptor(handler, settings))
+ != null) {
+ throw new MockitoException(
+ join(
+ "For "
+ + type.getName()
+ + ", static mocking is already registered in the current thread",
+ "",
+ "To create a new mock, the existing static mock registration must be deregistered"));
+ }
+ }
+
+ @Override
+ public void disable() {
+ if (interceptors.remove(type) == null) {
+ throw new MockitoException(
+ join(
+ "Could not deregister "
+ + type.getName()
+ + " as a static mock since it is not currently registered",
+ "",
+ "To register a static mock, use Mockito.mockStatic("
+ + type.getSimpleName()
+ + ".class)"));
+ }
+ }
+ }
+
+ private class InlineConstructionMockControl<T> implements ConstructionMockControl<T> {
+
+ private final Class<T> type;
+
+ private final Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory;
+ private final Function<MockedConstruction.Context, MockHandler<T>> handlerFactory;
+
+ private final MockedConstruction.MockInitializer<T> mockInitializer;
+
+ private final Map<Class<?>, BiConsumer<Object, MockedConstruction.Context>> interceptors;
+
+ private final List<Object> all = new ArrayList<>();
+ private int count;
+
+ private InlineConstructionMockControl(
+ Class<T> type,
+ Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory,
+ Function<MockedConstruction.Context, MockHandler<T>> handlerFactory,
+ MockedConstruction.MockInitializer<T> mockInitializer,
+ Map<Class<?>, BiConsumer<Object, MockedConstruction.Context>> interceptors) {
+ this.type = type;
+ this.settingsFactory = settingsFactory;
+ this.handlerFactory = handlerFactory;
+ this.mockInitializer = mockInitializer;
+ this.interceptors = interceptors;
+ }
+
+ @Override
+ public Class<T> getType() {
+ return type;
+ }
+
+ @Override
+ public void enable() {
+ if (interceptors.putIfAbsent(
+ type,
+ (object, context) -> {
+ ((InlineConstructionMockContext) context).count = ++count;
+ MockMethodInterceptor interceptor =
+ new MockMethodInterceptor(
+ handlerFactory.apply(context),
+ settingsFactory.apply(context));
+ mocks.put(object, interceptor);
+ try {
+ @SuppressWarnings("unchecked")
+ T cast = (T) object;
+ mockInitializer.prepare(cast, context);
+ } catch (Throwable t) {
+ mocks.remove(object); // TODO: filter stack trace?
+ throw new MockitoException(
+ "Could not initialize mocked construction", t);
+ }
+ all.add(object);
+ })
+ != null) {
+ throw new MockitoException(
+ join(
+ "For "
+ + type.getName()
+ + ", static mocking is already registered in the current thread",
+ "",
+ "To create a new mock, the existing static mock registration must be deregistered"));
+ }
+ }
+
+ @Override
+ public void disable() {
+ if (interceptors.remove(type) == null) {
+ throw new MockitoException(
+ join(
+ "Could not deregister "
+ + type.getName()
+ + " as a static mock since it is not currently registered",
+ "",
+ "To register a static mock, use Mockito.mockStatic("
+ + type.getSimpleName()
+ + ".class)"));
+ }
+ all.clear();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public List<T> getMocks() {
+ return (List<T>) all;
+ }
+ }
+
+ private static class InlineConstructionMockContext implements MockedConstruction.Context {
+
+ private static final Map<String, Class<?>> PRIMITIVES = new HashMap<>();
+
+ static {
+ PRIMITIVES.put(boolean.class.getName(), boolean.class);
+ PRIMITIVES.put(byte.class.getName(), byte.class);
+ PRIMITIVES.put(short.class.getName(), short.class);
+ PRIMITIVES.put(char.class.getName(), char.class);
+ PRIMITIVES.put(int.class.getName(), int.class);
+ PRIMITIVES.put(long.class.getName(), long.class);
+ PRIMITIVES.put(float.class.getName(), float.class);
+ PRIMITIVES.put(double.class.getName(), double.class);
+ }
+
+ private int count;
+
+ private final Object[] arguments;
+ private final Class<?> type;
+ private final String[] parameterTypeNames;
+
+ private InlineConstructionMockContext(
+ Object[] arguments, Class<?> type, String[] parameterTypeNames) {
+ this.arguments = arguments;
+ this.type = type;
+ this.parameterTypeNames = parameterTypeNames;
+ }
+
+ @Override
+ public int getCount() {
+ if (count == 0) {
+ throw new MockitoConfigurationException(
+ "mocked construction context is not initialized");
+ }
+ return count;
+ }
+
+ @Override
+ public Constructor<?> constructor() {
+ Class<?>[] parameterTypes = new Class<?>[parameterTypeNames.length];
+ int index = 0;
+ for (String parameterTypeName : parameterTypeNames) {
+ if (PRIMITIVES.containsKey(parameterTypeName)) {
+ parameterTypes[index++] = PRIMITIVES.get(parameterTypeName);
+ } else {
+ try {
+ parameterTypes[index++] =
+ Class.forName(parameterTypeName, false, type.getClassLoader());
+ } catch (ClassNotFoundException e) {
+ throw new MockitoException(
+ "Could not find parameter of type " + parameterTypeName, e);
+ }
+ }
+ }
+ try {
+ return type.getDeclaredConstructor(parameterTypes);
+ } catch (NoSuchMethodException e) {
+ throw new MockitoException(
+ join(
+ "Could not resolve constructor of type",
+ "",
+ type.getName(),
+ "",
+ "with arguments of types",
+ Arrays.toString(parameterTypes)),
+ e);
+ }
+ }
+
+ @Override
+ public List<?> arguments() {
+ return Collections.unmodifiableList(Arrays.asList(arguments));
+ }
+ }
+}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/MockFeatures.java b/src/main/java/org/mockito/internal/creation/bytebuddy/MockFeatures.java
index e92495f..ca27be0 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/MockFeatures.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/MockFeatures.java
@@ -4,29 +4,40 @@
*/
package org.mockito.internal.creation.bytebuddy;
-import org.mockito.mock.SerializableMode;
-
import java.util.Collections;
import java.util.Set;
+import org.mockito.mock.SerializableMode;
+import org.mockito.stubbing.Answer;
+
class MockFeatures<T> {
final Class<T> mockedType;
final Set<Class<?>> interfaces;
final SerializableMode serializableMode;
final boolean stripAnnotations;
+ final Answer defaultAnswer;
- private MockFeatures(Class<T> mockedType, Set<Class<?>> interfaces, SerializableMode serializableMode, boolean stripAnnotations) {
+ private MockFeatures(
+ Class<T> mockedType,
+ Set<Class<?>> interfaces,
+ SerializableMode serializableMode,
+ boolean stripAnnotations,
+ Answer defaultAnswer) {
this.mockedType = mockedType;
this.interfaces = Collections.unmodifiableSet(interfaces);
this.serializableMode = serializableMode;
this.stripAnnotations = stripAnnotations;
+ this.defaultAnswer = defaultAnswer;
}
- public static <T> MockFeatures<T> withMockFeatures(Class<T> mockedType,
- Set<Class<?>> interfaces,
- SerializableMode serializableMode,
- boolean stripAnnotations) {
- return new MockFeatures<T>(mockedType, interfaces, serializableMode, stripAnnotations);
+ public static <T> MockFeatures<T> withMockFeatures(
+ Class<T> mockedType,
+ Set<Class<?>> interfaces,
+ SerializableMode serializableMode,
+ boolean stripAnnotations,
+ Answer defaultAnswer) {
+ return new MockFeatures<T>(
+ mockedType, interfaces, serializableMode, stripAnnotations, defaultAnswer);
}
}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java
index f39a1a2..1490501 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java
@@ -4,21 +4,10 @@
*/
package org.mockito.internal.creation.bytebuddy;
-import net.bytebuddy.asm.Advice;
-import net.bytebuddy.description.method.MethodDescription;
-import net.bytebuddy.description.type.TypeDescription;
-import net.bytebuddy.dynamic.scaffold.MethodGraph;
-import net.bytebuddy.implementation.bind.annotation.Argument;
-import net.bytebuddy.implementation.bind.annotation.This;
-import net.bytebuddy.implementation.bytecode.assign.Assigner;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.debugging.LocationImpl;
-import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
-import org.mockito.internal.invocation.RealMethod;
-import org.mockito.internal.invocation.SerializableMethod;
-import org.mockito.internal.invocation.mockref.MockReference;
-import org.mockito.internal.invocation.mockref.MockWeakReference;
-import org.mockito.internal.util.concurrent.WeakConcurrentMap;
+import static net.bytebuddy.matcher.ElementMatchers.isConstructor;
+import static net.bytebuddy.matcher.ElementMatchers.isPrivate;
+import static net.bytebuddy.matcher.ElementMatchers.isStatic;
+import static net.bytebuddy.matcher.ElementMatchers.not;
import java.io.IOException;
import java.io.ObjectInputStream;
@@ -28,35 +17,86 @@
import java.lang.ref.SoftReference;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.Callable;
+import java.util.function.Predicate;
+
+import net.bytebuddy.ClassFileVersion;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.asm.AsmVisitorWrapper;
+import net.bytebuddy.description.field.FieldDescription;
+import net.bytebuddy.description.field.FieldList;
+import net.bytebuddy.description.method.MethodDescription;
+import net.bytebuddy.description.method.MethodList;
+import net.bytebuddy.description.method.ParameterDescription;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.dynamic.scaffold.MethodGraph;
+import net.bytebuddy.implementation.Implementation;
+import net.bytebuddy.implementation.bind.annotation.Argument;
+import net.bytebuddy.implementation.bind.annotation.This;
+import net.bytebuddy.implementation.bytecode.StackSize;
+import net.bytebuddy.implementation.bytecode.assign.Assigner;
+import net.bytebuddy.jar.asm.Label;
+import net.bytebuddy.jar.asm.MethodVisitor;
+import net.bytebuddy.jar.asm.Opcodes;
+import net.bytebuddy.jar.asm.Type;
+import net.bytebuddy.pool.TypePool;
+import net.bytebuddy.utility.OpenedClassReader;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher;
+import org.mockito.internal.debugging.LocationImpl;
+import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
+import org.mockito.internal.invocation.RealMethod;
+import org.mockito.internal.invocation.SerializableMethod;
+import org.mockito.internal.invocation.mockref.MockReference;
+import org.mockito.internal.invocation.mockref.MockWeakReference;
+import org.mockito.internal.util.concurrent.DetachedThreadLocal;
+import org.mockito.internal.util.concurrent.WeakConcurrentMap;
+import org.mockito.plugins.MemberAccessor;
public class MockMethodAdvice extends MockMethodDispatcher {
- final WeakConcurrentMap<Object, MockMethodInterceptor> interceptors;
+ private final WeakConcurrentMap<Object, MockMethodInterceptor> interceptors;
+ private final DetachedThreadLocal<Map<Class<?>, MockMethodInterceptor>> mockedStatics;
private final String identifier;
private final SelfCallInfo selfCallInfo = new SelfCallInfo();
private final MethodGraph.Compiler compiler = MethodGraph.Compiler.Default.forJavaHierarchy();
- private final WeakConcurrentMap<Class<?>, SoftReference<MethodGraph>> graphs
- = new WeakConcurrentMap.WithInlinedExpunction<Class<?>, SoftReference<MethodGraph>>();
+ private final WeakConcurrentMap<Class<?>, SoftReference<MethodGraph>> graphs =
+ new WeakConcurrentMap.WithInlinedExpunction<>();
- public MockMethodAdvice(WeakConcurrentMap<Object, MockMethodInterceptor> interceptors, String identifier) {
+ private final Predicate<Class<?>> isMockConstruction;
+ private final ConstructionCallback onConstruction;
+
+ public MockMethodAdvice(
+ WeakConcurrentMap<Object, MockMethodInterceptor> interceptors,
+ DetachedThreadLocal<Map<Class<?>, MockMethodInterceptor>> mockedStatics,
+ String identifier,
+ Predicate<Class<?>> isMockConstruction,
+ ConstructionCallback onConstruction) {
this.interceptors = interceptors;
+ this.mockedStatics = mockedStatics;
+ this.onConstruction = onConstruction;
this.identifier = identifier;
+ this.isMockConstruction = isMockConstruction;
}
@SuppressWarnings("unused")
@Advice.OnMethodEnter(skipOn = Advice.OnNonDefaultValue.class)
- private static Callable<?> enter(@Identifier String identifier,
- @Advice.This Object mock,
- @Advice.Origin Method origin,
- @Advice.AllArguments Object[] arguments) throws Throwable {
+ private static Callable<?> enter(
+ @Identifier String identifier,
+ @Advice.This Object mock,
+ @Advice.Origin Method origin,
+ @Advice.AllArguments Object[] arguments)
+ throws Throwable {
MockMethodDispatcher dispatcher = MockMethodDispatcher.get(identifier, mock);
- if (dispatcher == null || !dispatcher.isMocked(mock) || dispatcher.isOverridden(mock, origin)) {
+ if (dispatcher == null
+ || !dispatcher.isMocked(mock)
+ || dispatcher.isOverridden(mock, origin)) {
return null;
} else {
return dispatcher.handle(mock, origin, arguments);
@@ -65,8 +105,10 @@
@SuppressWarnings({"unused", "UnusedAssignment"})
@Advice.OnMethodExit
- private static void exit(@Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object returned,
- @Advice.Enter Callable<?> mocked) throws Throwable {
+ private static void exit(
+ @Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object returned,
+ @Advice.Enter Callable<?> mocked)
+ throws Throwable {
if (mocked != null) {
returned = mocked.call();
}
@@ -87,7 +129,8 @@
throwable.setStackTrace(cleared);
return throwable;
} catch (RuntimeException ignored) {
- // This should not happen unless someone instrumented or manipulated exception stack traces.
+ // This should not happen unless someone instrumented or manipulated exception stack
+ // traces.
return throwable;
}
}
@@ -104,13 +147,37 @@
} else {
realMethod = new RealMethodCall(selfCallInfo, origin, instance, arguments);
}
- Throwable t = new Throwable();
- t.setStackTrace(skipInlineMethodElement(t.getStackTrace()));
- return new ReturnValueWrapper(interceptor.doIntercept(instance,
- origin,
- arguments,
- realMethod,
- new LocationImpl(t)));
+ return new ReturnValueWrapper(
+ interceptor.doIntercept(
+ instance,
+ origin,
+ arguments,
+ realMethod,
+ new LocationImpl(new Throwable(), true)));
+ }
+
+ @Override
+ public Callable<?> handleStatic(Class<?> type, Method origin, Object[] arguments)
+ throws Throwable {
+ Map<Class<?>, MockMethodInterceptor> interceptors = mockedStatics.get();
+ if (interceptors == null || !interceptors.containsKey(type)) {
+ return null;
+ }
+ return new ReturnValueWrapper(
+ interceptors
+ .get(type)
+ .doIntercept(
+ type,
+ origin,
+ arguments,
+ new StaticMethodCall(selfCallInfo, type, origin, arguments),
+ new LocationImpl(new Throwable(), true)));
+ }
+
+ @Override
+ public Object handleConstruction(
+ Class<?> type, Object object, Object[] arguments, String[] parameterTypeNames) {
+ return onConstruction.apply(type, object, arguments, parameterTypeNames);
}
@Override
@@ -122,7 +189,16 @@
@Override
public boolean isMocked(Object instance) {
- return selfCallInfo.checkSuperCall(instance) && isMock(instance);
+ return selfCallInfo.checkSelfCall(instance) && isMock(instance);
+ }
+
+ @Override
+ public boolean isMockedStatic(Class<?> type) {
+ if (!selfCallInfo.checkSelfCall(type)) {
+ return false;
+ }
+ Map<Class<?>, ?> interceptors = mockedStatics.get();
+ return interceptors != null && interceptors.containsKey(type);
}
@Override
@@ -131,10 +207,21 @@
MethodGraph methodGraph = reference == null ? null : reference.get();
if (methodGraph == null) {
methodGraph = compiler.compile(new TypeDescription.ForLoadedType(instance.getClass()));
- graphs.put(instance.getClass(), new SoftReference<MethodGraph>(methodGraph));
+ graphs.put(instance.getClass(), new SoftReference<>(methodGraph));
}
- MethodGraph.Node node = methodGraph.locate(new MethodDescription.ForLoadedMethod(origin).asSignatureToken());
- return !node.getSort().isResolved() || !node.getRepresentative().asDefined().getDeclaringType().represents(origin.getDeclaringClass());
+ MethodGraph.Node node =
+ methodGraph.locate(
+ new MethodDescription.ForLoadedMethod(origin).asSignatureToken());
+ return !node.getSort().isResolved()
+ || !node.getRepresentative()
+ .asDefined()
+ .getDeclaringType()
+ .represents(origin.getDeclaringClass());
+ }
+
+ @Override
+ public boolean isConstructorMock(Class<?> type) {
+ return isMockConstruction.test(type);
}
private static class RealMethodCall implements RealMethod {
@@ -147,10 +234,11 @@
private final Object[] arguments;
- private RealMethodCall(SelfCallInfo selfCallInfo, Method origin, Object instance, Object[] arguments) {
+ private RealMethodCall(
+ SelfCallInfo selfCallInfo, Method origin, Object instance, Object[] arguments) {
this.selfCallInfo = selfCallInfo;
this.origin = origin;
- this.instanceRef = new MockWeakReference<Object>(instance);
+ this.instanceRef = new MockWeakReference<>(instance);
this.arguments = arguments;
}
@@ -161,13 +249,9 @@
@Override
public Object invoke() throws Throwable {
- if (!Modifier.isPublic(origin.getDeclaringClass().getModifiers() & origin.getModifiers())) {
- origin.setAccessible(true);
- }
selfCallInfo.set(instanceRef.get());
return tryInvoke(origin, instanceRef.get(), arguments);
}
-
}
private static class SerializableRealMethodCall implements RealMethod {
@@ -180,10 +264,11 @@
private final Object[] arguments;
- private SerializableRealMethodCall(String identifier, Method origin, Object instance, Object[] arguments) {
+ private SerializableRealMethodCall(
+ String identifier, Method origin, Object instance, Object[] arguments) {
this.origin = new SerializableMethod(origin);
this.identifier = identifier;
- this.instanceRef = new MockWeakReference<Object>(instance);
+ this.instanceRef = new MockWeakReference<>(instance);
this.arguments = arguments;
}
@@ -195,14 +280,14 @@
@Override
public Object invoke() throws Throwable {
Method method = origin.getJavaMethod();
- if (!Modifier.isPublic(method.getDeclaringClass().getModifiers() & method.getModifiers())) {
- method.setAccessible(true);
- }
- MockMethodDispatcher mockMethodDispatcher = MockMethodDispatcher.get(identifier, instanceRef.get());
+ MockMethodDispatcher mockMethodDispatcher =
+ MockMethodDispatcher.get(identifier, instanceRef.get());
if (!(mockMethodDispatcher instanceof MockMethodAdvice)) {
throw new MockitoException("Unexpected dispatcher for advice-based super call");
}
- Object previous = ((MockMethodAdvice) mockMethodDispatcher).selfCallInfo.replace(instanceRef.get());
+ Object previous =
+ ((MockMethodAdvice) mockMethodDispatcher)
+ .selfCallInfo.replace(instanceRef.get());
try {
return tryInvoke(method, instanceRef.get(), arguments);
} finally {
@@ -211,29 +296,60 @@
}
}
- private static Object tryInvoke(Method origin, Object instance, Object[] arguments) throws Throwable {
- try {
- return origin.invoke(instance, arguments);
- } catch (InvocationTargetException exception) {
- Throwable cause = exception.getCause();
- new ConditionalStackTraceFilter().filter(hideRecursiveCall(cause, new Throwable().getStackTrace().length, origin.getDeclaringClass()));
- throw cause;
+ private static class StaticMethodCall implements RealMethod {
+
+ private final SelfCallInfo selfCallInfo;
+
+ private final Class<?> type;
+
+ private final Method origin;
+
+ private final Object[] arguments;
+
+ private StaticMethodCall(
+ SelfCallInfo selfCallInfo, Class<?> type, Method origin, Object[] arguments) {
+ this.selfCallInfo = selfCallInfo;
+ this.type = type;
+ this.origin = origin;
+ this.arguments = arguments;
+ }
+
+ @Override
+ public boolean isInvokable() {
+ return true;
+ }
+
+ @Override
+ public Object invoke() throws Throwable {
+ selfCallInfo.set(type);
+ return tryInvoke(origin, null, arguments);
}
}
- // With inline mocking, mocks for concrete classes are not subclassed, so elements of the stubbing methods are not filtered out.
- // Therefore, if the method is inlined, skip the element.
- private static StackTraceElement[] skipInlineMethodElement(StackTraceElement[] elements) {
- List<StackTraceElement> list = new ArrayList<StackTraceElement>(elements.length);
- for (int i = 0; i < elements.length; i++) {
- StackTraceElement element = elements[i];
- list.add(element);
- if (element.getClassName().equals(MockMethodAdvice.class.getName()) && element.getMethodName().equals("handle")) {
- // If the current element is MockMethodAdvice#handle(), the next is assumed to be an inlined method.
- i++;
+ private static Object tryInvoke(Method origin, Object instance, Object[] arguments)
+ throws Throwable {
+ MemberAccessor accessor = Plugins.getMemberAccessor();
+ try {
+ return accessor.invoke(origin, instance, arguments);
+ } catch (InvocationTargetException exception) {
+ Throwable cause = exception.getCause();
+ StackTraceElement[] tmpStack = new Throwable().getStackTrace();
+
+ int skip = tmpStack.length;
+ // if there is a suitable instance, do not skip the root-cause for the exception
+ if (instance != null) {
+ skip = 0;
+ String causingClassName = instance.getClass().getName();
+ StackTraceElement stackFrame;
+ do {
+ stackFrame = tmpStack[skip++];
+ } while (stackFrame.getClassName().startsWith(causingClassName));
}
+
+ new ConditionalStackTraceFilter()
+ .filter(hideRecursiveCall(cause, skip, origin.getDeclaringClass()));
+ throw cause;
}
- return list.toArray(new StackTraceElement[list.size()]);
}
private static class ReturnValueWrapper implements Callable<Object> {
@@ -258,7 +374,7 @@
return current;
}
- boolean checkSuperCall(Object value) {
+ boolean checkSelfCall(Object value) {
if (value == get()) {
set(null);
return false;
@@ -268,26 +384,319 @@
}
}
- @Retention(RetentionPolicy.RUNTIME)
- @interface Identifier {
+ static class ConstructorShortcut
+ implements AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper {
+ private final String identifier;
+
+ ConstructorShortcut(String identifier) {
+ this.identifier = identifier;
+ }
+
+ @Override
+ public MethodVisitor wrap(
+ TypeDescription instrumentedType,
+ MethodDescription instrumentedMethod,
+ MethodVisitor methodVisitor,
+ Implementation.Context implementationContext,
+ TypePool typePool,
+ int writerFlags,
+ int readerFlags) {
+ if (instrumentedMethod.isConstructor() && !instrumentedType.represents(Object.class)) {
+ MethodList<MethodDescription.InDefinedShape> constructors =
+ instrumentedType
+ .getSuperClass()
+ .asErasure()
+ .getDeclaredMethods()
+ .filter(isConstructor().and(not(isPrivate())));
+ int arguments = Integer.MAX_VALUE;
+ boolean packagePrivate = true;
+ MethodDescription.InDefinedShape current = null;
+ for (MethodDescription.InDefinedShape constructor : constructors) {
+ // We are choosing the shortest constructor with regards to arguments.
+ // Yet, we prefer a non-package-private constructor since they require
+ // the super class to be on the same class loader.
+ if (constructor.getParameters().size() < arguments
+ && (packagePrivate || !constructor.isPackagePrivate())) {
+ arguments = constructor.getParameters().size();
+ packagePrivate = constructor.isPackagePrivate();
+ current = constructor;
+ }
+ }
+ if (current != null) {
+ final MethodDescription.InDefinedShape selected = current;
+ return new MethodVisitor(OpenedClassReader.ASM_API, methodVisitor) {
+ @Override
+ public void visitCode() {
+ super.visitCode();
+ /*
+ * The byte code that is added to the start of the method is roughly equivalent to
+ * the following byte code for a hypothetical constructor of class Current:
+ *
+ * if (MockMethodDispatcher.isConstructorMock(<identifier>, Current.class) {
+ * super(<default arguments>);
+ * Current o = (Current) MockMethodDispatcher.handleConstruction(Current.class,
+ * this,
+ * new Object[] {argument1, argument2, ...},
+ * new String[] {argumentType1, argumentType2, ...});
+ * if (o != null) {
+ * this.field = o.field; // for each declared field
+ * }
+ * return;
+ * }
+ *
+ * This avoids the invocation of the original constructor chain but fullfils the
+ * verifier requirement to invoke a super constructor.
+ */
+ Label label = new Label();
+ super.visitLdcInsn(identifier);
+ if (implementationContext
+ .getClassFileVersion()
+ .isAtLeast(ClassFileVersion.JAVA_V5)) {
+ super.visitLdcInsn(Type.getType(instrumentedType.getDescriptor()));
+ } else {
+ super.visitLdcInsn(instrumentedType.getName());
+ super.visitMethodInsn(
+ Opcodes.INVOKESTATIC,
+ Type.getInternalName(Class.class),
+ "forName",
+ Type.getMethodDescriptor(
+ Type.getType(Class.class),
+ Type.getType(String.class)),
+ false);
+ }
+ super.visitMethodInsn(
+ Opcodes.INVOKESTATIC,
+ Type.getInternalName(MockMethodDispatcher.class),
+ "isConstructorMock",
+ Type.getMethodDescriptor(
+ Type.BOOLEAN_TYPE,
+ Type.getType(String.class),
+ Type.getType(Class.class)),
+ false);
+ super.visitInsn(Opcodes.ICONST_0);
+ super.visitJumpInsn(Opcodes.IF_ICMPEQ, label);
+ super.visitVarInsn(Opcodes.ALOAD, 0);
+ for (TypeDescription type :
+ selected.getParameters().asTypeList().asErasures()) {
+ if (type.represents(boolean.class)
+ || type.represents(byte.class)
+ || type.represents(short.class)
+ || type.represents(char.class)
+ || type.represents(int.class)) {
+ super.visitInsn(Opcodes.ICONST_0);
+ } else if (type.represents(long.class)) {
+ super.visitInsn(Opcodes.LCONST_0);
+ } else if (type.represents(float.class)) {
+ super.visitInsn(Opcodes.FCONST_0);
+ } else if (type.represents(double.class)) {
+ super.visitInsn(Opcodes.DCONST_0);
+ } else {
+ super.visitInsn(Opcodes.ACONST_NULL);
+ }
+ }
+ super.visitMethodInsn(
+ Opcodes.INVOKESPECIAL,
+ selected.getDeclaringType().getInternalName(),
+ selected.getInternalName(),
+ selected.getDescriptor(),
+ false);
+ super.visitLdcInsn(identifier);
+ if (implementationContext
+ .getClassFileVersion()
+ .isAtLeast(ClassFileVersion.JAVA_V5)) {
+ super.visitLdcInsn(Type.getType(instrumentedType.getDescriptor()));
+ } else {
+ super.visitLdcInsn(instrumentedType.getName());
+ super.visitMethodInsn(
+ Opcodes.INVOKESTATIC,
+ Type.getInternalName(Class.class),
+ "forName",
+ Type.getMethodDescriptor(
+ Type.getType(Class.class),
+ Type.getType(String.class)),
+ false);
+ }
+ super.visitVarInsn(Opcodes.ALOAD, 0);
+ super.visitLdcInsn(instrumentedMethod.getParameters().size());
+ super.visitTypeInsn(
+ Opcodes.ANEWARRAY, Type.getInternalName(Object.class));
+ int index = 0;
+ for (ParameterDescription parameter :
+ instrumentedMethod.getParameters()) {
+ super.visitInsn(Opcodes.DUP);
+ super.visitLdcInsn(index++);
+ Type type =
+ Type.getType(
+ parameter.getType().asErasure().getDescriptor());
+ super.visitVarInsn(
+ type.getOpcode(Opcodes.ILOAD), parameter.getOffset());
+ if (parameter.getType().isPrimitive()) {
+ Type wrapper =
+ Type.getType(
+ parameter
+ .getType()
+ .asErasure()
+ .asBoxed()
+ .getDescriptor());
+ super.visitMethodInsn(
+ Opcodes.INVOKESTATIC,
+ wrapper.getInternalName(),
+ "valueOf",
+ Type.getMethodDescriptor(wrapper, type),
+ false);
+ }
+ super.visitInsn(Opcodes.AASTORE);
+ }
+ index = 0;
+ super.visitLdcInsn(instrumentedMethod.getParameters().size());
+ super.visitTypeInsn(
+ Opcodes.ANEWARRAY, Type.getInternalName(String.class));
+ for (TypeDescription typeDescription :
+ instrumentedMethod.getParameters().asTypeList().asErasures()) {
+ super.visitInsn(Opcodes.DUP);
+ super.visitLdcInsn(index++);
+ super.visitLdcInsn(typeDescription.getName());
+ super.visitInsn(Opcodes.AASTORE);
+ }
+ super.visitMethodInsn(
+ Opcodes.INVOKESTATIC,
+ Type.getInternalName(MockMethodDispatcher.class),
+ "handleConstruction",
+ Type.getMethodDescriptor(
+ Type.getType(Object.class),
+ Type.getType(String.class),
+ Type.getType(Class.class),
+ Type.getType(Object.class),
+ Type.getType(Object[].class),
+ Type.getType(String[].class)),
+ false);
+ FieldList<FieldDescription.InDefinedShape> fields =
+ instrumentedType.getDeclaredFields().filter(not(isStatic()));
+ super.visitTypeInsn(
+ Opcodes.CHECKCAST, instrumentedType.getInternalName());
+ super.visitInsn(Opcodes.DUP);
+ Label noSpy = new Label();
+ super.visitJumpInsn(Opcodes.IFNULL, noSpy);
+ for (FieldDescription field : fields) {
+ super.visitInsn(Opcodes.DUP);
+ super.visitFieldInsn(
+ Opcodes.GETFIELD,
+ instrumentedType.getInternalName(),
+ field.getInternalName(),
+ field.getDescriptor());
+ super.visitVarInsn(Opcodes.ALOAD, 0);
+ super.visitInsn(
+ field.getType().getStackSize() == StackSize.DOUBLE
+ ? Opcodes.DUP_X2
+ : Opcodes.DUP_X1);
+ super.visitInsn(Opcodes.POP);
+ super.visitFieldInsn(
+ Opcodes.PUTFIELD,
+ instrumentedType.getInternalName(),
+ field.getInternalName(),
+ field.getDescriptor());
+ }
+ super.visitLabel(noSpy);
+ if (implementationContext
+ .getClassFileVersion()
+ .isAtLeast(ClassFileVersion.JAVA_V6)) {
+ Object[] locals =
+ toFrames(
+ instrumentedType.getInternalName(),
+ instrumentedMethod
+ .getParameters()
+ .asTypeList()
+ .asErasures());
+ super.visitFrame(
+ Opcodes.F_FULL,
+ locals.length,
+ locals,
+ 1,
+ new Object[] {instrumentedType.getInternalName()});
+ }
+ super.visitInsn(Opcodes.POP);
+ super.visitInsn(Opcodes.RETURN);
+ super.visitLabel(label);
+ if (implementationContext
+ .getClassFileVersion()
+ .isAtLeast(ClassFileVersion.JAVA_V6)) {
+ Object[] locals =
+ toFrames(
+ Opcodes.UNINITIALIZED_THIS,
+ instrumentedMethod
+ .getParameters()
+ .asTypeList()
+ .asErasures());
+ super.visitFrame(
+ Opcodes.F_FULL, locals.length, locals, 0, new Object[0]);
+ }
+ }
+
+ @Override
+ public void visitMaxs(int maxStack, int maxLocals) {
+ int prequel = Math.max(5, selected.getStackSize());
+ for (ParameterDescription parameter :
+ instrumentedMethod.getParameters()) {
+ prequel =
+ Math.max(
+ prequel,
+ 6 + parameter.getType().getStackSize().getSize());
+ prequel = Math.max(prequel, 8);
+ }
+ super.visitMaxs(Math.max(maxStack, prequel), maxLocals);
+ }
+ };
+ }
+ }
+ return methodVisitor;
+ }
+
+ private static Object[] toFrames(Object self, List<TypeDescription> types) {
+ Object[] frames = new Object[1 + types.size()];
+ frames[0] = self;
+ int index = 0;
+ for (TypeDescription type : types) {
+ Object frame;
+ if (type.represents(boolean.class)
+ || type.represents(byte.class)
+ || type.represents(short.class)
+ || type.represents(char.class)
+ || type.represents(int.class)) {
+ frame = Opcodes.INTEGER;
+ } else if (type.represents(long.class)) {
+ frame = Opcodes.LONG;
+ } else if (type.represents(float.class)) {
+ frame = Opcodes.FLOAT;
+ } else if (type.represents(double.class)) {
+ frame = Opcodes.DOUBLE;
+ } else {
+ frame = type.getInternalName();
+ }
+ frames[++index] = frame;
+ }
+ return frames;
+ }
}
+ @Retention(RetentionPolicy.RUNTIME)
+ @interface Identifier {}
+
static class ForHashCode {
@SuppressWarnings("unused")
@Advice.OnMethodEnter(skipOn = Advice.OnNonDefaultValue.class)
- private static boolean enter(@Identifier String id,
- @Advice.This Object self) {
+ private static boolean enter(@Identifier String id, @Advice.This Object self) {
MockMethodDispatcher dispatcher = MockMethodDispatcher.get(id, self);
return dispatcher != null && dispatcher.isMock(self);
}
@SuppressWarnings({"unused", "UnusedAssignment"})
@Advice.OnMethodExit
- private static void enter(@Advice.This Object self,
- @Advice.Return(readOnly = false) int hashCode,
- @Advice.Enter boolean skipped) {
+ private static void enter(
+ @Advice.This Object self,
+ @Advice.Return(readOnly = false) int hashCode,
+ @Advice.Enter boolean skipped) {
if (skipped) {
hashCode = System.identityHashCode(self);
}
@@ -298,32 +707,65 @@
@SuppressWarnings("unused")
@Advice.OnMethodEnter(skipOn = Advice.OnNonDefaultValue.class)
- private static boolean enter(@Identifier String identifier,
- @Advice.This Object self) {
+ private static boolean enter(@Identifier String identifier, @Advice.This Object self) {
MockMethodDispatcher dispatcher = MockMethodDispatcher.get(identifier, self);
return dispatcher != null && dispatcher.isMock(self);
}
@SuppressWarnings({"unused", "UnusedAssignment"})
@Advice.OnMethodExit
- private static void enter(@Advice.This Object self,
- @Advice.Argument(0) Object other,
- @Advice.Return(readOnly = false) boolean equals,
- @Advice.Enter boolean skipped) {
+ private static void enter(
+ @Advice.This Object self,
+ @Advice.Argument(0) Object other,
+ @Advice.Return(readOnly = false) boolean equals,
+ @Advice.Enter boolean skipped) {
if (skipped) {
equals = self == other;
}
}
}
- public static class ForReadObject {
+ static class ForStatic {
@SuppressWarnings("unused")
- public static void doReadObject(@Identifier String identifier,
- @This MockAccess thiz,
- @Argument(0) ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+ @Advice.OnMethodEnter(skipOn = Advice.OnNonDefaultValue.class)
+ private static Callable<?> enter(
+ @Identifier String identifier,
+ @Advice.Origin Class<?> type,
+ @Advice.Origin Method origin,
+ @Advice.AllArguments Object[] arguments)
+ throws Throwable {
+ MockMethodDispatcher dispatcher = MockMethodDispatcher.getStatic(identifier, type);
+ if (dispatcher == null || !dispatcher.isMockedStatic(type)) {
+ return null;
+ } else {
+ return dispatcher.handleStatic(type, origin, arguments);
+ }
+ }
+
+ @SuppressWarnings({"unused", "UnusedAssignment"})
+ @Advice.OnMethodExit
+ private static void exit(
+ @Advice.Return(readOnly = false, typing = Assigner.Typing.DYNAMIC) Object returned,
+ @Advice.Enter Callable<?> mocked)
+ throws Throwable {
+ if (mocked != null) {
+ returned = mocked.call();
+ }
+ }
+ }
+
+ public static class ForReadObject {
+
+ @SuppressWarnings({"unused", "BanSerializableRead"})
+ public static void doReadObject(
+ @Identifier String identifier,
+ @This MockAccess thiz,
+ @Argument(0) ObjectInputStream objectInputStream)
+ throws IOException, ClassNotFoundException {
objectInputStream.defaultReadObject();
- MockMethodAdvice mockMethodAdvice = (MockMethodAdvice) MockMethodDispatcher.get(identifier, thiz);
+ MockMethodAdvice mockMethodAdvice =
+ (MockMethodAdvice) MockMethodDispatcher.get(identifier, thiz);
if (mockMethodAdvice != null) {
mockMethodAdvice.interceptors.put(thiz, thiz.getMockitoInterceptor());
}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodDispatcher.java b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodDispatcher.java
deleted file mode 100644
index 1bf4cce..0000000
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodDispatcher.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2016 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.creation.bytebuddy;
-
-import java.lang.reflect.Method;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-public abstract class MockMethodDispatcher {
-
- private static final ConcurrentMap<String, MockMethodDispatcher> INSTANCE = new ConcurrentHashMap<String, MockMethodDispatcher>();
-
- public static MockMethodDispatcher get(String identifier, Object mock) {
- if (mock == INSTANCE) { // Avoid endless loop if ConcurrentHashMap was redefined to check for being a mock.
- return null;
- } else {
- return INSTANCE.get(identifier);
- }
- }
-
- public static void set(String identifier, MockMethodDispatcher dispatcher) {
- INSTANCE.putIfAbsent(identifier, dispatcher);
- }
-
- public abstract Callable<?> handle(Object instance, Method origin, Object[] arguments) throws Throwable;
-
- public abstract boolean isMock(Object instance);
-
- public abstract boolean isMocked(Object instance);
-
- public abstract boolean isOverridden(Object instance, Method origin);
-}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java
index 9066927..83908ca 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodInterceptor.java
@@ -4,6 +4,15 @@
*/
package org.mockito.internal.creation.bytebuddy;
+import static org.mockito.internal.invocation.DefaultInvocationFactory.createInvocation;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.util.concurrent.Callable;
+
import net.bytebuddy.implementation.bind.annotation.AllArguments;
import net.bytebuddy.implementation.bind.annotation.Argument;
import net.bytebuddy.implementation.bind.annotation.BindingPriority;
@@ -19,13 +28,6 @@
import org.mockito.invocation.MockHandler;
import org.mockito.mock.MockCreationSettings;
-import java.io.ObjectStreamException;
-import java.io.Serializable;
-import java.lang.reflect.Method;
-import java.util.concurrent.Callable;
-
-import static org.mockito.internal.invocation.DefaultInvocationFactory.createInvocation;
-
public class MockMethodInterceptor implements Serializable {
private static final long serialVersionUID = 7152947254057253027L;
@@ -36,31 +38,58 @@
private final ByteBuddyCrossClassLoaderSerializationSupport serializationSupport;
+ private transient ThreadLocal<Object> weakReferenceHatch = new ThreadLocal<>();
+
public MockMethodInterceptor(MockHandler handler, MockCreationSettings mockCreationSettings) {
this.handler = handler;
this.mockCreationSettings = mockCreationSettings;
serializationSupport = new ByteBuddyCrossClassLoaderSerializationSupport();
}
- Object doIntercept(Object mock,
- Method invokedMethod,
- Object[] arguments,
- RealMethod realMethod) throws Throwable {
- return doIntercept(
- mock,
- invokedMethod,
- arguments,
- realMethod,
- new LocationImpl()
- );
+ private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
+ stream.defaultReadObject();
+ weakReferenceHatch = new ThreadLocal<>();
}
- Object doIntercept(Object mock,
- Method invokedMethod,
- Object[] arguments,
- RealMethod realMethod,
- Location location) throws Throwable {
- return handler.handle(createInvocation(mock, invokedMethod, arguments, realMethod, mockCreationSettings, location));
+ Object doIntercept(Object mock, Method invokedMethod, Object[] arguments, RealMethod realMethod)
+ throws Throwable {
+ return doIntercept(mock, invokedMethod, arguments, realMethod, new LocationImpl());
+ }
+
+ Object doIntercept(
+ Object mock,
+ Method invokedMethod,
+ Object[] arguments,
+ RealMethod realMethod,
+ Location location)
+ throws Throwable {
+ // If the currently dispatched method is used in a hot path, typically a tight loop and if
+ // the mock is not used after the currently dispatched method, the JVM might attempt a
+ // garbage collection of the mock instance even before the execution of the current
+ // method is completed. Since we only reference the mock weakly from hereon after to avoid
+ // leaking the instance, it might therefore be garbage collected before the
+ // handler.handle(...) method completes. Since the handler method expects the mock to be
+ // present while a method call onto the mock is dispatched, this can lead to the problem
+ // described in GitHub #1802.
+ //
+ // To avoid this problem, we distract the JVM JIT by escaping the mock instance to a thread
+ // local field for the duration of the handler's dispatch.
+ //
+ // When dropping support for Java 8, instead of this hatch we should use an explicit fence
+ // https://docs.oracle.com/javase/9/docs/api/java/lang/ref/Reference.html#reachabilityFence-java.lang.Object-
+ weakReferenceHatch.set(mock);
+ try {
+ return handler.handle(
+ createInvocation(
+ mock,
+ invokedMethod,
+ arguments,
+ realMethod,
+ mockCreationSettings,
+ location));
+ } finally {
+ weakReferenceHatch.remove();
+ }
}
public MockHandler getMockHandler() {
@@ -71,12 +100,14 @@
return serializationSupport;
}
- public static class ForHashCode {
+ public static final class ForHashCode {
@SuppressWarnings("unused")
public static int doIdentityHashCode(@This Object thiz) {
return System.identityHashCode(thiz);
}
+
+ private ForHashCode() {}
}
public static class ForEquals {
@@ -87,11 +118,13 @@
}
}
- public static class ForWriteReplace {
+ public static final class ForWriteReplace {
public static Object doWriteReplace(@This MockAccess thiz) throws ObjectStreamException {
return thiz.getMockitoInterceptor().getSerializationSupport().writeReplace(thiz);
}
+
+ private ForWriteReplace() {}
}
public static class DispatcherDefaultingToRealMethod {
@@ -99,38 +132,34 @@
@SuppressWarnings("unused")
@RuntimeType
@BindingPriority(BindingPriority.DEFAULT * 2)
- public static Object interceptSuperCallable(@This Object mock,
- @FieldValue("mockitoInterceptor") MockMethodInterceptor interceptor,
- @Origin Method invokedMethod,
- @AllArguments Object[] arguments,
- @SuperCall(serializableProxy = true) Callable<?> superCall) throws Throwable {
+ public static Object interceptSuperCallable(
+ @This Object mock,
+ @FieldValue("mockitoInterceptor") MockMethodInterceptor interceptor,
+ @Origin Method invokedMethod,
+ @AllArguments Object[] arguments,
+ @SuperCall(serializableProxy = true) Callable<?> superCall)
+ throws Throwable {
if (interceptor == null) {
return superCall.call();
}
return interceptor.doIntercept(
- mock,
- invokedMethod,
- arguments,
- new RealMethod.FromCallable(superCall)
- );
+ mock, invokedMethod, arguments, new RealMethod.FromCallable(superCall));
}
@SuppressWarnings("unused")
@RuntimeType
- public static Object interceptAbstract(@This Object mock,
- @FieldValue("mockitoInterceptor") MockMethodInterceptor interceptor,
- @StubValue Object stubValue,
- @Origin Method invokedMethod,
- @AllArguments Object[] arguments) throws Throwable {
+ public static Object interceptAbstract(
+ @This Object mock,
+ @FieldValue("mockitoInterceptor") MockMethodInterceptor interceptor,
+ @StubValue Object stubValue,
+ @Origin Method invokedMethod,
+ @AllArguments Object[] arguments)
+ throws Throwable {
if (interceptor == null) {
return stubValue;
}
return interceptor.doIntercept(
- mock,
- invokedMethod,
- arguments,
- RealMethod.IsIllegal.INSTANCE
- );
+ mock, invokedMethod, arguments, RealMethod.IsIllegal.INSTANCE);
}
}
}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/ModuleHandler.java b/src/main/java/org/mockito/internal/creation/bytebuddy/ModuleHandler.java
new file mode 100644
index 0000000..38716d0
--- /dev/null
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/ModuleHandler.java
@@ -0,0 +1,336 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import static net.bytebuddy.matcher.ElementMatchers.isTypeInitializer;
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Random;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.description.modifier.Ownership;
+import net.bytebuddy.description.modifier.Visibility;
+import net.bytebuddy.dynamic.scaffold.subclass.ConstructorStrategy;
+import net.bytebuddy.implementation.Implementation;
+import net.bytebuddy.implementation.MethodCall;
+import net.bytebuddy.implementation.StubMethod;
+import org.mockito.codegen.InjectionBase;
+import org.mockito.exceptions.base.MockitoException;
+
+abstract class ModuleHandler {
+
+ abstract boolean isOpened(Class<?> source, Class<?> target);
+
+ abstract boolean canRead(Class<?> source, Class<?> target);
+
+ abstract boolean isExported(Class<?> source);
+
+ abstract boolean isExported(Class<?> source, Class<?> target);
+
+ abstract Class<?> injectionBase(ClassLoader classLoader, String tyoeName);
+
+ abstract void adjustModuleGraph(Class<?> source, Class<?> target, boolean export, boolean read);
+
+ static ModuleHandler make(ByteBuddy byteBuddy, SubclassLoader loader, Random random) {
+ try {
+ return new ModuleSystemFound(byteBuddy, loader, random);
+ } catch (Exception ignored) {
+ return new NoModuleSystemFound();
+ }
+ }
+
+ private static class ModuleSystemFound extends ModuleHandler {
+
+ private final ByteBuddy byteBuddy;
+ private final SubclassLoader loader;
+ private final Random random;
+
+ private final int injectonBaseSuffix;
+
+ private final Method getModule,
+ isOpen,
+ isExported,
+ isExportedUnqualified,
+ canRead,
+ addExports,
+ addReads,
+ addOpens,
+ forName;
+
+ private ModuleSystemFound(ByteBuddy byteBuddy, SubclassLoader loader, Random random)
+ throws Exception {
+ this.byteBuddy = byteBuddy;
+ this.loader = loader;
+ this.random = random;
+ injectonBaseSuffix = Math.abs(random.nextInt());
+ Class<?> moduleType = Class.forName("java.lang.Module");
+ getModule = Class.class.getMethod("getModule");
+ isOpen = moduleType.getMethod("isOpen", String.class, moduleType);
+ isExported = moduleType.getMethod("isExported", String.class, moduleType);
+ isExportedUnqualified = moduleType.getMethod("isExported", String.class);
+ canRead = moduleType.getMethod("canRead", moduleType);
+ addExports = moduleType.getMethod("addExports", String.class, moduleType);
+ addReads = moduleType.getMethod("addReads", moduleType);
+ addOpens = moduleType.getMethod("addOpens", String.class, moduleType);
+ forName = Class.class.getMethod("forName", String.class);
+ }
+
+ @Override
+ boolean isOpened(Class<?> source, Class<?> target) {
+ if (source.getPackage() == null) {
+ return true;
+ }
+ return (Boolean)
+ invoke(
+ isOpen,
+ invoke(getModule, source),
+ source.getPackage().getName(),
+ invoke(getModule, target));
+ }
+
+ @Override
+ boolean canRead(Class<?> source, Class<?> target) {
+ return (Boolean) invoke(canRead, invoke(getModule, source), invoke(getModule, target));
+ }
+
+ @Override
+ boolean isExported(Class<?> source) {
+ if (source.getPackage() == null) {
+ return true;
+ }
+ return (Boolean)
+ invoke(
+ isExportedUnqualified,
+ invoke(getModule, source),
+ source.getPackage().getName());
+ }
+
+ @Override
+ boolean isExported(Class<?> source, Class<?> target) {
+ if (source.getPackage() == null) {
+ return true;
+ }
+ return (Boolean)
+ invoke(
+ isExported,
+ invoke(getModule, source),
+ source.getPackage().getName(),
+ invoke(getModule, target));
+ }
+
+ @Override
+ Class<?> injectionBase(ClassLoader classLoader, String typeName) {
+ String packageName = typeName.substring(0, typeName.lastIndexOf('.'));
+ if (classLoader == InjectionBase.class.getClassLoader()
+ && InjectionBase.class.getPackage().getName().equals(packageName)) {
+ return InjectionBase.class;
+ } else {
+ synchronized (this) {
+ String name;
+ int suffix = injectonBaseSuffix;
+ do {
+ name =
+ packageName
+ + "."
+ + InjectionBase.class.getSimpleName()
+ + "$"
+ + suffix++;
+ try {
+ Class<?> type = Class.forName(name, false, classLoader);
+ // The injected type must be defined in the class loader that is target
+ // of the injection. Otherwise,
+ // the class's unnamed module would differ from the intended module. To
+ // avoid conflicts, we increment
+ // the suffix until we hit a class with a known name and generate one if
+ // it does not exist.
+ if (type.getClassLoader() == classLoader) {
+ return type;
+ }
+ } catch (ClassNotFoundException ignored) {
+ break;
+ }
+ } while (true);
+ return byteBuddy
+ .subclass(Object.class, ConstructorStrategy.Default.NO_CONSTRUCTORS)
+ .name(name)
+ .make()
+ .load(
+ classLoader,
+ loader.resolveStrategy(InjectionBase.class, classLoader, false))
+ .getLoaded();
+ }
+ }
+ }
+
+ @Override
+ void adjustModuleGraph(Class<?> source, Class<?> target, boolean export, boolean read) {
+ boolean needsExport = export && !isExported(source, target);
+ boolean needsRead = read && !canRead(source, target);
+ if (!needsExport && !needsRead) {
+ return;
+ }
+ ClassLoader classLoader = source.getClassLoader();
+ if (classLoader == null) {
+ throw new MockitoException(
+ join(
+ "Cannot adjust module graph for modules in the bootstrap loader",
+ "",
+ source
+ + " is declared by the bootstrap loader and cannot be adjusted",
+ "Requires package export to " + target + ": " + needsExport,
+ "Requires adjusted reading of " + target + ": " + needsRead));
+ }
+ boolean targetVisible = classLoader == target.getClassLoader();
+ while (!targetVisible && classLoader != null) {
+ classLoader = classLoader.getParent();
+ targetVisible = classLoader == target.getClassLoader();
+ }
+ MethodCall targetLookup;
+ Implementation.Composable implementation;
+ if (targetVisible) {
+ targetLookup =
+ MethodCall.invoke(getModule)
+ .onMethodCall(MethodCall.invoke(forName).with(target.getName()));
+ implementation = StubMethod.INSTANCE;
+ } else {
+ Class<?> intermediate;
+ Field field;
+ try {
+ intermediate =
+ byteBuddy
+ .subclass(
+ Object.class,
+ ConstructorStrategy.Default.NO_CONSTRUCTORS)
+ .name(
+ String.format(
+ "%s$%d",
+ "org.mockito.codegen.MockitoTypeCarrier",
+ Math.abs(random.nextInt())))
+ .defineField(
+ "mockitoType",
+ Class.class,
+ Visibility.PUBLIC,
+ Ownership.STATIC)
+ .make()
+ .load(
+ source.getClassLoader(),
+ loader.resolveStrategy(
+ source, source.getClassLoader(), false))
+ .getLoaded();
+ field = intermediate.getField("mockitoType");
+ field.set(null, target);
+ } catch (Exception e) {
+ throw new MockitoException(
+ join(
+ "Could not create a carrier for making the Mockito type visible to "
+ + source,
+ "",
+ "This is required to adjust the module graph to enable mock creation"),
+ e);
+ }
+ targetLookup = MethodCall.invoke(getModule).onField(field);
+ implementation =
+ MethodCall.invoke(getModule)
+ .onMethodCall(
+ MethodCall.invoke(forName).with(intermediate.getName()));
+ }
+ MethodCall sourceLookup =
+ MethodCall.invoke(getModule)
+ .onMethodCall(MethodCall.invoke(forName).with(source.getName()));
+ if (needsExport) {
+ implementation =
+ implementation.andThen(
+ MethodCall.invoke(addExports)
+ .onMethodCall(sourceLookup)
+ .with(target.getPackage().getName())
+ .withMethodCall(targetLookup));
+ }
+ if (needsRead) {
+ implementation =
+ implementation.andThen(
+ MethodCall.invoke(addReads)
+ .onMethodCall(sourceLookup)
+ .withMethodCall(targetLookup));
+ }
+ try {
+ Class.forName(
+ byteBuddy
+ .subclass(Object.class)
+ .name(
+ String.format(
+ "%s$%s$%d",
+ source.getName(),
+ "MockitoModuleProbe",
+ Math.abs(random.nextInt())))
+ .invokable(isTypeInitializer())
+ .intercept(implementation)
+ .make()
+ .load(
+ source.getClassLoader(),
+ loader.resolveStrategy(
+ source, source.getClassLoader(), false))
+ .getLoaded()
+ .getName(),
+ true,
+ source.getClassLoader());
+ } catch (Exception e) {
+ throw new MockitoException(
+ join(
+ "Could not force module adjustment of the module of " + source,
+ "",
+ "This is required to adjust the module graph to enable mock creation"),
+ e);
+ }
+ }
+
+ private static Object invoke(Method method, Object target, Object... args) {
+ try {
+ return method.invoke(target, args);
+ } catch (Exception e) {
+ throw new MockitoException(
+ join(
+ "Could not invoke " + method + " using reflection",
+ "",
+ "Mockito attempted to interact with the Java module system but an unexpected method behavior was encountered"),
+ e);
+ }
+ }
+ }
+
+ private static class NoModuleSystemFound extends ModuleHandler {
+
+ @Override
+ boolean isOpened(Class<?> source, Class<?> target) {
+ return true;
+ }
+
+ @Override
+ boolean canRead(Class<?> source, Class<?> target) {
+ return true;
+ }
+
+ @Override
+ boolean isExported(Class<?> source) {
+ return true;
+ }
+
+ @Override
+ boolean isExported(Class<?> source, Class<?> target) {
+ return true;
+ }
+
+ @Override
+ Class<?> injectionBase(ClassLoader classLoader, String tyoeName) {
+ return InjectionBase.class;
+ }
+
+ @Override
+ void adjustModuleGraph(Class<?> source, Class<?> target, boolean export, boolean read) {
+ // empty
+ }
+ }
+}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java
index 79e89f2..533e287 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMaker.java
@@ -4,16 +4,16 @@
*/
package org.mockito.internal.creation.bytebuddy;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.creation.instance.Instantiator;
-import org.mockito.internal.util.Platform;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
+import static org.mockito.internal.util.StringUtil.join;
import java.lang.reflect.Modifier;
-import static org.mockito.internal.util.StringUtil.join;
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.util.Platform;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
/**
* Subclass based mock maker.
@@ -34,7 +34,8 @@
}
public SubclassByteBuddyMockMaker(SubclassLoader loader) {
- cachingMockBytecodeGenerator = new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(loader), false);
+ cachingMockBytecodeGenerator =
+ new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(loader), false);
}
@Override
@@ -50,36 +51,43 @@
return ensureMockIsAssignableToMockedType(settings, mockInstance);
} catch (ClassCastException cce) {
- throw new MockitoException(join(
- "ClassCastException occurred while creating the mockito mock :",
- " class to mock : " + describeClass(settings.getTypeToMock()),
- " created class : " + describeClass(mockedProxyType),
- " proxy instance class : " + describeClass(mockInstance),
- " instance creation by : " + instantiator.getClass().getSimpleName(),
- "",
- "You might experience classloading issues, please ask the mockito mailing-list.",
- ""
- ), cce);
+ throw new MockitoException(
+ join(
+ "ClassCastException occurred while creating the mockito mock :",
+ " class to mock : " + describeClass(settings.getTypeToMock()),
+ " created class : " + describeClass(mockedProxyType),
+ " proxy instance class : " + describeClass(mockInstance),
+ " instance creation by : " + instantiator.getClass().getSimpleName(),
+ "",
+ "You might experience classloading issues, please ask the mockito mailing-list.",
+ ""),
+ cce);
} catch (org.mockito.creation.instance.InstantiationException e) {
- throw new MockitoException("Unable to create mock instance of type '" + mockedProxyType.getSuperclass().getSimpleName() + "'", e);
+ throw new MockitoException(
+ "Unable to create mock instance of type '"
+ + mockedProxyType.getSuperclass().getSimpleName()
+ + "'",
+ e);
}
}
@Override
public <T> Class<? extends T> createMockType(MockCreationSettings<T> settings) {
try {
- return cachingMockBytecodeGenerator.mockClass(MockFeatures.withMockFeatures(
- settings.getTypeToMock(),
- settings.getExtraInterfaces(),
- settings.getSerializableMode(),
- settings.isStripAnnotations()
- ));
+ return cachingMockBytecodeGenerator.mockClass(
+ MockFeatures.withMockFeatures(
+ settings.getTypeToMock(),
+ settings.getExtraInterfaces(),
+ settings.getSerializableMode(),
+ settings.isStripAnnotations(),
+ settings.getDefaultAnswer()));
} catch (Exception bytecodeGenerationFailed) {
throw prettifyFailure(settings, bytecodeGenerationFailed);
}
}
- private static <T> T ensureMockIsAssignableToMockedType(MockCreationSettings<T> settings, T mock) {
+ private static <T> T ensureMockIsAssignableToMockedType(
+ MockCreationSettings<T> settings, T mock) {
// Force explicit cast to mocked type here, instead of
// relying on the JVM to implicitly cast on the client call site.
// This allows us to catch earlier the ClassCastException earlier
@@ -87,38 +95,49 @@
return typeToMock.cast(mock);
}
- private <T> RuntimeException prettifyFailure(MockCreationSettings<T> mockFeatures, Exception generationFailed) {
+ private <T> RuntimeException prettifyFailure(
+ MockCreationSettings<T> mockFeatures, Exception generationFailed) {
if (mockFeatures.getTypeToMock().isArray()) {
- throw new MockitoException(join(
- "Mockito cannot mock arrays: " + mockFeatures.getTypeToMock() + ".",
- ""
- ), generationFailed);
+ throw new MockitoException(
+ join("Mockito cannot mock arrays: " + mockFeatures.getTypeToMock() + ".", ""),
+ generationFailed);
}
if (Modifier.isPrivate(mockFeatures.getTypeToMock().getModifiers())) {
- throw new MockitoException(join(
- "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
- "Most likely it is due to mocking a private class that is not visible to Mockito",
- ""
- ), generationFailed);
+ throw new MockitoException(
+ join(
+ "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
+ "Most likely it is due to mocking a private class that is not visible to Mockito",
+ ""),
+ generationFailed);
}
- throw new MockitoException(join(
- "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
- "",
- "Mockito can only mock non-private & non-final classes.",
- "If you're not sure why you're getting this error, please report to the mailing list.",
- "",
- Platform.warnForVM(
- "IBM J9 VM", "Early IBM virtual machine are known to have issues with Mockito, please upgrade to an up-to-date version.\n",
- "Hotspot", Platform.isJava8BelowUpdate45() ? "Java 8 early builds have bugs that were addressed in Java 1.8.0_45, please update your JDK!\n" : ""
- ),
- Platform.describe(),
- "",
- "Underlying exception : " + generationFailed
- ), generationFailed);
+ throw new MockitoException(
+ join(
+ "Mockito cannot mock this class: " + mockFeatures.getTypeToMock() + ".",
+ "",
+ "Mockito can only mock non-private & non-final classes.",
+ "If you're not sure why you're getting this error, please report to the mailing list.",
+ "",
+ Platform.warnForVM(
+ "IBM J9 VM",
+ "Early IBM virtual machine are known to have issues with Mockito, please upgrade to an up-to-date version.\n",
+ "Hotspot",
+ Platform.isJava8BelowUpdate45()
+ ? "Java 8 early builds have bugs that were addressed in Java 1.8.0_45, please update your JDK!\n"
+ : ""),
+ Platform.describe(),
+ "",
+ "Underlying exception : " + generationFailed),
+ generationFailed);
}
private static String describeClass(Class<?> type) {
- return type == null ? "null" : "'" + type.getCanonicalName() + "', loaded by classloader : '" + type.getClassLoader() + "'";
+ return type == null
+ ? "null"
+ : "'"
+ + type.getCanonicalName()
+ + "', loaded by classloader : '"
+ + type.getClassLoader()
+ + "'";
}
private static String describeClass(Object instance) {
@@ -135,9 +154,7 @@
@Override
public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
- ((MockAccess) mock).setMockitoInterceptor(
- new MockMethodInterceptor(newHandler, settings)
- );
+ ((MockAccess) mock).setMockitoInterceptor(new MockMethodInterceptor(newHandler, settings));
}
@Override
@@ -145,12 +162,14 @@
return new TypeMockability() {
@Override
public boolean mockable() {
- return !type.isPrimitive() && !Modifier.isFinal(type.getModifiers());
+ return !type.isPrimitive()
+ && !Modifier.isFinal(type.getModifiers())
+ && !TypeSupport.INSTANCE.isSealed(type);
}
@Override
public String nonMockableReason() {
- if(mockable()) {
+ if (mockable()) {
return "";
}
if (type.isPrimitive()) {
@@ -159,8 +178,16 @@
if (Modifier.isFinal(type.getModifiers())) {
return "final class";
}
+ if (TypeSupport.INSTANCE.isSealed(type)) {
+ return "sealed class";
+ }
return join("not handled type");
}
};
}
+
+ @Override
+ public void clearAllCaches() {
+ cachingMockBytecodeGenerator.clearAllCaches();
+ }
}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java
index b659c73..f67fdfc 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java
@@ -4,6 +4,35 @@
*/
package org.mockito.internal.creation.bytebuddy;
+import static java.lang.Thread.currentThread;
+import static net.bytebuddy.description.modifier.Visibility.PRIVATE;
+import static net.bytebuddy.dynamic.Transformer.ForMethod.withModifiers;
+import static net.bytebuddy.implementation.MethodDelegation.to;
+import static net.bytebuddy.implementation.attribute.MethodAttributeAppender.ForInstrumentedMethod.INCLUDING_RECEIVER;
+import static net.bytebuddy.matcher.ElementMatchers.any;
+import static net.bytebuddy.matcher.ElementMatchers.hasParameters;
+import static net.bytebuddy.matcher.ElementMatchers.hasType;
+import static net.bytebuddy.matcher.ElementMatchers.isAnnotatedWith;
+import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy;
+import static net.bytebuddy.matcher.ElementMatchers.isEquals;
+import static net.bytebuddy.matcher.ElementMatchers.isHashCode;
+import static net.bytebuddy.matcher.ElementMatchers.isPackagePrivate;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.returns;
+import static net.bytebuddy.matcher.ElementMatchers.whereAny;
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Random;
import net.bytebuddy.ByteBuddy;
import net.bytebuddy.description.method.MethodDescription;
import net.bytebuddy.description.modifier.SynchronizationState;
@@ -15,36 +44,20 @@
import net.bytebuddy.implementation.Implementation;
import net.bytebuddy.implementation.attribute.MethodAttributeAppender;
import net.bytebuddy.matcher.ElementMatcher;
+import org.mockito.codegen.InjectionBase;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.creation.bytebuddy.ByteBuddyCrossClassLoaderSerializationSupport.CrossClassLoaderSerializableMock;
import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.DispatcherDefaultingToRealMethod;
import org.mockito.mock.SerializableMode;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Modifier;
-import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.Random;
-
-import static java.lang.Thread.currentThread;
-import static net.bytebuddy.description.modifier.Visibility.PRIVATE;
-import static net.bytebuddy.dynamic.Transformer.ForMethod.withModifiers;
-import static net.bytebuddy.implementation.MethodDelegation.to;
-import static net.bytebuddy.implementation.attribute.MethodAttributeAppender.ForInstrumentedMethod.INCLUDING_RECEIVER;
-import static net.bytebuddy.matcher.ElementMatchers.*;
-import static org.mockito.internal.util.StringUtil.join;
-
class SubclassBytecodeGenerator implements BytecodeGenerator {
private static final String CODEGEN_PACKAGE = "org.mockito.codegen.";
private final SubclassLoader loader;
-
+ private final ModuleHandler handler;
private final ByteBuddy byteBuddy;
private final Random random;
-
private final Implementation readReplace;
private final ElementMatcher<? super MethodDescription> matcher;
@@ -61,116 +74,252 @@
this(loader, null, any());
}
- public SubclassBytecodeGenerator(Implementation readReplace, ElementMatcher<? super MethodDescription> matcher) {
+ public SubclassBytecodeGenerator(
+ Implementation readReplace, ElementMatcher<? super MethodDescription> matcher) {
this(new SubclassInjectionLoader(), readReplace, matcher);
}
- protected SubclassBytecodeGenerator(SubclassLoader loader, Implementation readReplace, ElementMatcher<? super MethodDescription> matcher) {
+ protected SubclassBytecodeGenerator(
+ SubclassLoader loader,
+ Implementation readReplace,
+ ElementMatcher<? super MethodDescription> matcher) {
this.loader = loader;
this.readReplace = readReplace;
this.matcher = matcher;
byteBuddy = new ByteBuddy().with(TypeValidation.DISABLED);
random = new Random();
+ handler = ModuleHandler.make(byteBuddy, loader, random);
+ }
+
+ private static boolean needsSamePackageClassLoader(MockFeatures<?> features) {
+ if (!Modifier.isPublic(features.mockedType.getModifiers())
+ || !features.mockedType.isInterface()) {
+ // The mocked type is package private or is not an interface and thus may contain
+ // package private methods.
+ return true;
+ }
+ if (hasNonPublicTypeReference(features.mockedType)) {
+ return true;
+ }
+
+ for (Class<?> iface : features.interfaces) {
+ if (!Modifier.isPublic(iface.getModifiers())) {
+ return true;
+ }
+ if (hasNonPublicTypeReference(iface)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static boolean hasNonPublicTypeReference(Class<?> iface) {
+ for (Method method : iface.getMethods()) {
+ if (!Modifier.isPublic(method.getReturnType().getModifiers())) {
+ return true;
+ }
+ for (Class<?> param : method.getParameterTypes()) {
+ if (!Modifier.isPublic(param.getModifiers())) {
+ return true;
+ }
+ }
+ }
+ return false;
}
@Override
public <T> Class<? extends T> mockClass(MockFeatures<T> features) {
- String name = nameFor(features.mockedType);
+ MultipleParentClassLoader.Builder loaderBuilder =
+ new MultipleParentClassLoader.Builder()
+ .appendMostSpecific(features.mockedType)
+ .appendMostSpecific(features.interfaces)
+ .appendMostSpecific(
+ MockAccess.class, DispatcherDefaultingToRealMethod.class)
+ .appendMostSpecific(
+ MockMethodInterceptor.class,
+ MockMethodInterceptor.ForHashCode.class,
+ MockMethodInterceptor.ForEquals.class);
+ ClassLoader contextLoader = currentThread().getContextClassLoader();
+ boolean shouldIncludeContextLoader = true;
+ if (needsSamePackageClassLoader(features)) {
+ // For the generated class to access package-private methods, it must be defined by the
+ // same classloader as its type. All the other added classloaders are required to load
+ // the type; if the context classloader is a child of the mocked type's defining
+ // classloader, it will break a mock that would have worked. Check if the context class
+ // loader is a child of the classloader we'd otherwise use, and possibly skip it.
+ ClassLoader candidateLoader = loaderBuilder.build();
+ for (ClassLoader parent = contextLoader; parent != null; parent = parent.getParent()) {
+ if (parent == candidateLoader) {
+ shouldIncludeContextLoader = false;
+ break;
+ }
+ }
+ }
+ if (shouldIncludeContextLoader) {
+ loaderBuilder = loaderBuilder.appendMostSpecific(contextLoader);
+ }
+ ClassLoader classLoader = loaderBuilder.build();
+
+ // If Mockito does not need to create a new class loader and if a mock is not based on a JDK
+ // type, we attempt
+ // to define the mock class in the user runtime package to allow for mocking package private
+ // types and methods.
+ // This also requires that we are able to access the package of the mocked class either by
+ // override or explicit
+ // privilege given by the target package being opened to Mockito.
+ boolean localMock =
+ classLoader == features.mockedType.getClassLoader()
+ && features.serializableMode != SerializableMode.ACROSS_CLASSLOADERS
+ && !isComingFromJDK(features.mockedType)
+ && (loader.isDisrespectingOpenness()
+ || handler.isOpened(features.mockedType, MockAccess.class));
+ String typeName;
+ if (localMock
+ || (loader instanceof MultipleParentClassLoader
+ && !isComingFromJDK(features.mockedType))) {
+ typeName = features.mockedType.getName();
+ } else {
+ typeName =
+ InjectionBase.class.getPackage().getName()
+ + "."
+ + features.mockedType.getSimpleName();
+ }
+ String name =
+ String.format("%s$%s$%d", typeName, "MockitoMock", Math.abs(random.nextInt()));
+
+ if (localMock) {
+ handler.adjustModuleGraph(features.mockedType, MockAccess.class, false, true);
+ for (Class<?> iFace : features.interfaces) {
+ handler.adjustModuleGraph(iFace, features.mockedType, true, false);
+ handler.adjustModuleGraph(features.mockedType, iFace, false, true);
+ }
+ } else {
+ boolean exported = handler.isExported(features.mockedType);
+ Iterator<Class<?>> it = features.interfaces.iterator();
+ while (exported && it.hasNext()) {
+ exported = handler.isExported(it.next());
+ }
+ // We check if all mocked types are exported without qualification to avoid generating a
+ // hook type.
+ // unless this is necessary. We expect this to be the case for most mocked types what
+ // makes this a
+ // worthy performance optimization.
+ if (exported) {
+ assertVisibility(features.mockedType);
+ for (Class<?> iFace : features.interfaces) {
+ assertVisibility(iFace);
+ }
+ } else {
+ Class<?> hook = handler.injectionBase(classLoader, typeName);
+ assertVisibility(features.mockedType);
+ handler.adjustModuleGraph(features.mockedType, hook, true, false);
+ for (Class<?> iFace : features.interfaces) {
+ assertVisibility(iFace);
+ handler.adjustModuleGraph(iFace, hook, true, false);
+ }
+ }
+ }
+
DynamicType.Builder<T> builder =
- byteBuddy.subclass(features.mockedType)
- .name(name)
- .ignoreAlso(isGroovyMethod())
- .annotateType(features.stripAnnotations
- ? new Annotation[0]
- : features.mockedType.getAnnotations())
- .implement(new ArrayList<Type>(features.interfaces))
- .method(matcher)
- .intercept(dispatcher)
- .transform(withModifiers(SynchronizationState.PLAIN))
- .attribute(features.stripAnnotations
- ? MethodAttributeAppender.NoOp.INSTANCE
- : INCLUDING_RECEIVER)
- .method(isHashCode())
- .intercept(hashCode)
- .method(isEquals())
- .intercept(equals)
- .serialVersionUid(42L)
- .defineField("mockitoInterceptor", MockMethodInterceptor.class, PRIVATE)
- .implement(MockAccess.class)
- .intercept(FieldAccessor.ofBeanProperty());
+ byteBuddy
+ .subclass(features.mockedType)
+ .name(name)
+ .ignoreAlso(isGroovyMethod())
+ .annotateType(
+ features.stripAnnotations
+ ? new Annotation[0]
+ : features.mockedType.getAnnotations())
+ .implement(new ArrayList<Type>(features.interfaces))
+ .method(matcher)
+ .intercept(dispatcher)
+ .transform(withModifiers(SynchronizationState.PLAIN))
+ .attribute(
+ features.stripAnnotations
+ ? MethodAttributeAppender.NoOp.INSTANCE
+ : INCLUDING_RECEIVER)
+ .serialVersionUid(42L)
+ .defineField("mockitoInterceptor", MockMethodInterceptor.class, PRIVATE)
+ .implement(MockAccess.class)
+ .intercept(FieldAccessor.ofBeanProperty())
+ .method(isHashCode())
+ .intercept(hashCode)
+ .method(isEquals())
+ .intercept(equals);
if (features.serializableMode == SerializableMode.ACROSS_CLASSLOADERS) {
- builder = builder.implement(CrossClassLoaderSerializableMock.class)
- .intercept(writeReplace);
+ builder =
+ builder.implement(CrossClassLoaderSerializableMock.class)
+ .intercept(writeReplace);
}
if (readReplace != null) {
- builder = builder.defineMethod("readObject", void.class, Visibility.PRIVATE)
- .withParameters(ObjectInputStream.class)
- .throwing(ClassNotFoundException.class, IOException.class)
- .intercept(readReplace);
+ builder =
+ builder.defineMethod("readObject", void.class, Visibility.PRIVATE)
+ .withParameters(ObjectInputStream.class)
+ .throwing(ClassNotFoundException.class, IOException.class)
+ .intercept(readReplace);
}
- ClassLoader classLoader = new MultipleParentClassLoader.Builder()
- .append(features.mockedType)
- .append(features.interfaces)
- .append(currentThread().getContextClassLoader())
- .append(MockAccess.class, DispatcherDefaultingToRealMethod.class)
- .append(MockMethodInterceptor.class,
- MockMethodInterceptor.ForHashCode.class,
- MockMethodInterceptor.ForEquals.class).build(MockMethodInterceptor.class.getClassLoader());
- if (classLoader != features.mockedType.getClassLoader()) {
- assertVisibility(features.mockedType);
- for (Class<?> iFace : features.interfaces) {
- assertVisibility(iFace);
- }
- builder = builder.ignoreAlso(isPackagePrivate()
- .or(returns(isPackagePrivate()))
- .or(hasParameters(whereAny(hasType(isPackagePrivate())))));
+ if (name.startsWith(CODEGEN_PACKAGE) || classLoader instanceof MultipleParentClassLoader) {
+ builder =
+ builder.ignoreAlso(
+ isPackagePrivate()
+ .or(returns(isPackagePrivate()))
+ .or(hasParameters(whereAny(hasType(isPackagePrivate())))));
}
return builder.make()
- .load(classLoader, loader.resolveStrategy(features.mockedType, classLoader, name.startsWith(CODEGEN_PACKAGE)))
- .getLoaded();
+ .load(
+ classLoader,
+ loader.resolveStrategy(features.mockedType, classLoader, localMock))
+ .getLoaded();
+ }
+
+ @Override
+ public void mockClassStatic(Class<?> type) {
+ throw new MockitoException("The subclass byte code generator cannot create static mocks");
+ }
+
+ @Override
+ public void mockClassConstruction(Class<?> type) {
+ throw new MockitoException(
+ "The subclass byte code generator cannot create construction mocks");
+ }
+
+ private <T> Collection<Class<? super T>> getAllTypes(Class<T> type) {
+ Collection<Class<? super T>> supertypes = new LinkedList<>();
+ supertypes.add(type);
+ Class<? super T> superType = type;
+ while (superType != null) {
+ supertypes.add(superType);
+ superType = superType.getSuperclass();
+ }
+ return supertypes;
}
private static ElementMatcher<MethodDescription> isGroovyMethod() {
- return isDeclaredBy(named("groovy.lang.GroovyObjectSupport"));
- }
-
- // TODO inspect naming strategy (for OSGI, signed package, java.* (and bootstrap classes), etc...)
- private String nameFor(Class<?> type) {
- String typeName = type.getName();
- if (isComingFromJDK(type)
- || isComingFromSignedJar(type)
- || isComingFromSealedPackage(type)) {
- typeName = CODEGEN_PACKAGE + type.getSimpleName();
- }
- return String.format("%s$%s$%d", typeName, "MockitoMock", Math.abs(random.nextInt()));
+ return isDeclaredBy(named("groovy.lang.GroovyObjectSupport"))
+ .or(isAnnotatedWith(named("groovy.transform.Internal")));
}
private boolean isComingFromJDK(Class<?> type) {
// Comes from the manifest entry :
// Implementation-Title: Java Runtime Environment
// This entry is not necessarily present in every jar of the JDK
- return type.getPackage() != null && "Java Runtime Environment".equalsIgnoreCase(type.getPackage().getImplementationTitle())
+ return (type.getPackage() != null
+ && "Java Runtime Environment"
+ .equalsIgnoreCase(type.getPackage().getImplementationTitle()))
|| type.getName().startsWith("java.")
|| type.getName().startsWith("javax.");
}
- private boolean isComingFromSealedPackage(Class<?> type) {
- return type.getPackage() != null && type.getPackage().isSealed();
- }
-
- private boolean isComingFromSignedJar(Class<?> type) {
- return type.getSigners() != null;
- }
-
private static void assertVisibility(Class<?> type) {
if (!Modifier.isPublic(type.getModifiers())) {
- throw new MockitoException(join("Cannot create mock for " + type,
- "",
- "The type is not public and its mock class is loaded by a different class loader.",
- "This can have multiple reasons:",
- " - You are mocking a class with additional interfaces of another class loader",
- " - Mockito is loaded by a different class loader than the mocked type (e.g. with OSGi)",
- " - The thread's context class loader is different than the mock's class loader"));
+ throw new MockitoException(
+ join(
+ "Cannot create mock for " + type,
+ "",
+ "The type is not public and its mock class is loaded by a different class loader.",
+ "This can have multiple reasons:",
+ " - You are mocking a class with additional interfaces of another class loader",
+ " - Mockito is loaded by a different class loader than the mocked type (e.g. with OSGi)",
+ " - The thread's context class loader is different than the mock's class loader"));
}
}
}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassInjectionLoader.java b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassInjectionLoader.java
index 454dd8e..c70de01 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassInjectionLoader.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassInjectionLoader.java
@@ -4,28 +4,31 @@
*/
package org.mockito.internal.creation.bytebuddy;
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
import net.bytebuddy.dynamic.loading.ClassInjector;
import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
import org.mockito.codegen.InjectionBase;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.util.Platform;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-import static org.mockito.internal.util.StringUtil.join;
-
class SubclassInjectionLoader implements SubclassLoader {
- private static final String ERROR_MESSAGE = join("The current JVM does not support any class injection mechanism.",
- "",
- "Currently, Mockito supports injection via neither by method handle lookups or using sun.misc.Unsafe",
- "Neither seems to be available on your current JVM.");
+ private static final String ERROR_MESSAGE =
+ join(
+ "The current JVM does not support any class injection mechanism.",
+ "",
+ "Currently, Mockito supports injection via either by method handle lookups or using sun.misc.Unsafe",
+ "Neither seems to be available on your current JVM.");
private final SubclassLoader loader;
SubclassInjectionLoader() {
- if (!Boolean.getBoolean("org.mockito.internal.simulateJava11") && ClassInjector.UsingReflection.isAvailable()) {
+ if (!Boolean.getBoolean("org.mockito.internal.noUnsafeInjection")
+ && ClassInjector.UsingReflection.isAvailable()) {
this.loader = new WithReflection();
} else if (ClassInjector.UsingLookup.isAvailable()) {
this.loader = tryLookup();
@@ -38,7 +41,11 @@
try {
Class<?> methodHandles = Class.forName("java.lang.invoke.MethodHandles");
Object lookup = methodHandles.getMethod("lookup").invoke(null);
- Method privateLookupIn = methodHandles.getMethod("privateLookupIn", Class.class, Class.forName("java.lang.invoke.MethodHandles$Lookup"));
+ Method privateLookupIn =
+ methodHandles.getMethod(
+ "privateLookupIn",
+ Class.class,
+ Class.forName("java.lang.invoke.MethodHandles$Lookup"));
Object codegenLookup = privateLookupIn.invoke(null, InjectionBase.class, lookup);
return new WithLookup(lookup, codegenLookup, privateLookupIn);
} catch (Exception exception) {
@@ -49,8 +56,17 @@
private static class WithReflection implements SubclassLoader {
@Override
- public ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean codegen) {
- return ClassLoadingStrategy.Default.INJECTION.with(codegen ? InjectionBase.class.getProtectionDomain() : mockedType.getProtectionDomain());
+ public boolean isDisrespectingOpenness() {
+ return true;
+ }
+
+ @Override
+ public ClassLoadingStrategy<ClassLoader> resolveStrategy(
+ Class<?> mockedType, ClassLoader classLoader, boolean localMock) {
+ return ClassLoadingStrategy.Default.INJECTION.with(
+ localMock
+ ? mockedType.getProtectionDomain()
+ : InjectionBase.class.getProtectionDomain());
}
}
@@ -69,39 +85,53 @@
}
@Override
- public ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean codegen) {
- if (codegen) {
- return ClassLoadingStrategy.UsingLookup.of(codegenLookup);
- } else if (classLoader != mockedType.getClassLoader()) {
- return ClassLoadingStrategy.Default.WRAPPER.with(mockedType.getProtectionDomain());
- } else {
+ public boolean isDisrespectingOpenness() {
+ return false;
+ }
+
+ @Override
+ public ClassLoadingStrategy<ClassLoader> resolveStrategy(
+ Class<?> mockedType, ClassLoader classLoader, boolean localMock) {
+ if (localMock) {
try {
Object privateLookup;
try {
privateLookup = privateLookupIn.invoke(null, mockedType, lookup);
} catch (InvocationTargetException exception) {
if (exception.getCause() instanceof IllegalAccessException) {
- return ClassLoadingStrategy.Default.WRAPPER.with(mockedType.getProtectionDomain());
+ return ClassLoadingStrategy.Default.WRAPPER.with(
+ mockedType.getProtectionDomain());
} else {
throw exception.getCause();
}
}
return ClassLoadingStrategy.UsingLookup.of(privateLookup);
} catch (Throwable exception) {
- throw new MockitoException(join(
- "The Java module system prevents Mockito from defining a mock class in the same package as " + mockedType,
- "",
- "To overcome this, you must open and export the mocked type to Mockito.",
- "Remember that you can also do so programmatically if the mocked class is defined by the same module as your test code",
- exception
- ));
+ throw new MockitoException(
+ join(
+ "The Java module system prevents Mockito from defining a mock class in the same package as "
+ + mockedType,
+ "",
+ "To overcome this, you must open and export the mocked type to Mockito.",
+ "Remember that you can also do so programmatically if the mocked class is defined by the same module as your test code",
+ exception));
}
+ } else if (classLoader == InjectionBase.class.getClassLoader()) {
+ return ClassLoadingStrategy.UsingLookup.of(codegenLookup);
+ } else {
+ return ClassLoadingStrategy.Default.WRAPPER.with(mockedType.getProtectionDomain());
}
}
}
@Override
- public ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean codegen) {
- return loader.resolveStrategy(mockedType, classLoader, codegen);
+ public boolean isDisrespectingOpenness() {
+ return loader.isDisrespectingOpenness();
+ }
+
+ @Override
+ public ClassLoadingStrategy<ClassLoader> resolveStrategy(
+ Class<?> mockedType, ClassLoader classLoader, boolean localMock) {
+ return loader.resolveStrategy(mockedType, classLoader, localMock);
}
}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassLoader.java b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassLoader.java
index 194c282..289497d 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassLoader.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassLoader.java
@@ -12,12 +12,20 @@
public interface SubclassLoader {
/**
+ * Checks if this loader does not require a module to be open.
+ *
+ * @return {@code true} if this loader is not constraint to a target module being opened for loading a class.
+ */
+ boolean isDisrespectingOpenness();
+
+ /**
* Resolves a class loading strategy.
*
* @param mockedType The type being mocked.
* @param classLoader The class loader being used.
- * @param codegen {@code true} if the mock is loaded in the {@code org.mockito.codegen} package.
+ * @param localMock {@code true} if the mock is loaded within the runtime package of the mocked type.
* @return An appropriate class loading strategy.
*/
- ClassLoadingStrategy<ClassLoader> resolveStrategy(Class<?> mockedType, ClassLoader classLoader, boolean codegen);
+ ClassLoadingStrategy<ClassLoader> resolveStrategy(
+ Class<?> mockedType, ClassLoader classLoader, boolean localMock);
}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java
index ea51edf..30ed949 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java
@@ -4,39 +4,48 @@
*/
package org.mockito.internal.creation.bytebuddy;
+import java.lang.ref.ReferenceQueue;
+import java.util.Set;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
import net.bytebuddy.TypeCache;
import org.mockito.mock.SerializableMode;
-import java.lang.ref.ReferenceQueue;
-import java.util.Set;
-import java.util.concurrent.Callable;
+class TypeCachingBytecodeGenerator extends ReferenceQueue<ClassLoader>
+ implements BytecodeGenerator {
-class TypeCachingBytecodeGenerator extends ReferenceQueue<ClassLoader> implements BytecodeGenerator {
-
- private final Object BOOTSTRAP_LOCK = new Object();
+ private static final Object BOOTSTRAP_LOCK = new Object();
private final BytecodeGenerator bytecodeGenerator;
private final TypeCache<MockitoMockKey> typeCache;
+ private final ReadWriteLock lock = new ReentrantReadWriteLock();
+
public TypeCachingBytecodeGenerator(BytecodeGenerator bytecodeGenerator, boolean weak) {
this.bytecodeGenerator = bytecodeGenerator;
- typeCache = new TypeCache.WithInlineExpunction<MockitoMockKey>(weak ? TypeCache.Sort.WEAK : TypeCache.Sort.SOFT);
+ typeCache =
+ new TypeCache.WithInlineExpunction<>(
+ weak ? TypeCache.Sort.WEAK : TypeCache.Sort.SOFT);
}
@SuppressWarnings("unchecked")
@Override
public <T> Class<T> mockClass(final MockFeatures<T> params) {
+ lock.readLock().lock();
try {
ClassLoader classLoader = params.mockedType.getClassLoader();
- return (Class<T>) typeCache.findOrInsert(classLoader,
- new MockitoMockKey(params.mockedType, params.interfaces, params.serializableMode, params.stripAnnotations),
- new Callable<Class<?>>() {
- @Override
- public Class<?> call() throws Exception {
- return bytecodeGenerator.mockClass(params);
- }
- }, BOOTSTRAP_LOCK);
+ return (Class<T>)
+ typeCache.findOrInsert(
+ classLoader,
+ new MockitoMockKey(
+ params.mockedType,
+ params.interfaces,
+ params.serializableMode,
+ params.stripAnnotations),
+ () -> bytecodeGenerator.mockClass(params),
+ BOOTSTRAP_LOCK);
} catch (IllegalArgumentException exception) {
Throwable cause = exception.getCause();
if (cause instanceof RuntimeException) {
@@ -44,6 +53,29 @@
} else {
throw exception;
}
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ @Override
+ public void mockClassStatic(Class<?> type) {
+ bytecodeGenerator.mockClassStatic(type);
+ }
+
+ @Override
+ public void mockClassConstruction(Class<?> type) {
+ bytecodeGenerator.mockClassConstruction(type);
+ }
+
+ @Override
+ public void clearAllCaches() {
+ lock.writeLock().lock();
+ try {
+ typeCache.clear();
+ bytecodeGenerator.clearAllCaches();
+ } finally {
+ lock.writeLock().unlock();
}
}
@@ -52,10 +84,11 @@
private final SerializableMode serializableMode;
private final boolean stripAnnotations;
- private MockitoMockKey(Class<?> type,
- Set<Class<?>> additionalType,
- SerializableMode serializableMode,
- boolean stripAnnotations) {
+ private MockitoMockKey(
+ Class<?> type,
+ Set<Class<?>> additionalType,
+ SerializableMode serializableMode,
+ boolean stripAnnotations) {
super(type, additionalType);
this.serializableMode = serializableMode;
this.stripAnnotations = stripAnnotations;
@@ -63,12 +96,18 @@
@Override
public boolean equals(Object object) {
- if (this == object) return true;
- if (object == null || getClass() != object.getClass()) return false;
- if (!super.equals(object)) return false;
+ if (this == object) {
+ return true;
+ }
+ if (object == null || getClass() != object.getClass()) {
+ return false;
+ }
+ if (!super.equals(object)) {
+ return false;
+ }
MockitoMockKey that = (MockitoMockKey) object;
return stripAnnotations == that.stripAnnotations
- && serializableMode.equals(that.serializableMode);
+ && serializableMode.equals(that.serializableMode);
}
@Override
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/TypeSupport.java b/src/main/java/org/mockito/internal/creation/bytebuddy/TypeSupport.java
new file mode 100644
index 0000000..17df601
--- /dev/null
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/TypeSupport.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import org.mockito.exceptions.base.MockitoException;
+
+import java.lang.reflect.Method;
+
+class TypeSupport {
+
+ static final TypeSupport INSTANCE;
+
+ static {
+ Method isSealed;
+ try {
+ isSealed = Class.class.getMethod("isSealed");
+ } catch (NoSuchMethodException ignored) {
+ isSealed = null;
+ }
+ INSTANCE = new TypeSupport(isSealed);
+ }
+
+ private final Method isSealed;
+
+ private TypeSupport(Method isSealed) {
+ this.isSealed = isSealed;
+ }
+
+ boolean isSealed(Class<?> type) {
+ if (isSealed == null) {
+ return false;
+ }
+ try {
+ return (boolean) isSealed.invoke(type);
+ } catch (Throwable t) {
+ throw new MockitoException(
+ "Failed to check if type is sealed using handle " + isSealed, t);
+ }
+ }
+}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.java b/src/main/java/org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.java
new file mode 100644
index 0000000..82db0ba
--- /dev/null
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy.inject;
+
+import java.lang.reflect.Method;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+public abstract class MockMethodDispatcher {
+
+ static {
+ ClassLoader classLoader = MockMethodDispatcher.class.getClassLoader();
+ if (classLoader != null) {
+ // Do not use Mockito classes in here as this is executed on the boot loader.
+ throw new IllegalStateException(
+ MockMethodDispatcher.class.getName()
+ + " is not loaded by the bootstrap class loader but by an instance of "
+ + classLoader.getClass().getName()
+ + ".\n\nThis causes the inline mock maker to not work as expected. "
+ + "Please contact the maintainer of this class loader implementation "
+ + "to assure that this class is never loaded by another class loader. "
+ + "The bootstrap class loader must always be queried first for this "
+ + "class for Mockito's inline mock maker to function correctly.");
+ }
+ }
+
+ private static final ConcurrentMap<String, MockMethodDispatcher> DISPATCHERS =
+ new ConcurrentHashMap<>();
+
+ public static MockMethodDispatcher get(String identifier, Object mock) {
+ if (mock == DISPATCHERS) {
+ // Avoid endless loop if ConcurrentHashMap was redefined to check for being a mock.
+ return null;
+ } else {
+ return DISPATCHERS.get(identifier);
+ }
+ }
+
+ public static MockMethodDispatcher getStatic(String identifier, Class<?> type) {
+ if (MockMethodDispatcher.class.isAssignableFrom(type) || type == ConcurrentHashMap.class) {
+ // Avoid endless loop for lookups of self.
+ return null;
+ } else {
+ return DISPATCHERS.get(identifier);
+ }
+ }
+
+ public static void set(String identifier, MockMethodDispatcher dispatcher) {
+ DISPATCHERS.putIfAbsent(identifier, dispatcher);
+ }
+
+ @SuppressWarnings("unused")
+ public static boolean isConstructorMock(String identifier, Class<?> type) {
+ return DISPATCHERS.get(identifier).isConstructorMock(type);
+ }
+
+ public abstract boolean isConstructorMock(Class<?> type);
+
+ @SuppressWarnings("unused")
+ public static Object handleConstruction(
+ String identifier,
+ Class<?> type,
+ Object object,
+ Object[] arguments,
+ String[] parameterTypeNames) {
+ return DISPATCHERS
+ .get(identifier)
+ .handleConstruction(type, object, arguments, parameterTypeNames);
+ }
+
+ public abstract Callable<?> handle(Object instance, Method origin, Object[] arguments)
+ throws Throwable;
+
+ public abstract Callable<?> handleStatic(Class<?> type, Method origin, Object[] arguments)
+ throws Throwable;
+
+ public abstract Object handleConstruction(
+ Class<?> type, Object object, Object[] arguments, String[] parameterTypeNames);
+
+ public abstract boolean isMock(Object instance);
+
+ public abstract boolean isMocked(Object instance);
+
+ public abstract boolean isMockedStatic(Class<?> type);
+
+ public abstract boolean isOverridden(Object instance, Method origin);
+}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/inject/package-info.java b/src/main/java/org/mockito/internal/creation/bytebuddy/inject/package-info.java
new file mode 100644
index 0000000..5abed05
--- /dev/null
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/inject/package-info.java
@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+/**
+ * Internal classes, not to be used by clients. Intended for injection into the bootstrap class loader.
+ *
+ * Subject to change at any time without notice.
+ */
+package org.mockito.internal.creation.bytebuddy.inject;
diff --git a/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java b/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java
index 688526b..c882704 100644
--- a/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java
+++ b/src/main/java/org/mockito/internal/creation/instance/ConstructorInstantiator.java
@@ -4,18 +4,19 @@
*/
package org.mockito.internal.creation.instance;
+import static org.mockito.internal.util.StringUtil.join;
+
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
-import org.mockito.creation.instance.Instantiator;
import org.mockito.creation.instance.InstantiationException;
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.util.Primitives;
-import org.mockito.internal.util.reflection.AccessibilityChanger;
-
-import static org.mockito.internal.util.StringUtil.join;
+import org.mockito.plugins.MemberAccessor;
public class ConstructorInstantiator implements Instantiator {
@@ -25,6 +26,7 @@
* If an outer inject exists, it would be the first ([0]) element of the {@link #constructorArgs} array.
*/
private final boolean hasOuterClassInstance;
+
private final Object[] constructorArgs;
public ConstructorInstantiator(boolean hasOuterClassInstance, Object... constructorArgs) {
@@ -32,12 +34,13 @@
this.constructorArgs = constructorArgs;
}
+ @Override
public <T> T newInstance(Class<T> cls) {
return withParams(cls, constructorArgs);
}
private <T> T withParams(Class<T> cls, Object... params) {
- List<Constructor<?>> matchingConstructors = new LinkedList<Constructor<?>>();
+ List<Constructor<?>> matchingConstructors = new LinkedList<>();
try {
for (Constructor<?> constructor : cls.getDeclaredConstructors()) {
Class<?>[] types = constructor.getParameterTypes();
@@ -52,7 +55,7 @@
} catch (Exception e) {
throw paramsException(cls, e);
}
- if (matchingConstructors.size() == 0) {
+ if (matchingConstructors.isEmpty()) {
throw noMatchingConstructor(cls);
} else {
throw multipleMatchingConstructors(cls, matchingConstructors);
@@ -60,17 +63,21 @@
}
@SuppressWarnings("unchecked")
- private static <T> T invokeConstructor(Constructor<?> constructor, Object... params) throws java.lang.InstantiationException, IllegalAccessException, InvocationTargetException {
- AccessibilityChanger accessibility = new AccessibilityChanger();
- accessibility.enableAccess(constructor);
- return (T) constructor.newInstance(params);
+ private static <T> T invokeConstructor(Constructor<?> constructor, Object... params)
+ throws java.lang.InstantiationException, IllegalAccessException,
+ InvocationTargetException {
+ MemberAccessor accessor = Plugins.getMemberAccessor();
+ return (T) accessor.newInstance(constructor, params);
}
private InstantiationException paramsException(Class<?> cls, Exception e) {
- return new InstantiationException(join(
- "Unable to create instance of '" + cls.getSimpleName() + "'.",
- "Please ensure the target class has " + constructorArgsString() + " and executes cleanly.")
- , e);
+ return new InstantiationException(
+ join(
+ "Unable to create instance of '" + cls.getSimpleName() + "'.",
+ "Please ensure the target class has "
+ + constructorArgsString()
+ + " and executes cleanly."),
+ e);
}
private String constructorArgTypes() {
@@ -80,7 +87,8 @@
}
String[] constructorArgTypes = new String[constructorArgs.length - argPos];
for (int i = argPos; i < constructorArgs.length; ++i) {
- constructorArgTypes[i - argPos] = constructorArgs[i] == null ? null : constructorArgs[i].getClass().getName();
+ constructorArgTypes[i - argPos] =
+ constructorArgs[i] == null ? null : constructorArgs[i].getClass().getName();
}
return Arrays.toString(constructorArgTypes);
}
@@ -91,9 +99,14 @@
if (hasOuterClassInstance) {
outerInstanceHint = " and provided outer instance is correct";
}
- return new InstantiationException(join("Unable to create instance of '" + cls.getSimpleName() + "'.",
- "Please ensure that the target class has " + constructorString + outerInstanceHint + ".")
- , null);
+ return new InstantiationException(
+ join(
+ "Unable to create instance of '" + cls.getSimpleName() + "'.",
+ "Please ensure that the target class has "
+ + constructorString
+ + outerInstanceHint
+ + "."),
+ null);
}
private String constructorArgsString() {
@@ -101,19 +114,25 @@
if (constructorArgs.length == 0 || (hasOuterClassInstance && constructorArgs.length == 1)) {
constructorString = "a 0-arg constructor";
} else {
- constructorString = "a constructor that matches these argument types: " + constructorArgTypes();
+ constructorString =
+ "a constructor that matches these argument types: " + constructorArgTypes();
}
return constructorString;
}
- private InstantiationException multipleMatchingConstructors(Class<?> cls, List<Constructor<?>> constructors) {
- return new InstantiationException(join("Unable to create instance of '" + cls.getSimpleName() + "'.",
- "Multiple constructors could be matched to arguments of types " + constructorArgTypes() + ":",
- join("", " - ", constructors),
- "If you believe that Mockito could do a better job deciding on which constructor to use, please let us know.",
- "Ticket 685 contains the discussion and a workaround for ambiguous constructors using inner class.",
- "See https://github.com/mockito/mockito/issues/685"
- ), null);
+ private InstantiationException multipleMatchingConstructors(
+ Class<?> cls, List<Constructor<?>> constructors) {
+ return new InstantiationException(
+ join(
+ "Unable to create instance of '" + cls.getSimpleName() + "'.",
+ "Multiple constructors could be matched to arguments of types "
+ + constructorArgTypes()
+ + ":",
+ join("", " - ", constructors),
+ "If you believe that Mockito could do a better job deciding on which constructor to use, please let us know.",
+ "Ticket 685 contains the discussion and a workaround for ambiguous constructors using inner class.",
+ "See https://github.com/mockito/mockito/issues/685"),
+ null);
}
private static boolean paramsMatch(Class<?>[] types, Object[] params) {
@@ -125,8 +144,10 @@
if (types[i].isPrimitive()) {
return false;
}
- } else if ((!types[i].isPrimitive() && !types[i].isInstance(params[i])) ||
- (types[i].isPrimitive() && !types[i].equals(Primitives.primitiveTypeOf(params[i].getClass())))) {
+ } else if ((!types[i].isPrimitive() && !types[i].isInstance(params[i]))
+ || (types[i].isPrimitive()
+ && !types[i].equals(
+ Primitives.primitiveTypeOf(params[i].getClass())))) {
return false;
}
}
@@ -156,7 +177,8 @@
* @param matchingConstructors A list of equivalently best matching constructors found so far
* @param constructor The constructor to be evaluated against this list
*/
- private void evaluateConstructor(List<Constructor<?>> matchingConstructors, Constructor<?> constructor) {
+ private void evaluateConstructor(
+ List<Constructor<?>> matchingConstructors, Constructor<?> constructor) {
boolean newHasBetterParam = false;
boolean existingHasBetterParam = false;
diff --git a/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java b/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java
index 9c414f3..af071bf 100644
--- a/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java
+++ b/src/main/java/org/mockito/internal/creation/instance/DefaultInstantiatorProvider.java
@@ -10,11 +10,13 @@
public class DefaultInstantiatorProvider implements InstantiatorProvider2 {
- private final static Instantiator INSTANCE = new ObjenesisInstantiator();
+ private static final Instantiator INSTANCE = new ObjenesisInstantiator();
+ @Override
public Instantiator getInstantiator(MockCreationSettings<?> settings) {
if (settings != null && settings.getConstructorArgs() != null) {
- return new ConstructorInstantiator(settings.getOuterClassInstance() != null, settings.getConstructorArgs());
+ return new ConstructorInstantiator(
+ settings.getOuterClassInstance() != null, settings.getConstructorArgs());
} else {
return INSTANCE;
}
diff --git a/src/main/java/org/mockito/internal/creation/instance/Instantiator.java b/src/main/java/org/mockito/internal/creation/instance/Instantiator.java
index 85b6b3d..3760124 100644
--- a/src/main/java/org/mockito/internal/creation/instance/Instantiator.java
+++ b/src/main/java/org/mockito/internal/creation/instance/Instantiator.java
@@ -14,9 +14,6 @@
@Deprecated
public interface Instantiator {
- /**
- * Creates instance of given class
- */
- <T> T newInstance(Class<T> cls) throws InstantiationException;
-
+ /** Creates instance of given class */
+ <T> T newInstance(Class<T> cls);
}
diff --git a/src/main/java/org/mockito/internal/creation/instance/InstantiatorProvider2Adapter.java b/src/main/java/org/mockito/internal/creation/instance/InstantiatorProvider2Adapter.java
index a1ab5d5..de764d7 100644
--- a/src/main/java/org/mockito/internal/creation/instance/InstantiatorProvider2Adapter.java
+++ b/src/main/java/org/mockito/internal/creation/instance/InstantiatorProvider2Adapter.java
@@ -22,7 +22,7 @@
public Instantiator getInstantiator(final MockCreationSettings<?> settings) {
return new Instantiator() {
@Override
- public <T> T newInstance(Class<T> cls) throws InstantiationException {
+ public <T> T newInstance(Class<T> cls) {
try {
return provider.getInstantiator(settings).newInstance(cls);
} catch (org.mockito.creation.instance.InstantiationException e) {
diff --git a/src/main/java/org/mockito/internal/creation/instance/InstantiatorProviderAdapter.java b/src/main/java/org/mockito/internal/creation/instance/InstantiatorProviderAdapter.java
index c807925..62e98ab 100644
--- a/src/main/java/org/mockito/internal/creation/instance/InstantiatorProviderAdapter.java
+++ b/src/main/java/org/mockito/internal/creation/instance/InstantiatorProviderAdapter.java
@@ -24,7 +24,7 @@
public Instantiator getInstantiator(final MockCreationSettings<?> settings) {
return new Instantiator() {
@Override
- public <T> T newInstance(Class<T> cls) throws InstantiationException {
+ public <T> T newInstance(Class<T> cls) {
try {
return provider.getInstantiator(settings).newInstance(cls);
} catch (org.mockito.internal.creation.instance.InstantiationException e) {
diff --git a/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java b/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java
index 7e41f68..deffbe9 100644
--- a/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java
+++ b/src/main/java/org/mockito/internal/creation/instance/ObjenesisInstantiator.java
@@ -10,11 +10,14 @@
class ObjenesisInstantiator implements Instantiator {
- //TODO: in order to provide decent exception message when objenesis is not found,
- //have a constructor in this class that tries to instantiate ObjenesisStd and if it fails then show decent exception that dependency is missing
- //TODO: for the same reason catch and give better feedback when hamcrest core is not found.
- private final ObjenesisStd objenesis = new ObjenesisStd(new GlobalConfiguration().enableClassCache());
+ // TODO: in order to provide decent exception message when objenesis is not found,
+ // have a constructor in this class that tries to instantiate ObjenesisStd and if it fails then
+ // show decent exception that dependency is missing
+ // TODO: for the same reason catch and give better feedback when hamcrest core is not found.
+ private final ObjenesisStd objenesis =
+ new ObjenesisStd(new GlobalConfiguration().enableClassCache());
+ @Override
public <T> T newInstance(Class<T> cls) {
return objenesis.newInstance(cls);
}
diff --git a/src/main/java/org/mockito/internal/creation/proxy/ProxyMockMaker.java b/src/main/java/org/mockito/internal/creation/proxy/ProxyMockMaker.java
new file mode 100644
index 0000000..96770d3
--- /dev/null
+++ b/src/main/java/org/mockito/internal/creation/proxy/ProxyMockMaker.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.proxy;
+
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.debugging.LocationImpl;
+import org.mockito.internal.invocation.RealMethod;
+import org.mockito.internal.invocation.SerializableMethod;
+import org.mockito.internal.util.Platform;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.MockMaker;
+
+import java.lang.reflect.*;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.mockito.internal.invocation.DefaultInvocationFactory.createInvocation;
+import static org.mockito.internal.util.StringUtil.join;
+
+/**
+ * A mock maker that is using the {@link Proxy} utility and is therefore only capable of mocking interfaces but
+ * does not rely on manual byte code generation but only uses official and public Java API.
+ */
+public class ProxyMockMaker implements MockMaker {
+
+ private static final Object[] EMPTY = new Object[0];
+
+ private final Method invokeDefault;
+
+ public ProxyMockMaker() {
+ Method m;
+ try {
+ m =
+ InvocationHandler.class.getMethod(
+ "invokeDefault", Object.class, Method.class, Object[].class);
+ } catch (NoSuchMethodException ignored) {
+ m = null;
+ }
+ invokeDefault = m;
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
+ Class<?>[] ifaces = new Class<?>[settings.getExtraInterfaces().size() + 1];
+ ifaces[0] = settings.getTypeToMock();
+ int index = 1;
+ for (Class<?> iface : settings.getExtraInterfaces()) {
+ ifaces[index++] = iface;
+ }
+ return (T)
+ Proxy.newProxyInstance(
+ settings.getTypeToMock().getClassLoader(),
+ ifaces,
+ new MockInvocationHandler(handler, settings));
+ }
+
+ @Override
+ public MockHandler getHandler(Object mock) {
+ if (!Proxy.isProxyClass(mock.getClass())) {
+ return null;
+ }
+ InvocationHandler handler = Proxy.getInvocationHandler(mock);
+ if (!(handler instanceof MockInvocationHandler)) {
+ return null;
+ }
+ return ((MockInvocationHandler) handler).handler.get();
+ }
+
+ @Override
+ public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
+ ((MockInvocationHandler) Proxy.getInvocationHandler(mock)).handler.set(newHandler);
+ }
+
+ @Override
+ public TypeMockability isTypeMockable(Class<?> type) {
+ return new TypeMockability() {
+ @Override
+ public boolean mockable() {
+ return type.isInterface();
+ }
+
+ @Override
+ public String nonMockableReason() {
+ return mockable() ? "" : "non-interface";
+ }
+ };
+ }
+
+ private class MockInvocationHandler implements InvocationHandler {
+
+ private final AtomicReference<MockHandler<?>> handler;
+
+ private final MockCreationSettings<?> settings;
+
+ private MockInvocationHandler(MockHandler<?> handler, MockCreationSettings<?> settings) {
+ this.handler = new AtomicReference<>(handler);
+ this.settings = settings;
+ }
+
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ if (args == null) {
+ args = EMPTY;
+ }
+ if (method.getDeclaringClass() == Object.class) {
+ switch (method.getName()) {
+ case "hashCode":
+ return System.identityHashCode(proxy);
+ case "equals":
+ return proxy == args[0];
+ case "toString":
+ break;
+ default:
+ throw new MockitoException(
+ join(
+ "Unexpected overridable method of Object class found",
+ "",
+ "The method "
+ + method
+ + " was not expected to be declared. Either your JVM build offers "
+ + "non-official API or the current functionality is not supported",
+ Platform.describe()));
+ }
+ }
+ RealMethod realMethod;
+ if (invokeDefault == null || Modifier.isAbstract(method.getModifiers())) {
+ realMethod = RealMethod.IsIllegal.INSTANCE;
+ } else {
+ realMethod = new RealDefaultMethod(proxy, method, args);
+ }
+ return handler.get()
+ .handle(
+ createInvocation(
+ proxy, method, args, realMethod, settings, new LocationImpl()));
+ }
+ }
+
+ private class RealDefaultMethod implements RealMethod {
+
+ private final Object proxy;
+ private final SerializableMethod serializableMethod;
+ private final Object[] args;
+
+ private RealDefaultMethod(Object proxy, Method method, Object[] args) {
+ this.proxy = proxy;
+ this.serializableMethod = new SerializableMethod(method);
+ this.args = args;
+ }
+
+ @Override
+ public boolean isInvokable() {
+ return true;
+ }
+
+ @Override
+ public Object invoke() throws Throwable {
+ try {
+ return invokeDefault.invoke(null, proxy, serializableMethod.getJavaMethod(), args);
+ } catch (InvocationTargetException e) {
+ throw e.getTargetException();
+ } catch (IllegalAccessException | IllegalArgumentException e) {
+ throw new MockitoException(
+ join(
+ "Failed to access default method or invoked method with illegal arguments",
+ "",
+ "Method "
+ + serializableMethod.getJavaMethod()
+ + " could not be delegated, this is not supposed to happen",
+ Platform.describe()),
+ e);
+ }
+ }
+ }
+}
diff --git a/src/main/java/org/mockito/internal/creation/proxy/package-info.java b/src/main/java/org/mockito/internal/creation/proxy/package-info.java
new file mode 100644
index 0000000..0649d3b
--- /dev/null
+++ b/src/main/java/org/mockito/internal/creation/proxy/package-info.java
@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+/**
+ * Mock makers based on the {@link java.lang.reflect.Proxy} utility.
+ */
+package org.mockito.internal.creation.proxy;
diff --git a/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java b/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
index 81f52f9..9da7311 100644
--- a/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
+++ b/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
@@ -4,34 +4,41 @@
*/
package org.mockito.internal.creation.settings;
-import org.mockito.internal.listeners.StubbingLookupListener;
-import org.mockito.listeners.InvocationListener;
-import org.mockito.listeners.VerificationStartedListener;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.mock.MockName;
-import org.mockito.mock.SerializableMode;
-import org.mockito.stubbing.Answer;
-
import java.io.Serializable;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.StubbingLookupListener;
+import org.mockito.listeners.VerificationStartedListener;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.MockName;
+import org.mockito.mock.SerializableMode;
+import org.mockito.stubbing.Answer;
public class CreationSettings<T> implements MockCreationSettings<T>, Serializable {
private static final long serialVersionUID = -6789800638070123629L;
protected Class<T> typeToMock;
- protected Set<Class<?>> extraInterfaces = new LinkedHashSet<Class<?>>();
+ protected Set<Class<?>> extraInterfaces = new LinkedHashSet<>();
protected String name;
protected Object spiedInstance;
protected Answer<Object> defaultAnswer;
protected MockName mockName;
protected SerializableMode serializableMode = SerializableMode.NONE;
- protected List<InvocationListener> invocationListeners = new ArrayList<InvocationListener>();
- protected final List<StubbingLookupListener> stubbingLookupListeners = new ArrayList<StubbingLookupListener>();
- protected List<VerificationStartedListener> verificationStartedListeners = new LinkedList<VerificationStartedListener>();
+ protected List<InvocationListener> invocationListeners = new ArrayList<>();
+
+ // Other listeners in this class may also need concurrency-safe implementation. However, no
+ // issue was reported about it.
+ // If we do it, we need to understand usage patterns and choose the right concurrent
+ // implementation.
+ protected List<StubbingLookupListener> stubbingLookupListeners = new CopyOnWriteArrayList<>();
+
+ protected List<VerificationStartedListener> verificationStartedListeners = new LinkedList<>();
protected boolean stubOnly;
protected boolean stripAnnotations;
private boolean useConstructor;
@@ -43,6 +50,7 @@
@SuppressWarnings("unchecked")
public CreationSettings(CreationSettings copy) {
+ // TODO can we have a reflection test here? We had a couple of bugs here in the past.
this.typeToMock = copy.typeToMock;
this.extraInterfaces = copy.extraInterfaces;
this.name = copy.name;
@@ -51,6 +59,7 @@
this.mockName = copy.mockName;
this.serializableMode = copy.serializableMode;
this.invocationListeners = copy.invocationListeners;
+ this.stubbingLookupListeners = copy.stubbingLookupListeners;
this.verificationStartedListeners = copy.verificationStartedListeners;
this.stubOnly = copy.stubOnly;
this.useConstructor = copy.isUsingConstructor();
@@ -104,6 +113,7 @@
return this;
}
+ @Override
public boolean isSerializable() {
return serializableMode != SerializableMode.NONE;
}
@@ -128,6 +138,7 @@
return verificationStartedListeners;
}
+ @Override
public List<StubbingLookupListener> getStubbingLookupListeners() {
return stubbingLookupListeners;
}
diff --git a/src/main/java/org/mockito/internal/creation/util/MockitoMethodProxy.java b/src/main/java/org/mockito/internal/creation/util/MockitoMethodProxy.java
index 585a0c1..21642e4 100644
--- a/src/main/java/org/mockito/internal/creation/util/MockitoMethodProxy.java
+++ b/src/main/java/org/mockito/internal/creation/util/MockitoMethodProxy.java
@@ -4,7 +4,7 @@
*/
package org.mockito.internal.creation.util;
-//TODO SF Replace with RealMethod and get rid of (possibly).
+// TODO SF Replace with RealMethod and get rid of (possibly).
public interface MockitoMethodProxy {
Object invokeSuper(Object target, Object[] arguments);
}
diff --git a/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java b/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java
index 04a4f1d..7e26169 100644
--- a/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java
+++ b/src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java
@@ -4,14 +4,14 @@
*/
package org.mockito.internal.debugging;
+import java.util.Collection;
+import java.util.LinkedList;
+
import org.mockito.Mockito;
import org.mockito.internal.util.collections.ListUtil;
import org.mockito.invocation.Invocation;
import org.mockito.stubbing.Stubbing;
-import java.util.Collection;
-import java.util.LinkedList;
-
/**
* Prints invocations in human-readable, printable way
*/
@@ -26,22 +26,26 @@
StringBuilder sb = new StringBuilder();
int x = 1;
- for(Invocation i:invocations) {
+ for (Invocation i : invocations) {
if (x == 1) {
sb.append("[Mockito] Interactions of: ").append(mock).append("\n");
}
- sb.append(" ").append(x++).append(". ").append(i.toString()).append("\n");
+ sb.append(" ").append(x++).append(". ").append(i).append("\n");
sb.append(" ").append(i.getLocation()).append("\n");
if (i.stubInfo() != null) {
sb.append(" - stubbed ").append(i.stubInfo().stubbedAt()).append("\n");
}
}
- LinkedList<Stubbing> unused = ListUtil.filter(stubbings, new ListUtil.Filter<Stubbing>() {
- public boolean isOut(Stubbing s) {
- return s.wasUsed();
- }
- });
+ LinkedList<Stubbing> unused =
+ ListUtil.filter(
+ stubbings,
+ new ListUtil.Filter<Stubbing>() {
+ @Override
+ public boolean isOut(Stubbing s) {
+ return s.wasUsed();
+ }
+ });
if (unused.isEmpty()) {
return sb.toString();
@@ -49,7 +53,7 @@
sb.append("[Mockito] Unused stubbings of: ").append(mock).append("\n");
x = 1;
- for(Stubbing s:stubbings) {
+ for (Stubbing s : stubbings) {
sb.append(" ").append(x++).append(". ").append(s.getInvocation()).append("\n");
sb.append(" - stubbed ").append(s.getInvocation().getLocation()).append("\n");
}
diff --git a/src/main/java/org/mockito/internal/debugging/Localized.java b/src/main/java/org/mockito/internal/debugging/Localized.java
index 0588042..d1d7912 100644
--- a/src/main/java/org/mockito/internal/debugging/Localized.java
+++ b/src/main/java/org/mockito/internal/debugging/Localized.java
@@ -4,7 +4,6 @@
*/
package org.mockito.internal.debugging;
-
import org.mockito.invocation.Location;
public class Localized<T> {
diff --git a/src/main/java/org/mockito/internal/debugging/LocationImpl.java b/src/main/java/org/mockito/internal/debugging/LocationImpl.java
index 8561b62..cf25501 100644
--- a/src/main/java/org/mockito/internal/debugging/LocationImpl.java
+++ b/src/main/java/org/mockito/internal/debugging/LocationImpl.java
@@ -5,42 +5,63 @@
package org.mockito.internal.debugging;
import java.io.Serializable;
+
import org.mockito.internal.exceptions.stacktrace.StackTraceFilter;
import org.mockito.invocation.Location;
public class LocationImpl implements Location, Serializable {
private static final long serialVersionUID = -9054861157390980624L;
- //Limit the amount of objects being created, as this class is heavily instantiated:
- private static final StackTraceFilter defaultStackTraceFilter = new StackTraceFilter();
+ // Limit the amount of objects being created, as this class is heavily instantiated:
+ private static final StackTraceFilter stackTraceFilter = new StackTraceFilter();
- private final Throwable stackTraceHolder;
- private final StackTraceFilter stackTraceFilter;
+ private String stackTraceLine;
+ private String sourceFile;
public LocationImpl() {
- this(defaultStackTraceFilter);
+ this(new Throwable(), false);
+ }
+
+ public LocationImpl(Throwable stackTraceHolder, boolean isInline) {
+ this(stackTraceFilter, stackTraceHolder, isInline);
}
public LocationImpl(StackTraceFilter stackTraceFilter) {
- this(stackTraceFilter, new Throwable());
+ this(stackTraceFilter, new Throwable(), false);
}
- public LocationImpl(Throwable stackTraceHolder) {
- this(defaultStackTraceFilter, stackTraceHolder);
- }
-
- private LocationImpl(StackTraceFilter stackTraceFilter, Throwable stackTraceHolder) {
- this.stackTraceFilter = stackTraceFilter;
- this.stackTraceHolder = stackTraceHolder;
+ private LocationImpl(
+ StackTraceFilter stackTraceFilter, Throwable stackTraceHolder, boolean isInline) {
+ computeStackTraceInformation(stackTraceFilter, stackTraceHolder, isInline);
}
@Override
public String toString() {
- //TODO SF perhaps store the results after invocation?
- StackTraceElement[] filtered = stackTraceFilter.filter(stackTraceHolder.getStackTrace(), false);
- if (filtered.length == 0) {
- return "-> at <<unknown line>>";
+ return stackTraceLine;
+ }
+
+ /**
+ * Eagerly compute the stacktrace line from the stackTraceHolder. Storing the Throwable is
+ * memory-intensive for tests that have large stacktraces and have a lot of invocations on
+ * mocks.
+ */
+ private void computeStackTraceInformation(
+ StackTraceFilter stackTraceFilter, Throwable stackTraceHolder, boolean isInline) {
+ StackTraceElement filtered = stackTraceFilter.filterFirst(stackTraceHolder, isInline);
+
+ // there are corner cases where exception can have a null or empty stack trace
+ // for example, a custom exception can override getStackTrace() method
+ if (filtered == null) {
+ this.stackTraceLine = "-> at <<unknown line>>";
+ this.sourceFile = "<unknown source file>";
+ } else {
+ this.stackTraceLine = "-> at " + filtered;
+ this.sourceFile = filtered.getFileName();
}
- return "-> at " + filtered[0].toString();
+ }
+
+ @Override
+ public String getSourceFile() {
+ return sourceFile;
}
}
diff --git a/src/main/java/org/mockito/internal/debugging/LoggingListener.java b/src/main/java/org/mockito/internal/debugging/LoggingListener.java
index d014e87..6e0a645 100644
--- a/src/main/java/org/mockito/internal/debugging/LoggingListener.java
+++ b/src/main/java/org/mockito/internal/debugging/LoggingListener.java
@@ -4,35 +4,37 @@
*/
package org.mockito.internal.debugging;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.invocation.Invocation;
+import static org.mockito.internal.util.StringUtil.join;
import java.util.LinkedList;
import java.util.List;
-import static org.mockito.internal.util.StringUtil.join;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.invocation.Invocation;
public class LoggingListener implements FindingsListener {
private final boolean warnAboutUnstubbed;
- private final List<String> argMismatchStubs = new LinkedList<String>();
- private final List<String> unusedStubs = new LinkedList<String>();
- private final List<String> unstubbedCalls = new LinkedList<String>();
+ private final List<String> argMismatchStubs = new LinkedList<>();
+ private final List<String> unusedStubs = new LinkedList<>();
+ private final List<String> unstubbedCalls = new LinkedList<>();
public LoggingListener(boolean warnAboutUnstubbed) {
this.warnAboutUnstubbed = warnAboutUnstubbed;
}
+ @Override
public void foundStubCalledWithDifferentArgs(Invocation unused, InvocationMatcher unstubbed) {
- //TODO there is not good reason we should get Invocation and InvocationMatcher here
+ // TODO there is not good reason we should get Invocation and InvocationMatcher here
// we should pass 2 InvocationMatchers and testing is easier
- // it's also confusing that unstubbed invocation is passed as InvocationMatcher (should be rather Invocation)
+ // it's also confusing that unstubbed invocation is passed as InvocationMatcher (should be
+ // rather Invocation)
- //this information comes in pairs
+ // this information comes in pairs
String index = Integer.toString(indexOfNextPair(argMismatchStubs.size()));
- //making sure indentation is correct
+ // making sure indentation is correct
String padding = index.replaceAll("\\d", " ");
- argMismatchStubs.add(index + ". Stubbed " + unused.getLocation());
+ argMismatchStubs.add(index + ". Stubbed " + unused.getLocation());
argMismatchStubs.add(padding + " Invoked " + unstubbed.getInvocation().getLocation());
}
@@ -40,13 +42,16 @@
return (collectionSize / 2) + 1;
}
+ @Override
public void foundUnusedStub(Invocation unused) {
unusedStubs.add((unusedStubs.size() + 1) + ". " + unused.getLocation());
}
+ @Override
public void foundUnstubbed(InvocationMatcher unstubbed) {
if (warnAboutUnstubbed) {
- unstubbedCalls.add((unstubbedCalls.size() + 1) + ". " + unstubbed.getInvocation().getLocation());
+ unstubbedCalls.add(
+ (unstubbedCalls.size() + 1) + ". " + unstubbed.getInvocation().getLocation());
}
}
@@ -55,12 +60,14 @@
return "";
}
- List<String> lines = new LinkedList<String>();
- lines.add("[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):");
+ List<String> lines = new LinkedList<>();
+ lines.add(
+ "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):");
if (!argMismatchStubs.isEmpty()) {
lines.add("[Mockito]");
- lines.add("[Mockito] Argument mismatch between stubbing and actual invocation (is stubbing correct in the test?):");
+ lines.add(
+ "[Mockito] Argument mismatch between stubbing and actual invocation (is stubbing correct in the test?):");
lines.add("[Mockito]");
addOrderedList(lines, argMismatchStubs);
}
@@ -74,7 +81,8 @@
if (!unstubbedCalls.isEmpty()) {
lines.add("[Mockito]");
- lines.add("[Mockito] Unstubbed method invocations (perhaps missing stubbing in the test?):");
+ lines.add(
+ "[Mockito] Unstubbed method invocations (perhaps missing stubbing in the test?):");
lines.add("[Mockito]");
addOrderedList(lines, unstubbedCalls);
}
diff --git a/src/main/java/org/mockito/internal/debugging/MockitoDebuggerImpl.java b/src/main/java/org/mockito/internal/debugging/MockitoDebuggerImpl.java
index c14f0ab..7300b20 100644
--- a/src/main/java/org/mockito/internal/debugging/MockitoDebuggerImpl.java
+++ b/src/main/java/org/mockito/internal/debugging/MockitoDebuggerImpl.java
@@ -4,15 +4,15 @@
*/
package org.mockito.internal.debugging;
+import static java.util.Arrays.asList;
+
+import java.util.List;
+
import org.mockito.MockitoDebugger;
import org.mockito.internal.invocation.UnusedStubsFinder;
import org.mockito.internal.invocation.finder.AllInvocationsFinder;
import org.mockito.invocation.Invocation;
-import java.util.List;
-
-import static java.util.Arrays.asList;
-
public class MockitoDebuggerImpl implements MockitoDebugger {
private final UnusedStubsFinder unusedStubsFinder = new UnusedStubsFinder();
@@ -21,17 +21,17 @@
* TODO: when MockitoDebugger is deleted, delete this implementation, too
*/
@Deprecated
- public String printInvocations(Object ... mocks) {
+ public String printInvocations(Object... mocks) {
String out = "";
List<Invocation> invocations = AllInvocationsFinder.find(asList(mocks));
out += line("********************************");
out += line("*** Mockito interactions log ***");
out += line("********************************");
- for(Invocation i:invocations) {
+ for (Invocation i : invocations) {
out += line(i.toString());
out += line(" invoked: " + i.getLocation());
if (i.stubInfo() != null) {
- out += line(" stubbed: " + i.stubInfo().stubbedAt().toString());
+ out += line(" stubbed: " + i.stubInfo().stubbedAt());
}
}
@@ -43,7 +43,7 @@
out += line("*** Unused stubs ***");
out += line("********************************");
- for(Invocation i:invocations) {
+ for (Invocation i : invocations) {
out += line(i.toString());
out += line(" stubbed: " + i.getLocation());
}
diff --git a/src/main/java/org/mockito/internal/debugging/VerboseMockInvocationLogger.java b/src/main/java/org/mockito/internal/debugging/VerboseMockInvocationLogger.java
index c7b6ff6..a78be31 100644
--- a/src/main/java/org/mockito/internal/debugging/VerboseMockInvocationLogger.java
+++ b/src/main/java/org/mockito/internal/debugging/VerboseMockInvocationLogger.java
@@ -2,10 +2,10 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.debugging;
import java.io.PrintStream;
+
import org.mockito.invocation.DescribedInvocation;
import org.mockito.listeners.InvocationListener;
import org.mockito.listeners.MethodInvocationReport;
@@ -30,6 +30,7 @@
this.printStream = printStream;
}
+ @Override
public void reportInvocation(MethodInvocationReport methodInvocationReport) {
printHeader();
printStubInfo(methodInvocationReport);
@@ -40,11 +41,21 @@
private void printReturnedValueOrThrowable(MethodInvocationReport methodInvocationReport) {
if (methodInvocationReport.threwException()) {
- String message = methodInvocationReport.getThrowable().getMessage() == null ? "" : " with message " + methodInvocationReport.getThrowable().getMessage();
- printlnIndented("has thrown: " + methodInvocationReport.getThrowable().getClass() + message);
+ String message =
+ methodInvocationReport.getThrowable().getMessage() == null
+ ? ""
+ : " with message " + methodInvocationReport.getThrowable().getMessage();
+ printlnIndented(
+ "has thrown: " + methodInvocationReport.getThrowable().getClass() + message);
} else {
- String type = (methodInvocationReport.getReturnedValue() == null) ? "" : " (" + methodInvocationReport.getReturnedValue().getClass().getName() + ")";
- printlnIndented("has returned: \"" + methodInvocationReport.getReturnedValue() + "\"" + type);
+ String type =
+ (methodInvocationReport.getReturnedValue() == null)
+ ? ""
+ : " ("
+ + methodInvocationReport.getReturnedValue().getClass().getName()
+ + ")";
+ printlnIndented(
+ "has returned: \"" + methodInvocationReport.getReturnedValue() + "\"" + type);
}
}
@@ -56,21 +67,23 @@
private void printHeader() {
mockInvocationsCounter++;
- printStream.println("############ Logging method invocation #" + mockInvocationsCounter + " on mock/spy ########");
+ printStream.println(
+ "############ Logging method invocation #"
+ + mockInvocationsCounter
+ + " on mock/spy ########");
}
private void printInvocation(DescribedInvocation invocation) {
- printStream.println(invocation.toString());
-// printStream.println("Handling method call on a mock/spy.");
- printlnIndented("invoked: " + invocation.getLocation().toString());
+ printStream.println(invocation);
+ // printStream.println("Handling method call on a mock/spy.");
+ printlnIndented("invoked: " + invocation.getLocation());
}
private void printFooter() {
- printStream.println("");
+ printStream.println();
}
private void printlnIndented(String message) {
printStream.println(" " + message);
}
-
}
diff --git a/src/main/java/org/mockito/internal/debugging/WarningsCollector.java b/src/main/java/org/mockito/internal/debugging/WarningsCollector.java
index 3fb3e0e..5c6b8f0 100644
--- a/src/main/java/org/mockito/internal/debugging/WarningsCollector.java
+++ b/src/main/java/org/mockito/internal/debugging/WarningsCollector.java
@@ -4,21 +4,21 @@
*/
package org.mockito.internal.debugging;
+import java.util.LinkedList;
+import java.util.List;
+
import org.mockito.internal.invocation.InvocationMatcher;
import org.mockito.internal.invocation.UnusedStubsFinder;
import org.mockito.internal.invocation.finder.AllInvocationsFinder;
import org.mockito.invocation.Invocation;
-import java.util.LinkedList;
-import java.util.List;
-
@Deprecated
public class WarningsCollector {
private final List<Object> createdMocks;
public WarningsCollector() {
- createdMocks = new LinkedList<Object>();
+ createdMocks = new LinkedList<>();
}
public String getWarnings() {
diff --git a/src/main/java/org/mockito/internal/debugging/WarningsFinder.java b/src/main/java/org/mockito/internal/debugging/WarningsFinder.java
index 8b7c457..c766366 100644
--- a/src/main/java/org/mockito/internal/debugging/WarningsFinder.java
+++ b/src/main/java/org/mockito/internal/debugging/WarningsFinder.java
@@ -4,13 +4,13 @@
*/
package org.mockito.internal.debugging;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.invocation.Invocation;
-
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.invocation.Invocation;
+
public class WarningsFinder {
private final List<Invocation> baseUnusedStubs;
private final List<InvocationMatcher> baseAllInvocations;
@@ -21,16 +21,16 @@
}
public void find(FindingsListener findingsListener) {
- List<Invocation> unusedStubs = new LinkedList<Invocation>(this.baseUnusedStubs);
- List<InvocationMatcher> allInvocations = new LinkedList<InvocationMatcher>(this.baseAllInvocations);
+ List<Invocation> unusedStubs = new LinkedList<>(this.baseUnusedStubs);
+ List<InvocationMatcher> allInvocations = new LinkedList<>(this.baseAllInvocations);
Iterator<Invocation> unusedIterator = unusedStubs.iterator();
- while(unusedIterator.hasNext()) {
+ while (unusedIterator.hasNext()) {
Invocation unused = unusedIterator.next();
Iterator<InvocationMatcher> unstubbedIterator = allInvocations.iterator();
- while(unstubbedIterator.hasNext()) {
+ while (unstubbedIterator.hasNext()) {
InvocationMatcher unstubbed = unstubbedIterator.next();
- if(unstubbed.hasSimilarMethod(unused)) {
+ if (unstubbed.hasSimilarMethod(unused)) {
findingsListener.foundStubCalledWithDifferentArgs(unused, unstubbed);
unusedIterator.remove();
unstubbedIterator.remove();
diff --git a/src/main/java/org/mockito/internal/debugging/WarningsPrinterImpl.java b/src/main/java/org/mockito/internal/debugging/WarningsPrinterImpl.java
index ca18e85..e02e139 100644
--- a/src/main/java/org/mockito/internal/debugging/WarningsPrinterImpl.java
+++ b/src/main/java/org/mockito/internal/debugging/WarningsPrinterImpl.java
@@ -4,17 +4,20 @@
*/
package org.mockito.internal.debugging;
+import java.util.List;
+
import org.mockito.internal.invocation.InvocationMatcher;
import org.mockito.invocation.Invocation;
-import java.util.List;
-
public class WarningsPrinterImpl {
private final boolean warnAboutUnstubbed;
private final WarningsFinder finder;
- public WarningsPrinterImpl(List<Invocation> unusedStubs, List<InvocationMatcher> allInvocations, boolean warnAboutUnstubbed) {
+ public WarningsPrinterImpl(
+ List<Invocation> unusedStubs,
+ List<InvocationMatcher> allInvocations,
+ boolean warnAboutUnstubbed) {
this(warnAboutUnstubbed, new WarningsFinder(unusedStubs, allInvocations));
}
diff --git a/src/main/java/org/mockito/internal/exceptions/Reporter.java b/src/main/java/org/mockito/internal/exceptions/Reporter.java
index 38135a0..b22e128 100644
--- a/src/main/java/org/mockito/internal/exceptions/Reporter.java
+++ b/src/main/java/org/mockito/internal/exceptions/Reporter.java
@@ -2,17 +2,24 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.exceptions;
+import static org.mockito.internal.reporting.Pluralizer.pluralize;
+import static org.mockito.internal.reporting.Pluralizer.were_exactly_x_interactions;
+import static org.mockito.internal.util.StringUtil.join;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.*;
import org.mockito.exceptions.base.MockitoAssertionError;
import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.base.MockitoInitializationException;
import org.mockito.exceptions.misusing.*;
import org.mockito.exceptions.verification.MoreThanAllowedActualInvocations;
import org.mockito.exceptions.verification.NeverWantedButInvoked;
import org.mockito.exceptions.verification.NoInteractionsWanted;
import org.mockito.exceptions.verification.SmartNullPointerException;
-import org.mockito.exceptions.verification.TooLittleActualInvocations;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
import org.mockito.exceptions.verification.TooManyActualInvocations;
import org.mockito.exceptions.verification.VerificationInOrderFailure;
import org.mockito.exceptions.verification.WantedButNotInvoked;
@@ -26,19 +33,8 @@
import org.mockito.invocation.InvocationOnMock;
import org.mockito.invocation.Location;
import org.mockito.listeners.InvocationListener;
-import org.mockito.mock.MockName;
import org.mockito.mock.SerializableMode;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-import static org.mockito.internal.reporting.Pluralizer.pluralize;
-import static org.mockito.internal.reporting.Pluralizer.were_exactly_x_interactions;
-import static org.mockito.internal.util.StringUtil.join;
-
/**
* Reports verification and misusing errors.
* <p>
@@ -52,283 +48,314 @@
*/
public class Reporter {
- private final static String NON_PUBLIC_PARENT = "Mocking methods declared on non-public parent classes is not supported.";
+ private static final String NON_PUBLIC_PARENT =
+ "Mocking methods declared on non-public parent classes is not supported.";
- private Reporter() {
- }
+ private Reporter() {}
public static MockitoException checkedExceptionInvalid(Throwable t) {
- return new MockitoException(join(
- "Checked exception is invalid for this method!",
- "Invalid: " + t
- ));
+ return new MockitoException(
+ join("Checked exception is invalid for this method!", "Invalid: " + t));
}
public static MockitoException cannotStubWithNullThrowable() {
- return new MockitoException(join(
- "Cannot stub with null throwable!"
- ));
-
+ return new MockitoException(join("Cannot stub with null throwable!"));
}
public static MockitoException unfinishedStubbing(Location location) {
- return new UnfinishedStubbingException(join(
- "Unfinished stubbing detected here:",
- location,
- "",
- "E.g. thenReturn() may be missing.",
- "Examples of correct stubbing:",
- " when(mock.isOk()).thenReturn(true);",
- " when(mock.isOk()).thenThrow(exception);",
- " doThrow(exception).when(mock).someVoidMethod();",
- "Hints:",
- " 1. missing thenReturn()",
- " 2. you are trying to stub a final method, which is not supported",
- " 3: you are stubbing the behaviour of another mock inside before 'thenReturn' instruction if completed",
- ""
- ));
+ return new UnfinishedStubbingException(
+ join(
+ "Unfinished stubbing detected here:",
+ location,
+ "",
+ "E.g. thenReturn() may be missing.",
+ "Examples of correct stubbing:",
+ " when(mock.isOk()).thenReturn(true);",
+ " when(mock.isOk()).thenThrow(exception);",
+ " doThrow(exception).when(mock).someVoidMethod();",
+ "Hints:",
+ " 1. missing thenReturn()",
+ " 2. you are trying to stub a final method, which is not supported",
+ " 3. you are stubbing the behaviour of another mock inside before 'thenReturn' instruction is completed",
+ ""));
}
public static MockitoException incorrectUseOfApi() {
- return new MockitoException(join(
- "Incorrect use of API detected here:",
- new LocationImpl(),
- "",
- "You probably stored a reference to OngoingStubbing returned by when() and called stubbing methods like thenReturn() on this reference more than once.",
- "Examples of correct usage:",
- " when(mock.isOk()).thenReturn(true).thenReturn(false).thenThrow(exception);",
- " when(mock.isOk()).thenReturn(true, false).thenThrow(exception);",
- ""
- ));
+ return new MockitoException(
+ join(
+ "Incorrect use of API detected here:",
+ new LocationImpl(),
+ "",
+ "You probably stored a reference to OngoingStubbing returned by when() and called stubbing methods like thenReturn() on this reference more than once.",
+ "Examples of correct usage:",
+ " when(mock.isOk()).thenReturn(true).thenReturn(false).thenThrow(exception);",
+ " when(mock.isOk()).thenReturn(true, false).thenThrow(exception);",
+ ""));
}
public static MockitoException missingMethodInvocation() {
- return new MissingMethodInvocationException(join(
- "when() requires an argument which has to be 'a method call on a mock'.",
- "For example:",
- " when(mock.getArticles()).thenReturn(articles);",
- "",
- "Also, this error might show up because:",
- "1. you stub either of: final/private/equals()/hashCode() methods.",
- " Those methods *cannot* be stubbed/verified.",
- " " + NON_PUBLIC_PARENT,
- "2. inside when() you don't call method on mock but on some other object.",
- ""
- ));
+ return new MissingMethodInvocationException(
+ join(
+ "when() requires an argument which has to be 'a method call on a mock'.",
+ "For example:",
+ " when(mock.getArticles()).thenReturn(articles);",
+ "",
+ "Also, this error might show up because:",
+ "1. you stub either of: final/private/equals()/hashCode() methods.",
+ " Those methods *cannot* be stubbed/verified.",
+ " " + NON_PUBLIC_PARENT,
+ "2. inside when() you don't call method on mock but on some other object.",
+ ""));
}
public static MockitoException unfinishedVerificationException(Location location) {
- return new UnfinishedVerificationException(join(
- "Missing method call for verify(mock) here:",
- location,
- "",
- "Example of correct verification:",
- " verify(mock).doSomething()",
- "",
- "Also, this error might show up because you verify either of: final/private/equals()/hashCode() methods.",
- "Those methods *cannot* be stubbed/verified.",
- NON_PUBLIC_PARENT,
- ""
- ));
+ return new UnfinishedVerificationException(
+ join(
+ "Missing method call for verify(mock) here:",
+ location,
+ "",
+ "Example of correct verification:",
+ " verify(mock).doSomething()",
+ "",
+ "Also, this error might show up because you verify either of: final/private/equals()/hashCode() methods.",
+ "Those methods *cannot* be stubbed/verified.",
+ NON_PUBLIC_PARENT,
+ ""));
}
public static MockitoException notAMockPassedToVerify(Class<?> type) {
- return new NotAMockException(join(
- "Argument passed to verify() is of type " + type.getSimpleName() + " and is not a mock!",
- "Make sure you place the parenthesis correctly!",
- "See the examples of correct verifications:",
- " verify(mock).someMethod();",
- " verify(mock, times(10)).someMethod();",
- " verify(mock, atLeastOnce()).someMethod();"
- ));
+ return new NotAMockException(
+ join(
+ "Argument passed to verify() is of type "
+ + type.getSimpleName()
+ + " and is not a mock!",
+ "Make sure you place the parenthesis correctly!",
+ "See the examples of correct verifications:",
+ " verify(mock).someMethod();",
+ " verify(mock, times(10)).someMethod();",
+ " verify(mock, atLeastOnce()).someMethod();"));
}
public static MockitoException nullPassedToVerify() {
- return new NullInsteadOfMockException(join(
- "Argument passed to verify() should be a mock but is null!",
- "Examples of correct verifications:",
- " verify(mock).someMethod();",
- " verify(mock, times(10)).someMethod();",
- " verify(mock, atLeastOnce()).someMethod();",
- " not: verify(mock.someMethod());",
- "Also, if you use @Mock annotation don't miss initMocks()"
- ));
+ return new NullInsteadOfMockException(
+ join(
+ "Argument passed to verify() should be a mock but is null!",
+ "Examples of correct verifications:",
+ " verify(mock).someMethod();",
+ " verify(mock, times(10)).someMethod();",
+ " verify(mock, atLeastOnce()).someMethod();",
+ " not: verify(mock.someMethod());",
+ "Also, if you use @Mock annotation don't miss openMocks()"));
}
public static MockitoException notAMockPassedToWhenMethod() {
- return new NotAMockException(join(
- "Argument passed to when() is not a mock!",
- "Example of correct stubbing:",
- " doThrow(new RuntimeException()).when(mock).someMethod();"
- ));
+ return new NotAMockException(
+ join(
+ "Argument passed to when() is not a mock!",
+ "Example of correct stubbing:",
+ " doThrow(new RuntimeException()).when(mock).someMethod();"));
}
public static MockitoException nullPassedToWhenMethod() {
- return new NullInsteadOfMockException(join(
- "Argument passed to when() is null!",
- "Example of correct stubbing:",
- " doThrow(new RuntimeException()).when(mock).someMethod();",
- "Also, if you use @Mock annotation don't miss initMocks()"
- ));
+ return new NullInsteadOfMockException(
+ join(
+ "Argument passed to when() is null!",
+ "Example of correct stubbing:",
+ " doThrow(new RuntimeException()).when(mock).someMethod();",
+ "Also, if you use @Mock annotation don't miss openMocks()"));
}
public static MockitoException mocksHaveToBePassedToVerifyNoMoreInteractions() {
- return new MockitoException(join(
- "Method requires argument(s)!",
- "Pass mocks that should be verified, e.g:",
- " verifyNoMoreInteractions(mockOne, mockTwo);",
- " verifyZeroInteractions(mockOne, mockTwo);",
- ""
- ));
+ return new MockitoException(
+ join(
+ "Method requires argument(s)!",
+ "Pass mocks that should be verified, e.g:",
+ " verifyNoMoreInteractions(mockOne, mockTwo);",
+ " verifyNoInteractions(mockOne, mockTwo);",
+ ""));
}
public static MockitoException notAMockPassedToVerifyNoMoreInteractions() {
- return new NotAMockException(join(
- "Argument(s) passed is not a mock!",
- "Examples of correct verifications:",
- " verifyNoMoreInteractions(mockOne, mockTwo);",
- " verifyZeroInteractions(mockOne, mockTwo);",
- ""
- ));
+ return new NotAMockException(
+ join(
+ "Argument(s) passed is not a mock!",
+ "Examples of correct verifications:",
+ " verifyNoMoreInteractions(mockOne, mockTwo);",
+ " verifyNoInteractions(mockOne, mockTwo);",
+ ""));
}
public static MockitoException nullPassedToVerifyNoMoreInteractions() {
- return new NullInsteadOfMockException(join(
- "Argument(s) passed is null!",
- "Examples of correct verifications:",
- " verifyNoMoreInteractions(mockOne, mockTwo);",
- " verifyZeroInteractions(mockOne, mockTwo);"
- ));
+ return new NullInsteadOfMockException(
+ join(
+ "Argument(s) passed is null!",
+ "Examples of correct verifications:",
+ " verifyNoMoreInteractions(mockOne, mockTwo);",
+ " verifyNoInteractions(mockOne, mockTwo);"));
}
public static MockitoException notAMockPassedWhenCreatingInOrder() {
- return new NotAMockException(join(
- "Argument(s) passed is not a mock!",
- "Pass mocks that require verification in order.",
- "For example:",
- " InOrder inOrder = inOrder(mockOne, mockTwo);"
- ));
+ return new NotAMockException(
+ join(
+ "Argument(s) passed is not a mock!",
+ "Pass mocks that require verification in order.",
+ "For example:",
+ " InOrder inOrder = inOrder(mockOne, mockTwo);"));
}
public static MockitoException nullPassedWhenCreatingInOrder() {
- return new NullInsteadOfMockException(join(
- "Argument(s) passed is null!",
- "Pass mocks that require verification in order.",
- "For example:",
- " InOrder inOrder = inOrder(mockOne, mockTwo);"
- ));
+ return new NullInsteadOfMockException(
+ join(
+ "Argument(s) passed is null!",
+ "Pass mocks that require verification in order.",
+ "For example:",
+ " InOrder inOrder = inOrder(mockOne, mockTwo);"));
}
public static MockitoException mocksHaveToBePassedWhenCreatingInOrder() {
- return new MockitoException(join(
- "Method requires argument(s)!",
- "Pass mocks that require verification in order.",
- "For example:",
- " InOrder inOrder = inOrder(mockOne, mockTwo);"
- ));
+ return new MockitoException(
+ join(
+ "Method requires argument(s)!",
+ "Pass mocks that require verification in order.",
+ "For example:",
+ " InOrder inOrder = inOrder(mockOne, mockTwo);"));
}
public static MockitoException inOrderRequiresFamiliarMock() {
- return new MockitoException(join(
- "InOrder can only verify mocks that were passed in during creation of InOrder.",
- "For example:",
- " InOrder inOrder = inOrder(mockOne);",
- " inOrder.verify(mockOne).doStuff();"
- ));
+ return new MockitoException(
+ join(
+ "InOrder can only verify mocks that were passed in during creation of InOrder.",
+ "For example:",
+ " InOrder inOrder = inOrder(mockOne);",
+ " inOrder.verify(mockOne).doStuff();"));
}
- public static MockitoException invalidUseOfMatchers(int expectedMatchersCount, List<LocalizedMatcher> recordedMatchers) {
- return new InvalidUseOfMatchersException(join(
- "Invalid use of argument matchers!",
- expectedMatchersCount + " matchers expected, " + recordedMatchers.size() + " recorded:" +
- locationsOf(recordedMatchers),
- "",
- "This exception may occur if matchers are combined with raw values:",
- " //incorrect:",
- " someMethod(anyObject(), \"raw String\");",
- "When using matchers, all arguments have to be provided by matchers.",
- "For example:",
- " //correct:",
- " someMethod(anyObject(), eq(\"String by matcher\"));",
- "",
- "For more info see javadoc for Matchers class.",
- ""
- ));
+ public static MockitoException invalidUseOfMatchers(
+ int expectedMatchersCount, List<LocalizedMatcher> recordedMatchers) {
+ return new InvalidUseOfMatchersException(
+ join(
+ "Invalid use of argument matchers!",
+ expectedMatchersCount
+ + " matchers expected, "
+ + recordedMatchers.size()
+ + " recorded:"
+ + locationsOf(recordedMatchers),
+ "",
+ "This exception may occur if matchers are combined with raw values:",
+ " //incorrect:",
+ " someMethod(anyObject(), \"raw String\");",
+ "When using matchers, all arguments have to be provided by matchers.",
+ "For example:",
+ " //correct:",
+ " someMethod(anyObject(), eq(\"String by matcher\"));",
+ "",
+ "For more info see javadoc for Matchers class.",
+ ""));
}
- public static MockitoException incorrectUseOfAdditionalMatchers(String additionalMatcherName, int expectedSubMatchersCount, Collection<LocalizedMatcher> matcherStack) {
- return new InvalidUseOfMatchersException(join(
- "Invalid use of argument matchers inside additional matcher " + additionalMatcherName + " !",
- new LocationImpl(),
- "",
- expectedSubMatchersCount + " sub matchers expected, " + matcherStack.size() + " recorded:",
- locationsOf(matcherStack),
- "",
- "This exception may occur if matchers are combined with raw values:",
- " //incorrect:",
- " someMethod(AdditionalMatchers.and(isNotNull(), \"raw String\");",
- "When using matchers, all arguments have to be provided by matchers.",
- "For example:",
- " //correct:",
- " someMethod(AdditionalMatchers.and(isNotNull(), eq(\"raw String\"));",
- "",
- "For more info see javadoc for Matchers and AdditionalMatchers classes.",
- ""
- ));
+ public static MockitoException incorrectUseOfAdditionalMatchers(
+ String additionalMatcherName,
+ int expectedSubMatchersCount,
+ Collection<LocalizedMatcher> matcherStack) {
+ return new InvalidUseOfMatchersException(
+ join(
+ "Invalid use of argument matchers inside additional matcher "
+ + additionalMatcherName
+ + " !",
+ new LocationImpl(),
+ "",
+ expectedSubMatchersCount
+ + " sub matchers expected, "
+ + matcherStack.size()
+ + " recorded:",
+ locationsOf(matcherStack),
+ "",
+ "This exception may occur if matchers are combined with raw values:",
+ " //incorrect:",
+ " someMethod(AdditionalMatchers.and(isNotNull(), \"raw String\");",
+ "When using matchers, all arguments have to be provided by matchers.",
+ "For example:",
+ " //correct:",
+ " someMethod(AdditionalMatchers.and(isNotNull(), eq(\"raw String\"));",
+ "",
+ "For more info see javadoc for Matchers and AdditionalMatchers classes.",
+ ""));
}
- public static MockitoException stubPassedToVerify() {
- return new CannotVerifyStubOnlyMock(join(
- "Argument passed to verify() is a stubOnly() mock, not a full blown mock!",
- "If you intend to verify invocations on a mock, don't use stubOnly() in its MockSettings."
- ));
+ public static MockitoException stubPassedToVerify(Object mock) {
+ return new CannotVerifyStubOnlyMock(
+ join(
+ "Argument \""
+ + MockUtil.getMockName(mock)
+ + "\" passed to verify is a stubOnly() mock which cannot be verified.",
+ "If you intend to verify invocations on this mock, don't use stubOnly() in its MockSettings."));
}
public static MockitoException reportNoSubMatchersFound(String additionalMatcherName) {
- return new InvalidUseOfMatchersException(join(
- "No matchers found for additional matcher " + additionalMatcherName,
- new LocationImpl(),
- ""
- ));
+ return new InvalidUseOfMatchersException(
+ join(
+ "No matchers found for additional matcher " + additionalMatcherName,
+ new LocationImpl(),
+ ""));
}
-
private static Object locationsOf(Collection<LocalizedMatcher> matchers) {
- List<String> description = new ArrayList<String>();
- for (LocalizedMatcher matcher : matchers)
+ List<String> description = new ArrayList<>();
+ for (LocalizedMatcher matcher : matchers) {
description.add(matcher.getLocation().toString());
+ }
return join(description.toArray());
}
- public static AssertionError argumentsAreDifferent(String wanted, String actual, Location actualLocation) {
- String message = join("Argument(s) are different! Wanted:",
- wanted,
- new LocationImpl(),
- "Actual invocation has different arguments:",
- actual,
- actualLocation,
- ""
- );
+ public static AssertionError argumentsAreDifferent(
+ String wanted, List<String> actualCalls, List<Location> actualLocations) {
+ if (actualCalls == null
+ || actualLocations == null
+ || actualCalls.size() != actualLocations.size()) {
+ throw new IllegalArgumentException("actualCalls and actualLocations list must match");
+ }
- return ExceptionFactory.createArgumentsAreDifferentException(message, wanted, actual);
+ StringBuilder actualBuilder = new StringBuilder();
+ StringBuilder messageBuilder = new StringBuilder();
+ messageBuilder
+ .append("\n")
+ .append("Argument(s) are different! Wanted:\n")
+ .append(wanted)
+ .append("\n")
+ .append(new LocationImpl())
+ .append("\n")
+ .append("Actual invocations have different arguments:\n");
+
+ for (int i = 0; i < actualCalls.size(); i++) {
+ actualBuilder.append(actualCalls.get(i)).append("\n");
+
+ messageBuilder
+ .append(actualCalls.get(i))
+ .append("\n")
+ .append(actualLocations.get(i))
+ .append("\n");
+ }
+
+ return ExceptionFactory.createArgumentsAreDifferentException(
+ messageBuilder.toString(), wanted, actualBuilder.toString());
}
public static MockitoAssertionError wantedButNotInvoked(DescribedInvocation wanted) {
return new WantedButNotInvoked(createWantedButNotInvokedMessage(wanted));
}
- public static MockitoAssertionError wantedButNotInvoked(DescribedInvocation wanted, List<? extends DescribedInvocation> invocations) {
+ public static MockitoAssertionError wantedButNotInvoked(
+ DescribedInvocation wanted, List<? extends DescribedInvocation> invocations) {
String allInvocations;
if (invocations.isEmpty()) {
allInvocations = "Actually, there were zero interactions with this mock.\n";
} else {
- StringBuilder sb = new StringBuilder(
- "\nHowever, there " + were_exactly_x_interactions(invocations.size()) + " with this mock:\n");
+ StringBuilder sb =
+ new StringBuilder("\nHowever, there ")
+ .append(were_exactly_x_interactions(invocations.size()))
+ .append(" with this mock:\n");
for (DescribedInvocation i : invocations) {
- sb.append(i.toString())
- .append("\n")
- .append(i.getLocation())
- .append("\n\n");
+ sb.append(i).append("\n").append(i.getLocation()).append("\n\n");
}
allInvocations = sb.toString();
}
@@ -338,59 +365,67 @@
}
private static String createWantedButNotInvokedMessage(DescribedInvocation wanted) {
- return join(
- "Wanted but not invoked:",
- wanted.toString(),
- new LocationImpl(),
- ""
- );
+ return join("Wanted but not invoked:", wanted.toString(), new LocationImpl(), "");
}
- public static MockitoAssertionError wantedButNotInvokedInOrder(DescribedInvocation wanted, DescribedInvocation previous) {
- return new VerificationInOrderFailure(join(
- "Verification in order failure",
- "Wanted but not invoked:",
- wanted.toString(),
- new LocationImpl(),
- "Wanted anywhere AFTER following interaction:",
- previous.toString(),
- previous.getLocation(),
- ""
- ));
+ public static MockitoAssertionError wantedButNotInvokedInOrder(
+ DescribedInvocation wanted, DescribedInvocation previous) {
+ return new VerificationInOrderFailure(
+ join(
+ "Verification in order failure",
+ "Wanted but not invoked:",
+ wanted.toString(),
+ new LocationImpl(),
+ "Wanted anywhere AFTER following interaction:",
+ previous.toString(),
+ previous.getLocation(),
+ ""));
}
- public static MockitoAssertionError tooManyActualInvocations(int wantedCount, int actualCount, DescribedInvocation wanted, List<Location> locations) {
- String message = createTooManyInvocationsMessage(wantedCount, actualCount, wanted, locations);
+ public static MockitoAssertionError tooManyActualInvocations(
+ int wantedCount,
+ int actualCount,
+ DescribedInvocation wanted,
+ List<Location> locations) {
+ String message =
+ createTooManyInvocationsMessage(wantedCount, actualCount, wanted, locations);
return new TooManyActualInvocations(message);
}
- private static String createTooManyInvocationsMessage(int wantedCount, int actualCount, DescribedInvocation wanted,
- List<Location> invocations) {
+ private static String createTooManyInvocationsMessage(
+ int wantedCount,
+ int actualCount,
+ DescribedInvocation wanted,
+ List<Location> invocations) {
return join(
wanted.toString(),
"Wanted " + pluralize(wantedCount) + ":",
new LocationImpl(),
"But was " + pluralize(actualCount) + ":",
createAllLocationsMessage(invocations),
- ""
- );
+ "");
}
- public static MockitoAssertionError neverWantedButInvoked(DescribedInvocation wanted, List<Location> invocations) {
- return new NeverWantedButInvoked(join(
- wanted.toString(),
- "Never wanted here:",
- new LocationImpl(),
- "But invoked here:",
- createAllLocationsMessage(invocations)
- ));
+ public static MockitoAssertionError neverWantedButInvoked(
+ DescribedInvocation wanted, List<Invocation> invocations) {
+
+ return new NeverWantedButInvoked(
+ join(
+ wanted.toString(),
+ "Never wanted here:",
+ new LocationImpl(),
+ "But invoked here:",
+ createAllLocationsArgsMessage(invocations)));
}
- public static MockitoAssertionError tooManyActualInvocationsInOrder(int wantedCount, int actualCount, DescribedInvocation wanted, List<Location> invocations) {
- String message = createTooManyInvocationsMessage(wantedCount, actualCount, wanted, invocations);
- return new VerificationInOrderFailure(join(
- "Verification in order failure:" + message
- ));
+ public static MockitoAssertionError tooManyActualInvocationsInOrder(
+ int wantedCount,
+ int actualCount,
+ DescribedInvocation wanted,
+ List<Location> invocations) {
+ String message =
+ createTooManyInvocationsMessage(wantedCount, actualCount, wanted, invocations);
+ return new VerificationInOrderFailure(join("Verification in order failure:" + message));
}
private static String createAllLocationsMessage(List<Location> locations) {
@@ -404,305 +439,406 @@
return sb.toString();
}
- private static String createTooLittleInvocationsMessage(org.mockito.internal.reporting.Discrepancy discrepancy,
- DescribedInvocation wanted,
- List<Location> locations) {
+ private static String createAllLocationsArgsMessage(List<Invocation> invocations) {
+ StringBuilder sb = new StringBuilder();
+ for (Invocation invocation : invocations) {
+ Location location = invocation.getLocation();
+ if (location == null) {
+ continue;
+ }
+ sb.append(location)
+ .append(" with arguments: ")
+ .append(Arrays.toString(invocation.getArguments()))
+ .append("\n");
+ }
+ return sb.toString();
+ }
+
+ private static String createTooFewInvocationsMessage(
+ org.mockito.internal.reporting.Discrepancy discrepancy,
+ DescribedInvocation wanted,
+ List<Location> locations) {
return join(
wanted.toString(),
- "Wanted " + discrepancy.getPluralizedWantedCount() + (discrepancy.getWantedCount() == 0 ? "." : ":"),
+ "Wanted "
+ + discrepancy.getPluralizedWantedCount()
+ + (discrepancy.getWantedCount() == 0 ? "." : ":"),
new LocationImpl(),
- "But was " + discrepancy.getPluralizedActualCount() + (discrepancy.getActualCount() == 0 ? "." : ":"),
- createAllLocationsMessage(locations)
- );
+ "But was "
+ + discrepancy.getPluralizedActualCount()
+ + (discrepancy.getActualCount() == 0 ? "." : ":"),
+ createAllLocationsMessage(locations));
}
- public static MockitoAssertionError tooLittleActualInvocations(org.mockito.internal.reporting.Discrepancy discrepancy, DescribedInvocation wanted, List<Location> allLocations) {
- String message = createTooLittleInvocationsMessage(discrepancy, wanted, allLocations);
+ public static MockitoAssertionError tooFewActualInvocations(
+ org.mockito.internal.reporting.Discrepancy discrepancy,
+ DescribedInvocation wanted,
+ List<Location> allLocations) {
+ String message = createTooFewInvocationsMessage(discrepancy, wanted, allLocations);
- return new TooLittleActualInvocations(message);
+ return new TooFewActualInvocations(message);
}
- public static MockitoAssertionError tooLittleActualInvocationsInOrder(org.mockito.internal.reporting.Discrepancy discrepancy, DescribedInvocation wanted, List<Location> locations) {
- String message = createTooLittleInvocationsMessage(discrepancy, wanted, locations);
+ public static MockitoAssertionError tooFewActualInvocationsInOrder(
+ org.mockito.internal.reporting.Discrepancy discrepancy,
+ DescribedInvocation wanted,
+ List<Location> locations) {
+ String message = createTooFewInvocationsMessage(discrepancy, wanted, locations);
- return new VerificationInOrderFailure(join(
- "Verification in order failure:" + message
- ));
+ return new VerificationInOrderFailure(join("Verification in order failure:" + message));
}
- public static MockitoAssertionError noMoreInteractionsWanted(Invocation undesired, List<VerificationAwareInvocation> invocations) {
+ public static MockitoAssertionError noMoreInteractionsWanted(
+ Invocation undesired, List<VerificationAwareInvocation> invocations) {
ScenarioPrinter scenarioPrinter = new ScenarioPrinter();
String scenario = scenarioPrinter.print(invocations);
- return new NoInteractionsWanted(join(
- "No interactions wanted here:",
- new LocationImpl(),
- "But found this interaction on mock '" + safelyGetMockName(undesired.getMock()) + "':",
- undesired.getLocation(),
- scenario
- ));
+ return new NoInteractionsWanted(
+ join(
+ "No interactions wanted here:",
+ new LocationImpl(),
+ "But found this interaction on mock '"
+ + MockUtil.getMockName(undesired.getMock())
+ + "':",
+ undesired.getLocation(),
+ scenario));
}
public static MockitoAssertionError noMoreInteractionsWantedInOrder(Invocation undesired) {
- return new VerificationInOrderFailure(join(
- "No interactions wanted here:",
- new LocationImpl(),
- "But found this interaction on mock '" + safelyGetMockName(undesired.getMock()) + "':",
- undesired.getLocation()
- ));
+ return new VerificationInOrderFailure(
+ join(
+ "No interactions wanted here:",
+ new LocationImpl(),
+ "But found this interaction on mock '"
+ + MockUtil.getMockName(undesired.getMock())
+ + "':",
+ undesired.getLocation()));
+ }
+
+ public static MockitoAssertionError noInteractionsWanted(
+ Object mock, List<VerificationAwareInvocation> invocations) {
+ ScenarioPrinter scenarioPrinter = new ScenarioPrinter();
+ String scenario = scenarioPrinter.print(invocations);
+
+ List<Location> locations = new ArrayList<>();
+ for (VerificationAwareInvocation invocation : invocations) {
+ locations.add(invocation.getLocation());
+ }
+ return new NoInteractionsWanted(
+ join(
+ "No interactions wanted here:",
+ new LocationImpl(),
+ "But found these interactions on mock '"
+ + MockUtil.getMockName(mock)
+ + "':",
+ join("", locations),
+ scenario));
}
public static MockitoException cannotMockClass(Class<?> clazz, String reason) {
- return new MockitoException(join(
- "Cannot mock/spy " + clazz.toString(),
- "Mockito cannot mock/spy because :",
- " - " + reason
- ));
+ return new MockitoException(
+ join(
+ "Cannot mock/spy " + clazz,
+ "Mockito cannot mock/spy because :",
+ " - " + reason));
}
public static MockitoException cannotStubVoidMethodWithAReturnValue(String methodName) {
- return new CannotStubVoidMethodWithReturnValue(join(
- "'" + methodName + "' is a *void method* and it *cannot* be stubbed with a *return value*!",
- "Voids are usually stubbed with Throwables:",
- " doThrow(exception).when(mock).someVoidMethod();",
- "If you need to set the void method to do nothing you can use:",
- " doNothing().when(mock).someVoidMethod();",
- "For more information, check out the javadocs for Mockito.doNothing().",
- "***",
- "If you're unsure why you're getting above error read on.",
- "Due to the nature of the syntax above problem might occur because:",
- "1. The method you are trying to stub is *overloaded*. Make sure you are calling the right overloaded version.",
- "2. Somewhere in your test you are stubbing *final methods*. Sorry, Mockito does not verify/stub final methods.",
- "3. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
- " - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
- "4. " + NON_PUBLIC_PARENT,
- ""
- ));
+ return new CannotStubVoidMethodWithReturnValue(
+ join(
+ "'"
+ + methodName
+ + "' is a *void method* and it *cannot* be stubbed with a *return value*!",
+ "Voids are usually stubbed with Throwables:",
+ " doThrow(exception).when(mock).someVoidMethod();",
+ "If you need to set the void method to do nothing you can use:",
+ " doNothing().when(mock).someVoidMethod();",
+ "For more information, check out the javadocs for Mockito.doNothing().",
+ "***",
+ "If you're unsure why you're getting above error read on.",
+ "Due to the nature of the syntax above problem might occur because:",
+ "1. The method you are trying to stub is *overloaded*. Make sure you are calling the right overloaded version.",
+ "2. Somewhere in your test you are stubbing *final methods*. Sorry, Mockito does not verify/stub final methods.",
+ "3. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
+ " - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
+ "4. " + NON_PUBLIC_PARENT,
+ ""));
}
public static MockitoException onlyVoidMethodsCanBeSetToDoNothing() {
- return new MockitoException(join(
- "Only void methods can doNothing()!",
- "Example of correct use of doNothing():",
- " doNothing().",
- " doThrow(new RuntimeException())",
- " .when(mock).someVoidMethod();",
- "Above means:",
- "someVoidMethod() does nothing the 1st time but throws an exception the 2nd time is called"
- ));
+ return new MockitoException(
+ join(
+ "Only void methods can doNothing()!",
+ "Example of correct use of doNothing():",
+ " doNothing().",
+ " doThrow(new RuntimeException())",
+ " .when(mock).someVoidMethod();",
+ "Above means:",
+ "someVoidMethod() does nothing the 1st time but throws an exception the 2nd time is called"));
}
- public static MockitoException wrongTypeOfReturnValue(String expectedType, String actualType, String methodName) {
- return new WrongTypeOfReturnValue(join(
- actualType + " cannot be returned by " + methodName + "()",
- methodName + "() should return " + expectedType,
- "***",
- "If you're unsure why you're getting above error read on.",
- "Due to the nature of the syntax above problem might occur because:",
- "1. This exception *might* occur in wrongly written multi-threaded tests.",
- " Please refer to Mockito FAQ on limitations of concurrency testing.",
- "2. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
- " - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
- ""
- ));
+ public static MockitoException wrongTypeOfReturnValue(
+ String expectedType, String actualType, String methodName) {
+ return new WrongTypeOfReturnValue(
+ join(
+ actualType + " cannot be returned by " + methodName + "()",
+ methodName + "() should return " + expectedType,
+ "***",
+ "If you're unsure why you're getting above error read on.",
+ "Due to the nature of the syntax above problem might occur because:",
+ "1. This exception *might* occur in wrongly written multi-threaded tests.",
+ " Please refer to Mockito FAQ on limitations of concurrency testing.",
+ "2. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
+ " - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
+ ""));
}
- public static MockitoException wrongTypeReturnedByDefaultAnswer(Object mock, String expectedType, String actualType, String methodName) {
- return new WrongTypeOfReturnValue(join(
- "Default answer returned a result with the wrong type:",
- actualType + " cannot be returned by " + methodName + "()",
- methodName + "() should return " + expectedType,
- "",
- "The default answer of " + safelyGetMockName(mock) + " that was configured on the mock is probably incorrectly implemented.",
- ""
- ));
+ public static MockitoException wrongTypeReturnedByDefaultAnswer(
+ Object mock, String expectedType, String actualType, String methodName) {
+ return new WrongTypeOfReturnValue(
+ join(
+ "Default answer returned a result with the wrong type:",
+ actualType + " cannot be returned by " + methodName + "()",
+ methodName + "() should return " + expectedType,
+ "",
+ "The default answer of "
+ + MockUtil.getMockName(mock)
+ + " that was configured on the mock is probably incorrectly implemented.",
+ ""));
}
- public static MoreThanAllowedActualInvocations wantedAtMostX(int maxNumberOfInvocations, int foundSize) {
- return new MoreThanAllowedActualInvocations(join("Wanted at most " + pluralize(maxNumberOfInvocations) + " but was " + foundSize));
+ public static MoreThanAllowedActualInvocations wantedAtMostX(
+ int maxNumberOfInvocations, int foundSize) {
+ return new MoreThanAllowedActualInvocations(
+ join(
+ "Wanted at most "
+ + pluralize(maxNumberOfInvocations)
+ + " but was "
+ + foundSize));
}
public static MockitoException misplacedArgumentMatcher(List<LocalizedMatcher> lastMatchers) {
- return new InvalidUseOfMatchersException(join(
- "Misplaced or misused argument matcher detected here:",
- locationsOf(lastMatchers),
- "",
- "You cannot use argument matchers outside of verification or stubbing.",
- "Examples of correct usage of argument matchers:",
- " when(mock.get(anyInt())).thenReturn(null);",
- " doThrow(new RuntimeException()).when(mock).someVoidMethod(anyObject());",
- " verify(mock).someMethod(contains(\"foo\"))",
- "",
- "This message may appear after an NullPointerException if the last matcher is returning an object ",
- "like any() but the stubbed method signature expect a primitive argument, in this case,",
- "use primitive alternatives.",
- " when(mock.get(any())); // bad use, will raise NPE",
- " when(mock.get(anyInt())); // correct usage use",
- "",
- "Also, this error might show up because you use argument matchers with methods that cannot be mocked.",
- "Following methods *cannot* be stubbed/verified: final/private/equals()/hashCode().",
- NON_PUBLIC_PARENT,
- ""
- ));
+ return new InvalidUseOfMatchersException(
+ join(
+ "Misplaced or misused argument matcher detected here:",
+ locationsOf(lastMatchers),
+ "",
+ "You cannot use argument matchers outside of verification or stubbing.",
+ "Examples of correct usage of argument matchers:",
+ " when(mock.get(anyInt())).thenReturn(null);",
+ " doThrow(new RuntimeException()).when(mock).someVoidMethod(anyObject());",
+ " verify(mock).someMethod(contains(\"foo\"))",
+ "",
+ "This message may appear after an NullPointerException if the last matcher is returning an object ",
+ "like any() but the stubbed method signature expect a primitive argument, in this case,",
+ "use primitive alternatives.",
+ " when(mock.get(any())); // bad use, will raise NPE",
+ " when(mock.get(anyInt())); // correct usage use",
+ "",
+ "Also, this error might show up because you use argument matchers with methods that cannot be mocked.",
+ "Following methods *cannot* be stubbed/verified: final/private/equals()/hashCode().",
+ NON_PUBLIC_PARENT,
+ ""));
}
public static MockitoException smartNullPointerException(String invocation, Location location) {
- return new SmartNullPointerException(join(
- "You have a NullPointerException here:",
- new LocationImpl(),
- "because this method call was *not* stubbed correctly:",
- location,
- invocation,
- ""
- ));
+ return new SmartNullPointerException(
+ join(
+ "You have a NullPointerException here:",
+ new LocationImpl(),
+ "because this method call was *not* stubbed correctly:",
+ location,
+ invocation,
+ ""));
}
public static MockitoException noArgumentValueWasCaptured() {
- return new MockitoException(join(
- "No argument value was captured!",
- "You might have forgotten to use argument.capture() in verify()...",
- "...or you used capture() in stubbing but stubbed method was not called.",
- "Be aware that it is recommended to use capture() only with verify()",
- "",
- "Examples of correct argument capturing:",
- " ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);",
- " verify(mock).doSomething(argument.capture());",
- " assertEquals(\"John\", argument.getValue().getName());",
- ""
- ));
+ return new MockitoException(
+ join(
+ "No argument value was captured!",
+ "You might have forgotten to use argument.capture() in verify()...",
+ "...or you used capture() in stubbing but stubbed method was not called.",
+ "Be aware that it is recommended to use capture() only with verify()",
+ "",
+ "Examples of correct argument capturing:",
+ " ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);",
+ " verify(mock).doSomething(argument.capture());",
+ " assertEquals(\"John\", argument.getValue().getName());",
+ ""));
}
public static MockitoException extraInterfacesDoesNotAcceptNullParameters() {
- return new MockitoException(join(
- "extraInterfaces() does not accept null parameters."
- ));
+ return new MockitoException(join("extraInterfaces() does not accept null parameters."));
}
public static MockitoException extraInterfacesAcceptsOnlyInterfaces(Class<?> wrongType) {
- return new MockitoException(join(
- "extraInterfaces() accepts only interfaces.",
- "You passed following type: " + wrongType.getSimpleName() + " which is not an interface."
- ));
+ return new MockitoException(
+ join(
+ "extraInterfaces() accepts only interfaces.",
+ "You passed following type: "
+ + wrongType.getSimpleName()
+ + " which is not an interface."));
}
public static MockitoException extraInterfacesCannotContainMockedType(Class<?> wrongType) {
- return new MockitoException(join(
- "extraInterfaces() does not accept the same type as the mocked type.",
- "You mocked following type: " + wrongType.getSimpleName(),
- "and you passed the same very interface to the extraInterfaces()"
- ));
+ return new MockitoException(
+ join(
+ "extraInterfaces() does not accept the same type as the mocked type.",
+ "You mocked following type: " + wrongType.getSimpleName(),
+ "and you passed the same very interface to the extraInterfaces()"));
}
public static MockitoException extraInterfacesRequiresAtLeastOneInterface() {
- return new MockitoException(join(
- "extraInterfaces() requires at least one interface."
- ));
+ return new MockitoException(join("extraInterfaces() requires at least one interface."));
}
- public static MockitoException mockedTypeIsInconsistentWithSpiedInstanceType(Class<?> mockedType, Object spiedInstance) {
- return new MockitoException(join(
- "Mocked type must be the same as the type of your spied instance.",
- "Mocked type must be: " + spiedInstance.getClass().getSimpleName() + ", but is: " + mockedType.getSimpleName(),
- " //correct spying:",
- " spy = mock( ->ArrayList.class<- , withSettings().spiedInstance( ->new ArrayList()<- );",
- " //incorrect - types don't match:",
- " spy = mock( ->List.class<- , withSettings().spiedInstance( ->new ArrayList()<- );"
- ));
+ public static MockitoException mockedTypeIsInconsistentWithSpiedInstanceType(
+ Class<?> mockedType, Object spiedInstance) {
+ return new MockitoException(
+ join(
+ "Mocked type must be the same as the type of your spied instance.",
+ "Mocked type must be: "
+ + spiedInstance.getClass().getSimpleName()
+ + ", but is: "
+ + mockedType.getSimpleName(),
+ " //correct spying:",
+ " spy = mock( ->ArrayList.class<- , withSettings().spiedInstance( ->new ArrayList()<- );",
+ " //incorrect - types don't match:",
+ " spy = mock( ->List.class<- , withSettings().spiedInstance( ->new ArrayList()<- );"));
}
public static MockitoException cannotCallAbstractRealMethod() {
- return new MockitoException(join(
- "Cannot call abstract real method on java object!",
- "Calling real methods is only possible when mocking non abstract method.",
- " //correct example:",
- " when(mockOfConcreteClass.nonAbstractMethod()).thenCallRealMethod();"
- ));
+ return new MockitoException(
+ join(
+ "Cannot call abstract real method on java object!",
+ "Calling real methods is only possible when mocking non abstract method.",
+ " //correct example:",
+ " when(mockOfConcreteClass.nonAbstractMethod()).thenCallRealMethod();"));
}
public static MockitoException cannotVerifyToString() {
- return new MockitoException(join(
- "Mockito cannot verify toString()",
- "toString() is too often used behind of scenes (i.e. during String concatenation, in IDE debugging views). " +
- "Verifying it may give inconsistent or hard to understand results. " +
- "Not to mention that verifying toString() most likely hints awkward design (hard to explain in a short exception message. Trust me...)",
- "However, it is possible to stub toString(). Stubbing toString() smells a bit funny but there are rare, legitimate use cases."
- ));
+ return new MockitoException(
+ join(
+ "Mockito cannot verify toString()",
+ "toString() is too often used behind of scenes (i.e. during String concatenation, in IDE debugging views). "
+ + "Verifying it may give inconsistent or hard to understand results. "
+ + "Not to mention that verifying toString() most likely hints awkward design (hard to explain in a short exception message. Trust me...)",
+ "However, it is possible to stub toString(). Stubbing toString() smells a bit funny but there are rare, legitimate use cases."));
}
public static MockitoException moreThanOneAnnotationNotAllowed(String fieldName) {
- return new MockitoException("You cannot have more than one Mockito annotation on a field!\n" +
- "The field '" + fieldName + "' has multiple Mockito annotations.\n" +
- "For info how to use annotations see examples in javadoc for MockitoAnnotations class.");
+ return new MockitoException(
+ "You cannot have more than one Mockito annotation on a field!\n"
+ + "The field '"
+ + fieldName
+ + "' has multiple Mockito annotations.\n"
+ + "For info how to use annotations see examples in javadoc for MockitoAnnotations class.");
}
- public static MockitoException unsupportedCombinationOfAnnotations(String undesiredAnnotationOne, String undesiredAnnotationTwo) {
- return new MockitoException("This combination of annotations is not permitted on a single field:\n" +
- "@" + undesiredAnnotationOne + " and @" + undesiredAnnotationTwo);
+ public static MockitoException unsupportedCombinationOfAnnotations(
+ String undesiredAnnotationOne, String undesiredAnnotationTwo) {
+ return new MockitoException(
+ "This combination of annotations is not permitted on a single field:\n"
+ + "@"
+ + undesiredAnnotationOne
+ + " and @"
+ + undesiredAnnotationTwo);
}
- public static MockitoException cannotInitializeForSpyAnnotation(String fieldName, Exception details) {
- return new MockitoException(join("Cannot instantiate a @Spy for '" + fieldName + "' field.",
- "You haven't provided the instance for spying at field declaration so I tried to construct the instance.",
- "However, I failed because: " + details.getMessage(),
- "Examples of correct usage of @Spy:",
- " @Spy List mock = new LinkedList();",
- " @Spy Foo foo; //only if Foo has parameterless constructor",
- " //also, don't forget about MockitoAnnotations.initMocks();",
- ""), details);
+ public static MockitoException cannotInitializeForSpyAnnotation(
+ String fieldName, Exception details) {
+ return new MockitoException(
+ join(
+ "Cannot instantiate a @Spy for '" + fieldName + "' field.",
+ "You haven't provided the instance for spying at field declaration so I tried to construct the instance.",
+ "However, I failed because: " + details.getMessage(),
+ "Examples of correct usage of @Spy:",
+ " @Spy List mock = new LinkedList();",
+ " @Spy Foo foo; //only if Foo has parameterless constructor",
+ " //also, don't forget about MockitoAnnotations.openMocks();",
+ ""),
+ details);
}
- public static MockitoException cannotInitializeForInjectMocksAnnotation(String fieldName, String causeMessage) {
- return new MockitoException(join("Cannot instantiate @InjectMocks field named '" + fieldName + "'! Cause: "+causeMessage,
- "You haven't provided the instance at field declaration so I tried to construct the instance.",
- "Examples of correct usage of @InjectMocks:",
- " @InjectMocks Service service = new Service();",
- " @InjectMocks Service service;",
- " //and... don't forget about some @Mocks for injection :)",
- ""));
+ public static MockitoException cannotInitializeForInjectMocksAnnotation(
+ String fieldName, String causeMessage) {
+ return new MockitoException(
+ join(
+ "Cannot instantiate @InjectMocks field named '"
+ + fieldName
+ + "'! Cause: "
+ + causeMessage,
+ "You haven't provided the instance at field declaration so I tried to construct the instance.",
+ "Examples of correct usage of @InjectMocks:",
+ " @InjectMocks Service service = new Service();",
+ " @InjectMocks Service service;",
+ " //and... don't forget about some @Mocks for injection :)",
+ ""));
}
public static MockitoException atMostAndNeverShouldNotBeUsedWithTimeout() {
- return new FriendlyReminderException(join("",
- "Don't panic! I'm just a friendly reminder!",
- "timeout() should not be used with atMost() or never() because...",
- "...it does not make much sense - the test would have passed immediately in concurrency",
- "We kept this method only to avoid compilation errors when upgrading Mockito.",
- "In future release we will remove timeout(x).atMost(y) from the API.",
- "If you want to find out more please refer to issue 235",
- ""));
+ return new FriendlyReminderException(
+ join(
+ "",
+ "Don't panic! I'm just a friendly reminder!",
+ "timeout() should not be used with atMost() or never() because...",
+ "...it does not make much sense - the test would have passed immediately in concurrency",
+ "We kept this method only to avoid compilation errors when upgrading Mockito.",
+ "In future release we will remove timeout(x).atMost(y) from the API.",
+ "If you want to find out more please refer to issue 235",
+ ""));
}
- public static MockitoException fieldInitialisationThrewException(Field field, Throwable details) {
- return new InjectMocksException(join(
- "Cannot instantiate @InjectMocks field named '" + field.getName() + "' of type '" + field.getType() + "'.",
- "You haven't provided the instance at field declaration so I tried to construct the instance.",
- "However the constructor or the initialization block threw an exception : " + details.getMessage(),
- ""), details);
-
+ public static MockitoException fieldInitialisationThrewException(
+ Field field, Throwable details) {
+ return new InjectMocksException(
+ join(
+ "Cannot instantiate @InjectMocks field named '"
+ + field.getName()
+ + "' of type '"
+ + field.getType()
+ + "'.",
+ "You haven't provided the instance at field declaration so I tried to construct the instance.",
+ "However the constructor or the initialization block threw an exception : "
+ + details.getMessage(),
+ ""),
+ details);
}
public static MockitoException methodDoesNotAcceptParameter(String method, String parameter) {
- return new MockitoException(method + "() does not accept " + parameter + " See the Javadoc.");
+ return new MockitoException(
+ method + "() does not accept " + parameter + " See the Javadoc.");
}
- public static MockitoException invocationListenersRequiresAtLeastOneListener() {
- return new MockitoException("invocationListeners() requires at least one listener");
+ public static MockitoException requiresAtLeastOneListener(String method) {
+ return new MockitoException(method + "() requires at least one listener");
}
- public static MockitoException invocationListenerThrewException(InvocationListener listener, Throwable listenerThrowable) {
- return new MockitoException(join(
- "The invocation listener with type " + listener.getClass().getName(),
- "threw an exception : " + listenerThrowable.getClass().getName() + listenerThrowable.getMessage()), listenerThrowable);
+ public static MockitoException invocationListenerThrewException(
+ InvocationListener listener, Throwable listenerThrowable) {
+ return new MockitoException(
+ join(
+ "The invocation listener with type " + listener.getClass().getName(),
+ "threw an exception : "
+ + listenerThrowable.getClass().getName()
+ + listenerThrowable.getMessage()),
+ listenerThrowable);
}
- public static MockitoException cannotInjectDependency(Field field, Object matchingMock, Exception details) {
- return new MockitoException(join(
- "Mockito couldn't inject mock dependency '" + safelyGetMockName(matchingMock) + "' on field ",
- "'" + field + "'",
- "whose type '" + field.getDeclaringClass().getCanonicalName() + "' was annotated by @InjectMocks in your test.",
- "Also I failed because: " + exceptionCauseMessageIfAvailable(details),
- ""
- ), details);
+ public static MockitoException cannotInjectDependency(
+ Field field, Object matchingMock, Exception details) {
+ return new MockitoException(
+ join(
+ "Mockito couldn't inject mock dependency '"
+ + MockUtil.getMockName(matchingMock)
+ + "' on field ",
+ "'" + field + "'",
+ "whose type '"
+ + field.getDeclaringClass().getCanonicalName()
+ + "' was annotated by @InjectMocks in your test.",
+ "Also I failed because: " + exceptionCauseMessageIfAvailable(details),
+ ""),
+ details);
}
private static String exceptionCauseMessageIfAvailable(Exception details) {
@@ -712,43 +848,55 @@
return details.getCause().getMessage();
}
- public static MockitoException mockedTypeIsInconsistentWithDelegatedInstanceType(Class<?> mockedType, Object delegatedInstance) {
- return new MockitoException(join(
- "Mocked type must be the same as the type of your delegated instance.",
- "Mocked type must be: " + delegatedInstance.getClass().getSimpleName() + ", but is: " + mockedType.getSimpleName(),
- " //correct delegate:",
- " spy = mock( ->List.class<- , withSettings().delegatedInstance( ->new ArrayList()<- );",
- " //incorrect - types don't match:",
- " spy = mock( ->List.class<- , withSettings().delegatedInstance( ->new HashSet()<- );"
- ));
+ public static MockitoException mockedTypeIsInconsistentWithDelegatedInstanceType(
+ Class<?> mockedType, Object delegatedInstance) {
+ return new MockitoException(
+ join(
+ "Mocked type must be the same as the type of your delegated instance.",
+ "Mocked type must be: "
+ + delegatedInstance.getClass().getSimpleName()
+ + ", but is: "
+ + mockedType.getSimpleName(),
+ " //correct delegate:",
+ " spy = mock( ->List.class<- , withSettings().delegatedInstance( ->new ArrayList()<- );",
+ " //incorrect - types don't match:",
+ " spy = mock( ->List.class<- , withSettings().delegatedInstance( ->new HashSet()<- );"));
}
public static MockitoException spyAndDelegateAreMutuallyExclusive() {
- return new MockitoException(join(
- "Settings should not define a spy instance and a delegated instance at the same time."
- ));
+ return new MockitoException(
+ join(
+ "Settings should not define a spy instance and a delegated instance at the same time."));
}
public static MockitoException invalidArgumentRangeAtIdentityAnswerCreationTime() {
- return new MockitoException(join(
- "Invalid argument index.",
- "The index need to be a positive number that indicates the position of the argument to return.",
- "However it is possible to use the -1 value to indicates that the last argument should be",
- "returned."));
+ return new MockitoException(
+ join(
+ "Invalid argument index.",
+ "The index need to be a positive number that indicates the position of the argument to return.",
+ "However it is possible to use the -1 value to indicates that the last argument should be",
+ "returned."));
}
- public static MockitoException invalidArgumentPositionRangeAtInvocationTime(InvocationOnMock invocation, boolean willReturnLastParameter, int argumentIndex) {
- return new MockitoException(join(
- "Invalid argument index for the current invocation of method : ",
- " -> " + safelyGetMockName(invocation.getMock()) + "." + invocation.getMethod().getName() + "()",
- "",
- (willReturnLastParameter ?
- "Last parameter wanted" :
- "Wanted parameter at position " + argumentIndex) + " but " + possibleArgumentTypesOf(invocation),
- "The index need to be a positive number that indicates a valid position of the argument in the invocation.",
- "However it is possible to use the -1 value to indicates that the last argument should be returned.",
- ""
- ));
+ public static MockitoException invalidArgumentPositionRangeAtInvocationTime(
+ InvocationOnMock invocation, boolean willReturnLastParameter, int argumentIndex) {
+ return new MockitoException(
+ join(
+ "Invalid argument index for the current invocation of method : ",
+ " -> "
+ + MockUtil.getMockName(invocation.getMock())
+ + "."
+ + invocation.getMethod().getName()
+ + "()",
+ "",
+ (willReturnLastParameter
+ ? "Last parameter wanted"
+ : "Wanted parameter at position " + argumentIndex)
+ + " but "
+ + possibleArgumentTypesOf(invocation),
+ "The index need to be a positive number that indicates a valid position of the argument in the invocation.",
+ "However it is possible to use the -1 value to indicates that the last argument should be returned.",
+ ""));
}
private static StringBuilder possibleArgumentTypesOf(InvocationOnMock invocation) {
@@ -757,12 +905,19 @@
return new StringBuilder("the method has no arguments.\n");
}
- StringBuilder stringBuilder = new StringBuilder("the possible argument indexes for this method are :\n");
- for (int i = 0, parameterTypesLength = parameterTypes.length; i < parameterTypesLength; i++) {
+ StringBuilder stringBuilder =
+ new StringBuilder("the possible argument indexes for this method are :\n");
+ for (int i = 0, parameterTypesLength = parameterTypes.length;
+ i < parameterTypesLength;
+ i++) {
stringBuilder.append(" [").append(i);
if (invocation.getMethod().isVarArgs() && i == parameterTypesLength - 1) {
- stringBuilder.append("+] ").append(parameterTypes[i].getComponentType().getSimpleName()).append(" <- Vararg").append("\n");
+ stringBuilder
+ .append("+] ")
+ .append(parameterTypes[i].getComponentType().getSimpleName())
+ .append(" <- Vararg")
+ .append("\n");
} else {
stringBuilder.append("] ").append(parameterTypes[i].getSimpleName()).append("\n");
}
@@ -770,105 +925,143 @@
return stringBuilder;
}
- public static MockitoException wrongTypeOfArgumentToReturn(InvocationOnMock invocation, String expectedType, Class<?> actualType, int argumentIndex) {
- return new WrongTypeOfReturnValue(join(
- "The argument of type '" + actualType.getSimpleName() + "' cannot be returned because the following ",
- "method should return the type '" + expectedType + "'",
- " -> " + safelyGetMockName(invocation.getMock()) + "." + invocation.getMethod().getName() + "()",
- "",
- "The reason for this error can be :",
- "1. The wanted argument position is incorrect.",
- "2. The answer is used on the wrong interaction.",
- "",
- "Position of the wanted argument is " + argumentIndex + " and " + possibleArgumentTypesOf(invocation),
- "***",
- "However if you're still unsure why you're getting above error read on.",
- "Due to the nature of the syntax above problem might occur because:",
- "1. This exception *might* occur in wrongly written multi-threaded tests.",
- " Please refer to Mockito FAQ on limitations of concurrency testing.",
- "2. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
- " - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
- ""
- ));
+ public static MockitoException wrongTypeOfArgumentToReturn(
+ InvocationOnMock invocation,
+ String expectedType,
+ Class<?> actualType,
+ int argumentIndex) {
+ return new WrongTypeOfReturnValue(
+ join(
+ "The argument of type '"
+ + actualType.getSimpleName()
+ + "' cannot be returned because the following ",
+ "method should return the type '" + expectedType + "'",
+ " -> "
+ + MockUtil.getMockName(invocation.getMock())
+ + "."
+ + invocation.getMethod().getName()
+ + "()",
+ "",
+ "The reason for this error can be :",
+ "1. The wanted argument position is incorrect.",
+ "2. The answer is used on the wrong interaction.",
+ "",
+ "Position of the wanted argument is "
+ + argumentIndex
+ + " and "
+ + possibleArgumentTypesOf(invocation),
+ "***",
+ "However if you're still unsure why you're getting above error read on.",
+ "Due to the nature of the syntax above problem might occur because:",
+ "1. This exception *might* occur in wrongly written multi-threaded tests.",
+ " Please refer to Mockito FAQ on limitations of concurrency testing.",
+ "2. A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies - ",
+ " - with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.",
+ ""));
}
public static MockitoException defaultAnswerDoesNotAcceptNullParameter() {
return new MockitoException("defaultAnswer() does not accept null parameter");
}
- public static MockitoException serializableWontWorkForObjectsThatDontImplementSerializable(Class<?> classToMock) {
- return new MockitoException(join(
- "You are using the setting 'withSettings().serializable()' however the type you are trying to mock '" + classToMock.getSimpleName() + "'",
- "do not implement Serializable AND do not have a no-arg constructor.",
- "This combination is requested, otherwise you will get an 'java.io.InvalidClassException' when the mock will be serialized",
- "",
- "Also note that as requested by the Java serialization specification, the whole hierarchy need to implements Serializable,",
- "i.e. the top-most superclass has to implements Serializable.",
- ""
- ));
+ public static MockitoException serializableWontWorkForObjectsThatDontImplementSerializable(
+ Class<?> classToMock) {
+ return new MockitoException(
+ join(
+ "You are using the setting 'withSettings().serializable()' however the type you are trying to mock '"
+ + classToMock.getSimpleName()
+ + "'",
+ "do not implement Serializable AND do not have a no-arg constructor.",
+ "This combination is requested, otherwise you will get an 'java.io.InvalidClassException' when the mock will be serialized",
+ "",
+ "Also note that as requested by the Java serialization specification, the whole hierarchy need to implements Serializable,",
+ "i.e. the top-most superclass has to implements Serializable.",
+ ""));
}
- public static MockitoException delegatedMethodHasWrongReturnType(Method mockMethod, Method delegateMethod, Object mock, Object delegate) {
- return new MockitoException(join(
- "Methods called on delegated instance must have compatible return types with the mock.",
- "When calling: " + mockMethod + " on mock: " + safelyGetMockName(mock),
- "return type should be: " + mockMethod.getReturnType().getSimpleName() + ", but was: " + delegateMethod.getReturnType().getSimpleName(),
- "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods",
- "(delegate instance had type: " + delegate.getClass().getSimpleName() + ")"
- ));
+ public static MockitoException delegatedMethodHasWrongReturnType(
+ Method mockMethod, Method delegateMethod, Object mock, Object delegate) {
+ return new MockitoException(
+ join(
+ "Methods called on delegated instance must have compatible return types with the mock.",
+ "When calling: " + mockMethod + " on mock: " + MockUtil.getMockName(mock),
+ "return type should be: "
+ + mockMethod.getReturnType().getSimpleName()
+ + ", but was: "
+ + delegateMethod.getReturnType().getSimpleName(),
+ "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods",
+ "(delegate instance had type: "
+ + delegate.getClass().getSimpleName()
+ + ")"));
}
- public static MockitoException delegatedMethodDoesNotExistOnDelegate(Method mockMethod, Object mock, Object delegate) {
- return new MockitoException(join(
- "Methods called on mock must exist in delegated instance.",
- "When calling: " + mockMethod + " on mock: " + safelyGetMockName(mock),
- "no such method was found.",
- "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods",
- "(delegate instance had type: " + delegate.getClass().getSimpleName() + ")"
- ));
+ public static MockitoException delegatedMethodDoesNotExistOnDelegate(
+ Method mockMethod, Object mock, Object delegate) {
+ return new MockitoException(
+ join(
+ "Methods called on mock must exist in delegated instance.",
+ "When calling: " + mockMethod + " on mock: " + MockUtil.getMockName(mock),
+ "no such method was found.",
+ "Check that the instance passed to delegatesTo() is of the correct type or contains compatible methods",
+ "(delegate instance had type: "
+ + delegate.getClass().getSimpleName()
+ + ")"));
}
public static MockitoException usingConstructorWithFancySerializable(SerializableMode mode) {
- return new MockitoException("Mocks instantiated with constructor cannot be combined with " + mode + " serialization mode.");
+ return new MockitoException(
+ "Mocks instantiated with constructor cannot be combined with "
+ + mode
+ + " serialization mode.");
}
public static MockitoException cannotCreateTimerWithNegativeDurationTime(long durationMillis) {
- return new FriendlyReminderException(join(
- "",
- "Don't panic! I'm just a friendly reminder!",
- "It is impossible for time to go backward, therefore...",
- "You cannot put negative value of duration: (" + durationMillis + ")",
- "as argument of timer methods (after(), timeout())",
- ""
- ));
+ return new FriendlyReminderException(
+ join(
+ "",
+ "Don't panic! I'm just a friendly reminder!",
+ "It is impossible for time to go backward, therefore...",
+ "You cannot put negative value of duration: (" + durationMillis + ")",
+ "as argument of timer methods (after(), timeout())",
+ ""));
}
public static MockitoException notAnException() {
- return new MockitoException(join(
- "Exception type cannot be null.",
- "This may happen with doThrow(Class)|thenThrow(Class) family of methods if passing null parameter."));
+ return new MockitoException(
+ join(
+ "Exception type cannot be null.",
+ "This may happen with doThrow(Class)|thenThrow(Class) family of methods if passing null parameter."));
}
- private static MockName safelyGetMockName(Object mock) {
- return MockUtil.getMockName(mock);
+ public static MockitoException inlineClassWithoutUnboxImpl(
+ Class<?> inlineClass, Exception details) {
+ return new MockitoException(
+ join(
+ "Kotlin inline class should have unbox-impl() method,",
+ "but " + inlineClass + " does not."),
+ details);
}
- public static UnnecessaryStubbingException formatUnncessaryStubbingException(Class<?> testClass, Collection<Invocation> unnecessaryStubbings) {
+ public static UnnecessaryStubbingException formatUnncessaryStubbingException(
+ Class<?> testClass, Collection<Invocation> unnecessaryStubbings) {
StringBuilder stubbings = new StringBuilder();
int count = 1;
for (Invocation u : unnecessaryStubbings) {
stubbings.append("\n ").append(count++).append(". ").append(u.getLocation());
}
- String heading = (testClass != null)?
- "Unnecessary stubbings detected in test class: " + testClass.getSimpleName() :
- "Unnecessary stubbings detected.";
+ String heading =
+ (testClass != null)
+ ? "Unnecessary stubbings detected in test class: "
+ + testClass.getSimpleName()
+ : "Unnecessary stubbings detected.";
- return new UnnecessaryStubbingException(join(
- heading,
- "Clean & maintainable test code requires zero unnecessary code.",
- "Following stubbings are unnecessary (click to navigate to relevant line of code):" + stubbings,
- "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class."
- ));
+ return new UnnecessaryStubbingException(
+ join(
+ heading,
+ "Clean & maintainable test code requires zero unnecessary code.",
+ "Following stubbings are unnecessary (click to navigate to relevant line of code):"
+ + stubbings,
+ "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class."));
}
public static void unncessaryStubbingException(List<Invocation> unused) {
@@ -883,39 +1076,61 @@
stubbings.append(" ").append(count++).append(". ").append(s);
stubbings.append("\n ").append(s.getLocation()).append("\n");
}
- stubbings.deleteCharAt(stubbings.length()-1); //remove trailing end of line
+ stubbings.deleteCharAt(stubbings.length() - 1); // remove trailing end of line
- throw new PotentialStubbingProblem(join(
- "Strict stubbing argument mismatch. Please check:",
- " - this invocation of '" + actualInvocation.getMethod().getName() + "' method:",
- " " + actualInvocation,
- " " + actualInvocation.getLocation(),
- " - has following stubbing(s) with different arguments:",
- stubbings,
- "Typically, stubbing argument mismatch indicates user mistake when writing tests.",
- "Mockito fails early so that you can debug potential problem easily.",
- "However, there are legit scenarios when this exception generates false negative signal:",
- " - stubbing the same method multiple times using 'given().will()' or 'when().then()' API",
- " Please use 'will().given()' or 'doReturn().when()' API for stubbing.",
- " - stubbed method is intentionally invoked with different arguments by code under test",
- " Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).",
- "For more information see javadoc for PotentialStubbingProblem class."));
+ throw new PotentialStubbingProblem(
+ join(
+ "Strict stubbing argument mismatch. Please check:",
+ " - this invocation of '"
+ + actualInvocation.getMethod().getName()
+ + "' method:",
+ " " + actualInvocation,
+ " " + actualInvocation.getLocation(),
+ " - has following stubbing(s) with different arguments:",
+ stubbings,
+ "Typically, stubbing argument mismatch indicates user mistake when writing tests.",
+ "Mockito fails early so that you can debug potential problem easily.",
+ "However, there are legit scenarios when this exception generates false negative signal:",
+ " - stubbing the same method multiple times using 'given().will()' or 'when().then()' API",
+ " Please use 'will().given()' or 'doReturn().when()' API for stubbing.",
+ " - stubbed method is intentionally invoked with different arguments by code under test",
+ " Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).",
+ "For more information see javadoc for PotentialStubbingProblem class."));
}
public static void redundantMockitoListener(String listenerType) {
- throw new RedundantListenerException(join(
- "Problems adding Mockito listener.",
- "Listener of type '" + listenerType + "' has already been added and not removed.",
- "It indicates that previous listener was not removed according to the API.",
- "When you add a listener, don't forget to remove the listener afterwards:",
- " Mockito.framework().removeListener(myListener);",
- "For more information, see the javadoc for RedundantListenerException class."));
+ throw new RedundantListenerException(
+ join(
+ "Problems adding Mockito listener.",
+ "Listener of type '"
+ + listenerType
+ + "' has already been added and not removed.",
+ "It indicates that previous listener was not removed according to the API.",
+ "When you add a listener, don't forget to remove the listener afterwards:",
+ " Mockito.framework().removeListener(myListener);",
+ "For more information, see the javadoc for RedundantListenerException class."));
}
public static void unfinishedMockingSession() {
- throw new UnfinishedMockingSessionException(join(
- "Unfinished mocking session detected.",
- "Previous MockitoSession was not concluded with 'finishMocking()'.",
- "For examples of correct usage see javadoc for MockitoSession class."));
+ throw new UnfinishedMockingSessionException(
+ join(
+ "Unfinished mocking session detected.",
+ "Previous MockitoSession was not concluded with 'finishMocking()'.",
+ "For examples of correct usage see javadoc for MockitoSession class."));
+ }
+
+ public static void missingByteBuddyDependency(Throwable t) {
+ if (t instanceof NoClassDefFoundError
+ && t.getMessage() != null
+ && t.getMessage().startsWith("net/bytebuddy/")) {
+ throw new MockitoInitializationException(
+ join(
+ "It seems like you are running Mockito with an incomplete or inconsistent class path. Byte Buddy could not be loaded.",
+ "",
+ "Byte Buddy is available on Maven Central as 'net.bytebuddy:byte-buddy' with the module name 'net.bytebuddy'.",
+ "For the inline mock maker, 'net.bytebuddy:byte-buddy-agent' with the module name 'net.bytebuddy.agent' is also required.",
+ "Normally, your IDE or build tool (such as Maven or Gradle) should take care of your class path completion but "),
+ t);
+ }
}
}
diff --git a/src/main/java/org/mockito/internal/exceptions/VerificationAwareInvocation.java b/src/main/java/org/mockito/internal/exceptions/VerificationAwareInvocation.java
index 9920aa6..865ee58 100644
--- a/src/main/java/org/mockito/internal/exceptions/VerificationAwareInvocation.java
+++ b/src/main/java/org/mockito/internal/exceptions/VerificationAwareInvocation.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.exceptions;
import org.mockito.invocation.DescribedInvocation;
@@ -10,5 +9,4 @@
public interface VerificationAwareInvocation extends DescribedInvocation {
boolean isVerified();
-
}
diff --git a/src/main/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilter.java b/src/main/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilter.java
index c0d1150..61d9664 100644
--- a/src/main/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilter.java
+++ b/src/main/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilter.java
@@ -2,14 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.exceptions.stacktrace;
+import java.io.Serializable;
+
import org.mockito.configuration.IMockitoConfiguration;
import org.mockito.internal.configuration.GlobalConfiguration;
-import java.io.Serializable;
-
public class ConditionalStackTraceFilter implements Serializable {
private static final long serialVersionUID = -8085849703510292641L;
diff --git a/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleaner.java b/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleaner.java
index 6f7b956..6b05752 100644
--- a/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleaner.java
+++ b/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleaner.java
@@ -23,7 +23,8 @@
}
private static boolean isMockDispatcher(String className) {
- return (className.contains("$$EnhancerByMockitoWithCGLIB$$") || className.contains("$MockitoMock$"));
+ return (className.contains("$$EnhancerByMockitoWithCGLIB$$")
+ || className.contains("$MockitoMock$"));
}
private static boolean isFromMockito(String className) {
@@ -36,7 +37,7 @@
private static boolean isFromMockitoRunner(String className) {
return className.startsWith("org.mockito.internal.runners.")
- || className.startsWith("org.mockito.runners.")
- || className.startsWith("org.mockito.junit.");
+ || className.startsWith("org.mockito.runners.")
+ || className.startsWith("org.mockito.junit.");
}
}
diff --git a/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleanerProvider.java b/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleanerProvider.java
index ef500ce..4a23639 100644
--- a/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleanerProvider.java
+++ b/src/main/java/org/mockito/internal/exceptions/stacktrace/DefaultStackTraceCleanerProvider.java
@@ -12,6 +12,7 @@
*/
public class DefaultStackTraceCleanerProvider implements StackTraceCleanerProvider {
+ @Override
public StackTraceCleaner getStackTraceCleaner(StackTraceCleaner defaultCleaner) {
return defaultCleaner;
}
diff --git a/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java b/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java
index e8b0cb0..ad0ede2 100644
--- a/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java
+++ b/src/main/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilter.java
@@ -2,22 +2,41 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.exceptions.stacktrace;
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
import org.mockito.exceptions.stacktrace.StackTraceCleaner;
import org.mockito.internal.configuration.plugins.Plugins;
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.List;
-
public class StackTraceFilter implements Serializable {
static final long serialVersionUID = -5499819791513105700L;
private static final StackTraceCleaner CLEANER =
- Plugins.getStackTraceCleanerProvider().getStackTraceCleaner(new DefaultStackTraceCleaner());
+ Plugins.getStackTraceCleanerProvider()
+ .getStackTraceCleaner(new DefaultStackTraceCleaner());
+
+ private static Object JAVA_LANG_ACCESS;
+ private static Method GET_STACK_TRACE_ELEMENT;
+
+ static {
+ try {
+ JAVA_LANG_ACCESS =
+ Class.forName("sun.misc.SharedSecrets")
+ .getMethod("getJavaLangAccess")
+ .invoke(null);
+ GET_STACK_TRACE_ELEMENT =
+ Class.forName("sun.misc.JavaLangAccess")
+ .getMethod("getStackTraceElement", Throwable.class, int.class);
+ } catch (Exception ignored) {
+ // Use the slow computational path for filtering stacktraces if fast path does not exist
+ // in JVM
+ }
+ }
/**
* Example how the filter works (+/- means good/bad):
@@ -26,9 +45,9 @@
* <strike>If any good are in the middle of bad those are also removed.</strike>
*/
public StackTraceElement[] filter(StackTraceElement[] target, boolean keepTop) {
- //TODO: profile
- //TODO: investigate "keepTop" commit history - no effect!
- final List<StackTraceElement> filtered = new ArrayList<StackTraceElement>();
+ // TODO: profile
+ // TODO: investigate "keepTop" commit history - no effect!
+ final List<StackTraceElement> filtered = new ArrayList<>();
for (StackTraceElement element : target) {
if (CLEANER.isIn(element)) {
filtered.add(element);
@@ -37,4 +56,78 @@
StackTraceElement[] result = new StackTraceElement[filtered.size()];
return filtered.toArray(result);
}
+
+ /**
+ * This filtering strategy makes use of a fast-path computation to retrieve stackTraceElements
+ * from a Stacktrace of a Throwable. It does so, by taking advantage of {@link
+ * sun.misc.SharedSecrets} and {@link sun.misc.JavaLangAccess}.
+ *
+ * <p>The {@link sun.misc.SharedSecrets} provides a method to obtain an instance of an {@link
+ * sun.misc.JavaLangAccess}. The latter class has a method to fast-path into {@link
+ * Throwable#getStackTrace()} and retrieve a single {@link StackTraceElement}. This prevents the
+ * JVM from having to generate a full stacktrace, which could potentially be expensive if
+ * stacktraces become very large.
+ *
+ * @param target The throwable target to find the first {@link StackTraceElement} that should
+ * not be filtered out per {@link StackTraceFilter#CLEANER}.
+ * @return The first {@link StackTraceElement} outside of the {@link StackTraceFilter#CLEANER}
+ */
+ public StackTraceElement filterFirst(Throwable target, boolean isInline) {
+ boolean shouldSkip = isInline;
+
+ if (GET_STACK_TRACE_ELEMENT != null) {
+ int i = 0;
+
+ // The assumption here is that the CLEANER filter will not filter out every single
+ // element. However, since we don't want to compute the full length of the stacktrace,
+ // we don't know the upper boundary. Therefore, simply increment the counter and go as
+ // far as we have to go, assuming that we get there. If, in the rare occasion, we
+ // don't, we fall back to the old slow path.
+ while (true) {
+ try {
+ StackTraceElement stackTraceElement =
+ (StackTraceElement)
+ GET_STACK_TRACE_ELEMENT.invoke(JAVA_LANG_ACCESS, target, i);
+
+ if (CLEANER.isIn(stackTraceElement)) {
+ if (shouldSkip) {
+ shouldSkip = false;
+ } else {
+ return stackTraceElement;
+ }
+ }
+ } catch (Exception e) {
+ // Fall back to slow path
+ break;
+ }
+ i++;
+ }
+ }
+
+ // If we can't use the fast path of retrieving stackTraceElements, use the slow path by
+ // iterating over the actual stacktrace
+ for (StackTraceElement stackTraceElement : target.getStackTrace()) {
+ if (CLEANER.isIn(stackTraceElement)) {
+ if (shouldSkip) {
+ shouldSkip = false;
+ } else {
+ return stackTraceElement;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Finds the source file of the target stack trace.
+ * Returns the default value if source file cannot be found.
+ */
+ public String findSourceFile(StackTraceElement[] target, String defaultValue) {
+ for (StackTraceElement e : target) {
+ if (CLEANER.isIn(e)) {
+ return e.getFileName();
+ }
+ }
+ return defaultValue;
+ }
}
diff --git a/src/main/java/org/mockito/internal/exceptions/util/ScenarioPrinter.java b/src/main/java/org/mockito/internal/exceptions/util/ScenarioPrinter.java
index a3e60fe..7b4375d 100644
--- a/src/main/java/org/mockito/internal/exceptions/util/ScenarioPrinter.java
+++ b/src/main/java/org/mockito/internal/exceptions/util/ScenarioPrinter.java
@@ -14,9 +14,10 @@
if (invocations.size() == 1) {
return "Actually, above is the only interaction with this mock.";
}
- StringBuilder sb = new StringBuilder(
- "***\n" +
- "For your reference, here is the list of all invocations ([?] - means unverified).\n");
+ StringBuilder sb =
+ new StringBuilder(
+ "***\n"
+ + "For your reference, here is the list of all invocations ([?] - means unverified).\n");
int counter = 0;
for (VerificationAwareInvocation i : invocations) {
@@ -28,5 +29,4 @@
}
return sb.toString();
}
-
}
diff --git a/src/main/java/org/mockito/internal/framework/DefaultMockitoFramework.java b/src/main/java/org/mockito/internal/framework/DefaultMockitoFramework.java
index d92fc28..f4a9882 100644
--- a/src/main/java/org/mockito/internal/framework/DefaultMockitoFramework.java
+++ b/src/main/java/org/mockito/internal/framework/DefaultMockitoFramework.java
@@ -4,6 +4,8 @@
*/
package org.mockito.internal.framework;
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+
import org.mockito.MockitoFramework;
import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.invocation.DefaultInvocationFactory;
@@ -14,16 +16,16 @@
import org.mockito.plugins.MockMaker;
import org.mockito.plugins.MockitoPlugins;
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-
public class DefaultMockitoFramework implements MockitoFramework {
+ @Override
public MockitoFramework addListener(MockitoListener listener) {
Checks.checkNotNull(listener, "listener");
mockingProgress().addListener(listener);
return this;
}
+ @Override
public MockitoFramework removeListener(MockitoListener listener) {
Checks.checkNotNull(listener, "listener");
mockingProgress().removeListener(listener);
diff --git a/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java b/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java
index c3f15f3..549019d 100644
--- a/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java
+++ b/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java
@@ -7,13 +7,15 @@
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.MockitoSession;
+import org.mockito.exceptions.base.MockitoException;
import org.mockito.exceptions.misusing.RedundantListenerException;
import org.mockito.internal.exceptions.Reporter;
import org.mockito.internal.junit.TestFinishedEvent;
import org.mockito.internal.junit.UniversalTestListener;
-import org.mockito.internal.util.MockitoLogger;
+import org.mockito.plugins.MockitoLogger;
import org.mockito.quality.Strictness;
+import java.util.ArrayList;
import java.util.List;
public class DefaultMockitoSession implements MockitoSession {
@@ -21,33 +23,34 @@
private final String name;
private final UniversalTestListener listener;
- public DefaultMockitoSession(List<Object> testClassInstances, String name, Strictness strictness, MockitoLogger logger) {
+ private final List<AutoCloseable> closeables = new ArrayList<>();
+
+ public DefaultMockitoSession(
+ List<Object> testClassInstances,
+ String name,
+ Strictness strictness,
+ MockitoLogger logger) {
this.name = name;
listener = new UniversalTestListener(strictness, logger);
try {
- //So that the listener can capture mock creation events
+ // So that the listener can capture mock creation events
Mockito.framework().addListener(listener);
} catch (RedundantListenerException e) {
Reporter.unfinishedMockingSession();
}
try {
for (Object testClassInstance : testClassInstances) {
- MockitoAnnotations.initMocks(testClassInstance);
+ closeables.add(MockitoAnnotations.openMocks(testClassInstance));
}
- } catch (RuntimeException | Error e) {
+ } catch (RuntimeException e) {
try {
- // TODO: ideally this scenario should be tested on DefaultMockitoSessionBuilderTest,
- // but we don't have any Android.bp project to run it.
- // Besides, the latest Mockito code (https://github.com/mockito/mockito/blob/main/src/main/java/org/mockito/internal/framework/DefaultMockitoSession.java
- // at the time this patch was merged) has a different workflow, where the listener
- // is marked as dirty when an exception is thrown, so we're forking the solution.
- Mockito.framework().removeListener(listener);
- } catch (RuntimeException | Error e2) {
- // Ignore it, as the real failure is e, thrown at the end
- System.err.println("DefaultMockitoSession: ignoring exception thrown when removing "
- + "listener " + listener);
- e2.printStackTrace(System.err);
+ release();
+ } catch (Throwable t) {
+ e.addSuppressed(t);
}
+
+ // clean up in case 'openMocks' fails
+ listener.setListenerDirty();
throw e;
}
}
@@ -64,27 +67,43 @@
@Override
public void finishMocking(final Throwable failure) {
- //Cleaning up the state, we no longer need the listener hooked up
- //The listener implements MockCreationListener and at this point
- //we no longer need to listen on mock creation events. We are wrapping up the session
- Mockito.framework().removeListener(listener);
+ try {
+ // Cleaning up the state, we no longer need the listener hooked up
+ // The listener implements MockCreationListener and at this point
+ // we no longer need to listen on mock creation events. We are wrapping up the session
+ Mockito.framework().removeListener(listener);
- //Emit test finished event so that validation such as strict stubbing can take place
- listener.testFinished(new TestFinishedEvent() {
- @Override
- public Throwable getFailure() {
- return failure;
- }
- @Override
- public String getTestName() {
- return name;
- }
- });
+ // Emit test finished event so that validation such as strict stubbing can take place
+ listener.testFinished(
+ new TestFinishedEvent() {
+ @Override
+ public Throwable getFailure() {
+ return failure;
+ }
- //Validate only when there is no test failure to avoid reporting multiple problems
- if (failure == null) {
- //Finally, validate user's misuse of Mockito framework.
- Mockito.validateMockitoUsage();
+ @Override
+ public String getTestName() {
+ return name;
+ }
+ });
+
+ // Validate only when there is no test failure to avoid reporting multiple problems
+ if (failure == null) {
+ // Finally, validate user's misuse of Mockito framework.
+ Mockito.validateMockitoUsage();
+ }
+ } finally {
+ release();
+ }
+ }
+
+ private void release() {
+ for (AutoCloseable closeable : closeables) {
+ try {
+ closeable.close();
+ } catch (Exception e) {
+ throw new MockitoException("Failed to release " + closeable, e);
+ }
}
}
}
diff --git a/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java b/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java
index 9892422..99869fa 100644
--- a/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java
+++ b/src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java
@@ -17,6 +17,7 @@
this.matcher = matcher;
}
+ @Override
public boolean matches(Object argument) {
return this.matcher.matches(argument);
}
@@ -25,8 +26,9 @@
return matcher instanceof VarargMatcher;
}
+ @Override
public String toString() {
- //TODO SF add unit tests and integ test coverage for describeTo()
+ // TODO SF add unit tests and integ test coverage for toString()
return StringDescription.toString(matcher);
}
}
diff --git a/src/main/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractor.java b/src/main/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractor.java
index f9c8806..5d46ad7 100644
--- a/src/main/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractor.java
+++ b/src/main/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractor.java
@@ -4,22 +4,22 @@
*/
package org.mockito.internal.hamcrest;
+import static org.mockito.internal.util.reflection.GenericTypeExtractor.genericTypeOf;
+
import org.hamcrest.BaseMatcher;
import org.hamcrest.Matcher;
-import static org.mockito.internal.util.reflection.GenericTypeExtractor.genericTypeOf;
-
-/**
- * Extracts generic type of matcher
- */
-public class MatcherGenericTypeExtractor {
+/** Extracts generic type of matcher */
+public final class MatcherGenericTypeExtractor {
/**
* Gets the generic type of given matcher. For example,
* for matcher class that extends BaseMatcher[Integer] this method returns Integer
*/
public static Class<?> genericTypeOfMatcher(Class<?> matcherClass) {
- //TODO SF check if we can reuse it for Mockito ArgumentMatcher
+ // TODO SF check if we can reuse it for Mockito ArgumentMatcher
return genericTypeOf(matcherClass, BaseMatcher.class, Matcher.class);
}
+
+ private MatcherGenericTypeExtractor() {}
}
diff --git a/src/main/java/org/mockito/internal/handler/InvocationNotifierHandler.java b/src/main/java/org/mockito/internal/handler/InvocationNotifierHandler.java
index da2500a..b1c84df 100644
--- a/src/main/java/org/mockito/internal/handler/InvocationNotifierHandler.java
+++ b/src/main/java/org/mockito/internal/handler/InvocationNotifierHandler.java
@@ -4,21 +4,19 @@
*/
package org.mockito.internal.handler;
-import org.mockito.invocation.InvocationContainer;
+import static org.mockito.internal.exceptions.Reporter.invocationListenerThrewException;
+
+import java.util.List;
+
import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationContainer;
import org.mockito.invocation.MockHandler;
import org.mockito.listeners.InvocationListener;
import org.mockito.mock.MockCreationSettings;
-import java.util.List;
-
-import static org.mockito.internal.exceptions.Reporter.invocationListenerThrewException;
-
/**
* Handler, that call all listeners wanted for this mock, before delegating it
* to the parameterized handler.
- *
- * Also imposterize MockHandlerImpl, delegate all call of InternalMockHandler to the real mockHandler
*/
class InvocationNotifierHandler<T> implements MockHandler<T> {
@@ -30,23 +28,24 @@
this.invocationListeners = settings.getInvocationListeners();
}
+ @Override
public Object handle(Invocation invocation) throws Throwable {
try {
Object returnedValue = mockHandler.handle(invocation);
notifyMethodCall(invocation, returnedValue);
return returnedValue;
- } catch (Throwable t){
+ } catch (Throwable t) {
notifyMethodCallException(invocation, t);
throw t;
}
}
-
private void notifyMethodCall(Invocation invocation, Object returnValue) {
for (InvocationListener listener : invocationListeners) {
try {
- listener.reportInvocation(new NotifiedMethodInvocationReport(invocation, returnValue));
- } catch(Throwable listenerThrowable) {
+ listener.reportInvocation(
+ new NotifiedMethodInvocationReport(invocation, returnValue));
+ } catch (Throwable listenerThrowable) {
throw invocationListenerThrewException(listener, listenerThrowable);
}
}
@@ -55,19 +54,21 @@
private void notifyMethodCallException(Invocation invocation, Throwable exception) {
for (InvocationListener listener : invocationListeners) {
try {
- listener.reportInvocation(new NotifiedMethodInvocationReport(invocation, exception));
- } catch(Throwable listenerThrowable) {
+ listener.reportInvocation(
+ new NotifiedMethodInvocationReport(invocation, exception));
+ } catch (Throwable listenerThrowable) {
throw invocationListenerThrewException(listener, listenerThrowable);
}
}
}
+ @Override
public MockCreationSettings<T> getMockSettings() {
return mockHandler.getMockSettings();
}
+ @Override
public InvocationContainer getInvocationContainer() {
return mockHandler.getInvocationContainer();
}
-
}
diff --git a/src/main/java/org/mockito/internal/handler/MockHandlerFactory.java b/src/main/java/org/mockito/internal/handler/MockHandlerFactory.java
index e8b44cb..c735cd4 100644
--- a/src/main/java/org/mockito/internal/handler/MockHandlerFactory.java
+++ b/src/main/java/org/mockito/internal/handler/MockHandlerFactory.java
@@ -7,14 +7,14 @@
import org.mockito.invocation.MockHandler;
import org.mockito.mock.MockCreationSettings;
-/**
- * by Szczepan Faber, created at: 5/21/12
- */
-public class MockHandlerFactory {
+/** by Szczepan Faber, created at: 5/21/12 */
+public final class MockHandlerFactory {
public static <T> MockHandler<T> createMockHandler(MockCreationSettings<T> settings) {
MockHandler<T> handler = new MockHandlerImpl<T>(settings);
MockHandler<T> nullResultGuardian = new NullResultGuardian<T>(handler);
return new InvocationNotifierHandler<T>(nullResultGuardian, settings);
}
+
+ private MockHandlerFactory() {}
}
diff --git a/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java b/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java
index a5c6458..17b967e 100644
--- a/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java
+++ b/src/main/java/org/mockito/internal/handler/MockHandlerImpl.java
@@ -4,6 +4,9 @@
*/
package org.mockito.internal.handler;
+import static org.mockito.internal.listeners.StubbingLookupNotifier.notifyStubbedAnswerLookup;
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+
import org.mockito.internal.creation.settings.CreationSettings;
import org.mockito.internal.invocation.InvocationMatcher;
import org.mockito.internal.invocation.MatchersBinder;
@@ -11,6 +14,7 @@
import org.mockito.internal.stubbing.OngoingStubbingImpl;
import org.mockito.internal.stubbing.StubbedInvocationMatcher;
import org.mockito.internal.stubbing.answers.DefaultAnswerValidator;
+import org.mockito.internal.util.MockUtil;
import org.mockito.internal.verification.MockAwareVerificationMode;
import org.mockito.internal.verification.VerificationDataImpl;
import org.mockito.invocation.Invocation;
@@ -19,9 +23,6 @@
import org.mockito.mock.MockCreationSettings;
import org.mockito.verification.VerificationMode;
-import static org.mockito.internal.listeners.StubbingLookupNotifier.notifyStubbedAnswerLookup;
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-
/**
* Invocation handler set on mock objects.
*
@@ -44,22 +45,21 @@
this.invocationContainer = new InvocationContainerImpl(mockSettings);
}
+ @Override
public Object handle(Invocation invocation) throws Throwable {
if (invocationContainer.hasAnswersForStubbing()) {
// stubbing voids with doThrow() or doAnswer() style
- InvocationMatcher invocationMatcher = matchersBinder.bindMatchers(
- mockingProgress().getArgumentMatcherStorage(),
- invocation
- );
+ InvocationMatcher invocationMatcher =
+ matchersBinder.bindMatchers(
+ mockingProgress().getArgumentMatcherStorage(), invocation);
invocationContainer.setMethodForStubbing(invocationMatcher);
return null;
}
VerificationMode verificationMode = mockingProgress().pullVerificationMode();
- InvocationMatcher invocationMatcher = matchersBinder.bindMatchers(
- mockingProgress().getArgumentMatcherStorage(),
- invocation
- );
+ InvocationMatcher invocationMatcher =
+ matchersBinder.bindMatchers(
+ mockingProgress().getArgumentMatcherStorage(), invocation);
mockingProgress().validateState();
@@ -67,12 +67,16 @@
if (verificationMode != null) {
// We need to check if verification was started on the correct mock
// - see VerifyingWithAnExtraCallToADifferentMockTest (bug 138)
- if (((MockAwareVerificationMode) verificationMode).getMock() == invocation.getMock()) {
- VerificationDataImpl data = new VerificationDataImpl(invocationContainer, invocationMatcher);
+ if (MockUtil.areSameMocks(
+ ((MockAwareVerificationMode) verificationMode).getMock(),
+ invocation.getMock())) {
+ VerificationDataImpl data =
+ new VerificationDataImpl(invocationContainer, invocationMatcher);
verificationMode.verify(data);
return null;
} else {
- // this means there is an invocation on a different mock. Re-adding verification mode
+ // this means there is an invocation on a different mock. Re-adding verification
+ // mode
// - see VerifyingWithAnExtraCallToADifferentMockTest (bug 138)
mockingProgress().verificationStarted(verificationMode);
}
@@ -86,8 +90,11 @@
// look for existing answer for this invocation
StubbedInvocationMatcher stubbing = invocationContainer.findAnswerFor(invocation);
// TODO #793 - when completed, we should be able to get rid of the casting below
- notifyStubbedAnswerLookup(invocation, stubbing, invocationContainer.getStubbingsAscending(),
- (CreationSettings) mockSettings);
+ notifyStubbedAnswerLookup(
+ invocation,
+ stubbing,
+ invocationContainer.getStubbingsAscending(),
+ (CreationSettings) mockSettings);
if (stubbing != null) {
stubbing.captureArgumentsFrom(invocation);
@@ -95,28 +102,32 @@
try {
return stubbing.answer(invocation);
} finally {
- //Needed so that we correctly isolate stubbings in some scenarios
- //see MockitoStubbedCallInAnswerTest or issue #1279
+ // Needed so that we correctly isolate stubbings in some scenarios
+ // see MockitoStubbedCallInAnswerTest or issue #1279
mockingProgress().reportOngoingStubbing(ongoingStubbing);
}
} else {
Object ret = mockSettings.getDefaultAnswer().answer(invocation);
DefaultAnswerValidator.validateReturnValueFor(invocation, ret);
- //Mockito uses it to redo setting invocation for potential stubbing in case of partial mocks / spies.
- //Without it, the real method inside 'when' might have delegated to other self method
- //and overwrite the intended stubbed method with a different one.
- //This means we would be stubbing a wrong method.
- //Typically this would led to runtime exception that validates return type with stubbed method signature.
+ // Mockito uses it to redo setting invocation for potential stubbing in case of partial
+ // mocks / spies.
+ // Without it, the real method inside 'when' might have delegated to other self method
+ // and overwrite the intended stubbed method with a different one.
+ // This means we would be stubbing a wrong method.
+ // Typically this would led to runtime exception that validates return type with stubbed
+ // method signature.
invocationContainer.resetInvocationForPotentialStubbing(invocationMatcher);
return ret;
}
}
+ @Override
public MockCreationSettings<T> getMockSettings() {
return mockSettings;
}
+ @Override
public InvocationContainer getInvocationContainer() {
return invocationContainer;
}
diff --git a/src/main/java/org/mockito/internal/handler/NotifiedMethodInvocationReport.java b/src/main/java/org/mockito/internal/handler/NotifiedMethodInvocationReport.java
index 1684f9b..39871c8 100644
--- a/src/main/java/org/mockito/internal/handler/NotifiedMethodInvocationReport.java
+++ b/src/main/java/org/mockito/internal/handler/NotifiedMethodInvocationReport.java
@@ -4,12 +4,12 @@
*/
package org.mockito.internal.handler;
+import static org.mockito.internal.matchers.Equality.areEqual;
+
import org.mockito.invocation.DescribedInvocation;
import org.mockito.invocation.Invocation;
import org.mockito.listeners.MethodInvocationReport;
-import static org.mockito.internal.matchers.Equality.areEqual;
-
/**
* Report on a method call
*/
@@ -18,7 +18,6 @@
private final Object returnedValue;
private final Throwable throwable;
-
/**
* Build a new {@link org.mockito.listeners.MethodInvocationReport} with a return value.
*
@@ -45,38 +44,50 @@
this.throwable = throwable;
}
+ @Override
public DescribedInvocation getInvocation() {
return invocation;
}
+ @Override
public Object getReturnedValue() {
return returnedValue;
}
+ @Override
public Throwable getThrowable() {
return throwable;
}
+ @Override
public boolean threwException() {
return throwable != null;
}
+ @Override
public String getLocationOfStubbing() {
- return (invocation.stubInfo() == null) ? null : invocation.stubInfo().stubbedAt().toString();
+ return (invocation.stubInfo() == null)
+ ? null
+ : invocation.stubInfo().stubbedAt().toString();
}
-
+ @Override
public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
NotifiedMethodInvocationReport that = (NotifiedMethodInvocationReport) o;
- return areEqual(invocation, that.invocation) &&
- areEqual(returnedValue, that.returnedValue) &&
- areEqual(throwable, that.throwable);
+ return areEqual(invocation, that.invocation)
+ && areEqual(returnedValue, that.returnedValue)
+ && areEqual(throwable, that.throwable);
}
+ @Override
public int hashCode() {
int result = invocation != null ? invocation.hashCode() : 0;
result = 31 * result + (returnedValue != null ? returnedValue.hashCode() : 0);
diff --git a/src/main/java/org/mockito/internal/handler/NullResultGuardian.java b/src/main/java/org/mockito/internal/handler/NullResultGuardian.java
index 7f4a3a7..65de62e 100644
--- a/src/main/java/org/mockito/internal/handler/NullResultGuardian.java
+++ b/src/main/java/org/mockito/internal/handler/NullResultGuardian.java
@@ -4,13 +4,13 @@
*/
package org.mockito.internal.handler;
-import org.mockito.invocation.InvocationContainer;
+import static org.mockito.internal.util.Primitives.defaultValue;
+
import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationContainer;
import org.mockito.invocation.MockHandler;
import org.mockito.mock.MockCreationSettings;
-import static org.mockito.internal.util.Primitives.defaultValue;
-
/**
* Protects the results from delegate MockHandler. Makes sure the results are valid.
*
@@ -28,12 +28,12 @@
public Object handle(Invocation invocation) throws Throwable {
Object result = delegate.handle(invocation);
Class<?> returnType = invocation.getMethod().getReturnType();
- if(result == null && returnType.isPrimitive()) {
- //primitive values cannot be null
+ if (result == null && returnType.isPrimitive()) {
+ // primitive values cannot be null
return defaultValue(returnType);
}
return result;
- }
+ }
@Override
public MockCreationSettings<T> getMockSettings() {
diff --git a/src/main/java/org/mockito/internal/invocation/AbstractAwareMethod.java b/src/main/java/org/mockito/internal/invocation/AbstractAwareMethod.java
index 2b36073..5e49215 100644
--- a/src/main/java/org/mockito/internal/invocation/AbstractAwareMethod.java
+++ b/src/main/java/org/mockito/internal/invocation/AbstractAwareMethod.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation;
public interface AbstractAwareMethod {
diff --git a/src/main/java/org/mockito/internal/invocation/ArgumentsProcessor.java b/src/main/java/org/mockito/internal/invocation/ArgumentsProcessor.java
index 2621193..aa3edf0 100644
--- a/src/main/java/org/mockito/internal/invocation/ArgumentsProcessor.java
+++ b/src/main/java/org/mockito/internal/invocation/ArgumentsProcessor.java
@@ -4,31 +4,34 @@
*/
package org.mockito.internal.invocation;
-import org.mockito.ArgumentMatcher;
-import org.mockito.internal.matchers.ArrayEquals;
-import org.mockito.internal.matchers.Equals;
-
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-/**
- * by Szczepan Faber, created at: 3/31/12
- */
-public class ArgumentsProcessor {
- // drops hidden synthetic parameters (last continuation parameter from Kotlin suspending functions)
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.matchers.ArrayEquals;
+import org.mockito.internal.matchers.Equals;
+
+/** by Szczepan Faber, created at: 3/31/12 */
+public final class ArgumentsProcessor {
+ // drops hidden synthetic parameters (last continuation parameter from Kotlin suspending
+ // functions)
// and expands varargs
public static Object[] expandArgs(MockitoMethod method, Object[] args) {
int nParams = method.getParameterTypes().length;
- if (args != null && args.length > nParams)
- args = Arrays.copyOf(args, nParams); // drop extra args (currently -- Kotlin continuation synthetic arg)
+ if (args != null && args.length > nParams) {
+ args = Arrays.copyOf(args, nParams);
+ } // drop extra args (currently -- Kotlin continuation synthetic
+ // arg)
return expandVarArgs(method.isVarArgs(), args);
}
// expands array varArgs that are given by runtime (1, [a, b]) into true
// varArgs (1, a, b);
private static Object[] expandVarArgs(final boolean isVarArgs, final Object[] args) {
- if (!isVarArgs || isNullOrEmpty(args) || args[args.length - 1] != null && !args[args.length - 1].getClass().isArray()) {
+ if (!isVarArgs
+ || isNullOrEmpty(args)
+ || (args[args.length - 1] != null && !args[args.length - 1].getClass().isArray())) {
return args == null ? new Object[0] : args;
}
@@ -36,7 +39,7 @@
Object[] varArgs;
if (args[nonVarArgsCount] == null) {
// in case someone deliberately passed null varArg array
- varArgs = new Object[] { null };
+ varArgs = new Object[] {null};
} else {
varArgs = ArrayEquals.createObjectArray(args[nonVarArgsCount]);
}
@@ -52,7 +55,7 @@
}
public static List<ArgumentMatcher> argumentsToMatchers(Object[] arguments) {
- List<ArgumentMatcher> matchers = new ArrayList<ArgumentMatcher>(arguments.length);
+ List<ArgumentMatcher> matchers = new ArrayList<>(arguments.length);
for (Object arg : arguments) {
if (arg != null && arg.getClass().isArray()) {
matchers.add(new ArrayEquals(arg));
@@ -63,5 +66,5 @@
return matchers;
}
-
+ private ArgumentsProcessor() {}
}
diff --git a/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java b/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java
index d08f6b1..81f8015 100644
--- a/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java
+++ b/src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java
@@ -4,48 +4,74 @@
*/
package org.mockito.internal.invocation;
+import java.lang.reflect.Method;
+import java.util.concurrent.Callable;
+
import org.mockito.internal.creation.DelegatingMethod;
-import org.mockito.internal.invocation.mockref.MockWeakReference;
import org.mockito.internal.debugging.LocationImpl;
+import org.mockito.internal.invocation.mockref.MockWeakReference;
import org.mockito.internal.progress.SequenceNumber;
import org.mockito.invocation.Invocation;
import org.mockito.invocation.InvocationFactory;
import org.mockito.invocation.Location;
import org.mockito.mock.MockCreationSettings;
-import java.lang.reflect.Method;
-import java.util.concurrent.Callable;
-
public class DefaultInvocationFactory implements InvocationFactory {
- public Invocation createInvocation(Object target, MockCreationSettings settings, Method method, final Callable realMethod, Object... args) {
+ public Invocation createInvocation(
+ Object target,
+ MockCreationSettings settings,
+ Method method,
+ final Callable realMethod,
+ Object... args) {
RealMethod superMethod = new RealMethod.FromCallable(realMethod);
return createInvocation(target, settings, method, superMethod, args);
}
- public Invocation createInvocation(Object target, MockCreationSettings settings, Method method, RealMethodBehavior realMethod, Object... args) {
+ @Override
+ public Invocation createInvocation(
+ Object target,
+ MockCreationSettings settings,
+ Method method,
+ RealMethodBehavior realMethod,
+ Object... args) {
RealMethod superMethod = new RealMethod.FromBehavior(realMethod);
return createInvocation(target, settings, method, superMethod, args);
}
- private Invocation createInvocation(Object target, MockCreationSettings settings, Method method, RealMethod superMethod, Object[] args) {
+ private Invocation createInvocation(
+ Object target,
+ MockCreationSettings settings,
+ Method method,
+ RealMethod superMethod,
+ Object[] args) {
return createInvocation(target, method, args, superMethod, settings);
}
- public static InterceptedInvocation createInvocation(Object mock, Method invokedMethod, Object[] arguments, RealMethod realMethod, MockCreationSettings settings, Location location) {
+ public static InterceptedInvocation createInvocation(
+ Object mock,
+ Method invokedMethod,
+ Object[] arguments,
+ RealMethod realMethod,
+ MockCreationSettings settings,
+ Location location) {
return new InterceptedInvocation(
- new MockWeakReference<Object>(mock),
- createMockitoMethod(invokedMethod, settings),
- arguments,
- realMethod,
- location,
- SequenceNumber.next()
- );
+ new MockWeakReference<Object>(mock),
+ createMockitoMethod(invokedMethod, settings),
+ arguments,
+ realMethod,
+ location,
+ SequenceNumber.next());
}
- private static InterceptedInvocation createInvocation(Object mock, Method invokedMethod, Object[]
- arguments, RealMethod realMethod, MockCreationSettings settings) {
- return createInvocation(mock, invokedMethod, arguments, realMethod, settings, new LocationImpl());
+ private static InterceptedInvocation createInvocation(
+ Object mock,
+ Method invokedMethod,
+ Object[] arguments,
+ RealMethod realMethod,
+ MockCreationSettings settings) {
+ return createInvocation(
+ mock, invokedMethod, arguments, realMethod, settings, new LocationImpl());
}
private static MockitoMethod createMockitoMethod(Method method, MockCreationSettings settings) {
diff --git a/src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java b/src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java
index b9cf072..20316ec 100644
--- a/src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java
+++ b/src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java
@@ -4,25 +4,29 @@
*/
package org.mockito.internal.invocation;
-import org.mockito.internal.invocation.mockref.MockReference;
+import static org.mockito.internal.exceptions.Reporter.cannotCallAbstractRealMethod;
+import static org.mockito.internal.invocation.ArgumentsProcessor.argumentsToMatchers;
+
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+
+import org.mockito.ArgumentMatcher;
import org.mockito.internal.exceptions.VerificationAwareInvocation;
+import org.mockito.internal.invocation.mockref.MockReference;
import org.mockito.internal.reporting.PrintSettings;
import org.mockito.invocation.Invocation;
import org.mockito.invocation.Location;
import org.mockito.invocation.StubInfo;
-import java.lang.reflect.Method;
-import java.util.Arrays;
-
-import static org.mockito.internal.exceptions.Reporter.cannotCallAbstractRealMethod;
-
public class InterceptedInvocation implements Invocation, VerificationAwareInvocation {
private static final long serialVersionUID = 475027563923510472L;
private final MockReference<Object> mockRef;
private final MockitoMethod mockitoMethod;
- private final Object[] arguments, rawArguments;
+ private final Object[] arguments;
+ private final Object[] rawArguments;
private final RealMethod realMethod;
private final int sequenceNumber;
@@ -33,12 +37,13 @@
private boolean isIgnoredForVerification;
private StubInfo stubInfo;
- public InterceptedInvocation(MockReference<Object> mockRef,
- MockitoMethod mockitoMethod,
- Object[] arguments,
- RealMethod realMethod,
- Location location,
- int sequenceNumber) {
+ public InterceptedInvocation(
+ MockReference<Object> mockRef,
+ MockitoMethod mockitoMethod,
+ Object[] arguments,
+ RealMethod realMethod,
+ Location location,
+ int sequenceNumber) {
this.mockRef = mockRef;
this.mockitoMethod = mockitoMethod;
this.arguments = ArgumentsProcessor.expandArgs(mockitoMethod, arguments);
@@ -120,6 +125,16 @@
}
@Override
+ public <T> T getArgument(int index, Class<T> clazz) {
+ return clazz.cast(arguments[index]);
+ }
+
+ @Override
+ public List<ArgumentMatcher> getArgumentsAsMatchers() {
+ return argumentsToMatchers(getArguments());
+ }
+
+ @Override
public Object callRealMethod() throws Throwable {
if (!realMethod.isInvokable()) {
throw cannotCallAbstractRealMethod();
@@ -127,15 +142,40 @@
return realMethod.invoke();
}
+ /**
+ * @deprecated Not used by Mockito but by mockito-scala
+ */
+ @Deprecated
+ public MockReference<Object> getMockRef() {
+ return mockRef;
+ }
+
+ /**
+ * @deprecated Not used by Mockito but by mockito-scala
+ */
+ @Deprecated
+ public MockitoMethod getMockitoMethod() {
+ return mockitoMethod;
+ }
+
+ /**
+ * @deprecated Not used by Mockito but by mockito-scala
+ */
+ @Deprecated
+ public RealMethod getRealMethod() {
+ return realMethod;
+ }
+
@Override
public int hashCode() {
- //TODO SF we need to provide hash code implementation so that there are no unexpected, slight perf issues
+ // TODO SF we need to provide hash code implementation so that there are no unexpected,
+ // slight perf issues
return 1;
}
@Override
public boolean equals(Object o) {
- if (o == null || !o.getClass().equals(this.getClass())) {
+ if (!(o instanceof InterceptedInvocation)) {
return false;
}
InterceptedInvocation other = (InterceptedInvocation) o;
@@ -148,17 +188,20 @@
return Arrays.equals(arguments, this.arguments);
}
+ @Override
public String toString() {
- return new PrintSettings().print(ArgumentsProcessor.argumentsToMatchers(getArguments()), this);
+ return new PrintSettings().print(getArgumentsAsMatchers(), this);
}
- public final static RealMethod NO_OP = new RealMethod() {
- public boolean isInvokable() {
- return false;
- }
- public Object invoke() throws Throwable {
- return null;
- }
- };
+ public static final RealMethod NO_OP =
+ new RealMethod() {
+ @Override
+ public boolean isInvokable() {
+ return false;
+ }
+ public Object invoke() throws Throwable {
+ return null;
+ }
+ };
}
diff --git a/src/main/java/org/mockito/internal/invocation/InvocationComparator.java b/src/main/java/org/mockito/internal/invocation/InvocationComparator.java
index 46dc08e..2af9358 100644
--- a/src/main/java/org/mockito/internal/invocation/InvocationComparator.java
+++ b/src/main/java/org/mockito/internal/invocation/InvocationComparator.java
@@ -4,15 +4,16 @@
*/
package org.mockito.internal.invocation;
-import org.mockito.invocation.Invocation;
-
import java.util.Comparator;
+import org.mockito.invocation.Invocation;
+
/**
* Compares invocations based on the sequence number
*/
public class InvocationComparator implements Comparator<Invocation> {
+ @Override
public int compare(Invocation o1, Invocation o2) {
- return Integer.valueOf(o1.getSequenceNumber()).compareTo(o2.getSequenceNumber());
+ return Integer.compare(o1.getSequenceNumber(), o2.getSequenceNumber());
}
}
diff --git a/src/main/java/org/mockito/internal/invocation/InvocationMarker.java b/src/main/java/org/mockito/internal/invocation/InvocationMarker.java
index fc48b4d..5f32dea 100644
--- a/src/main/java/org/mockito/internal/invocation/InvocationMarker.java
+++ b/src/main/java/org/mockito/internal/invocation/InvocationMarker.java
@@ -4,15 +4,15 @@
*/
package org.mockito.internal.invocation;
+import java.util.List;
+
import org.mockito.internal.verification.api.InOrderContext;
import org.mockito.invocation.Invocation;
import org.mockito.invocation.MatchableInvocation;
-import java.util.List;
-
public class InvocationMarker {
- private InvocationMarker(){}
+ private InvocationMarker() {}
public static void markVerified(List<Invocation> invocations, MatchableInvocation wanted) {
for (Invocation invocation : invocations) {
@@ -25,7 +25,8 @@
wanted.captureArgumentsFrom(invocation);
}
- public static void markVerifiedInOrder(List<Invocation> chunk, MatchableInvocation wanted, InOrderContext context) {
+ public static void markVerifiedInOrder(
+ List<Invocation> chunk, MatchableInvocation wanted, InOrderContext context) {
markVerified(chunk, wanted);
for (Invocation i : chunk) {
diff --git a/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java b/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java
index 83a28ff..6cc7a8c 100644
--- a/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java
+++ b/src/main/java/org/mockito/internal/invocation/InvocationMatcher.java
@@ -2,10 +2,8 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation;
-import static org.mockito.internal.invocation.ArgumentsProcessor.argumentsToMatchers;
import static org.mockito.internal.invocation.MatcherApplicationStrategy.getMatcherApplicationStrategyFor;
import static org.mockito.internal.invocation.TypeSafeMatching.matchesTypeSafe;
@@ -15,6 +13,7 @@
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
+
import org.mockito.ArgumentMatcher;
import org.mockito.internal.matchers.CapturesArguments;
import org.mockito.internal.reporting.PrintSettings;
@@ -32,11 +31,11 @@
private final Invocation invocation;
private final List<ArgumentMatcher<?>> matchers;
- @SuppressWarnings({ "rawtypes", "unchecked" })
+ @SuppressWarnings({"rawtypes", "unchecked"})
public InvocationMatcher(Invocation invocation, List<ArgumentMatcher> matchers) {
this.invocation = invocation;
if (matchers.isEmpty()) {
- this.matchers = (List) argumentsToMatchers(invocation.getArguments());
+ this.matchers = (List) invocation.getArgumentsAsMatchers();
} else {
this.matchers = (List) matchers;
}
@@ -44,11 +43,11 @@
@SuppressWarnings("rawtypes")
public InvocationMatcher(Invocation invocation) {
- this(invocation, Collections.<ArgumentMatcher> emptyList());
+ this(invocation, Collections.<ArgumentMatcher>emptyList());
}
public static List<InvocationMatcher> createFrom(List<Invocation> invocations) {
- LinkedList<InvocationMatcher> out = new LinkedList<InvocationMatcher>();
+ LinkedList<InvocationMatcher> out = new LinkedList<>();
for (Invocation i : invocations) {
out.add(new InvocationMatcher(i));
}
@@ -65,20 +64,22 @@
}
@Override
- @SuppressWarnings({ "unchecked", "rawtypes" })
+ @SuppressWarnings({"unchecked", "rawtypes"})
public List<ArgumentMatcher> getMatchers() {
return (List) matchers;
}
@Override
- @SuppressWarnings({ "unchecked", "rawtypes" })
+ @SuppressWarnings({"unchecked", "rawtypes"})
public String toString() {
return new PrintSettings().print((List) matchers, invocation);
}
@Override
public boolean matches(Invocation candidate) {
- return invocation.getMock().equals(candidate.getMock()) && hasSameMethod(candidate) && argumentsMatch(candidate);
+ return invocation.getMock() == candidate.getMock()
+ && hasSameMethod(candidate)
+ && argumentsMatch(candidate);
}
/**
@@ -108,7 +109,8 @@
@Override
public boolean hasSameMethod(Invocation candidate) {
// not using method.equals() for 1 good reason:
- // sometimes java generates forwarding methods when generics are in play see JavaGenericsForwardingMethodsTest
+ // sometimes java generates forwarding methods when generics are in play see
+ // JavaGenericsForwardingMethodsTest
Method m1 = invocation.getMethod();
Method m2 = candidate.getMethod();
@@ -128,7 +130,8 @@
@Override
public void captureArgumentsFrom(Invocation invocation) {
- MatcherApplicationStrategy strategy = getMatcherApplicationStrategyFor(invocation, matchers);
+ MatcherApplicationStrategy strategy =
+ getMatcherApplicationStrategyFor(invocation, matchers);
strategy.forEachMatcherAndArgument(captureArgument());
}
@@ -146,9 +149,10 @@
};
}
- @SuppressWarnings({ "rawtypes", "unchecked" })
+ @SuppressWarnings({"rawtypes", "unchecked"})
private boolean argumentsMatch(Invocation actual) {
List matchers = getMatchers();
- return getMatcherApplicationStrategyFor(actual, matchers).forEachMatcherAndArgument( matchesTypeSafe());
+ return getMatcherApplicationStrategyFor(actual, matchers)
+ .forEachMatcherAndArgument(matchesTypeSafe());
}
}
diff --git a/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java b/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java
index 260321b..fc0cb22 100644
--- a/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java
+++ b/src/main/java/org/mockito/internal/invocation/InvocationsFinder.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation;
import java.util.LinkedList;
@@ -17,14 +16,17 @@
public class InvocationsFinder {
- private InvocationsFinder() {
- }
+ private InvocationsFinder() {}
- public static List<Invocation> findInvocations(List<Invocation> invocations, MatchableInvocation wanted) {
+ public static List<Invocation> findInvocations(
+ List<Invocation> invocations, MatchableInvocation wanted) {
return ListUtil.filter(invocations, new RemoveNotMatching(wanted));
}
- public static List<Invocation> findAllMatchingUnverifiedChunks(List<Invocation> invocations, MatchableInvocation wanted, InOrderContext orderingContext) {
+ public static List<Invocation> findAllMatchingUnverifiedChunks(
+ List<Invocation> invocations,
+ MatchableInvocation wanted,
+ InOrderContext orderingContext) {
List<Invocation> unverified = removeVerifiedInOrder(invocations, orderingContext);
return ListUtil.filter(unverified, new RemoveNotMatching(wanted));
}
@@ -44,7 +46,11 @@
* if wanted is 1 and mode is times(x), where x != 2 then returns
* 1,1,1
*/
- public static List<Invocation> findMatchingChunk(List<Invocation> invocations, MatchableInvocation wanted, int wantedCount, InOrderContext context) {
+ public static List<Invocation> findMatchingChunk(
+ List<Invocation> invocations,
+ MatchableInvocation wanted,
+ int wantedCount,
+ InOrderContext context) {
List<Invocation> unverified = removeVerifiedInOrder(invocations, context);
List<Invocation> firstChunk = getFirstMatchingChunk(wanted, unverified);
@@ -55,8 +61,9 @@
}
}
- private static List<Invocation> getFirstMatchingChunk(MatchableInvocation wanted, List<Invocation> unverified) {
- List<Invocation> firstChunk = new LinkedList<Invocation>();
+ private static List<Invocation> getFirstMatchingChunk(
+ MatchableInvocation wanted, List<Invocation> unverified) {
+ List<Invocation> firstChunk = new LinkedList<>();
for (Invocation invocation : unverified) {
if (wanted.matches(invocation)) {
firstChunk.add(invocation);
@@ -67,16 +74,18 @@
return firstChunk;
}
- public static Invocation findFirstMatchingUnverifiedInvocation(List<Invocation> invocations, MatchableInvocation wanted, InOrderContext context ){
- for( Invocation invocation : removeVerifiedInOrder( invocations, context )){
- if( wanted.matches( invocation )){
+ public static Invocation findFirstMatchingUnverifiedInvocation(
+ List<Invocation> invocations, MatchableInvocation wanted, InOrderContext context) {
+ for (Invocation invocation : removeVerifiedInOrder(invocations, context)) {
+ if (wanted.matches(invocation)) {
return invocation;
}
}
return null;
}
- public static Invocation findSimilarInvocation(List<Invocation> invocations, MatchableInvocation wanted) {
+ public static Invocation findSimilarInvocation(
+ List<Invocation> invocations, MatchableInvocation wanted) {
Invocation firstSimilar = null;
for (Invocation invocation : invocations) {
if (!wanted.hasSimilarMethod(invocation)) {
@@ -116,8 +125,10 @@
}
}
- public static Invocation findPreviousVerifiedInOrder(List<Invocation> invocations, InOrderContext context) {
- LinkedList<Invocation> verifiedOnly = ListUtil.filter(invocations, new RemoveUnverifiedInOrder(context));
+ public static Invocation findPreviousVerifiedInOrder(
+ List<Invocation> invocations, InOrderContext context) {
+ LinkedList<Invocation> verifiedOnly =
+ ListUtil.filter(invocations, new RemoveUnverifiedInOrder(context));
if (verifiedOnly.isEmpty()) {
return null;
@@ -126,8 +137,9 @@
}
}
- private static List<Invocation> removeVerifiedInOrder(List<Invocation> invocations, InOrderContext orderingContext) {
- List<Invocation> unverified = new LinkedList<Invocation>();
+ private static List<Invocation> removeVerifiedInOrder(
+ List<Invocation> invocations, InOrderContext orderingContext) {
+ List<Invocation> unverified = new LinkedList<>();
for (Invocation i : invocations) {
if (orderingContext.isVerified(i)) {
unverified.clear();
@@ -139,7 +151,7 @@
}
public static List<Location> getAllLocations(List<Invocation> invocations) {
- List<Location> locations = new LinkedList<Location>();
+ List<Location> locations = new LinkedList<>();
for (Invocation invocation : invocations) {
locations.add(invocation.getLocation());
}
@@ -153,6 +165,7 @@
this.wanted = wanted;
}
+ @Override
public boolean isOut(Invocation invocation) {
return !wanted.matches(invocation);
}
@@ -165,6 +178,7 @@
this.orderingContext = orderingContext;
}
+ @Override
public boolean isOut(Invocation invocation) {
return !orderingContext.isVerified(invocation);
}
@@ -184,9 +198,10 @@
* @param context
* @param orderedInvocations
*/
- public static Invocation findFirstUnverifiedInOrder(InOrderContext context, List<Invocation> orderedInvocations) {
+ public static Invocation findFirstUnverifiedInOrder(
+ InOrderContext context, List<Invocation> orderedInvocations) {
Invocation candidate = null;
- for(Invocation i : orderedInvocations) {
+ for (Invocation i : orderedInvocations) {
if (!context.isVerified(i)) {
candidate = candidate != null ? candidate : i;
} else {
diff --git a/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java b/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java
index e47156f..acc7382 100644
--- a/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java
+++ b/src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java
@@ -23,9 +23,10 @@
private final List<ArgumentMatcher<?>> matchers;
private final MatcherApplicationType matchingType;
-
-
- private MatcherApplicationStrategy(Invocation invocation, List<ArgumentMatcher<?>> matchers, MatcherApplicationType matchingType) {
+ private MatcherApplicationStrategy(
+ Invocation invocation,
+ List<ArgumentMatcher<?>> matchers,
+ MatcherApplicationType matchingType) {
this.invocation = invocation;
if (matchingType == MATCH_EACH_VARARGS_WITH_LAST_MATCHER) {
int times = varargLength(invocation);
@@ -49,7 +50,8 @@
* {@link CapturingMatcher}
* @return never <code>null</code>
*/
- public static MatcherApplicationStrategy getMatcherApplicationStrategyFor(Invocation invocation, List<ArgumentMatcher<?>> matchers) {
+ public static MatcherApplicationStrategy getMatcherApplicationStrategyFor(
+ Invocation invocation, List<ArgumentMatcher<?>> matchers) {
MatcherApplicationType type = getMatcherApplicationType(invocation, matchers);
return new MatcherApplicationStrategy(invocation, matchers, type);
@@ -72,8 +74,9 @@
* </ul>
*/
public boolean forEachMatcherAndArgument(ArgumentMatcherAction action) {
- if (matchingType == ERROR_UNSUPPORTED_NUMBER_OF_MATCHERS)
+ if (matchingType == ERROR_UNSUPPORTED_NUMBER_OF_MATCHERS) {
return false;
+ }
Object[] arguments = invocation.getArguments();
for (int i = 0; i < arguments.length; i++) {
@@ -87,7 +90,8 @@
return true;
}
- private static MatcherApplicationType getMatcherApplicationType(Invocation invocation, List<ArgumentMatcher<?>> matchers) {
+ private static MatcherApplicationType getMatcherApplicationType(
+ Invocation invocation, List<ArgumentMatcher<?>> matchers) {
final int rawArguments = invocation.getRawArguments().length;
final int expandedArguments = invocation.getArguments().length;
final int matcherCount = matchers.size();
@@ -106,12 +110,13 @@
private static boolean isLastMatcherVarargMatcher(final List<ArgumentMatcher<?>> matchers) {
ArgumentMatcher<?> argumentMatcher = lastMatcher(matchers);
if (argumentMatcher instanceof HamcrestArgumentMatcher<?>) {
- return ((HamcrestArgumentMatcher<?>) argumentMatcher).isVarargMatcher();
+ return ((HamcrestArgumentMatcher<?>) argumentMatcher).isVarargMatcher();
}
return argumentMatcher instanceof VarargMatcher;
}
- private static List<ArgumentMatcher<?>> appendLastMatcherNTimes(List<ArgumentMatcher<?>> matchers, int timesToAppendLastMatcher) {
+ private static List<ArgumentMatcher<?>> appendLastMatcherNTimes(
+ List<ArgumentMatcher<?>> matchers, int timesToAppendLastMatcher) {
ArgumentMatcher<?> lastMatcher = lastMatcher(matchers);
List<ArgumentMatcher<?>> expandedMatchers = new ArrayList<ArgumentMatcher<?>>(matchers);
@@ -132,6 +137,8 @@
}
enum MatcherApplicationType {
- ONE_MATCHER_PER_ARGUMENT, MATCH_EACH_VARARGS_WITH_LAST_MATCHER, ERROR_UNSUPPORTED_NUMBER_OF_MATCHERS;
+ ONE_MATCHER_PER_ARGUMENT,
+ MATCH_EACH_VARARGS_WITH_LAST_MATCHER,
+ ERROR_UNSUPPORTED_NUMBER_OF_MATCHERS;
}
}
diff --git a/src/main/java/org/mockito/internal/invocation/MatchersBinder.java b/src/main/java/org/mockito/internal/invocation/MatchersBinder.java
index 8a01d2c..dd3f239 100644
--- a/src/main/java/org/mockito/internal/invocation/MatchersBinder.java
+++ b/src/main/java/org/mockito/internal/invocation/MatchersBinder.java
@@ -2,10 +2,8 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation;
-
import static org.mockito.internal.exceptions.Reporter.invalidUseOfMatchers;
import java.io.Serializable;
@@ -20,11 +18,12 @@
@SuppressWarnings("unchecked")
public class MatchersBinder implements Serializable {
- public InvocationMatcher bindMatchers(ArgumentMatcherStorage argumentMatcherStorage, Invocation invocation) {
+ public InvocationMatcher bindMatchers(
+ ArgumentMatcherStorage argumentMatcherStorage, Invocation invocation) {
List<LocalizedMatcher> lastMatchers = argumentMatcherStorage.pullLocalizedMatchers();
validateMatchers(invocation, lastMatchers);
- List<ArgumentMatcher> matchers = new LinkedList<ArgumentMatcher>();
+ List<ArgumentMatcher> matchers = new LinkedList<>();
for (LocalizedMatcher m : lastMatchers) {
matchers.add(m.getMatcher());
}
diff --git a/src/main/java/org/mockito/internal/invocation/RealMethod.java b/src/main/java/org/mockito/internal/invocation/RealMethod.java
index b7c8c17..8cb8b72 100644
--- a/src/main/java/org/mockito/internal/invocation/RealMethod.java
+++ b/src/main/java/org/mockito/internal/invocation/RealMethod.java
@@ -4,13 +4,13 @@
*/
package org.mockito.internal.invocation;
+import java.io.Serializable;
+import java.util.concurrent.Callable;
+
import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
import org.mockito.invocation.InvocationFactory;
import org.mockito.invocation.InvocationOnMock;
-import java.io.Serializable;
-import java.util.concurrent.Callable;
-
/**
* Interface that wraps a 'real' method of the mock object.
* Needed for test spies or {@link InvocationOnMock#callRealMethod()}.
@@ -18,7 +18,6 @@
public interface RealMethod extends Serializable {
enum IsIllegal implements RealMethod {
-
INSTANCE;
@Override
@@ -34,12 +33,13 @@
class FromCallable extends FromBehavior implements RealMethod {
public FromCallable(final Callable<?> callable) {
- super(new InvocationFactory.RealMethodBehavior() {
- @Override
- public Object call() throws Throwable {
- return callable.call();
- }
- });
+ super(
+ new InvocationFactory.RealMethodBehavior() {
+ @Override
+ public Object call() throws Throwable {
+ return callable.call();
+ }
+ });
}
}
diff --git a/src/main/java/org/mockito/internal/invocation/SerializableMethod.java b/src/main/java/org/mockito/internal/invocation/SerializableMethod.java
index 0ebbe97..f007371 100644
--- a/src/main/java/org/mockito/internal/invocation/SerializableMethod.java
+++ b/src/main/java/org/mockito/internal/invocation/SerializableMethod.java
@@ -4,14 +4,14 @@
*/
package org.mockito.internal.invocation;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.creation.SuspendMethod;
-
import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.creation.SuspendMethod;
+
public class SerializableMethod implements Serializable, MockitoMethod {
private static final long serialVersionUID = 6005610965006048445L;
@@ -24,7 +24,7 @@
private final boolean isVarArgs;
private final boolean isAbstract;
- private volatile transient Method method;
+ private transient volatile Method method;
public SerializableMethod(Method method) {
this.method = method;
@@ -37,30 +37,37 @@
isAbstract = (method.getModifiers() & Modifier.ABSTRACT) != 0;
}
+ @Override
public String getName() {
return methodName;
}
+ @Override
public Class<?> getReturnType() {
return returnType;
}
+ @Override
public Class<?>[] getParameterTypes() {
return parameterTypes;
}
+ @Override
public Class<?>[] getExceptionTypes() {
return exceptionTypes;
}
+ @Override
public boolean isVarArgs() {
return isVarArgs;
}
+ @Override
public boolean isAbstract() {
return isAbstract;
}
+ @Override
public Method getJavaMethod() {
if (method != null) {
return method;
@@ -69,14 +76,18 @@
method = declaringClass.getDeclaredMethod(methodName, parameterTypes);
return method;
} catch (SecurityException e) {
- String message = String.format(
- "The method %1$s.%2$s is probably private or protected and cannot be mocked.\n" +
- "Please report this as a defect with an example of how to reproduce it.", declaringClass, methodName);
+ String message =
+ String.format(
+ "The method %1$s.%2$s is probably private or protected and cannot be mocked.\n"
+ + "Please report this as a defect with an example of how to reproduce it.",
+ declaringClass, methodName);
throw new MockitoException(message, e);
} catch (NoSuchMethodException e) {
- String message = String.format(
- "The method %1$s.%2$s does not exists and you should not get to this point.\n" +
- "Please report this as a defect with an example of how to reproduce it.", declaringClass, methodName);
+ String message =
+ String.format(
+ "The method %1$s.%2$s does not exists and you should not get to this point.\n"
+ + "Please report this as a defect with an example of how to reproduce it.",
+ declaringClass, methodName);
throw new MockitoException(message, e);
}
}
@@ -88,30 +99,40 @@
@Override
public boolean equals(Object obj) {
- if (this == obj)
+ if (this == obj) {
return true;
- if (obj == null)
+ }
+ if (obj == null) {
return false;
- if (getClass() != obj.getClass())
+ }
+ if (getClass() != obj.getClass()) {
return false;
+ }
SerializableMethod other = (SerializableMethod) obj;
if (declaringClass == null) {
- if (other.declaringClass != null)
+ if (other.declaringClass != null) {
return false;
- } else if (!declaringClass.equals(other.declaringClass))
+ }
+ } else if (!declaringClass.equals(other.declaringClass)) {
return false;
+ }
if (methodName == null) {
- if (other.methodName != null)
+ if (other.methodName != null) {
return false;
- } else if (!methodName.equals(other.methodName))
+ }
+ } else if (!methodName.equals(other.methodName)) {
return false;
- if (!Arrays.equals(parameterTypes, other.parameterTypes))
+ }
+ if (!Arrays.equals(parameterTypes, other.parameterTypes)) {
return false;
+ }
if (returnType == null) {
- if (other.returnType != null)
+ if (other.returnType != null) {
return false;
- } else if (!returnType.equals(other.returnType))
+ }
+ } else if (!returnType.equals(other.returnType)) {
return false;
+ }
return true;
}
}
diff --git a/src/main/java/org/mockito/internal/invocation/StubInfoImpl.java b/src/main/java/org/mockito/internal/invocation/StubInfoImpl.java
index 794d25a..c2720d3 100644
--- a/src/main/java/org/mockito/internal/invocation/StubInfoImpl.java
+++ b/src/main/java/org/mockito/internal/invocation/StubInfoImpl.java
@@ -4,12 +4,12 @@
*/
package org.mockito.internal.invocation;
+import java.io.Serializable;
+
import org.mockito.invocation.DescribedInvocation;
import org.mockito.invocation.Location;
import org.mockito.invocation.StubInfo;
-import java.io.Serializable;
-
public class StubInfoImpl implements StubInfo, Serializable {
private static final long serialVersionUID = 2125827349332068867L;
private final DescribedInvocation stubbedAt;
@@ -18,6 +18,7 @@
this.stubbedAt = stubbedAt;
}
+ @Override
public Location stubbedAt() {
return stubbedAt.getLocation();
}
diff --git a/src/main/java/org/mockito/internal/invocation/TypeSafeMatching.java b/src/main/java/org/mockito/internal/invocation/TypeSafeMatching.java
index 1452137..b4ca07a 100644
--- a/src/main/java/org/mockito/internal/invocation/TypeSafeMatching.java
+++ b/src/main/java/org/mockito/internal/invocation/TypeSafeMatching.java
@@ -8,31 +8,31 @@
import org.mockito.ArgumentMatcher;
-@SuppressWarnings({"unchecked","rawtypes"})
+@SuppressWarnings({"unchecked", "rawtypes"})
public class TypeSafeMatching implements ArgumentMatcherAction {
- private final static ArgumentMatcherAction TYPE_SAFE_MATCHING_ACTION = new TypeSafeMatching();
+ private static final ArgumentMatcherAction TYPE_SAFE_MATCHING_ACTION = new TypeSafeMatching();
private TypeSafeMatching() {}
-
- public static ArgumentMatcherAction matchesTypeSafe(){
+ public static ArgumentMatcherAction matchesTypeSafe() {
return TYPE_SAFE_MATCHING_ACTION;
}
+
@Override
public boolean apply(ArgumentMatcher matcher, Object argument) {
return isCompatible(matcher, argument) && matcher.matches(argument);
}
-
/**
* Returns <code>true</code> if the given <b>argument</b> can be passed to
* the given <code>argumentMatcher</code> without causing a
* {@link ClassCastException}.
*/
private static boolean isCompatible(ArgumentMatcher<?> argumentMatcher, Object argument) {
- if (argument == null)
+ if (argument == null) {
return true;
+ }
Class<?> expectedArgumentType = getArgumentType(argumentMatcher);
@@ -51,7 +51,10 @@
return method.getParameterTypes()[0];
}
}
- throw new NoSuchMethodError("Method 'matches(T)' not found in ArgumentMatcher: " + argumentMatcher + " !\r\n Please file a bug with this stack trace at: https://github.com/mockito/mockito/issues/new ");
+ throw new NoSuchMethodError(
+ "Method 'matches(T)' not found in ArgumentMatcher: "
+ + argumentMatcher
+ + " !\r\n Please file a bug with this stack trace at: https://github.com/mockito/mockito/issues/new ");
}
/**
diff --git a/src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java b/src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java
index 5aec36d..fd8efa6 100644
--- a/src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java
+++ b/src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java
@@ -2,16 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation;
+import java.util.LinkedList;
+import java.util.List;
+
import org.mockito.internal.util.MockUtil;
import org.mockito.invocation.Invocation;
import org.mockito.stubbing.Stubbing;
-import java.util.LinkedList;
-import java.util.List;
-
@Deprecated
public class UnusedStubsFinder {
@@ -21,12 +20,13 @@
* @param mocks full list of mocks
*/
public List<Invocation> find(List<?> mocks) {
- List<Invocation> unused = new LinkedList<Invocation>();
+ List<Invocation> unused = new LinkedList<>();
for (Object mock : mocks) {
- List<Stubbing> fromSingleMock = MockUtil.getInvocationContainer(mock).getStubbingsDescending();
- for(Stubbing s : fromSingleMock) {
+ List<Stubbing> fromSingleMock =
+ MockUtil.getInvocationContainer(mock).getStubbingsDescending();
+ for (Stubbing s : fromSingleMock) {
if (!s.wasUsed()) {
- unused.add(s.getInvocation());
+ unused.add(s.getInvocation());
}
}
}
diff --git a/src/main/java/org/mockito/internal/invocation/finder/AllInvocationsFinder.java b/src/main/java/org/mockito/internal/invocation/finder/AllInvocationsFinder.java
index 15dafdf..4d1e767 100644
--- a/src/main/java/org/mockito/internal/invocation/finder/AllInvocationsFinder.java
+++ b/src/main/java/org/mockito/internal/invocation/finder/AllInvocationsFinder.java
@@ -2,16 +2,18 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation.finder;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
import org.mockito.internal.invocation.InvocationComparator;
-import org.mockito.stubbing.Stubbing;
import org.mockito.internal.stubbing.StubbingComparator;
import org.mockito.internal.util.DefaultMockingDetails;
import org.mockito.invocation.Invocation;
-
-import java.util.*;
+import org.mockito.stubbing.Stubbing;
public class AllInvocationsFinder {
@@ -24,13 +26,14 @@
* @return invocations
*/
public static List<Invocation> find(Iterable<?> mocks) {
- Set<Invocation> invocationsInOrder = new TreeSet<Invocation>(new InvocationComparator());
+ Set<Invocation> invocationsInOrder = new TreeSet<>(new InvocationComparator());
for (Object mock : mocks) {
- Collection<Invocation> fromSingleMock = new DefaultMockingDetails(mock).getInvocations();
+ Collection<Invocation> fromSingleMock =
+ new DefaultMockingDetails(mock).getInvocations();
invocationsInOrder.addAll(fromSingleMock);
}
- return new LinkedList<Invocation>(invocationsInOrder);
+ return new LinkedList<>(invocationsInOrder);
}
/**
@@ -40,9 +43,16 @@
* @return stubbings
*/
public static Set<Stubbing> findStubbings(Iterable<?> mocks) {
- Set<Stubbing> stubbings = new TreeSet<Stubbing>(new StubbingComparator());
+ Set<Stubbing> stubbings = new TreeSet<>(new StubbingComparator());
for (Object mock : mocks) {
- Collection<? extends Stubbing> fromSingleMock = new DefaultMockingDetails(mock).getStubbings();
+ // TODO due to the limited scope of static mocks they cannot be processed
+ // it would rather be required to trigger this stubbing control upon releasing
+ // the static mock.
+ if (mock instanceof Class<?>) {
+ continue;
+ }
+ Collection<? extends Stubbing> fromSingleMock =
+ new DefaultMockingDetails(mock).getStubbings();
stubbings.addAll(fromSingleMock);
}
diff --git a/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java b/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java
index 819c7e0..19b0ac0 100644
--- a/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java
+++ b/src/main/java/org/mockito/internal/invocation/finder/VerifiableInvocationsFinder.java
@@ -2,15 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation.finder;
+import java.util.List;
+
import org.mockito.internal.util.collections.ListUtil;
import org.mockito.internal.util.collections.ListUtil.Filter;
import org.mockito.invocation.Invocation;
-import java.util.List;
-
/**
* Author: Szczepan Faber, created at: 4/3/11
*/
@@ -23,7 +22,8 @@
return ListUtil.filter(invocations, new RemoveIgnoredForVerification());
}
- private static class RemoveIgnoredForVerification implements Filter<Invocation>{
+ private static class RemoveIgnoredForVerification implements Filter<Invocation> {
+ @Override
public boolean isOut(Invocation invocation) {
return invocation.isIgnoredForVerification();
}
diff --git a/src/main/java/org/mockito/internal/invocation/mockref/MockReference.java b/src/main/java/org/mockito/internal/invocation/mockref/MockReference.java
index 0dac2ea..3a42c57 100644
--- a/src/main/java/org/mockito/internal/invocation/mockref/MockReference.java
+++ b/src/main/java/org/mockito/internal/invocation/mockref/MockReference.java
@@ -2,7 +2,6 @@
* Copyright (c) 2018 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation.mockref;
import java.io.Serializable;
diff --git a/src/main/java/org/mockito/internal/invocation/mockref/MockStrongReference.java b/src/main/java/org/mockito/internal/invocation/mockref/MockStrongReference.java
index 3b20ee5..b80883b 100644
--- a/src/main/java/org/mockito/internal/invocation/mockref/MockStrongReference.java
+++ b/src/main/java/org/mockito/internal/invocation/mockref/MockStrongReference.java
@@ -2,7 +2,6 @@
* Copyright (c) 2018 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation.mockref;
import java.io.ObjectStreamException;
diff --git a/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java b/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java
index 256745b..ddf7f68 100644
--- a/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java
+++ b/src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java
@@ -2,7 +2,6 @@
* Copyright (c) 2018 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation.mockref;
import java.io.ObjectStreamException;
@@ -29,14 +28,15 @@
T ref = this.ref.get();
if (ref == null) {
- throw new IllegalStateException("The mock object was garbage collected. " +
- "This should not happen in normal circumstances when using public API. " +
- "Typically, the test class keeps strong reference to the mock object " +
- "and it prevents getting the mock collected. Mockito internally needs " +
- "to keep weak references to mock objects to avoid memory leaks for " +
- "certain types of MockMaker implementations. If you see this exception " +
- "using Mockito public API, please file a bug. For more information see " +
- "issue #1313.");
+ throw new IllegalStateException(
+ "The mock object was garbage collected. "
+ + "This should not happen in normal circumstances when using public API. "
+ + "Typically, the test class keeps strong reference to the mock object "
+ + "and it prevents getting the mock collected. Mockito internally needs "
+ + "to keep weak references to mock objects to avoid memory leaks for "
+ + "certain types of MockMaker implementations. If you see this exception "
+ + "using Mockito public API, please file a bug. For more information see "
+ + "issue #1313.");
}
return ref;
diff --git a/src/main/java/org/mockito/internal/junit/ArgMismatchFinder.java b/src/main/java/org/mockito/internal/junit/ArgMismatchFinder.java
index e1de445..9c4ec44 100644
--- a/src/main/java/org/mockito/internal/junit/ArgMismatchFinder.java
+++ b/src/main/java/org/mockito/internal/junit/ArgMismatchFinder.java
@@ -20,9 +20,13 @@
continue;
}
for (Stubbing stubbing : AllInvocationsFinder.findStubbings(mocks)) {
- //method name & mock matches
- if (!stubbing.wasUsed() && stubbing.getInvocation().getMock() == i.getMock()
- && stubbing.getInvocation().getMethod().getName().equals(i.getMethod().getName())) {
+ // method name & mock matches
+ if (!stubbing.wasUsed()
+ && stubbing.getInvocation().getMock() == i.getMock()
+ && stubbing.getInvocation()
+ .getMethod()
+ .getName()
+ .equals(i.getMethod().getName())) {
mismatches.add(i, stubbing.getInvocation());
}
}
diff --git a/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java b/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java
index 4885d63..c713863 100644
--- a/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java
+++ b/src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java
@@ -4,25 +4,28 @@
*/
package org.mockito.internal.junit;
-import org.mockito.internal.exceptions.Reporter;
-import org.mockito.internal.listeners.StubbingLookupEvent;
-import org.mockito.internal.listeners.StubbingLookupListener;
-import org.mockito.internal.stubbing.UnusedStubbingReporting;
-import org.mockito.invocation.Invocation;
-import org.mockito.quality.Strictness;
-import org.mockito.stubbing.Stubbing;
+import static org.mockito.internal.stubbing.StrictnessSelector.determineStrictness;
+import java.io.Serializable;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
-import static org.mockito.internal.stubbing.StrictnessSelector.determineStrictness;
+import org.mockito.internal.exceptions.Reporter;
+import org.mockito.internal.stubbing.UnusedStubbingReporting;
+import org.mockito.invocation.Invocation;
+import org.mockito.listeners.StubbingLookupEvent;
+import org.mockito.listeners.StubbingLookupListener;
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.Stubbing;
/**
* Default implementation of stubbing lookup listener.
* Fails early if stub called with unexpected arguments, but only if current strictness is set to STRICT_STUBS.
*/
-class DefaultStubbingLookupListener implements StubbingLookupListener {
+class DefaultStubbingLookupListener implements StubbingLookupListener, Serializable {
+
+ private static final long serialVersionUID = -6789800638070123629L;
private Strictness currentStrictness;
private boolean mismatchesReported;
@@ -31,33 +34,51 @@
this.currentStrictness = strictness;
}
+ @Override
public void onStubbingLookup(StubbingLookupEvent event) {
- Strictness actualStrictness = determineStrictness(event.getStubbingFound(), event.getMockSettings(), currentStrictness);
+ Strictness actualStrictness =
+ determineStrictness(
+ event.getStubbingFound(), event.getMockSettings(), currentStrictness);
if (actualStrictness != Strictness.STRICT_STUBS) {
return;
}
if (event.getStubbingFound() == null) {
- //If stubbing was not found for invocation it means that either the mock invocation was not stubbed or
- //we have a stubbing arg mismatch.
- List<Invocation> argMismatchStubbings = potentialArgMismatches(event.getInvocation(), event.getAllStubbings());
+ // If stubbing was not found for invocation it means that either the mock invocation was
+ // not stubbed or
+ // we have a stubbing arg mismatch.
+ List<Invocation> argMismatchStubbings =
+ potentialArgMismatches(event.getInvocation(), event.getAllStubbings());
if (!argMismatchStubbings.isEmpty()) {
mismatchesReported = true;
Reporter.potentialStubbingProblem(event.getInvocation(), argMismatchStubbings);
}
} else {
- //when strict stubs are in use, every time a stub is realized in the code it is implicitly marked as verified
- //this way, the users don't have to repeat themselves to verify stubbed invocations (DRY)
+ // when strict stubs are in use, every time a stub is realized in the code it is
+ // implicitly marked as verified
+ // this way, the users don't have to repeat themselves to verify stubbed invocations
+ // (DRY)
event.getInvocation().markVerified();
}
}
- private static List<Invocation> potentialArgMismatches(Invocation invocation, Collection<Stubbing> stubbings) {
- List<Invocation> matchingStubbings = new LinkedList<Invocation>();
+ private static List<Invocation> potentialArgMismatches(
+ Invocation invocation, Collection<Stubbing> stubbings) {
+ List<Invocation> matchingStubbings = new LinkedList<>();
for (Stubbing s : stubbings) {
if (UnusedStubbingReporting.shouldBeReported(s)
- && s.getInvocation().getMethod().getName().equals(invocation.getMethod().getName())) {
+ && s.getInvocation()
+ .getMethod()
+ .getName()
+ .equals(invocation.getMethod().getName())
+ // If stubbing and invocation are in the same source file we assume they are in
+ // the test code,
+ // and we don't flag it as mismatch:
+ && !s.getInvocation()
+ .getLocation()
+ .getSourceFile()
+ .equals(invocation.getLocation().getSourceFile())) {
matchingStubbings.add(s.getInvocation());
}
}
diff --git a/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java b/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java
index c3b348b..269ab9c 100644
--- a/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java
+++ b/src/main/java/org/mockito/internal/junit/DefaultTestFinishedEvent.java
@@ -9,7 +9,8 @@
private final String testMethodName;
private final Throwable testFailure;
- public DefaultTestFinishedEvent(Object testClassInstance, String testMethodName, Throwable testFailure) {
+ public DefaultTestFinishedEvent(
+ Object testClassInstance, String testMethodName, Throwable testFailure) {
this.testClassInstance = testClassInstance;
this.testMethodName = testMethodName;
this.testFailure = testFailure;
diff --git a/src/main/java/org/mockito/internal/junit/ExceptionFactory.java b/src/main/java/org/mockito/internal/junit/ExceptionFactory.java
index 3664aea..7c5a841 100644
--- a/src/main/java/org/mockito/internal/junit/ExceptionFactory.java
+++ b/src/main/java/org/mockito/internal/junit/ExceptionFactory.java
@@ -4,49 +4,45 @@
*/
package org.mockito.internal.junit;
-import junit.framework.ComparisonFailure;
import org.mockito.exceptions.verification.ArgumentsAreDifferent;
public class ExceptionFactory {
- private final static boolean hasJUnit = canLoadJunitClass();
+ private ExceptionFactory() {}
- private ExceptionFactory() {
+ private static interface ExceptionFactoryImpl {
+ AssertionError create(String message, String wanted, String actual);
}
- /**
- * If JUnit is used, an AssertionError is returned that extends from JUnit {@link ComparisonFailure} and hence provide a better IDE support as the comparison result is comparable
- */
- public static AssertionError createArgumentsAreDifferentException(String message, String wanted, String actual) {
- if (hasJUnit) {
- return createJUnitArgumentsAreDifferent(message, wanted, actual);
- }
- return new ArgumentsAreDifferent(message);
- }
+ private static final ExceptionFactoryImpl factory;
- private static AssertionError createJUnitArgumentsAreDifferent(String message, String wanted, String actual) {
- return JUnitArgsAreDifferent.create(message, wanted, actual);
- }
+ static {
+ ExceptionFactoryImpl theFactory = null;
- private static boolean canLoadJunitClass() {
try {
- JUnitArgsAreDifferent.create("message", "wanted", "actual");
- } catch (NoClassDefFoundError onlyIfJUnitIsNotAvailable) {
- return false;
+ Class.forName("org.opentest4j.AssertionFailedError");
+ theFactory = org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent::new;
+ } catch (ClassNotFoundException onlyIfOpenTestIsNotAvailable) {
+ try {
+ Class.forName("junit.framework.ComparisonFailure");
+ theFactory = org.mockito.exceptions.verification.junit.ArgumentsAreDifferent::new;
+ } catch (ClassNotFoundException onlyIfJUnitIsNotAvailable) {
+ }
}
- return true;
+ factory = (theFactory == null) ? ArgumentsAreDifferent::new : theFactory;
}
/**
- * Don't inline this class! It allows create the JUnit-ArgumentsAreDifferent exception without the need to use reflection.
- * <p>
- * If JUnit is not available a call to {@link #create(String, String, String)} will throw a {@link NoClassDefFoundError}.
- * The {@link NoClassDefFoundError} will be thrown by the class loader cause the JUnit class {@link ComparisonFailure}
- * can't be loaded which is a upper class of ArgumentsAreDifferent.
+ * Returns an AssertionError that describes the fact that the arguments of an invocation are different.
+ * If {@link org.opentest4j.AssertionFailedError} is on the class path (used by JUnit 5 and others),
+ * it returns a class that extends it. Otherwise, if {@link junit.framework.ComparisonFailure} is on the
+ * class path (shipped with JUnit 3 and 4), it will return a class that extends that. This provides
+ * better IDE support as the comparison result can be opened in a visual diff. If neither are available,
+ * it returns an instance of
+ * {@link org.mockito.exceptions.verification.ArgumentsAreDifferent}.
*/
- private static class JUnitArgsAreDifferent {
- static AssertionError create(String message, String wanted, String actual) {
- return new org.mockito.exceptions.verification.junit.ArgumentsAreDifferent(message, wanted, actual);
- }
+ public static AssertionError createArgumentsAreDifferentException(
+ String message, String wanted, String actual) {
+ return factory.create(message, wanted, actual);
}
}
diff --git a/src/main/java/org/mockito/internal/junit/JUnitRule.java b/src/main/java/org/mockito/internal/junit/JUnitRule.java
index b825416..0439f98 100644
--- a/src/main/java/org/mockito/internal/junit/JUnitRule.java
+++ b/src/main/java/org/mockito/internal/junit/JUnitRule.java
@@ -6,69 +6,35 @@
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.Statement;
-import org.mockito.Mockito;
-import org.mockito.MockitoSession;
-import org.mockito.internal.session.MockitoSessionLoggerAdapter;
-import org.mockito.internal.util.MockitoLogger;
-import org.mockito.quality.Strictness;
import org.mockito.junit.MockitoRule;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.quality.Strictness;
-/**
- * Internal implementation.
- */
-public class JUnitRule implements MockitoRule {
+/** Internal implementation. */
+public final class JUnitRule implements MockitoRule {
- private final MockitoLogger logger;
- private Strictness strictness;
- private MockitoSession session;
+ private final JUnitSessionStore sessionStore;
- /**
- * @param strictness how strict mocking / stubbing is concerned
- */
+ /** @param strictness how strict mocking / stubbing is concerned */
public JUnitRule(MockitoLogger logger, Strictness strictness) {
- this.logger = logger;
- this.strictness = strictness;
+ this.sessionStore = new JUnitSessionStore(logger, strictness);
}
- @Override
- public Statement apply(final Statement base, final FrameworkMethod method, final Object target) {
- return new Statement() {
- public void evaluate() throws Throwable {
- session = Mockito.mockitoSession()
- .name(target.getClass().getSimpleName() + "." + method.getName())
- .strictness(strictness)
- .logger(new MockitoSessionLoggerAdapter(logger))
- .initMocks(target)
- .startMocking();
- Throwable testFailure = evaluateSafely(base);
- session.finishMocking(testFailure);
- if (testFailure != null) {
- throw testFailure;
- }
- }
-
- private Throwable evaluateSafely(Statement base) {
- try {
- base.evaluate();
- return null;
- } catch (Throwable throwable) {
- return throwable;
- }
- }
- };
+ @Override
+ public Statement apply(
+ final Statement base, final FrameworkMethod method, final Object target) {
+ return sessionStore.createStatement(
+ base, target.getClass().getSimpleName() + "." + method.getName(), target);
}
+ @Override
public MockitoRule silent() {
return strictness(Strictness.LENIENT);
}
+ @Override
public MockitoRule strictness(Strictness strictness) {
- this.strictness = strictness;
- // session is null when this method is called during initialization of
- // the @Rule field of the test class
- if (session != null) {
- session.setStrictness(strictness);
- }
+ sessionStore.setStrictness(strictness);
return this;
}
}
diff --git a/src/main/java/org/mockito/internal/junit/JUnitSessionStore.java b/src/main/java/org/mockito/internal/junit/JUnitSessionStore.java
new file mode 100644
index 0000000..5aa1557
--- /dev/null
+++ b/src/main/java/org/mockito/internal/junit/JUnitSessionStore.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import org.junit.runners.model.Statement;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.MockitoSession;
+import org.mockito.internal.session.MockitoSessionLoggerAdapter;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.quality.Strictness;
+
+class JUnitSessionStore {
+
+ private final MockitoLogger logger;
+ private MockitoSession session;
+ protected Strictness strictness;
+
+ JUnitSessionStore(MockitoLogger logger, Strictness strictness) {
+ this.logger = logger;
+ this.strictness = strictness;
+ }
+
+ Statement createStatement(final Statement base, final String methodName, final Object target) {
+ return new Statement() {
+ @Override
+ public void evaluate() throws Throwable {
+ AutoCloseable closeable;
+ if (session == null) {
+ session =
+ Mockito.mockitoSession()
+ .name(methodName)
+ .strictness(strictness)
+ .logger(new MockitoSessionLoggerAdapter(logger))
+ .initMocks(target)
+ .startMocking();
+ closeable = null;
+ } else {
+ closeable = MockitoAnnotations.openMocks(target);
+ }
+ Throwable testFailure = evaluateSafely(base);
+ session.finishMocking(testFailure);
+ if (closeable != null) {
+ closeable.close();
+ }
+ if (testFailure != null) {
+ throw testFailure;
+ }
+ }
+
+ private Throwable evaluateSafely(Statement base) {
+ try {
+ base.evaluate();
+ return null;
+ } catch (Throwable throwable) {
+ return throwable;
+ }
+ }
+ };
+ }
+
+ void setStrictness(Strictness strictness) {
+ this.strictness = strictness;
+ // session is null when this method is called during initialization of
+ // the @Rule field of the test class
+ if (session != null) {
+ session.setStrictness(strictness);
+ }
+ }
+}
diff --git a/src/main/java/org/mockito/internal/junit/JUnitTestRule.java b/src/main/java/org/mockito/internal/junit/JUnitTestRule.java
new file mode 100644
index 0000000..3cbf2c6
--- /dev/null
+++ b/src/main/java/org/mockito/internal/junit/JUnitTestRule.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.junit;
+
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+import org.mockito.junit.MockitoTestRule;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.quality.Strictness;
+
+public final class JUnitTestRule implements MockitoTestRule {
+
+ private final Object testInstance;
+ private final JUnitSessionStore sessionStore;
+
+ public JUnitTestRule(MockitoLogger logger, Strictness strictness, Object testInstance) {
+ this.sessionStore = new JUnitSessionStore(logger, strictness);
+ this.testInstance = testInstance;
+ }
+
+ @Override
+ public Statement apply(Statement base, Description description) {
+ return sessionStore.createStatement(base, description.getDisplayName(), this.testInstance);
+ }
+
+ @Override
+ public MockitoTestRule silent() {
+ return strictness(Strictness.LENIENT);
+ }
+
+ @Override
+ public MockitoTestRule strictness(Strictness strictness) {
+ sessionStore.setStrictness(strictness);
+ return this;
+ }
+}
diff --git a/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java b/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java
index 26d4e4e..ec877b5 100644
--- a/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java
+++ b/src/main/java/org/mockito/internal/junit/MismatchReportingTestListener.java
@@ -4,37 +4,44 @@
*/
package org.mockito.internal.junit;
-import org.mockito.internal.util.MockitoLogger;
-import org.mockito.mock.MockCreationSettings;
-
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.MockitoLogger;
+
/**
* Reports stubbing argument mismatches to the supplied logger
*/
public class MismatchReportingTestListener implements MockitoTestListener {
private final MockitoLogger logger;
- private List<Object> mocks = new LinkedList<Object>();
+ private List<Object> mocks = new LinkedList<>();
public MismatchReportingTestListener(MockitoLogger logger) {
this.logger = logger;
}
+ @Override
public void testFinished(TestFinishedEvent event) {
Collection<Object> createdMocks = mocks;
- //At this point, we don't need the mocks any more and we can mark all collected mocks for gc
- //TODO make it better, it's easy to forget to clean up mocks and we still create new instance of list that nobody will read, it's also duplicated
- mocks = new LinkedList<Object>();
+ // At this point, we don't need the mocks any more and we can mark all collected mocks for
+ // gc
+ // TODO make it better, it's easy to forget to clean up mocks and we still create new
+ // instance of list that nobody will read, it's also duplicated
+ mocks = new LinkedList<>();
if (event.getFailure() != null) {
- //print unused stubbings only when test succeeds to avoid reporting multiple problems and confusing users
- new ArgMismatchFinder().getStubbingArgMismatches(createdMocks).format(event.getTestName(), logger);
+ // print unused stubbings only when test succeeds to avoid reporting multiple problems
+ // and confusing users
+ new ArgMismatchFinder()
+ .getStubbingArgMismatches(createdMocks)
+ .format(event.getTestName(), logger);
}
}
+ @Override
public void onMockCreated(Object mock, MockCreationSettings settings) {
this.mocks.add(mock);
}
diff --git a/src/main/java/org/mockito/internal/junit/NoOpTestListener.java b/src/main/java/org/mockito/internal/junit/NoOpTestListener.java
index f6eea7e..77c7d4e 100644
--- a/src/main/java/org/mockito/internal/junit/NoOpTestListener.java
+++ b/src/main/java/org/mockito/internal/junit/NoOpTestListener.java
@@ -8,7 +8,9 @@
public class NoOpTestListener implements MockitoTestListener {
+ @Override
public void testFinished(TestFinishedEvent event) {}
+ @Override
public void onMockCreated(Object mock, MockCreationSettings settings) {}
}
diff --git a/src/main/java/org/mockito/internal/junit/StrictStubsRunnerTestListener.java b/src/main/java/org/mockito/internal/junit/StrictStubsRunnerTestListener.java
index 9e60c31..8d6cc6c 100644
--- a/src/main/java/org/mockito/internal/junit/StrictStubsRunnerTestListener.java
+++ b/src/main/java/org/mockito/internal/junit/StrictStubsRunnerTestListener.java
@@ -4,7 +4,6 @@
*/
package org.mockito.internal.junit;
-import org.mockito.internal.creation.settings.CreationSettings;
import org.mockito.mock.MockCreationSettings;
import org.mockito.quality.Strictness;
@@ -13,17 +12,18 @@
*/
public class StrictStubsRunnerTestListener implements MockitoTestListener {
- private final DefaultStubbingLookupListener stubbingLookupListener = new DefaultStubbingLookupListener(Strictness.STRICT_STUBS);
+ private final DefaultStubbingLookupListener stubbingLookupListener =
+ new DefaultStubbingLookupListener(Strictness.STRICT_STUBS);
@Override
public void testFinished(TestFinishedEvent event) {}
@Override
public void onMockCreated(Object mock, MockCreationSettings settings) {
- //It is not ideal that we modify the state of MockCreationSettings object
- //MockCreationSettings is intended to be an immutable view of the creation settings
- //In future, we should start passing MockSettings object to the creation listener
- //TODO #793 - when completed, we should be able to get rid of the CreationSettings casting below
- ((CreationSettings) settings).getStubbingLookupListeners().add(stubbingLookupListener);
+ // It is not ideal that we modify the state of MockCreationSettings object
+ // MockCreationSettings is intended to be an immutable view of the creation settings
+ // However, we our previous listeners work this way and it hasn't backfired.
+ // Since it is simple and pragmatic, we'll keep it for now.
+ settings.getStubbingLookupListeners().add(stubbingLookupListener);
}
}
diff --git a/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java b/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java
index 3d6342c..3fb3bad 100644
--- a/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java
+++ b/src/main/java/org/mockito/internal/junit/StubbingArgMismatches.java
@@ -4,27 +4,25 @@
*/
package org.mockito.internal.junit;
-import org.mockito.internal.util.MockitoLogger;
-import org.mockito.invocation.Invocation;
-
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
+import org.mockito.invocation.Invocation;
+import org.mockito.plugins.MockitoLogger;
+
/**
* Contains stubbing arg mismatches, knows how to format them
*/
class StubbingArgMismatches {
- final Map<Invocation, Set<Invocation>> mismatches = new LinkedHashMap<Invocation, Set<Invocation>>();
+ final Map<Invocation, Set<Invocation>> mismatches = new LinkedHashMap<>();
public void add(Invocation invocation, Invocation stubbing) {
- Set<Invocation> matchingInvocations = mismatches.get(stubbing);
- if (matchingInvocations == null) {
- matchingInvocations = new LinkedHashSet<Invocation>();
- mismatches.put(stubbing, matchingInvocations);
- }
+ Set<Invocation> matchingInvocations =
+ mismatches.computeIfAbsent(
+ stubbing, (Invocation k) -> new LinkedHashSet<Invocation>());
matchingInvocations.add(invocation);
}
@@ -49,6 +47,7 @@
return mismatches.size();
}
+ @Override
public String toString() {
return "" + mismatches;
}
diff --git a/src/main/java/org/mockito/internal/junit/StubbingHint.java b/src/main/java/org/mockito/internal/junit/StubbingHint.java
index 3675a4d..2710425 100644
--- a/src/main/java/org/mockito/internal/junit/StubbingHint.java
+++ b/src/main/java/org/mockito/internal/junit/StubbingHint.java
@@ -12,18 +12,21 @@
private final StringBuilder hint;
StubbingHint(String testName) {
- hint = new StringBuilder("[MockitoHint] ")
- .append(testName).append(" (see javadoc for MockitoHint):");
+ hint =
+ new StringBuilder("[MockitoHint] ")
+ .append(testName)
+ .append(" (see javadoc for MockitoHint):");
}
- void appendLine(Object ... elements) {
+ void appendLine(Object... elements) {
hint.append("\n[MockitoHint] ");
for (Object e : elements) {
hint.append(e);
}
}
+ @Override
public String toString() {
- return hint.toString() + "\n";
+ return hint + "\n";
}
}
diff --git a/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java b/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java
index 43b373a..a2c10cf 100644
--- a/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java
+++ b/src/main/java/org/mockito/internal/junit/TestFinishedEvent.java
@@ -9,5 +9,4 @@
Throwable getFailure();
String getTestName();
-
}
diff --git a/src/main/java/org/mockito/internal/junit/UniversalTestListener.java b/src/main/java/org/mockito/internal/junit/UniversalTestListener.java
index f670c64..72e3c09 100644
--- a/src/main/java/org/mockito/internal/junit/UniversalTestListener.java
+++ b/src/main/java/org/mockito/internal/junit/UniversalTestListener.java
@@ -4,15 +4,13 @@
*/
package org.mockito.internal.junit;
-import org.mockito.internal.creation.settings.CreationSettings;
-import org.mockito.internal.listeners.AutoCleanableListener;
-import org.mockito.internal.util.MockitoLogger;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.quality.Strictness;
-
import java.util.Collection;
import java.util.IdentityHashMap;
-import java.util.Map;
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.internal.listeners.AutoCleanableListener;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.quality.Strictness;
/**
* Universal test listener that behaves accordingly to current setting of strictness.
@@ -24,51 +22,67 @@
private Strictness currentStrictness;
private final MockitoLogger logger;
- private Map<Object, MockCreationSettings> mocks = new IdentityHashMap<Object, MockCreationSettings>();
- private DefaultStubbingLookupListener stubbingLookupListener;
+ private IdentityHashMap mocks = new IdentityHashMap<Object, MockCreationSettings>();
+ private final DefaultStubbingLookupListener stubbingLookupListener;
private boolean listenerDirty;
public UniversalTestListener(Strictness initialStrictness, MockitoLogger logger) {
this.currentStrictness = initialStrictness;
this.logger = logger;
- //creating single stubbing lookup listener per junit rule instance / test method
- //this way, when strictness is updated in the middle of the test it will affect the behavior of the stubbing listener
+ // creating single stubbing lookup listener per junit rule instance / test method
+ // this way, when strictness is updated in the middle of the test it will affect the
+ // behavior of the stubbing listener
this.stubbingLookupListener = new DefaultStubbingLookupListener(currentStrictness);
}
@Override
public void testFinished(TestFinishedEvent event) {
Collection<Object> createdMocks = mocks.keySet();
- //At this point, we don't need the mocks any more and we can mark all collected mocks for gc
- //TODO make it better, it's easy to forget to clean up mocks and we still create new instance of list that nobody will read, it's also duplicated
- //TODO clean up all other state, null out stubbingLookupListener
- mocks = new IdentityHashMap<Object, MockCreationSettings>();
+ // At this point, we don't need the mocks any more and we can mark all collected mocks for
+ // gc
+ // TODO make it better, it's easy to forget to clean up mocks and we still create new
+ // instance of list that nobody will read, it's also duplicated
+ // TODO clean up all other state, null out stubbingLookupListener
+ mocks = new IdentityHashMap<>();
switch (currentStrictness) {
- case WARN: emitWarnings(logger, event, createdMocks); break;
- case STRICT_STUBS: reportUnusedStubs(event, createdMocks); break;
- case LENIENT: break;
- default: throw new IllegalStateException("Unknown strictness: " + currentStrictness);
+ case WARN:
+ emitWarnings(logger, event, createdMocks);
+ break;
+ case STRICT_STUBS:
+ reportUnusedStubs(event, createdMocks);
+ break;
+ case LENIENT:
+ break;
+ default:
+ throw new IllegalStateException("Unknown strictness: " + currentStrictness);
}
}
private void reportUnusedStubs(TestFinishedEvent event, Collection<Object> mocks) {
- //If there is some other failure (or mismatches were detected) don't report another exception to avoid confusion
+ // If there is some other failure (or mismatches were detected) don't report another
+ // exception to avoid confusion
if (event.getFailure() == null && !stubbingLookupListener.isMismatchesReported()) {
UnusedStubbings unused = new UnusedStubbingsFinder().getUnusedStubbings(mocks);
unused.reportUnused();
}
}
- private static void emitWarnings(MockitoLogger logger, TestFinishedEvent event, Collection<Object> mocks) {
+ private static void emitWarnings(
+ MockitoLogger logger, TestFinishedEvent event, Collection<Object> mocks) {
if (event.getFailure() != null) {
- //print stubbing mismatches only when there is a test failure
- //to avoid false negatives. Give hint only when test fails.
- new ArgMismatchFinder().getStubbingArgMismatches(mocks).format(event.getTestName(), logger);
+ // print stubbing mismatches only when there is a test failure
+ // to avoid false negatives. Give hint only when test fails.
+ new ArgMismatchFinder()
+ .getStubbingArgMismatches(mocks)
+ .format(event.getTestName(), logger);
} else {
- //print unused stubbings only when test succeeds to avoid reporting multiple problems and confusing users
- new UnusedStubbingsFinder().getUnusedStubbings(mocks).format(event.getTestName(), logger);
+ // print unused stubbings only when test succeeds to avoid reporting multiple problems
+ // and confusing users
+ new UnusedStubbingsFinder()
+ .getUnusedStubbings(mocks)
+ .format(event.getTestName(), logger);
}
}
@@ -76,10 +90,11 @@
public void onMockCreated(Object mock, MockCreationSettings settings) {
this.mocks.put(mock, settings);
- //It is not ideal that we modify the state of MockCreationSettings object
- //MockCreationSettings is intended to be an immutable view of the creation settings
- //In future, we should start passing MockSettings object to the creation listener
- //TODO #793 - when completed, we should be able to get rid of the CreationSettings casting below
+ // It is not ideal that we modify the state of MockCreationSettings object
+ // MockCreationSettings is intended to be an immutable view of the creation settings
+ // In future, we should start passing MockSettings object to the creation listener
+ // TODO #793 - when completed, we should be able to get rid of the CreationSettings casting
+ // below
((CreationSettings) settings).getStubbingLookupListeners().add(stubbingLookupListener);
}
diff --git a/src/main/java/org/mockito/internal/junit/UnnecessaryStubbingsReporter.java b/src/main/java/org/mockito/internal/junit/UnnecessaryStubbingsReporter.java
index c5a8afe..2ba1fb9 100644
--- a/src/main/java/org/mockito/internal/junit/UnnecessaryStubbingsReporter.java
+++ b/src/main/java/org/mockito/internal/junit/UnnecessaryStubbingsReporter.java
@@ -4,6 +4,10 @@
*/
package org.mockito.internal.junit;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
import org.junit.runner.Description;
import org.junit.runner.notification.Failure;
import org.junit.runner.notification.RunNotifier;
@@ -12,27 +16,27 @@
import org.mockito.listeners.MockCreationListener;
import org.mockito.mock.MockCreationSettings;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
-
/**
* Reports unnecessary stubbings
*/
public class UnnecessaryStubbingsReporter implements MockCreationListener {
- private List<Object> mocks = new LinkedList<Object>();
+ private final List<Object> mocks = new LinkedList<Object>();
public void validateUnusedStubs(Class<?> testClass, RunNotifier notifier) {
- Collection<Invocation> unused = new UnusedStubbingsFinder().getUnusedStubbingsByLocation(mocks);
+ Collection<Invocation> unused =
+ new UnusedStubbingsFinder().getUnusedStubbingsByLocation(mocks);
if (unused.isEmpty()) {
- return; //whoa!!! All stubbings were used!
+ return; // whoa!!! All stubbings were used!
}
- //Oups, there are unused stubbings
- Description unnecessaryStubbings = Description.createTestDescription(testClass, "unnecessary Mockito stubbings");
- notifier.fireTestFailure(new Failure(unnecessaryStubbings,
- Reporter.formatUnncessaryStubbingException(testClass, unused)));
+ // Oups, there are unused stubbings
+ Description unnecessaryStubbings =
+ Description.createTestDescription(testClass, "unnecessary Mockito stubbings");
+ notifier.fireTestFailure(
+ new Failure(
+ unnecessaryStubbings,
+ Reporter.formatUnncessaryStubbingException(testClass, unused)));
}
@Override
diff --git a/src/main/java/org/mockito/internal/junit/UnusedStubbings.java b/src/main/java/org/mockito/internal/junit/UnusedStubbings.java
index 3505d2c..4c4fbf9 100644
--- a/src/main/java/org/mockito/internal/junit/UnusedStubbings.java
+++ b/src/main/java/org/mockito/internal/junit/UnusedStubbings.java
@@ -4,15 +4,15 @@
*/
package org.mockito.internal.junit;
-import org.mockito.internal.exceptions.Reporter;
-import org.mockito.internal.util.MockitoLogger;
-import org.mockito.invocation.Invocation;
-import org.mockito.stubbing.Stubbing;
-
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
+import org.mockito.internal.exceptions.Reporter;
+import org.mockito.invocation.Invocation;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.stubbing.Stubbing;
+
/**
* Contains unused stubbings, knows how to format them
*/
@@ -43,6 +43,7 @@
return unused.size();
}
+ @Override
public String toString() {
return unused.toString();
}
@@ -52,7 +53,7 @@
return;
}
- List<Invocation> invocations = new LinkedList<Invocation>();
+ List<Invocation> invocations = new LinkedList<>();
for (Stubbing stubbing : unused) {
invocations.add(stubbing.getInvocation());
}
diff --git a/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java b/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java
index 14c61c5..c7fd12a 100644
--- a/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java
+++ b/src/main/java/org/mockito/internal/junit/UnusedStubbingsFinder.java
@@ -4,11 +4,7 @@
*/
package org.mockito.internal.junit;
-import org.mockito.internal.invocation.finder.AllInvocationsFinder;
-import org.mockito.internal.stubbing.UnusedStubbingReporting;
-import org.mockito.internal.util.collections.ListUtil.Filter;
-import org.mockito.invocation.Invocation;
-import org.mockito.stubbing.Stubbing;
+import static org.mockito.internal.util.collections.ListUtil.filter;
import java.util.Collection;
import java.util.HashSet;
@@ -17,7 +13,11 @@
import java.util.Map;
import java.util.Set;
-import static org.mockito.internal.util.collections.ListUtil.filter;
+import org.mockito.internal.invocation.finder.AllInvocationsFinder;
+import org.mockito.internal.stubbing.UnusedStubbingReporting;
+import org.mockito.internal.util.collections.ListUtil.Filter;
+import org.mockito.invocation.Invocation;
+import org.mockito.stubbing.Stubbing;
/**
* Finds unused stubbings
@@ -31,11 +31,15 @@
public UnusedStubbings getUnusedStubbings(Iterable<Object> mocks) {
Set<Stubbing> stubbings = AllInvocationsFinder.findStubbings(mocks);
- List<Stubbing> unused = filter(stubbings, new Filter<Stubbing>() {
- public boolean isOut(Stubbing s) {
- return !UnusedStubbingReporting.shouldBeReported(s);
- }
- });
+ List<Stubbing> unused =
+ filter(
+ stubbings,
+ new Filter<Stubbing>() {
+ @Override
+ public boolean isOut(Stubbing s) {
+ return !UnusedStubbingReporting.shouldBeReported(s);
+ }
+ });
return new UnusedStubbings(unused);
}
@@ -53,9 +57,9 @@
public Collection<Invocation> getUnusedStubbingsByLocation(Iterable<Object> mocks) {
Set<Stubbing> stubbings = AllInvocationsFinder.findStubbings(mocks);
- //1st pass, collect all the locations of the stubbings that were used
- //note that those are _not_ locations where the stubbings was used
- Set<String> locationsOfUsedStubbings = new HashSet<String>();
+ // 1st pass, collect all the locations of the stubbings that were used
+ // note that those are _not_ locations where the stubbings was used
+ Set<String> locationsOfUsedStubbings = new HashSet<>();
for (Stubbing s : stubbings) {
if (!UnusedStubbingReporting.shouldBeReported(s)) {
String location = s.getInvocation().getLocation().toString();
@@ -63,11 +67,12 @@
}
}
- //2nd pass, collect unused stubbings by location
- //If the location matches we assume the stubbing was used in at least one test method
- //Also, using map to deduplicate reported unused stubbings
- // if unused stubbing appear in the setup method / constructor we don't want to report it per each test case
- Map<String, Invocation> out = new LinkedHashMap<String, Invocation>();
+ // 2nd pass, collect unused stubbings by location
+ // If the location matches we assume the stubbing was used in at least one test method
+ // Also, using map to deduplicate reported unused stubbings
+ // if unused stubbing appear in the setup method / constructor we don't want to report it
+ // per each test case
+ Map<String, Invocation> out = new LinkedHashMap<>();
for (Stubbing s : stubbings) {
String location = s.getInvocation().getLocation().toString();
if (!locationsOfUsedStubbings.contains(location)) {
diff --git a/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java b/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java
index 7c19d35..dcb4d16 100644
--- a/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java
+++ b/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java
@@ -27,6 +27,7 @@
this.resetBuilder();
}
+ @Override
public Statement apply(final Statement base, final Description description) {
return new Statement() {
@Override
@@ -36,16 +37,20 @@
base.evaluate();
VerificationCollectorImpl.this.collectAndReport();
} finally {
- // If base.evaluate() throws an error, we must explicitly reset the VerificationStrategy
+ // If base.evaluate() throws an error, we must explicitly reset the
+ // VerificationStrategy
// to prevent subsequent tests to be assert lazily
- mockingProgress().setVerificationStrategy(MockingProgressImpl.getDefaultVerificationStrategy());
+ mockingProgress()
+ .setVerificationStrategy(
+ MockingProgressImpl.getDefaultVerificationStrategy());
}
}
};
}
public void collectAndReport() throws MockitoAssertionError {
- mockingProgress().setVerificationStrategy(MockingProgressImpl.getDefaultVerificationStrategy());
+ mockingProgress()
+ .setVerificationStrategy(MockingProgressImpl.getDefaultVerificationStrategy());
if (this.numberOfFailures > 0) {
String error = this.builder.toString();
@@ -56,26 +61,32 @@
}
}
+ @Override
public VerificationCollector assertLazily() {
- mockingProgress().setVerificationStrategy(new VerificationStrategy() {
- public VerificationMode maybeVerifyLazily(VerificationMode mode) {
- return new VerificationWrapper(mode);
- }
- });
+ mockingProgress()
+ .setVerificationStrategy(
+ new VerificationStrategy() {
+ @Override
+ public VerificationMode maybeVerifyLazily(VerificationMode mode) {
+ return new VerificationWrapper(mode);
+ }
+ });
return this;
}
private void resetBuilder() {
- this.builder = new StringBuilder()
- .append("There were multiple verification failures:");
+ this.builder = new StringBuilder().append("There were multiple verification failures:");
this.numberOfFailures = 0;
}
private void append(String message) {
this.numberOfFailures++;
- this.builder.append('\n')
- .append(this.numberOfFailures).append(". ")
- .append(message.substring(1, message.length()));
+ this.builder
+ .append('\n')
+ .append(this.numberOfFailures)
+ .append(". ")
+ .append(message.trim())
+ .append('\n');
}
private class VerificationWrapper implements VerificationMode {
@@ -86,17 +97,18 @@
this.delegate = delegate;
}
+ @Override
public void verify(VerificationData data) {
try {
this.delegate.verify(data);
- } catch (MockitoAssertionError error) {
+ } catch (AssertionError error) {
VerificationCollectorImpl.this.append(error.getMessage());
}
}
+ @Override
public VerificationMode description(String description) {
throw new IllegalStateException("Should not fail in this mode");
}
}
-
}
diff --git a/src/main/java/org/mockito/internal/junit/util/JUnitFailureHacker.java b/src/main/java/org/mockito/internal/junit/util/JUnitFailureHacker.java
index 393867b..d6e784c 100644
--- a/src/main/java/org/mockito/internal/junit/util/JUnitFailureHacker.java
+++ b/src/main/java/org/mockito/internal/junit/util/JUnitFailureHacker.java
@@ -5,8 +5,11 @@
package org.mockito.internal.junit.util;
import java.lang.reflect.Field;
+
import org.junit.runner.notification.Failure;
+import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.exceptions.ExceptionIncludingMockitoWarnings;
+import org.mockito.plugins.MemberAccessor;
@Deprecated
public class JUnitFailureHacker {
@@ -15,13 +18,17 @@
if (isEmpty(warnings)) {
return;
}
- //TODO: this has to protect the use in case jUnit changes and this internal state logic fails
+ // TODO: this has to protect the use in case jUnit changes and this internal state logic
+ // fails
Throwable throwable = (Throwable) getInternalState(failure, "fThrownException");
- String newMessage = "contains both: actual test failure *and* Mockito warnings.\n" +
- warnings + "\n *** The actual failure is because of: ***\n";
+ String newMessage =
+ "contains both: actual test failure *and* Mockito warnings.\n"
+ + warnings
+ + "\n *** The actual failure is because of: ***\n";
- ExceptionIncludingMockitoWarnings e = new ExceptionIncludingMockitoWarnings(newMessage, throwable);
+ ExceptionIncludingMockitoWarnings e =
+ new ExceptionIncludingMockitoWarnings(newMessage, throwable);
e.setStackTrace(throwable.getStackTrace());
setInternalState(failure, "fThrownException", e);
}
@@ -31,24 +38,28 @@
}
private static Object getInternalState(Object target, String field) {
+ MemberAccessor accessor = Plugins.getMemberAccessor();
Class<?> c = target.getClass();
try {
Field f = getFieldFromHierarchy(c, field);
- f.setAccessible(true);
- return f.get(target);
+ return accessor.get(f, target);
} catch (Exception e) {
- throw new RuntimeException("Unable to get internal state on a private field. Please report to mockito mailing list.", e);
+ throw new RuntimeException(
+ "Unable to get internal state on a private field. Please report to mockito mailing list.",
+ e);
}
}
private static void setInternalState(Object target, String field, Object value) {
+ MemberAccessor accessor = Plugins.getMemberAccessor();
Class<?> c = target.getClass();
try {
Field f = getFieldFromHierarchy(c, field);
- f.setAccessible(true);
- f.set(target, value);
+ accessor.set(f, target, value);
} catch (Exception e) {
- throw new RuntimeException("Unable to set internal state on a private field. Please report to mockito mailing list.", e);
+ throw new RuntimeException(
+ "Unable to set internal state on a private field. Please report to mockito mailing list.",
+ e);
}
}
@@ -60,9 +71,11 @@
}
if (f == null) {
throw new RuntimeException(
- "You want me to get this field: '" + field +
- "' on this class: '" + clazz.getSimpleName() +
- "' but this field is not declared within the hierarchy of this class!");
+ "You want me to get this field: '"
+ + field
+ + "' on this class: '"
+ + clazz.getSimpleName()
+ + "' but this field is not declared within the hierarchy of this class!");
}
return f;
}
diff --git a/src/main/java/org/mockito/internal/listeners/StubbingLookupListener.java b/src/main/java/org/mockito/internal/listeners/StubbingLookupListener.java
deleted file mode 100644
index 6fa37a1..0000000
--- a/src/main/java/org/mockito/internal/listeners/StubbingLookupListener.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.listeners;
-
-/**
- * Listens to attempts to look up stubbing answer for given mocks. This class is internal for now.
- * <p>
- * How does it work?
- * When method is called on the mock object, Mockito looks for any answer (stubbing) declared on that mock.
- * If the stubbed answer is found, that answer is invoked (value returned, thrown exception, etc.).
- * If the answer is not found (e.g. that invocation was not stubbed on the mock), mock's default answer is used.
- * This listener implementation is notified when Mockito looked up an answer for invocation on a mock.
- * <p>
- * If we make this interface a part of public API (and we should):
- * - make the implementation unified with InvocationListener (for example: common parent, marker interface MockObjectListener
- * single method for adding listeners so long they inherit from the parent)
- * - make the error handling strict
- * so that Mockito provides decent message when listener fails due to poor implementation.
- */
-public interface StubbingLookupListener {
-
- /**
- * Called by the framework when Mockito looked up an answer for invocation on a mock.
- *
- * @param stubbingLookupEvent - Information about the looked up stubbing
- */
- void onStubbingLookup(StubbingLookupEvent stubbingLookupEvent);
-}
diff --git a/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java b/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java
index 3e55001..5331628 100644
--- a/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java
+++ b/src/main/java/org/mockito/internal/listeners/StubbingLookupNotifier.java
@@ -4,38 +4,45 @@
*/
package org.mockito.internal.listeners;
-import org.mockito.internal.creation.settings.CreationSettings;
-import org.mockito.invocation.Invocation;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.stubbing.Stubbing;
-
import java.util.Collection;
import java.util.List;
-public class StubbingLookupNotifier {
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.invocation.Invocation;
+import org.mockito.listeners.StubbingLookupEvent;
+import org.mockito.listeners.StubbingLookupListener;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.stubbing.Stubbing;
- public static void notifyStubbedAnswerLookup(Invocation invocation, Stubbing stubbingFound,
- Collection<Stubbing> allStubbings, CreationSettings creationSettings) {
+public final class StubbingLookupNotifier {
+
+ public static void notifyStubbedAnswerLookup(
+ Invocation invocation,
+ Stubbing stubbingFound,
+ Collection<Stubbing> allStubbings,
+ CreationSettings creationSettings) {
List<StubbingLookupListener> listeners = creationSettings.getStubbingLookupListeners();
if (listeners.isEmpty()) {
return;
}
- StubbingLookupEvent event = new Event(invocation, stubbingFound, allStubbings, creationSettings);
+ StubbingLookupEvent event =
+ new Event(invocation, stubbingFound, allStubbings, creationSettings);
for (StubbingLookupListener listener : listeners) {
listener.onStubbingLookup(event);
}
}
static class Event implements StubbingLookupEvent {
- final private Invocation invocation;
- final private Stubbing stubbing;
- final private Collection<Stubbing> allStubbings;
- final private MockCreationSettings mockSettings;
+ private final Invocation invocation;
+ private final Stubbing stubbing;
+ private final Collection<Stubbing> allStubbings;
+ private final MockCreationSettings mockSettings;
- public Event(Invocation invocation,
- Stubbing stubbing,
- Collection<Stubbing> allStubbings,
- MockCreationSettings mockSettings) {
+ public Event(
+ Invocation invocation,
+ Stubbing stubbing,
+ Collection<Stubbing> allStubbings,
+ MockCreationSettings mockSettings) {
this.invocation = invocation;
this.stubbing = stubbing;
this.allStubbings = allStubbings;
@@ -62,4 +69,6 @@
return mockSettings;
}
}
+
+ private StubbingLookupNotifier() {}
}
diff --git a/src/main/java/org/mockito/internal/listeners/VerificationStartedNotifier.java b/src/main/java/org/mockito/internal/listeners/VerificationStartedNotifier.java
index 0292db0..9a5a890 100644
--- a/src/main/java/org/mockito/internal/listeners/VerificationStartedNotifier.java
+++ b/src/main/java/org/mockito/internal/listeners/VerificationStartedNotifier.java
@@ -4,6 +4,9 @@
*/
package org.mockito.internal.listeners;
+import java.util.List;
+import java.util.Set;
+
import org.mockito.MockingDetails;
import org.mockito.Mockito;
import org.mockito.internal.exceptions.Reporter;
@@ -12,12 +15,10 @@
import org.mockito.listeners.VerificationStartedListener;
import org.mockito.mock.MockCreationSettings;
-import java.util.List;
-import java.util.Set;
+public final class VerificationStartedNotifier {
-public class VerificationStartedNotifier {
-
- public static Object notifyVerificationStarted(List<VerificationStartedListener> listeners, MockingDetails originalMockingDetails) {
+ public static Object notifyVerificationStarted(
+ List<VerificationStartedListener> listeners, MockingDetails originalMockingDetails) {
if (listeners.isEmpty()) {
return originalMockingDetails.getMock();
}
@@ -37,20 +38,28 @@
this.mock = originalMockingDetails.getMock();
}
+ @Override
public void setMock(Object mock) {
if (mock == null) {
- throw Reporter.methodDoesNotAcceptParameter("VerificationStartedEvent.setMock", "null parameter.");
+ throw Reporter.methodDoesNotAcceptParameter(
+ "VerificationStartedEvent.setMock", "null parameter.");
}
MockingDetails mockingDetails = Mockito.mockingDetails(mock);
if (!mockingDetails.isMock()) {
- throw Reporter.methodDoesNotAcceptParameter("VerificationStartedEvent.setMock", "parameter which is not a Mockito mock.\n" +
- " Received parameter: " + ValuePrinter.print(mock) + ".\n ");
+ throw Reporter.methodDoesNotAcceptParameter(
+ "VerificationStartedEvent.setMock",
+ "parameter which is not a Mockito mock.\n"
+ + " Received parameter: "
+ + ValuePrinter.print(mock)
+ + ".\n ");
}
- MockCreationSettings originalMockSettings = this.originalMockingDetails.getMockCreationSettings();
+ MockCreationSettings originalMockSettings =
+ this.originalMockingDetails.getMockCreationSettings();
assertCompatibleTypes(mock, originalMockSettings);
this.mock = mock;
}
+ @Override
public Object getMock() {
return mock;
}
@@ -59,21 +68,34 @@
static void assertCompatibleTypes(Object mock, MockCreationSettings originalSettings) {
Class originalType = originalSettings.getTypeToMock();
if (!originalType.isInstance(mock)) {
- throw Reporter.methodDoesNotAcceptParameter("VerificationStartedEvent.setMock",
- "parameter which is not the same type as the original mock.\n" +
- " Required type: " + originalType.getName() + "\n" +
- " Received parameter: " + ValuePrinter.print(mock) + ".\n ");
+ throw Reporter.methodDoesNotAcceptParameter(
+ "VerificationStartedEvent.setMock",
+ "parameter which is not the same type as the original mock.\n"
+ + " Required type: "
+ + originalType.getName()
+ + "\n"
+ + " Received parameter: "
+ + ValuePrinter.print(mock)
+ + ".\n ");
}
for (Class iface : (Set<Class>) originalSettings.getExtraInterfaces()) {
if (!iface.isInstance(mock)) {
- throw Reporter.methodDoesNotAcceptParameter("VerificationStartedEvent.setMock",
- "parameter which does not implement all extra interfaces of the original mock.\n" +
- " Required type: " + originalType.getName() + "\n" +
- " Required extra interface: " + iface.getName() + "\n" +
- " Received parameter: " + ValuePrinter.print(mock) + ".\n ");
-
+ throw Reporter.methodDoesNotAcceptParameter(
+ "VerificationStartedEvent.setMock",
+ "parameter which does not implement all extra interfaces of the original mock.\n"
+ + " Required type: "
+ + originalType.getName()
+ + "\n"
+ + " Required extra interface: "
+ + iface.getName()
+ + "\n"
+ + " Received parameter: "
+ + ValuePrinter.print(mock)
+ + ".\n ");
}
}
}
+
+ private VerificationStartedNotifier() {}
}
diff --git a/src/main/java/org/mockito/internal/matchers/And.java b/src/main/java/org/mockito/internal/matchers/And.java
index 2c8f11c..417e88d 100644
--- a/src/main/java/org/mockito/internal/matchers/And.java
+++ b/src/main/java/org/mockito/internal/matchers/And.java
@@ -2,28 +2,29 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
import java.io.Serializable;
import org.mockito.ArgumentMatcher;
-@SuppressWarnings({ "unchecked", "serial","rawtypes" })
+@SuppressWarnings({"unchecked", "serial", "rawtypes"})
public class And implements ArgumentMatcher<Object>, Serializable {
- private ArgumentMatcher m1;
- private ArgumentMatcher m2;
+ private final ArgumentMatcher m1;
+ private final ArgumentMatcher m2;
public And(ArgumentMatcher<?> m1, ArgumentMatcher<?> m2) {
this.m1 = m1;
this.m2 = m2;
}
+ @Override
public boolean matches(Object actual) {
return m1.matches(actual) && m2.matches(actual);
}
+ @Override
public String toString() {
- return "and("+m1+", "+m2+")";
+ return "and(" + m1 + ", " + m2 + ")";
}
}
diff --git a/src/main/java/org/mockito/internal/matchers/Any.java b/src/main/java/org/mockito/internal/matchers/Any.java
index 58b6404..7ad113f 100644
--- a/src/main/java/org/mockito/internal/matchers/Any.java
+++ b/src/main/java/org/mockito/internal/matchers/Any.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
import java.io.Serializable;
@@ -13,10 +12,12 @@
public static final Any ANY = new Any();
+ @Override
public boolean matches(Object actual) {
return true;
}
+ @Override
public String toString() {
return "<any>";
}
diff --git a/src/main/java/org/mockito/internal/matchers/ArrayEquals.java b/src/main/java/org/mockito/internal/matchers/ArrayEquals.java
index d647d1e..b487773 100644
--- a/src/main/java/org/mockito/internal/matchers/ArrayEquals.java
+++ b/src/main/java/org/mockito/internal/matchers/ArrayEquals.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
import java.lang.reflect.Array;
@@ -14,6 +13,7 @@
super(wanted);
}
+ @Override
public boolean matches(Object actual) {
Object wanted = getWanted();
if (wanted == null || actual == null) {
@@ -40,6 +40,7 @@
return false;
}
+ @Override
public String toString() {
if (getWanted() != null && getWanted().getClass().isArray()) {
return appendArray(createObjectArray(getWanted()));
@@ -49,10 +50,10 @@
}
private String appendArray(Object[] array) {
- //TODO SF overlap with ValuePrinter
+ // TODO SF overlap with ValuePrinter
StringBuilder out = new StringBuilder("[");
for (int i = 0; i < array.length; i++) {
- out.append(new Equals(array[i]).toString());
+ out.append(new Equals(array[i]));
if (i != array.length - 1) {
out.append(", ");
}
diff --git a/src/main/java/org/mockito/internal/matchers/CapturesArguments.java b/src/main/java/org/mockito/internal/matchers/CapturesArguments.java
index 0c13853..2e1981c 100644
--- a/src/main/java/org/mockito/internal/matchers/CapturesArguments.java
+++ b/src/main/java/org/mockito/internal/matchers/CapturesArguments.java
@@ -4,9 +4,7 @@
*/
package org.mockito.internal.matchers;
-
public interface CapturesArguments {
void captureFrom(Object argument);
-
}
diff --git a/src/main/java/org/mockito/internal/matchers/CapturingMatcher.java b/src/main/java/org/mockito/internal/matchers/CapturingMatcher.java
index 1b30ce8..5138839 100644
--- a/src/main/java/org/mockito/internal/matchers/CapturingMatcher.java
+++ b/src/main/java/org/mockito/internal/matchers/CapturingMatcher.java
@@ -4,8 +4,6 @@
*/
package org.mockito.internal.matchers;
-import org.mockito.ArgumentMatcher;
-
import static org.mockito.internal.exceptions.Reporter.noArgumentValueWasCaptured;
import java.io.Serializable;
@@ -15,19 +13,24 @@
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
-@SuppressWarnings("unchecked")
-public class CapturingMatcher<T> implements ArgumentMatcher<T>, CapturesArguments, VarargMatcher, Serializable {
+import org.mockito.ArgumentMatcher;
- private final List<Object> arguments = new ArrayList<Object>();
+@SuppressWarnings("unchecked")
+public class CapturingMatcher<T>
+ implements ArgumentMatcher<T>, CapturesArguments, VarargMatcher, Serializable {
+
+ private final List<Object> arguments = new ArrayList<>();
private final ReadWriteLock lock = new ReentrantReadWriteLock();
private final Lock readLock = lock.readLock();
private final Lock writeLock = lock.writeLock();
+ @Override
public boolean matches(Object argument) {
return true;
}
+ @Override
public String toString() {
return "<Capturing argument>";
}
@@ -54,6 +57,7 @@
}
}
+ @Override
public void captureFrom(Object argument) {
writeLock.lock();
try {
diff --git a/src/main/java/org/mockito/internal/matchers/CompareEqual.java b/src/main/java/org/mockito/internal/matchers/CompareEqual.java
index eb21c46..4c84f22 100644
--- a/src/main/java/org/mockito/internal/matchers/CompareEqual.java
+++ b/src/main/java/org/mockito/internal/matchers/CompareEqual.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
import java.io.Serializable;
diff --git a/src/main/java/org/mockito/internal/matchers/CompareTo.java b/src/main/java/org/mockito/internal/matchers/CompareTo.java
index 88f95cc..587bdc5 100644
--- a/src/main/java/org/mockito/internal/matchers/CompareTo.java
+++ b/src/main/java/org/mockito/internal/matchers/CompareTo.java
@@ -2,14 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
-import org.mockito.ArgumentMatcher;
-
import java.io.Serializable;
-public abstract class CompareTo<T extends Comparable<T>> implements ArgumentMatcher<T>, Serializable {
+import org.mockito.ArgumentMatcher;
+
+public abstract class CompareTo<T extends Comparable<T>>
+ implements ArgumentMatcher<T>, Serializable {
private final T wanted;
public CompareTo(T value) {
@@ -21,7 +21,7 @@
if (actual == null) {
return false;
}
- if (!actual.getClass().isInstance(wanted)){
+ if (!actual.getClass().isInstance(wanted)) {
return false;
}
diff --git a/src/main/java/org/mockito/internal/matchers/Contains.java b/src/main/java/org/mockito/internal/matchers/Contains.java
index daa7608..a52f1fb 100644
--- a/src/main/java/org/mockito/internal/matchers/Contains.java
+++ b/src/main/java/org/mockito/internal/matchers/Contains.java
@@ -2,13 +2,11 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
-import org.mockito.ArgumentMatcher;
-
import java.io.Serializable;
+import org.mockito.ArgumentMatcher;
public class Contains implements ArgumentMatcher<String>, Serializable {
@@ -18,10 +16,12 @@
this.substring = substring;
}
+ @Override
public boolean matches(String actual) {
return actual != null && actual.contains(substring);
}
+ @Override
public String toString() {
return "contains(\"" + substring + "\")";
}
diff --git a/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java b/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java
index 3b69fbc..8c698fd 100644
--- a/src/main/java/org/mockito/internal/matchers/ContainsExtraTypeInfo.java
+++ b/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(String)} method.
*/
public interface ContainsExtraTypeInfo {
/**
+ * @param className - name of the class to be printed in description
* Returns more verbose description of the object which include type information
*/
- String toStringWithType();
+ 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()}
+ * If the type matches, there is no point in rendering result from {@link #toStringWithType(String)}
*/
boolean typeMatches(Object target);
+
+ /**
+ *
+ * @return Returns the wanted argument
+ */
+ Object getWanted();
}
diff --git a/src/main/java/org/mockito/internal/matchers/EndsWith.java b/src/main/java/org/mockito/internal/matchers/EndsWith.java
index 2abde2b..4056210 100644
--- a/src/main/java/org/mockito/internal/matchers/EndsWith.java
+++ b/src/main/java/org/mockito/internal/matchers/EndsWith.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
import java.io.Serializable;
@@ -17,10 +16,12 @@
this.suffix = suffix;
}
+ @Override
public boolean matches(String actual) {
return actual != null && actual.endsWith(suffix);
}
+ @Override
public String toString() {
return "endsWith(\"" + suffix + "\")";
}
diff --git a/src/main/java/org/mockito/internal/matchers/Equality.java b/src/main/java/org/mockito/internal/matchers/Equality.java
index 9702550..a1cd701 100644
--- a/src/main/java/org/mockito/internal/matchers/Equality.java
+++ b/src/main/java/org/mockito/internal/matchers/Equality.java
@@ -6,13 +6,13 @@
import java.lang.reflect.Array;
-//stolen from hamcrest because I didn't want to have more dependency than Matcher class
-public class Equality {
+// stolen from hamcrest because I didn't want to have more dependency than Matcher class
+public final class Equality {
public static boolean areEqual(Object o1, Object o2) {
- if (o1 == o2 ) {
+ if (o1 == o2) {
return true;
- } else if (o1 == null || o2 == null) {
+ } else if (o1 == null || o2 == null) {
return false;
} else if (isArray(o1)) {
return isArray(o2) && areArraysEqual(o1, o2);
@@ -22,8 +22,7 @@
}
static boolean areArraysEqual(Object o1, Object o2) {
- return areArrayLengthsEqual(o1, o2)
- && areArrayElementsEqual(o1, o2);
+ return areArrayLengthsEqual(o1, o2) && areArrayElementsEqual(o1, o2);
}
static boolean areArrayLengthsEqual(Object o1, Object o2) {
@@ -32,7 +31,9 @@
static boolean areArrayElementsEqual(Object o1, Object o2) {
for (int i = 0; i < Array.getLength(o1); i++) {
- if (!areEqual(Array.get(o1, i), Array.get(o2, i))) return false;
+ if (!areEqual(Array.get(o1, i), Array.get(o2, i))) {
+ return false;
+ }
}
return true;
}
@@ -40,4 +41,6 @@
static boolean isArray(Object o) {
return o.getClass().isArray();
}
+
+ private Equality() {}
}
diff --git a/src/main/java/org/mockito/internal/matchers/Equals.java b/src/main/java/org/mockito/internal/matchers/Equals.java
index ba9f37f..8b07b2d 100644
--- a/src/main/java/org/mockito/internal/matchers/Equals.java
+++ b/src/main/java/org/mockito/internal/matchers/Equals.java
@@ -2,14 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
+import java.io.Serializable;
+
import org.mockito.ArgumentMatcher;
import org.mockito.internal.matchers.text.ValuePrinter;
-import java.io.Serializable;
-
public class Equals implements ArgumentMatcher<Object>, ContainsExtraTypeInfo, Serializable {
private final Object wanted;
@@ -18,10 +17,12 @@
this.wanted = wanted;
}
+ @Override
public boolean matches(Object actual) {
return Equality.areEqual(this.wanted, actual);
}
+ @Override
public String toString() {
return describe(wanted);
}
@@ -30,17 +31,19 @@
return ValuePrinter.print(object);
}
- protected final Object getWanted() {
+ @Override
+ public final Object getWanted() {
return wanted;
}
@Override
public boolean equals(Object o) {
- if (o == null || !this.getClass().equals(o.getClass())) {
+ if (!(o instanceof Equals)) {
return false;
}
Equals other = (Equals) o;
- return this.wanted == null && other.wanted == null || this.wanted != null && this.wanted.equals(other.wanted);
+ return (this.wanted == null && other.wanted == null)
+ || this.wanted != null && this.wanted.equals(other.wanted);
}
@Override
@@ -48,10 +51,12 @@
return 1;
}
- public String toStringWithType() {
- return "("+ wanted.getClass().getSimpleName() +") " + describe(wanted);
+ @Override
+ public String toStringWithType(String className) {
+ return "(" + className + ") " + describe(wanted);
}
+ @Override
public boolean typeMatches(Object target) {
return wanted != null && target != null && target.getClass() == wanted.getClass();
}
diff --git a/src/main/java/org/mockito/internal/matchers/EqualsWithDelta.java b/src/main/java/org/mockito/internal/matchers/EqualsWithDelta.java
index d5d8e19..46fd4d6 100644
--- a/src/main/java/org/mockito/internal/matchers/EqualsWithDelta.java
+++ b/src/main/java/org/mockito/internal/matchers/EqualsWithDelta.java
@@ -2,13 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
-import org.mockito.ArgumentMatcher;
-
import java.io.Serializable;
+import org.mockito.ArgumentMatcher;
+
public class EqualsWithDelta implements ArgumentMatcher<Number>, Serializable {
private final Number wanted;
@@ -19,6 +18,7 @@
this.delta = delta;
}
+ @Override
public boolean matches(Number actual) {
if (wanted == null ^ actual == null) {
return false;
@@ -29,10 +29,10 @@
}
return wanted.doubleValue() - delta.doubleValue() <= actual.doubleValue()
- && actual.doubleValue() <= wanted.doubleValue()
- + delta.doubleValue();
+ && actual.doubleValue() <= wanted.doubleValue() + delta.doubleValue();
}
+ @Override
public String toString() {
return "eq(" + wanted + ", " + delta + ")";
}
diff --git a/src/main/java/org/mockito/internal/matchers/Find.java b/src/main/java/org/mockito/internal/matchers/Find.java
index 178c444..530e4c0 100644
--- a/src/main/java/org/mockito/internal/matchers/Find.java
+++ b/src/main/java/org/mockito/internal/matchers/Find.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
import java.io.Serializable;
@@ -18,11 +17,13 @@
this.regex = regex;
}
+ @Override
public boolean matches(String actual) {
return actual != null && Pattern.compile(regex).matcher(actual).find();
}
+ @Override
public String toString() {
- return "find(\"" + regex.replaceAll("\\\\", "\\\\\\\\") + "\")";
+ return "find(\"" + regex.replace("\\", "\\\\") + "\")";
}
}
diff --git a/src/main/java/org/mockito/internal/matchers/GreaterOrEqual.java b/src/main/java/org/mockito/internal/matchers/GreaterOrEqual.java
index f1c8ff2..45e1855 100644
--- a/src/main/java/org/mockito/internal/matchers/GreaterOrEqual.java
+++ b/src/main/java/org/mockito/internal/matchers/GreaterOrEqual.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
import java.io.Serializable;
diff --git a/src/main/java/org/mockito/internal/matchers/GreaterThan.java b/src/main/java/org/mockito/internal/matchers/GreaterThan.java
index 46497c1..3b1f96c 100644
--- a/src/main/java/org/mockito/internal/matchers/GreaterThan.java
+++ b/src/main/java/org/mockito/internal/matchers/GreaterThan.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
import java.io.Serializable;
diff --git a/src/main/java/org/mockito/internal/matchers/InstanceOf.java b/src/main/java/org/mockito/internal/matchers/InstanceOf.java
index 2876aa2..1b4b30e 100644
--- a/src/main/java/org/mockito/internal/matchers/InstanceOf.java
+++ b/src/main/java/org/mockito/internal/matchers/InstanceOf.java
@@ -2,19 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
+import java.io.Serializable;
+
import org.mockito.ArgumentMatcher;
import org.mockito.internal.util.Primitives;
-import java.io.Serializable;
-
-
public class InstanceOf implements ArgumentMatcher<Object>, Serializable {
private final Class<?> clazz;
- private String description;
+ private final String description;
public InstanceOf(Class<?> clazz) {
this(clazz, "isA(" + clazz.getCanonicalName() + ")");
@@ -25,12 +23,14 @@
this.description = describedAs;
}
+ @Override
public boolean matches(Object actual) {
- return (actual != null) &&
- (Primitives.isAssignableFromWrapper(actual.getClass(), clazz)
+ return (actual != null)
+ && (Primitives.isAssignableFromWrapper(actual.getClass(), clazz)
|| clazz.isAssignableFrom(actual.getClass()));
}
+ @Override
public String toString() {
return description;
}
@@ -45,6 +45,4 @@
super(clazz, describedAs);
}
}
-
-
}
diff --git a/src/main/java/org/mockito/internal/matchers/LessOrEqual.java b/src/main/java/org/mockito/internal/matchers/LessOrEqual.java
index 1b3d737..c634054 100644
--- a/src/main/java/org/mockito/internal/matchers/LessOrEqual.java
+++ b/src/main/java/org/mockito/internal/matchers/LessOrEqual.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
import java.io.Serializable;
diff --git a/src/main/java/org/mockito/internal/matchers/LessThan.java b/src/main/java/org/mockito/internal/matchers/LessThan.java
index c0c931e..67b7428 100644
--- a/src/main/java/org/mockito/internal/matchers/LessThan.java
+++ b/src/main/java/org/mockito/internal/matchers/LessThan.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
import java.io.Serializable;
diff --git a/src/main/java/org/mockito/internal/matchers/Matches.java b/src/main/java/org/mockito/internal/matchers/Matches.java
index 2a15c47..dcd7347 100644
--- a/src/main/java/org/mockito/internal/matchers/Matches.java
+++ b/src/main/java/org/mockito/internal/matchers/Matches.java
@@ -2,11 +2,11 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
import java.io.Serializable;
import java.util.regex.Pattern;
+
import org.mockito.ArgumentMatcher;
public class Matches implements ArgumentMatcher<Object>, Serializable {
@@ -21,11 +21,13 @@
this.pattern = pattern;
}
+ @Override
public boolean matches(Object actual) {
- return (actual instanceof String) && pattern.matcher((String) actual).matches();
+ return (actual instanceof String) && pattern.matcher((String) actual).find();
}
+ @Override
public String toString() {
- return "matches(\"" + pattern.pattern().replaceAll("\\\\", "\\\\\\\\") + "\")";
+ return "matches(\"" + pattern.pattern().replace("\\", "\\\\") + "\")";
}
}
diff --git a/src/main/java/org/mockito/internal/matchers/Not.java b/src/main/java/org/mockito/internal/matchers/Not.java
index 1cece9d..bd35eaf 100644
--- a/src/main/java/org/mockito/internal/matchers/Not.java
+++ b/src/main/java/org/mockito/internal/matchers/Not.java
@@ -2,14 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
-import org.mockito.ArgumentMatcher;
-
import java.io.Serializable;
-@SuppressWarnings({ "unchecked", "serial","rawtypes" })
+import org.mockito.ArgumentMatcher;
+
+@SuppressWarnings({"unchecked", "serial", "rawtypes"})
public class Not implements ArgumentMatcher<Object>, Serializable {
private final ArgumentMatcher matcher;
@@ -18,10 +17,12 @@
this.matcher = matcher;
}
+ @Override
public boolean matches(Object actual) {
return !matcher.matches(actual);
}
+ @Override
public String toString() {
return "not(" + matcher + ")";
}
diff --git a/src/main/java/org/mockito/internal/matchers/NotNull.java b/src/main/java/org/mockito/internal/matchers/NotNull.java
index 1b4b36d..2902f57 100644
--- a/src/main/java/org/mockito/internal/matchers/NotNull.java
+++ b/src/main/java/org/mockito/internal/matchers/NotNull.java
@@ -2,24 +2,24 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
-import org.mockito.ArgumentMatcher;
-
import java.io.Serializable;
+import org.mockito.ArgumentMatcher;
+
public class NotNull implements ArgumentMatcher<Object>, Serializable {
public static final NotNull NOT_NULL = new NotNull();
- private NotNull() {
- }
+ private NotNull() {}
+ @Override
public boolean matches(Object actual) {
return actual != null;
}
+ @Override
public String toString() {
return "notNull()";
}
diff --git a/src/main/java/org/mockito/internal/matchers/Null.java b/src/main/java/org/mockito/internal/matchers/Null.java
index 650a606..69eee48 100644
--- a/src/main/java/org/mockito/internal/matchers/Null.java
+++ b/src/main/java/org/mockito/internal/matchers/Null.java
@@ -2,24 +2,24 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
-import org.mockito.ArgumentMatcher;
-
import java.io.Serializable;
+import org.mockito.ArgumentMatcher;
+
public class Null implements ArgumentMatcher<Object>, Serializable {
public static final Null NULL = new Null();
- private Null() {
- }
+ private Null() {}
+ @Override
public boolean matches(Object actual) {
return actual == null;
}
+ @Override
public String toString() {
return "isNull()";
}
diff --git a/src/main/java/org/mockito/internal/matchers/Or.java b/src/main/java/org/mockito/internal/matchers/Or.java
index 803a533..ed7bbde 100644
--- a/src/main/java/org/mockito/internal/matchers/Or.java
+++ b/src/main/java/org/mockito/internal/matchers/Or.java
@@ -2,14 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
import java.io.Serializable;
import org.mockito.ArgumentMatcher;
-@SuppressWarnings({ "unchecked", "serial","rawtypes" })
+@SuppressWarnings({"unchecked", "serial", "rawtypes"})
public class Or implements ArgumentMatcher<Object>, Serializable {
private final ArgumentMatcher m1;
private final ArgumentMatcher m2;
@@ -19,11 +18,13 @@
this.m2 = m2;
}
+ @Override
public boolean matches(Object actual) {
return m1.matches(actual) || m2.matches(actual);
}
+ @Override
public String toString() {
- return "or("+m1+", "+m2+")";
+ return "or(" + m1 + ", " + m2 + ")";
}
}
diff --git a/src/main/java/org/mockito/internal/matchers/Same.java b/src/main/java/org/mockito/internal/matchers/Same.java
index b834376..0e23c5c 100644
--- a/src/main/java/org/mockito/internal/matchers/Same.java
+++ b/src/main/java/org/mockito/internal/matchers/Same.java
@@ -2,14 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
+import java.io.Serializable;
+
import org.mockito.ArgumentMatcher;
import org.mockito.internal.matchers.text.ValuePrinter;
-import java.io.Serializable;
-
public class Same implements ArgumentMatcher<Object>, Serializable {
private final Object wanted;
@@ -18,10 +17,12 @@
this.wanted = wanted;
}
+ @Override
public boolean matches(Object actual) {
return wanted == actual;
}
+ @Override
public String toString() {
return "same(" + ValuePrinter.print(wanted) + ")";
}
diff --git a/src/main/java/org/mockito/internal/matchers/StartsWith.java b/src/main/java/org/mockito/internal/matchers/StartsWith.java
index f89c2c0..2daae97 100644
--- a/src/main/java/org/mockito/internal/matchers/StartsWith.java
+++ b/src/main/java/org/mockito/internal/matchers/StartsWith.java
@@ -2,13 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
-import org.mockito.ArgumentMatcher;
-
import java.io.Serializable;
+import org.mockito.ArgumentMatcher;
+
public class StartsWith implements ArgumentMatcher<String>, Serializable {
private final String prefix;
@@ -17,10 +16,12 @@
this.prefix = prefix;
}
+ @Override
public boolean matches(String actual) {
return actual != null && actual.startsWith(prefix);
}
+ @Override
public String toString() {
return "startsWith(\"" + prefix + "\")";
}
diff --git a/src/main/java/org/mockito/internal/matchers/VarargMatcher.java b/src/main/java/org/mockito/internal/matchers/VarargMatcher.java
index fc843f6..43a2759 100644
--- a/src/main/java/org/mockito/internal/matchers/VarargMatcher.java
+++ b/src/main/java/org/mockito/internal/matchers/VarargMatcher.java
@@ -10,5 +10,4 @@
* Internal interface that informs Mockito that the matcher is intended to capture varargs.
* This information is needed when mockito collects the arguments.
*/
-public interface VarargMatcher extends Serializable {
-}
+public interface VarargMatcher extends Serializable {}
diff --git a/src/main/java/org/mockito/internal/matchers/apachecommons/EqualsBuilder.java b/src/main/java/org/mockito/internal/matchers/apachecommons/EqualsBuilder.java
index 92662c8..eaa1516 100644
--- a/src/main/java/org/mockito/internal/matchers/apachecommons/EqualsBuilder.java
+++ b/src/main/java/org/mockito/internal/matchers/apachecommons/EqualsBuilder.java
@@ -2,18 +2,19 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
-//NON-STANDARD LICENCE HEADER HERE - THAT'S OK
-//Class comes from Apache Commons Lang, added some tiny changes
package org.mockito.internal.matchers.apachecommons;
-import java.lang.reflect.AccessibleObject;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.MemberAccessor;
+
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
+import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+// Class comes from Apache Commons Lang, added some tiny changes
/**
* <p>Assists in implementing {@link Object#equals(Object)} methods.</p>
*
@@ -92,7 +93,7 @@
// do nothing for now.
}
- //-------------------------------------------------------------------------
+ // -------------------------------------------------------------------------
/**
* <p>This method uses reflection to determine if the two <code>Object</code>s
@@ -188,7 +189,8 @@
* @return <code>true</code> if the two Objects have tested equals.
* @since 2.1.0
*/
- public static boolean reflectionEquals(Object lhs, Object rhs, boolean testTransients, Class<?> reflectUpToClass) {
+ public static boolean reflectionEquals(
+ Object lhs, Object rhs, boolean testTransients, Class<?> reflectUpToClass) {
return reflectionEquals(lhs, rhs, testTransients, reflectUpToClass, null);
}
@@ -218,7 +220,11 @@
* @return <code>true</code> if the two Objects have tested equals.
* @since 2.1.0
*/
- public static boolean reflectionEquals(Object lhs, Object rhs, boolean testTransients, Class<?> reflectUpToClass,
+ public static boolean reflectionEquals(
+ Object lhs,
+ Object rhs,
+ boolean testTransients,
+ Class<?> reflectUpToClass,
String[] excludeFields) {
if (lhs == rhs) {
return true;
@@ -250,20 +256,16 @@
return false;
}
EqualsBuilder equalsBuilder = new EqualsBuilder();
- try {
- reflectionAppend(lhs, rhs, testClass, equalsBuilder, testTransients, excludeFields);
- while (testClass.getSuperclass() != null && testClass != reflectUpToClass) {
- testClass = testClass.getSuperclass();
- reflectionAppend(lhs, rhs, testClass, equalsBuilder, testTransients, excludeFields);
- }
- } catch (IllegalArgumentException e) {
- // In this case, we tried to test a subclass vs. a superclass and
- // the subclass has ivars or the ivars are transient and
- // we are testing transients.
- // If a subclass has ivars that we are trying to test them, we get an
- // exception and we know that the objects are not equal.
+ if (reflectionAppend(lhs, rhs, testClass, equalsBuilder, testTransients, excludeFields)) {
return false;
}
+ while (testClass.getSuperclass() != null && testClass != reflectUpToClass) {
+ testClass = testClass.getSuperclass();
+ if (reflectionAppend(
+ lhs, rhs, testClass, equalsBuilder, testTransients, excludeFields)) {
+ return false;
+ }
+ }
return equalsBuilder.isEquals();
}
@@ -278,34 +280,41 @@
* @param useTransients whether to test transient fields
* @param excludeFields array of field names to exclude from testing
*/
- private static void reflectionAppend(
- Object lhs,
- Object rhs,
- Class<?> clazz,
- EqualsBuilder builder,
- boolean useTransients,
- String[] excludeFields) {
+ private static boolean reflectionAppend(
+ Object lhs,
+ Object rhs,
+ Class<?> clazz,
+ EqualsBuilder builder,
+ boolean useTransients,
+ String[] excludeFields) {
Field[] fields = clazz.getDeclaredFields();
- List<String> excludedFieldList = excludeFields != null ? Arrays.asList(excludeFields) : Collections.<String>emptyList();
- AccessibleObject.setAccessible(fields, true);
+ List<String> excludedFieldList =
+ excludeFields != null
+ ? Arrays.asList(excludeFields)
+ : Collections.<String>emptyList();
+ MemberAccessor accessor = Plugins.getMemberAccessor();
for (int i = 0; i < fields.length && builder.isEquals; i++) {
Field f = fields[i];
if (!excludedFieldList.contains(f.getName())
- && (f.getName().indexOf('$') == -1)
- && (useTransients || !Modifier.isTransient(f.getModifiers()))
- && (!Modifier.isStatic(f.getModifiers()))) {
+ && (f.getName().indexOf('$') == -1)
+ && (useTransients || !Modifier.isTransient(f.getModifiers()))
+ && !Modifier.isStatic(f.getModifiers())) {
try {
- builder.append(f.get(lhs), f.get(rhs));
- } catch (IllegalAccessException e) {
- //this can't happen. Would get a Security exception instead
- //throw a runtime exception in case the impossible happens.
- throw new InternalError("Unexpected IllegalAccessException");
+ builder.append(accessor.get(f, lhs), accessor.get(f, rhs));
+ } catch (RuntimeException | IllegalAccessException ignored) {
+ // In this case, we tried to test a subclass vs. a superclass and
+ // the subclass has ivars or the ivars are transient and we are
+ // testing transients. If a subclass has ivars that we are trying
+ // to test them, we get an exception and we know that the objects
+ // are not equal.
+ return true;
}
}
}
+ return false;
}
- //-------------------------------------------------------------------------
+ // -------------------------------------------------------------------------
/**
* <p>Adds the result of <code>super.equals()</code> to this builder.</p>
@@ -319,7 +328,7 @@
return this;
}
- //-------------------------------------------------------------------------
+ // -------------------------------------------------------------------------
/**
* <p>Test if two <code>Object</code>s are equal using their
@@ -342,8 +351,8 @@
}
Class<?> lhsClass = lhs.getClass();
if (!lhsClass.isArray()) {
- if (lhs instanceof java.math.BigDecimal && rhs instanceof java.math.BigDecimal) {
- isEquals = (((java.math.BigDecimal) lhs).compareTo((java.math.BigDecimal) rhs) == 0);
+ if (lhs instanceof BigDecimal && rhs instanceof BigDecimal) {
+ isEquals = (((BigDecimal) lhs).compareTo((BigDecimal) rhs) == 0);
} else {
// The simple case, not an array, just test the element
isEquals = lhs.equals(rhs);
@@ -352,8 +361,8 @@
// Here when we compare different dimensions, for example: a boolean[][] to a boolean[]
this.setEquals(false);
- // 'Switch' on type of array, to dispatch to the correct handler
- // This handles multi dimensional arrays of the same depth
+ // 'Switch' on type of array, to dispatch to the correct handler
+ // This handles multi dimensional arrays of the same depth
} else if (lhs instanceof long[]) {
append((long[]) lhs, (long[]) rhs);
} else if (lhs instanceof int[]) {
@@ -487,7 +496,7 @@
* @param lhs the left hand <code>boolean</code>
* @param rhs the right hand <code>boolean</code>
* @return EqualsBuilder - used to chain calls.
- */
+ */
public EqualsBuilder append(boolean lhs, boolean rhs) {
isEquals &= (lhs == rhs);
return this;
diff --git a/src/main/java/org/mockito/internal/matchers/apachecommons/ReflectionEquals.java b/src/main/java/org/mockito/internal/matchers/apachecommons/ReflectionEquals.java
index 2787e97..6dcbfc6 100644
--- a/src/main/java/org/mockito/internal/matchers/apachecommons/ReflectionEquals.java
+++ b/src/main/java/org/mockito/internal/matchers/apachecommons/ReflectionEquals.java
@@ -2,13 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers.apachecommons;
-import org.mockito.ArgumentMatcher;
-
import java.io.Serializable;
+import org.mockito.ArgumentMatcher;
+
public class ReflectionEquals implements ArgumentMatcher<Object>, Serializable {
private final Object wanted;
@@ -19,10 +18,12 @@
this.excludeFields = excludeFields;
}
+ @Override
public boolean matches(Object actual) {
return EqualsBuilder.reflectionEquals(wanted, actual, excludeFields);
}
+ @Override
public String toString() {
return "refEq(" + wanted + ")";
}
diff --git a/src/main/java/org/mockito/internal/matchers/text/MatcherToString.java b/src/main/java/org/mockito/internal/matchers/text/MatcherToString.java
index f67b868..d59cbac 100644
--- a/src/main/java/org/mockito/internal/matchers/text/MatcherToString.java
+++ b/src/main/java/org/mockito/internal/matchers/text/MatcherToString.java
@@ -5,15 +5,14 @@
package org.mockito.internal.matchers.text;
import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
-import static org.mockito.internal.util.StringUtil.decamelizeMatcher;
+import static org.mockito.internal.util.StringUtil.decamelizeMatcherName;
import java.lang.reflect.Method;
+
import org.mockito.ArgumentMatcher;
-/**
- * Provides better toString() text for matcher that don't have toString() method declared.
- */
-class MatcherToString {
+/** Provides better toString() text for matcher that don't have toString() method declared. */
+final class MatcherToString {
/**
* Attempts to provide more descriptive toString() for given matcher.
@@ -27,17 +26,28 @@
*/
static String toString(ArgumentMatcher<?> matcher) {
Class<?> cls = matcher.getClass();
- while(cls != Object.class) {
+ while (cls != Object.class) {
Method[] methods = cls.getDeclaredMethods();
for (Method m : methods) {
- if(isToStringMethod(m)) {
+ if (isToStringMethod(m)) {
return matcher.toString();
}
}
cls = cls.getSuperclass();
}
- return decamelizeMatcher(matcher.getClass().getSimpleName());
+
+ String matcherName;
+ Class<?> matcherClass = matcher.getClass();
+ // Lambdas have non-empty getSimpleName() (despite being synthetic)
+ // but that name is not useful for user
+ if (matcherClass.isSynthetic()) {
+ matcherName = "";
+ } else {
+ matcherName = matcherClass.getSimpleName();
+ }
+
+ return decamelizeMatcherName(matcherName);
}
-
+ private MatcherToString() {}
}
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 98194fc..9ceab39 100644
--- a/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java
+++ b/src/main/java/org/mockito/internal/matchers/text/MatchersPrinter.java
@@ -4,14 +4,14 @@
*/
package org.mockito.internal.matchers.text;
-import org.mockito.ArgumentMatcher;
-import org.mockito.internal.matchers.ContainsExtraTypeInfo;
-import org.mockito.internal.reporting.PrintSettings;
-
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.matchers.ContainsExtraTypeInfo;
+import org.mockito.internal.reporting.PrintSettings;
+
@SuppressWarnings("unchecked")
public class MatchersPrinter {
@@ -25,12 +25,30 @@
return ValuePrinter.printValues("(\n ", ",\n ", "\n);", args);
}
- private Iterator<FormattedText> applyPrintSettings(List<ArgumentMatcher> matchers, PrintSettings printSettings) {
- List<FormattedText> out = new LinkedList<FormattedText>();
+ private Iterator<FormattedText> applyPrintSettings(
+ List<ArgumentMatcher> matchers, PrintSettings printSettings) {
+ List<FormattedText> 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()));
+ if (matcher instanceof ContainsExtraTypeInfo) {
+ ContainsExtraTypeInfo typeInfoMatcher = (ContainsExtraTypeInfo) matcher;
+ 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(simpleNameOfArgument)));
+ } else if (printSettings.fullyQualifiedNameFor(simpleNameOfArgument)) {
+ out.add(
+ new FormattedText(
+ typeInfoMatcher.toStringWithType(fullyQualifiedClassName)));
+ } 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/matchers/text/ValuePrinter.java b/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java
index 6f5882f..4517d75 100644
--- a/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java
+++ b/src/main/java/org/mockito/internal/matchers/text/ValuePrinter.java
@@ -8,15 +8,13 @@
import java.util.Iterator;
import java.util.Map;
-import static java.lang.String.valueOf;
-
/**
* Prints a Java object value in a way humans can read it neatly.
* Inspired on hamcrest. Used for printing arguments in verification errors.
*/
public class ValuePrinter {
- private ValuePrinter(){}
+ private ValuePrinter() {}
/**
* Prints given value so that it is neatly readable by humans.
@@ -51,21 +49,27 @@
return printMap((Map<?, ?>) value);
}
if (value.getClass().isArray()) {
- return printValues("[", ", ", "]", new Iterator<Object>() {
- private int currentIndex = 0;
+ return printValues(
+ "[",
+ ", ",
+ "]",
+ new Iterator<Object>() {
+ private int currentIndex = 0;
- public boolean hasNext() {
- return currentIndex < Array.getLength(value);
- }
+ @Override
+ public boolean hasNext() {
+ return currentIndex < Array.getLength(value);
+ }
- public Object next() {
- return Array.get(value, currentIndex++);
- }
+ public Object next() {
+ return Array.get(value, currentIndex++);
+ }
- public void remove() {
- throw new UnsupportedOperationException("cannot remove items from an array");
- }
- });
+ public void remove() {
+ throw new UnsupportedOperationException(
+ "cannot remove items from an array");
+ }
+ });
}
if (value instanceof FormattedText) {
return (((FormattedText) value).getText());
@@ -74,7 +78,7 @@
return descriptionOf(value);
}
- private static String printMap(Map<?,?> map) {
+ private static String printMap(Map<?, ?> map) {
StringBuilder result = new StringBuilder();
Iterator<? extends Map.Entry<?, ?>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
@@ -84,7 +88,7 @@
result.append(", ");
}
}
- return "{" + result.toString() + "}";
+ return "{" + result + "}";
}
/**
@@ -97,19 +101,20 @@
*
* @return neatly formatted value list
*/
- public static String printValues(String start, String separator, String end, Iterator<?> values) {
- if(start == null){
+ public static String printValues(
+ String start, String separator, String end, Iterator<?> values) {
+ if (start == null) {
start = "(";
}
- if (separator == null){
+ if (separator == null) {
separator = ",";
}
- if (end == null){
+ if (end == null) {
end = ")";
}
StringBuilder sb = new StringBuilder(start);
- while(values.hasNext()) {
+ while (values.hasNext()) {
sb.append(print(values.next()));
if (values.hasNext()) {
sb.append(separator);
@@ -143,9 +148,8 @@
private static String descriptionOf(Object value) {
try {
- return valueOf(value);
- }
- catch (Exception e) {
+ return String.valueOf(value);
+ } catch (RuntimeException e) {
return value.getClass().getName() + "@" + Integer.toHexString(value.hashCode());
}
}
diff --git a/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorage.java b/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorage.java
index 572b9d4..24bb8a4 100644
--- a/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorage.java
+++ b/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorage.java
@@ -4,11 +4,11 @@
*/
package org.mockito.internal.progress;
+import java.util.List;
+
import org.mockito.ArgumentMatcher;
import org.mockito.internal.matchers.LocalizedMatcher;
-import java.util.List;
-
@SuppressWarnings("unchecked")
public interface ArgumentMatcherStorage {
@@ -25,5 +25,4 @@
void validateState();
void reset();
-
}
diff --git a/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorageImpl.java b/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorageImpl.java
index 6e8dd24..dbbc027 100644
--- a/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorageImpl.java
+++ b/src/main/java/org/mockito/internal/progress/ArgumentMatcherStorageImpl.java
@@ -2,39 +2,41 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.progress;
+import static java.util.Collections.emptyList;
+
+import static org.mockito.internal.exceptions.Reporter.incorrectUseOfAdditionalMatchers;
+import static org.mockito.internal.exceptions.Reporter.misplacedArgumentMatcher;
+import static org.mockito.internal.exceptions.Reporter.reportNoSubMatchersFound;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
import org.mockito.ArgumentMatcher;
import org.mockito.internal.matchers.And;
import org.mockito.internal.matchers.LocalizedMatcher;
import org.mockito.internal.matchers.Not;
import org.mockito.internal.matchers.Or;
-import static java.util.Collections.emptyList;
-import static org.mockito.internal.exceptions.Reporter.incorrectUseOfAdditionalMatchers;
-import static org.mockito.internal.exceptions.Reporter.misplacedArgumentMatcher;
-import static org.mockito.internal.exceptions.Reporter.reportNoSubMatchersFound;
-
-import java.util.*;
-
public class ArgumentMatcherStorageImpl implements ArgumentMatcherStorage {
private static final int TWO_SUB_MATCHERS = 2;
private static final int ONE_SUB_MATCHER = 1;
- private final Stack<LocalizedMatcher> matcherStack = new Stack<LocalizedMatcher>();
+ private final Stack<LocalizedMatcher> matcherStack = new Stack<>();
+ @Override
public void reportMatcher(ArgumentMatcher<?> matcher) {
matcherStack.push(new LocalizedMatcher(matcher));
}
+ @Override
public List<LocalizedMatcher> pullLocalizedMatchers() {
if (matcherStack.isEmpty()) {
return emptyList();
}
- List<LocalizedMatcher> lastMatchers = resetStack();
- return lastMatchers;
+ return resetStack();
}
public void reportAnd() {
@@ -46,6 +48,7 @@
reportMatcher(new And(m1, m2));
}
+ @Override
public void reportOr() {
assertStateFor("Or(?)", TWO_SUB_MATCHERS);
@@ -55,6 +58,7 @@
reportMatcher(new Or(m1, m2));
}
+ @Override
public void reportNot() {
assertStateFor("Not(?)", ONE_SUB_MATCHER);
@@ -63,6 +67,7 @@
reportMatcher(new Not(m));
}
+ @Override
public void validateState() {
if (!matcherStack.isEmpty()) {
List<LocalizedMatcher> lastMatchers = resetStack();
@@ -70,6 +75,7 @@
}
}
+ @Override
public void reset() {
matcherStack.clear();
}
@@ -80,7 +86,8 @@
}
if (matcherStack.size() < subMatchersCount) {
List<LocalizedMatcher> lastMatchers = resetStack();
- throw incorrectUseOfAdditionalMatchers(additionalMatcherName, subMatchersCount, lastMatchers);
+ throw incorrectUseOfAdditionalMatchers(
+ additionalMatcherName, subMatchersCount, lastMatchers);
}
}
@@ -89,9 +96,8 @@
}
private List<LocalizedMatcher> resetStack() {
- ArrayList<LocalizedMatcher> lastMatchers = new ArrayList<LocalizedMatcher>(matcherStack);
+ ArrayList<LocalizedMatcher> lastMatchers = new ArrayList<>(matcherStack);
reset();
return lastMatchers;
}
-
}
diff --git a/src/main/java/org/mockito/internal/progress/MockingProgress.java b/src/main/java/org/mockito/internal/progress/MockingProgress.java
index 47bc900..abdf68d 100644
--- a/src/main/java/org/mockito/internal/progress/MockingProgress.java
+++ b/src/main/java/org/mockito/internal/progress/MockingProgress.java
@@ -2,10 +2,10 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.progress;
import java.util.Set;
+
import org.mockito.listeners.MockitoListener;
import org.mockito.listeners.VerificationListener;
import org.mockito.mock.MockCreationSettings;
@@ -43,6 +43,8 @@
void mockingStarted(Object mock, MockCreationSettings settings);
+ void mockingStarted(Class<?> mock, MockCreationSettings settings);
+
void addListener(MockitoListener listener);
void removeListener(MockitoListener listener);
diff --git a/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java b/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java
index 5c4fbbc..991b5e4 100644
--- a/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java
+++ b/src/main/java/org/mockito/internal/progress/MockingProgressImpl.java
@@ -2,9 +2,16 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.progress;
+import static org.mockito.internal.exceptions.Reporter.unfinishedStubbing;
+import static org.mockito.internal.exceptions.Reporter.unfinishedVerificationException;
+
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
import org.mockito.internal.configuration.GlobalConfiguration;
import org.mockito.internal.debugging.Localized;
import org.mockito.internal.debugging.LocationImpl;
@@ -19,14 +26,6 @@
import org.mockito.verification.VerificationMode;
import org.mockito.verification.VerificationStrategy;
-import java.util.LinkedHashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
-import static org.mockito.internal.exceptions.Reporter.unfinishedStubbing;
-import static org.mockito.internal.exceptions.Reporter.unfinishedVerificationException;
-
@SuppressWarnings("unchecked")
public class MockingProgressImpl implements MockingProgress {
@@ -36,7 +35,7 @@
private Localized<VerificationMode> verificationMode;
private Location stubbingInProgress = null;
private VerificationStrategy verificationStrategy;
- private final Set<MockitoListener> listeners = new LinkedHashSet<MockitoListener>();
+ private final Set<MockitoListener> listeners = new LinkedHashSet<>();
public MockingProgressImpl() {
this.verificationStrategy = getDefaultVerificationStrategy();
@@ -44,16 +43,19 @@
public static VerificationStrategy getDefaultVerificationStrategy() {
return new VerificationStrategy() {
+ @Override
public VerificationMode maybeVerifyLazily(VerificationMode mode) {
return mode;
}
};
}
+ @Override
public void reportOngoingStubbing(OngoingStubbing ongoingStubbing) {
this.ongoingStubbing = ongoingStubbing;
}
+ @Override
public OngoingStubbing<?> pullOngoingStubbing() {
OngoingStubbing<?> temp = ongoingStubbing;
ongoingStubbing = null;
@@ -62,7 +64,7 @@
@Override
public Set<VerificationListener> verificationListeners() {
- final LinkedHashSet<VerificationListener> verificationListeners = new LinkedHashSet<VerificationListener>();
+ final LinkedHashSet<VerificationListener> verificationListeners = new LinkedHashSet<>();
for (MockitoListener listener : listeners) {
if (listener instanceof VerificationListener) {
@@ -73,20 +75,23 @@
return verificationListeners;
}
-
+ @Override
public void verificationStarted(VerificationMode verify) {
validateState();
resetOngoingStubbing();
verificationMode = new Localized(verify);
}
- /* (non-Javadoc)
+ /**
+ * (non-Javadoc)
+ *
* @see org.mockito.internal.progress.MockingProgress#resetOngoingStubbing()
*/
public void resetOngoingStubbing() {
ongoingStubbing = null;
}
+ @Override
public VerificationMode pullVerificationMode() {
if (verificationMode == null) {
return null;
@@ -97,15 +102,17 @@
return temp;
}
+ @Override
public void stubbingStarted() {
validateState();
stubbingInProgress = new LocationImpl();
}
+ @Override
public void validateState() {
validateMostStuff();
- //validate stubbing:
+ // validate stubbing:
if (stubbingInProgress != null) {
Location temp = stubbingInProgress;
stubbingInProgress = null;
@@ -114,8 +121,9 @@
}
private void validateMostStuff() {
- //State is cool when GlobalConfiguration is already loaded
- //this cannot really be tested functionally because I cannot dynamically mess up org.mockito.configuration.MockitoConfiguration class
+ // State is cool when GlobalConfiguration is already loaded
+ // this cannot really be tested functionally because I cannot dynamically mess up
+ // org.mockito.configuration.MockitoConfiguration class
GlobalConfiguration.validate();
if (verificationMode != null) {
@@ -127,26 +135,34 @@
getArgumentMatcherStorage().validateState();
}
+ @Override
public void stubbingCompleted() {
stubbingInProgress = null;
}
+ @Override
public String toString() {
- return "ongoingStubbing: " + ongoingStubbing +
- ", verificationMode: " + verificationMode +
- ", stubbingInProgress: " + stubbingInProgress;
+ return "ongoingStubbing: "
+ + ongoingStubbing
+ + ", verificationMode: "
+ + verificationMode
+ + ", stubbingInProgress: "
+ + stubbingInProgress;
}
+ @Override
public void reset() {
stubbingInProgress = null;
verificationMode = null;
getArgumentMatcherStorage().reset();
}
+ @Override
public ArgumentMatcherStorage getArgumentMatcherStorage() {
return argumentMatcherStorage;
}
+ @Override
public void mockingStarted(Object mock, MockCreationSettings settings) {
for (MockitoListener listener : listeners) {
if (listener instanceof MockCreationListener) {
@@ -156,55 +172,70 @@
validateMostStuff();
}
+ @Override
+ public void mockingStarted(Class<?> mock, MockCreationSettings settings) {
+ for (MockitoListener listener : listeners) {
+ if (listener instanceof MockCreationListener) {
+ ((MockCreationListener) listener).onStaticMockCreated(mock, settings);
+ }
+ }
+ validateMostStuff();
+ }
+
+ @Override
public void addListener(MockitoListener listener) {
addListener(listener, listeners);
}
static void addListener(MockitoListener listener, Set<MockitoListener> listeners) {
- List<MockitoListener> delete = new LinkedList<MockitoListener>();
+ List<MockitoListener> delete = new LinkedList<>();
for (MockitoListener existing : listeners) {
if (existing.getClass().equals(listener.getClass())) {
- if (existing instanceof AutoCleanableListener && ((AutoCleanableListener) existing).isListenerDirty()) {
- //dirty listener means that there was an exception even before the test started
- //if we fail here with redundant mockito listener exception there will be multiple failures causing confusion
- //so we simply remove the existing listener and move on
+ if (existing instanceof AutoCleanableListener
+ && ((AutoCleanableListener) existing).isListenerDirty()) {
+ // dirty listener means that there was an exception even before the test started
+ // if we fail here with redundant mockito listener exception there will be
+ // multiple failures causing confusion
+ // so we simply remove the existing listener and move on
delete.add(existing);
} else {
Reporter.redundantMockitoListener(listener.getClass().getSimpleName());
}
}
}
- //delete dirty listeners so they don't occupy state/memory and don't receive notifications
- for (MockitoListener toDelete : delete) {
- listeners.remove(toDelete);
- }
+ // delete dirty listeners so they don't occupy state/memory and don't receive notifications
+ listeners.removeAll(delete);
listeners.add(listener);
}
+ @Override
public void removeListener(MockitoListener listener) {
this.listeners.remove(listener);
}
+ @Override
public void setVerificationStrategy(VerificationStrategy strategy) {
this.verificationStrategy = strategy;
}
+ @Override
public VerificationMode maybeVerifyLazily(VerificationMode mode) {
return this.verificationStrategy.maybeVerifyLazily(mode);
}
+ @Override
public void clearListeners() {
listeners.clear();
}
- /*
+ /*
- //TODO 545 thread safety of all mockito
+ //TODO 545 thread safety of all mockito
- use cases:
- - single threaded execution throughout
- - single threaded mock creation, stubbing & verification, multi-threaded interaction with mock
- - thread per test case
+ use cases:
+ - single threaded execution throughout
+ - single threaded mock creation, stubbing & verification, multi-threaded interaction with mock
+ - thread per test case
- */
+ */
}
diff --git a/src/main/java/org/mockito/internal/progress/SequenceNumber.java b/src/main/java/org/mockito/internal/progress/SequenceNumber.java
index bc7a07d..50e45cc 100644
--- a/src/main/java/org/mockito/internal/progress/SequenceNumber.java
+++ b/src/main/java/org/mockito/internal/progress/SequenceNumber.java
@@ -4,11 +4,13 @@
*/
package org.mockito.internal.progress;
-public class SequenceNumber {
+public final class SequenceNumber {
private static int sequenceNumber = 1;
public static synchronized int next() {
return sequenceNumber++;
}
+
+ private SequenceNumber() {}
}
diff --git a/src/main/java/org/mockito/internal/progress/ThreadSafeMockingProgress.java b/src/main/java/org/mockito/internal/progress/ThreadSafeMockingProgress.java
index 4735a11..adb9b99 100644
--- a/src/main/java/org/mockito/internal/progress/ThreadSafeMockingProgress.java
+++ b/src/main/java/org/mockito/internal/progress/ThreadSafeMockingProgress.java
@@ -9,15 +9,15 @@
*/
public class ThreadSafeMockingProgress {
- private static final ThreadLocal<MockingProgress> MOCKING_PROGRESS_PROVIDER = new ThreadLocal<MockingProgress>() {
- @Override
- protected MockingProgress initialValue() {
- return new MockingProgressImpl();
- }
- };
+ private static final ThreadLocal<MockingProgress> MOCKING_PROGRESS_PROVIDER =
+ new ThreadLocal<MockingProgress>() {
+ @Override
+ protected MockingProgress initialValue() {
+ return new MockingProgressImpl();
+ }
+ };
- private ThreadSafeMockingProgress() {
- }
+ private ThreadSafeMockingProgress() {}
/**
* Returns the {@link MockingProgress} for the current Thread.
@@ -26,7 +26,7 @@
*
* @return never <code>null</code>
*/
- public final static MockingProgress mockingProgress() {
+ public static final MockingProgress mockingProgress() {
return MOCKING_PROGRESS_PROVIDER.get();
}
}
diff --git a/src/main/java/org/mockito/internal/reporting/Pluralizer.java b/src/main/java/org/mockito/internal/reporting/Pluralizer.java
index 1e8d0e3..a8b083f 100644
--- a/src/main/java/org/mockito/internal/reporting/Pluralizer.java
+++ b/src/main/java/org/mockito/internal/reporting/Pluralizer.java
@@ -4,7 +4,7 @@
*/
package org.mockito.internal.reporting;
-public class Pluralizer {
+public final class Pluralizer {
public static String pluralize(int number) {
return number == 1 ? "1 time" : number + " times";
@@ -17,4 +17,6 @@
return "were exactly " + x + " interactions";
}
}
+
+ private Pluralizer() {}
}
diff --git a/src/main/java/org/mockito/internal/reporting/PrintSettings.java b/src/main/java/org/mockito/internal/reporting/PrintSettings.java
index 7986c35..41794ad 100644
--- a/src/main/java/org/mockito/internal/reporting/PrintSettings.java
+++ b/src/main/java/org/mockito/internal/reporting/PrintSettings.java
@@ -4,22 +4,24 @@
*/
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.invocation.ArgumentsProcessor;
import org.mockito.internal.matchers.text.MatchersPrinter;
import org.mockito.internal.util.MockUtil;
import org.mockito.invocation.Invocation;
import org.mockito.invocation.MatchableInvocation;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
public class PrintSettings {
public static final int MAX_LINE_LENGTH = 45;
private boolean multiline;
- private List<Integer> withTypeInfo = new LinkedList<Integer>();
+ private List<Integer> withTypeInfo = new LinkedList<>();
+ private Set<String> withFullyQualifiedName = Collections.emptySet();
public void setMultiline(boolean multiline) {
this.multiline = multiline;
@@ -29,7 +31,7 @@
return multiline;
}
- public static PrintSettings verboseMatchers(Integer ... indexesOfMatchers) {
+ public static PrintSettings verboseMatchers(Integer... indexesOfMatchers) {
PrintSettings settings = new PrintSettings();
settings.setMatchersToBeDescribedWithExtraTypeInfo(indexesOfMatchers);
return settings;
@@ -39,13 +41,22 @@
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 = MockUtil.getMockName(invocation.getMock()) + "." + invocation.getMethod().getName();
+ String qualifiedName =
+ MockUtil.getMockName(invocation.getMock()) + "." + invocation.getMethod().getName();
String invocationString = qualifiedName + matchersPrinter.getArgumentsLine(matchers, this);
if (isMultiline() || (!matchers.isEmpty() && invocationString.length() > MAX_LINE_LENGTH)) {
return qualifiedName + matchersPrinter.getArgumentsBlock(matchers, this);
@@ -55,7 +66,7 @@
}
public String print(Invocation invocation) {
- return print(ArgumentsProcessor.argumentsToMatchers(invocation.getArguments()), invocation);
+ return print(invocation.getArgumentsAsMatchers(), invocation);
}
public String print(MatchableInvocation invocation) {
diff --git a/src/main/java/org/mockito/internal/reporting/SmartPrinter.java b/src/main/java/org/mockito/internal/reporting/SmartPrinter.java
index 8da053d..f4b1f71 100644
--- a/src/main/java/org/mockito/internal/reporting/SmartPrinter.java
+++ b/src/main/java/org/mockito/internal/reporting/SmartPrinter.java
@@ -4,6 +4,10 @@
*/
package org.mockito.internal.reporting;
+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;
@@ -16,22 +20,54 @@
public class SmartPrinter {
private final String wanted;
- private final String actual;
+ private final List<String> actuals;
- public SmartPrinter(MatchableInvocation wanted, Invocation actual, Integer ... indexesOfMatchersToBeDescribedWithExtraTypeInfo) {
+ public SmartPrinter(
+ MatchableInvocation wanted,
+ Invocation actual,
+ Integer... indexesOfMatchersToBeDescribedWithExtraTypeInfo) {
+ this(
+ wanted,
+ Collections.singletonList(actual),
+ indexesOfMatchersToBeDescribedWithExtraTypeInfo,
+ Collections.emptySet());
+ }
+
+ public SmartPrinter(
+ MatchableInvocation wanted,
+ List<Invocation> allActualInvocations,
+ Integer[] indexesOfMatchersToBeDescribedWithExtraTypeInfo,
+ Set<String> classNamesToBeDescribedWithFullName) {
PrintSettings printSettings = new PrintSettings();
- printSettings.setMultiline(wanted.toString().contains("\n") || actual.toString().contains("\n"));
- printSettings.setMatchersToBeDescribedWithExtraTypeInfo(indexesOfMatchersToBeDescribedWithExtraTypeInfo);
+ printSettings.setMultiline(isMultiLine(wanted, allActualInvocations));
+ printSettings.setMatchersToBeDescribedWithExtraTypeInfo(
+ indexesOfMatchersToBeDescribedWithExtraTypeInfo);
+ printSettings.setMatchersToBeDescribedWithFullName(classNamesToBeDescribedWithFullName);
this.wanted = printSettings.print(wanted);
- this.actual = printSettings.print(actual);
+
+ List<String> actuals = new ArrayList<>();
+ for (Invocation actual : allActualInvocations) {
+ actuals.add(printSettings.print(actual));
+ }
+ this.actuals = Collections.unmodifiableList(actuals);
}
public String getWanted() {
return wanted;
}
- public String getActual() {
- return actual;
+ public List<String> getActuals() {
+ return actuals;
+ }
+
+ private static boolean isMultiLine(
+ MatchableInvocation wanted, List<Invocation> allActualInvocations) {
+ boolean isWantedMultiline = wanted.toString().contains("\n");
+ boolean isAnyActualMultiline = false;
+ for (Invocation invocation : allActualInvocations) {
+ isAnyActualMultiline |= invocation.toString().contains("\n");
+ }
+ return isWantedMultiline || isAnyActualMultiline;
}
}
diff --git a/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java b/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java
index 2f26ff1..6b69b82 100644
--- a/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java
+++ b/src/main/java/org/mockito/internal/runners/DefaultInternalRunner.java
@@ -24,71 +24,95 @@
private final BlockJUnit4ClassRunner runner;
- public DefaultInternalRunner(Class<?> testClass, final Supplier<MockitoTestListener> listenerSupplier) throws InitializationError {
- runner = new BlockJUnit4ClassRunner(testClass) {
+ public DefaultInternalRunner(
+ Class<?> testClass, final Supplier<MockitoTestListener> listenerSupplier)
+ throws InitializationError {
+ runner =
+ new BlockJUnit4ClassRunner(testClass) {
- public Object target;
- private MockitoTestListener mockitoTestListener;
-
- protected Statement withBefores(FrameworkMethod method, Object target, Statement statement) {
- this.target = target;
- // get new test listener and add it to the framework
- mockitoTestListener = listenerSupplier.get();
- Mockito.framework().addListener(mockitoTestListener);
- // init annotated mocks before tests
- MockitoAnnotations.initMocks(target);
- return super.withBefores(method, target, statement);
- }
-
- public void run(final RunNotifier notifier) {
- RunListener listener = new RunListener() {
- private boolean started;
- Throwable failure;
+ public Object target;
+ private MockitoTestListener mockitoTestListener;
@Override
- public void testStarted(Description description) throws Exception {
- started = true;
- }
-
- @Override
- public void testFailure(Failure failure) throws Exception {
- this.failure = failure.getException();
- // If the test fails during the setup, `testFinished` is never invoked
- // Therefore, if we have not started, cleanup the testlistener
- if (!started && mockitoTestListener != null) {
- Mockito.framework().removeListener(mockitoTestListener);
- }
- }
-
- @Override
- public void testFinished(Description description) throws Exception {
- try {
- if (mockitoTestListener != null) {
- Mockito.framework().removeListener(mockitoTestListener);
- mockitoTestListener.testFinished(new DefaultTestFinishedEvent(target, description.getMethodName(), failure));
+ protected Statement withBefores(
+ FrameworkMethod method, final Object target, Statement statement) {
+ this.target = target;
+ final Statement base = super.withBefores(method, target, statement);
+ return new Statement() {
+ @Override
+ public void evaluate() throws Throwable {
+ AutoCloseable closeable;
+ if (mockitoTestListener == null) {
+ // get new test listener and add it to the framework
+ mockitoTestListener = listenerSupplier.get();
+ Mockito.framework().addListener(mockitoTestListener);
+ // init annotated mocks before tests
+ closeable = MockitoAnnotations.openMocks(target);
+ } else {
+ closeable = null;
+ }
+ try {
+ base.evaluate();
+ } finally {
+ if (closeable != null) {
+ closeable.close();
+ }
+ }
}
- Mockito.validateMockitoUsage();
- } catch (Throwable t) {
- //In order to produce clean exception to the user we need to fire test failure with the right description
- //Otherwise JUnit framework will report failure with some generic test name
- notifier.fireTestFailure(new Failure(description, t));
- }
+ };
+ }
+
+ public void run(final RunNotifier notifier) {
+ RunListener listener =
+ new RunListener() {
+ Throwable failure;
+
+ @Override
+ public void testFailure(Failure failure) throws Exception {
+ this.failure = failure.getException();
+ }
+
+ @Override
+ public void testFinished(Description description)
+ throws Exception {
+ try {
+ if (mockitoTestListener != null) {
+ Mockito.framework()
+ .removeListener(mockitoTestListener);
+ mockitoTestListener.testFinished(
+ new DefaultTestFinishedEvent(
+ target,
+ description.getMethodName(),
+ failure));
+ mockitoTestListener = null;
+ }
+ Mockito.validateMockitoUsage();
+ } catch (Throwable t) {
+ // In order to produce clean exception to the user we
+ // need to fire test failure with the right description
+ // Otherwise JUnit framework will report failure with
+ // some generic test name
+ notifier.fireTestFailure(new Failure(description, t));
+ }
+ }
+ };
+ notifier.addListener(listener);
+ super.run(notifier);
}
};
- notifier.addListener(listener);
- super.run(notifier);
- }
- };
}
+ @Override
public void run(final RunNotifier notifier) {
runner.run(notifier);
}
+ @Override
public Description getDescription() {
return runner.getDescription();
}
+ @Override
public void filter(Filter filter) throws NoTestsRemainException {
runner.filter(filter);
}
diff --git a/src/main/java/org/mockito/internal/runners/InternalRunner.java b/src/main/java/org/mockito/internal/runners/InternalRunner.java
index 85b2f3c..d06d005 100644
--- a/src/main/java/org/mockito/internal/runners/InternalRunner.java
+++ b/src/main/java/org/mockito/internal/runners/InternalRunner.java
@@ -17,5 +17,4 @@
void run(RunNotifier notifier);
Description getDescription();
-
}
diff --git a/src/main/java/org/mockito/internal/runners/RunnerFactory.java b/src/main/java/org/mockito/internal/runners/RunnerFactory.java
index 61456dc..369dc8b 100644
--- a/src/main/java/org/mockito/internal/runners/RunnerFactory.java
+++ b/src/main/java/org/mockito/internal/runners/RunnerFactory.java
@@ -4,44 +4,46 @@
*/
package org.mockito.internal.runners;
+import static org.mockito.internal.runners.util.TestMethodsFinder.hasTestMethods;
+
+import java.lang.reflect.InvocationTargetException;
+
import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.junit.MismatchReportingTestListener;
import org.mockito.internal.junit.MockitoTestListener;
import org.mockito.internal.junit.NoOpTestListener;
import org.mockito.internal.junit.StrictStubsRunnerTestListener;
import org.mockito.internal.runners.util.RunnerProvider;
-import org.mockito.internal.util.ConsoleMockitoLogger;
import org.mockito.internal.util.Supplier;
-import java.lang.reflect.InvocationTargetException;
-
-import static org.mockito.internal.runners.util.TestMethodsFinder.hasTestMethods;
-
/**
* Creates instances of Mockito JUnit Runner in a safe way, e.g. detecting inadequate version of JUnit, etc.
*/
public class RunnerFactory {
- /**
- * Creates silent runner implementation
- */
+ /** Creates silent runner implementation */
public InternalRunner create(Class<?> klass) throws InvocationTargetException {
- return create(klass, new Supplier<MockitoTestListener>() {
- public MockitoTestListener get() {
- return new NoOpTestListener();
- }
- });
+ return create(
+ klass,
+ new Supplier<MockitoTestListener>() {
+ public MockitoTestListener get() {
+ return new NoOpTestListener();
+ }
+ });
}
/**
* Creates strict runner implementation
*/
public InternalRunner createStrict(Class<?> klass) throws InvocationTargetException {
- return create(klass, new Supplier<MockitoTestListener>() {
- public MockitoTestListener get() {
- return new MismatchReportingTestListener(new ConsoleMockitoLogger());
- }
- });
+ return create(
+ klass,
+ new Supplier<MockitoTestListener>() {
+ public MockitoTestListener get() {
+ return new MismatchReportingTestListener(Plugins.getMockitoLogger());
+ }
+ });
}
/**
@@ -50,43 +52,49 @@
* TODO, let's try to apply Brice suggestion and use switch + Strictness
*/
public InternalRunner createStrictStubs(Class<?> klass) throws InvocationTargetException {
- return create(klass, new Supplier<MockitoTestListener>() {
- public MockitoTestListener get() {
- return new StrictStubsRunnerTestListener();
- }
- });
+ return create(
+ klass,
+ new Supplier<MockitoTestListener>() {
+ public MockitoTestListener get() {
+ return new StrictStubsRunnerTestListener();
+ }
+ });
}
/**
* Creates runner implementation with provided listener supplier
*/
- public InternalRunner create(Class<?> klass, Supplier<MockitoTestListener> listenerSupplier) throws InvocationTargetException {
+ public InternalRunner create(Class<?> klass, Supplier<MockitoTestListener> listenerSupplier)
+ throws InvocationTargetException {
try {
String runnerClassName = "org.mockito.internal.runners.DefaultInternalRunner";
- //Warning: I'm using String literal on purpose!
- //When JUnit is not on classpath, we want the code to throw exception here so that we can catch it
- //If we statically link the class, we will get Error when class is loaded
+ // Warning: I'm using String literal on purpose!
+ // When JUnit is not on classpath, we want the code to throw exception here so that we
+ // can catch it
+ // If we statically link the class, we will get Error when class is loaded
return new RunnerProvider().newInstance(runnerClassName, klass, listenerSupplier);
} catch (InvocationTargetException e) {
if (!hasTestMethods(klass)) {
throw new MockitoException(
- "\n" +
- "\n" +
- "No tests found in " + klass.getSimpleName() + "\n" +
- "Is the method annotated with @Test?\n" +
- "Is the method public?\n"
- , e);
+ "\n"
+ + "\n"
+ + "No tests found in "
+ + klass.getSimpleName()
+ + "\n"
+ + "Is the method annotated with @Test?\n"
+ + "Is the method public?\n",
+ e);
}
throw e;
} catch (Throwable t) {
throw new MockitoException(
- "\n" +
- "\n" +
- "MockitoRunner can only be used with JUnit 4.5 or higher.\n" +
- "You can upgrade your JUnit version or write your own Runner (please consider contributing your runner to the Mockito community).\n" +
- "Bear in mind that you can still enjoy all features of the framework without using runners (they are completely optional).\n" +
- "If you get this error despite using JUnit 4.5 or higher then please report this error to the mockito mailing list.\n"
- , t);
+ "\n"
+ + "\n"
+ + "MockitoRunner can only be used with JUnit 4.5 or higher.\n"
+ + "You can upgrade your JUnit version or write your own Runner (please consider contributing your runner to the Mockito community).\n"
+ + "Bear in mind that you can still enjoy all features of the framework without using runners (they are completely optional).\n"
+ + "If you get this error despite using JUnit 4.5 or higher then please report this error to the mockito mailing list.\n",
+ t);
}
}
}
diff --git a/src/main/java/org/mockito/internal/runners/StrictRunner.java b/src/main/java/org/mockito/internal/runners/StrictRunner.java
index d87289f..b3ea774 100644
--- a/src/main/java/org/mockito/internal/runners/StrictRunner.java
+++ b/src/main/java/org/mockito/internal/runners/StrictRunner.java
@@ -27,8 +27,10 @@
this.testClass = testClass;
}
+ @Override
public void run(RunNotifier notifier) {
- //TODO need to be able to opt in for full stack trace instead of just relying on the stack trace filter
+ // TODO need to be able to opt in for full stack trace instead of just relying on the stack
+ // trace filter
UnnecessaryStubbingsReporter reporter = new UnnecessaryStubbingsReporter();
FailureDetector listener = new FailureDetector();
@@ -42,18 +44,22 @@
}
if (!filterRequested && listener.isSuccessful()) {
- //only report when:
- //1. if all tests from given test have ran (filter requested is false)
- // Otherwise we would report unnecessary stubs even if the user runs just single test from the class
- //2. tests are successful (we don't want to add an extra failure on top of any existing failure, to avoid confusion)
+ // only report when:
+ // 1. if all tests from given test have ran (filter requested is false)
+ // Otherwise we would report unnecessary stubs even if the user runs just single test
+ // from the class
+ // 2. tests are successful (we don't want to add an extra failure on top of any existing
+ // failure, to avoid confusion)
reporter.validateUnusedStubs(testClass, notifier);
}
}
+ @Override
public Description getDescription() {
return runner.getDescription();
}
+ @Override
public void filter(Filter filter) throws NoTestsRemainException {
filterRequested = true;
runner.filter(filter);
diff --git a/src/main/java/org/mockito/internal/runners/util/RunnerProvider.java b/src/main/java/org/mockito/internal/runners/util/RunnerProvider.java
index e3ed92a..30c6c4c 100644
--- a/src/main/java/org/mockito/internal/runners/util/RunnerProvider.java
+++ b/src/main/java/org/mockito/internal/runners/util/RunnerProvider.java
@@ -4,19 +4,21 @@
*/
package org.mockito.internal.runners.util;
-import org.mockito.internal.runners.InternalRunner;
-
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
+import org.mockito.internal.runners.InternalRunner;
+
public class RunnerProvider {
- public InternalRunner newInstance(String runnerClassName, Object ... constructorArgs) throws Exception {
+ public InternalRunner newInstance(String runnerClassName, Object... constructorArgs)
+ throws Exception {
Constructor<?> constructor;
try {
Class<?> runnerClass = Class.forName(runnerClassName);
if (runnerClass.getConstructors().length != 1) {
- throw new IllegalArgumentException("Expected " + runnerClassName + " to have exactly one constructor.");
+ throw new IllegalArgumentException(
+ "Expected " + runnerClassName + " to have exactly one constructor.");
}
constructor = runnerClass.getConstructors()[0];
} catch (Exception e) {
diff --git a/src/main/java/org/mockito/internal/runners/util/TestMethodsFinder.java b/src/main/java/org/mockito/internal/runners/util/TestMethodsFinder.java
index f435df3..40d71ea 100644
--- a/src/main/java/org/mockito/internal/runners/util/TestMethodsFinder.java
+++ b/src/main/java/org/mockito/internal/runners/util/TestMethodsFinder.java
@@ -4,17 +4,17 @@
*/
package org.mockito.internal.runners.util;
-import org.junit.Test;
-
import java.lang.reflect.Method;
+import org.junit.Test;
+
public class TestMethodsFinder {
private TestMethodsFinder() {}
public static boolean hasTestMethods(Class<?> klass) {
Method[] methods = klass.getMethods();
- for(Method m:methods) {
+ for (Method m : methods) {
if (m.isAnnotationPresent(Test.class)) {
return true;
}
diff --git a/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java b/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java
index d9b21e5..6fe3dcb 100644
--- a/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java
+++ b/src/main/java/org/mockito/internal/session/DefaultMockitoSessionBuilder.java
@@ -4,22 +4,22 @@
*/
package org.mockito.internal.session;
-import org.mockito.MockitoSession;
-import org.mockito.internal.framework.DefaultMockitoSession;
-import org.mockito.internal.util.ConsoleMockitoLogger;
-import org.mockito.internal.util.MockitoLogger;
-import org.mockito.quality.Strictness;
-import org.mockito.session.MockitoSessionBuilder;
-import org.mockito.session.MockitoSessionLogger;
+import static java.util.Collections.emptyList;
import java.util.ArrayList;
import java.util.List;
-import static java.util.Collections.emptyList;
+import org.mockito.MockitoSession;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.framework.DefaultMockitoSession;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.quality.Strictness;
+import org.mockito.session.MockitoSessionBuilder;
+import org.mockito.session.MockitoSessionLogger;
public class DefaultMockitoSessionBuilder implements MockitoSessionBuilder {
- private List<Object> testClassInstances = new ArrayList<Object>();
+ private final List<Object> testClassInstances = new ArrayList<Object>();
private String name;
private Strictness strictness;
private MockitoSessionLogger logger;
@@ -62,19 +62,25 @@
@Override
public MockitoSession startMocking() {
- //Configure default values
+ // Configure default values
List<Object> effectiveTestClassInstances;
String effectiveName;
if (testClassInstances.isEmpty()) {
effectiveTestClassInstances = emptyList();
effectiveName = this.name == null ? "<Unnamed Session>" : this.name;
} else {
- effectiveTestClassInstances = new ArrayList<Object>(testClassInstances);
+ effectiveTestClassInstances = new ArrayList<>(testClassInstances);
Object lastTestClassInstance = testClassInstances.get(testClassInstances.size() - 1);
- effectiveName = this.name == null ? lastTestClassInstance.getClass().getName() : this.name;
+ effectiveName =
+ this.name == null ? lastTestClassInstance.getClass().getName() : this.name;
}
- Strictness effectiveStrictness = this.strictness == null ? Strictness.STRICT_STUBS : this.strictness;
- MockitoLogger logger = this.logger == null ? new ConsoleMockitoLogger() : new MockitoLoggerAdapter(this.logger);
- return new DefaultMockitoSession(effectiveTestClassInstances, effectiveName, effectiveStrictness, logger);
+ Strictness effectiveStrictness =
+ this.strictness == null ? Strictness.STRICT_STUBS : this.strictness;
+ MockitoLogger logger =
+ this.logger == null
+ ? Plugins.getMockitoLogger()
+ : new MockitoLoggerAdapter(this.logger);
+ return new DefaultMockitoSession(
+ effectiveTestClassInstances, effectiveName, effectiveStrictness, logger);
}
}
diff --git a/src/main/java/org/mockito/internal/session/MockitoLoggerAdapter.java b/src/main/java/org/mockito/internal/session/MockitoLoggerAdapter.java
index b7329e7..2197317 100644
--- a/src/main/java/org/mockito/internal/session/MockitoLoggerAdapter.java
+++ b/src/main/java/org/mockito/internal/session/MockitoLoggerAdapter.java
@@ -4,7 +4,7 @@
*/
package org.mockito.internal.session;
-import org.mockito.internal.util.MockitoLogger;
+import org.mockito.plugins.MockitoLogger;
import org.mockito.session.MockitoSessionLogger;
class MockitoLoggerAdapter implements MockitoLogger {
diff --git a/src/main/java/org/mockito/internal/session/MockitoSessionLoggerAdapter.java b/src/main/java/org/mockito/internal/session/MockitoSessionLoggerAdapter.java
index 2e8634b..f4770c5 100644
--- a/src/main/java/org/mockito/internal/session/MockitoSessionLoggerAdapter.java
+++ b/src/main/java/org/mockito/internal/session/MockitoSessionLoggerAdapter.java
@@ -4,7 +4,7 @@
*/
package org.mockito.internal.session;
-import org.mockito.internal.util.MockitoLogger;
+import org.mockito.plugins.MockitoLogger;
import org.mockito.session.MockitoSessionLogger;
public class MockitoSessionLoggerAdapter implements MockitoSessionLogger {
diff --git a/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java b/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java
index 6dd99cd..7a59cf1 100644
--- a/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java
+++ b/src/main/java/org/mockito/internal/stubbing/BaseStubbing.java
@@ -6,15 +6,29 @@
import static org.mockito.internal.exceptions.Reporter.notAnException;
import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-import static org.objenesis.ObjenesisHelper.newInstance;
import org.mockito.internal.stubbing.answers.CallsRealMethods;
import org.mockito.internal.stubbing.answers.Returns;
import org.mockito.internal.stubbing.answers.ThrowsException;
+import org.mockito.internal.stubbing.answers.ThrowsExceptionForClassType;
+import org.mockito.stubbing.Answer;
import org.mockito.stubbing.OngoingStubbing;
public abstract class BaseStubbing<T> implements OngoingStubbing<T> {
+ // Keep strong ref to mock preventing premature garbage collection when using 'One-liner stubs'.
+ // See #1541.
+ private final Object strongMockRef;
+
+ BaseStubbing(Object mock) {
+ this.strongMockRef = mock;
+ }
+
+ @Override
+ public OngoingStubbing<T> then(Answer<?> answer) {
+ return thenAnswer(answer);
+ }
+
@Override
public OngoingStubbing<T> thenReturn(T value) {
return thenAnswer(new Returns(value));
@@ -25,7 +39,8 @@
OngoingStubbing<T> stubbing = thenReturn(value);
if (values == null) {
// For no good reason we're configuring null answer here
- // This has been like that since forever, so let's keep it for compatibility (unless users complain)
+ // This has been like that since forever, so let's keep it for compatibility (unless
+ // users complain)
return stubbing.thenReturn(null);
}
for (T v : values) {
@@ -60,11 +75,12 @@
mockingProgress().reset();
throw notAnException();
}
- return thenThrow(newInstance(throwableType));
+ return thenAnswer(new ThrowsExceptionForClassType(throwableType));
}
@Override
- public OngoingStubbing<T> thenThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
+ public OngoingStubbing<T> thenThrow(
+ Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
if (nextToBeThrown == null) {
return thenThrow((Class<Throwable>) null);
}
@@ -79,6 +95,10 @@
public OngoingStubbing<T> thenCallRealMethod() {
return thenAnswer(new CallsRealMethods());
}
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public <M> M getMock() {
+ return (M) this.strongMockRef;
+ }
}
-
-
diff --git a/src/main/java/org/mockito/internal/stubbing/ConsecutiveStubbing.java b/src/main/java/org/mockito/internal/stubbing/ConsecutiveStubbing.java
index a5cdc04..e7b269f 100644
--- a/src/main/java/org/mockito/internal/stubbing/ConsecutiveStubbing.java
+++ b/src/main/java/org/mockito/internal/stubbing/ConsecutiveStubbing.java
@@ -8,23 +8,17 @@
import org.mockito.stubbing.OngoingStubbing;
public class ConsecutiveStubbing<T> extends BaseStubbing<T> {
- private final InvocationContainerImpl invocationContainerImpl;
- public ConsecutiveStubbing(InvocationContainerImpl invocationContainerImpl) {
- this.invocationContainerImpl = invocationContainerImpl;
+ private final InvocationContainerImpl invocationContainer;
+
+ ConsecutiveStubbing(InvocationContainerImpl invocationContainer) {
+ super(invocationContainer.invokedMock());
+ this.invocationContainer = invocationContainer;
}
+ @Override
public OngoingStubbing<T> thenAnswer(Answer<?> answer) {
- invocationContainerImpl.addConsecutiveAnswer(answer);
+ invocationContainer.addConsecutiveAnswer(answer);
return this;
}
-
- public OngoingStubbing<T> then(Answer<?> answer) {
- return thenAnswer(answer);
- }
-
- @SuppressWarnings("unchecked")
- public <M> M getMock() {
- return (M) invocationContainerImpl.invokedMock();
- }
}
diff --git a/src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java b/src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java
index 0f3fe07..6986c20 100644
--- a/src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java
+++ b/src/main/java/org/mockito/internal/stubbing/DefaultLenientStubber.java
@@ -13,7 +13,7 @@
public class DefaultLenientStubber implements LenientStubber {
- private final static MockitoCore MOCKITO_CORE = new MockitoCore();
+ private static final MockitoCore MOCKITO_CORE = new MockitoCore();
@Override
public Stubber doThrow(Throwable... toBeThrown) {
@@ -26,7 +26,8 @@
}
@Override
- public Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
+ public Stubber doThrow(
+ Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
return stubber().doThrow(toBeThrown, nextToBeThrown);
}
@@ -57,7 +58,8 @@
@Override
public <T> OngoingStubbing<T> when(T methodCall) {
- OngoingStubbingImpl<T> ongoingStubbing = (OngoingStubbingImpl) MOCKITO_CORE.when(methodCall);
+ OngoingStubbingImpl<T> ongoingStubbing =
+ (OngoingStubbingImpl) MOCKITO_CORE.when(methodCall);
ongoingStubbing.setStrictness(Strictness.LENIENT);
return ongoingStubbing;
}
diff --git a/src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java b/src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java
index 56491b8..e143379 100644
--- a/src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java
+++ b/src/main/java/org/mockito/internal/stubbing/DoAnswerStyleStubbing.java
@@ -4,19 +4,19 @@
*/
package org.mockito.internal.stubbing;
-import org.mockito.quality.Strictness;
-import org.mockito.stubbing.Answer;
-
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.Answer;
+
/**
* Holds answers declared using 'doAnswer' stubbing style.
*/
class DoAnswerStyleStubbing implements Serializable {
- private final List<Answer<?>> answers = new ArrayList<Answer<?>>();
+ private final List<Answer<?>> answers = new ArrayList<>();
private Strictness stubbingStrictness;
void setAnswers(List<Answer<?>> answers, Strictness stubbingStrictness) {
diff --git a/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java b/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
index 6c98f37..849300e 100644
--- a/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
+++ b/src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java
@@ -4,6 +4,14 @@
*/
package org.mockito.internal.stubbing;
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
import org.mockito.internal.invocation.StubInfoImpl;
import org.mockito.internal.verification.DefaultRegisteredInvocations;
import org.mockito.internal.verification.RegisteredInvocations;
@@ -17,19 +25,11 @@
import org.mockito.stubbing.Stubbing;
import org.mockito.stubbing.ValidableAnswer;
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-
@SuppressWarnings("unchecked")
public class InvocationContainerImpl implements InvocationContainer, Serializable {
private static final long serialVersionUID = -5334301962749537177L;
- private final LinkedList<StubbedInvocationMatcher> stubbed = new LinkedList<StubbedInvocationMatcher>();
+ private final LinkedList<StubbedInvocationMatcher> stubbed = new LinkedList<>();
private final DoAnswerStyleStubbing doAnswerStyleStubbing;
private final RegisteredInvocations registeredInvocations;
private final Strictness mockStrictness;
@@ -56,14 +56,9 @@
addAnswer(answer, false, stubbingStrictness);
}
- public void addConsecutiveAnswer(Answer answer) {
- addAnswer(answer, true, null);
- }
-
- /**
- * Adds new stubbed answer and returns the invocation matcher the answer was added to.
- */
- public StubbedInvocationMatcher addAnswer(Answer answer, boolean isConsecutive, Strictness stubbingStrictness) {
+ /** Adds new stubbed answer and returns the invocation matcher the answer was added to. */
+ public StubbedInvocationMatcher addAnswer(
+ Answer answer, boolean isConsecutive, Strictness stubbingStrictness) {
Invocation invocation = invocationForStubbing.getInvocation();
mockingProgress().stubbingCompleted();
if (answer instanceof ValidableAnswer) {
@@ -74,13 +69,20 @@
if (isConsecutive) {
stubbed.getFirst().addAnswer(answer);
} else {
- Strictness effectiveStrictness = stubbingStrictness != null ? stubbingStrictness : this.mockStrictness;
- stubbed.addFirst(new StubbedInvocationMatcher(answer, invocationForStubbing, effectiveStrictness));
+ Strictness effectiveStrictness =
+ stubbingStrictness != null ? stubbingStrictness : this.mockStrictness;
+ stubbed.addFirst(
+ new StubbedInvocationMatcher(
+ answer, invocationForStubbing, effectiveStrictness));
}
return stubbed.getFirst();
}
}
+ public void addConsecutiveAnswer(Answer answer) {
+ addAnswer(answer, true, null);
+ }
+
Object answerTo(Invocation invocation) throws Throwable {
return findAnswerFor(invocation).answer(invocation);
}
@@ -90,7 +92,8 @@
for (StubbedInvocationMatcher s : stubbed) {
if (s.matches(invocation)) {
s.markStubUsed(invocation);
- //TODO we should mark stubbed at the point of stubbing, not at the point where the stub is being used
+ // TODO we should mark stubbed at the point of stubbing, not at the point where
+ // the stub is being used
invocation.markStubbed(new StubInfoImpl(s));
return s;
}
@@ -119,7 +122,10 @@
invocationForStubbing = invocation;
assert hasAnswersForStubbing();
for (int i = 0; i < doAnswerStyleStubbing.getAnswers().size(); i++) {
- addAnswer(doAnswerStyleStubbing.getAnswers().get(i), i != 0, doAnswerStyleStubbing.getStubbingStrictness());
+ addAnswer(
+ doAnswerStyleStubbing.getAnswers().get(i),
+ i != 0,
+ doAnswerStyleStubbing.getStubbingStrictness());
}
doAnswerStyleStubbing.clear();
}
@@ -148,7 +154,7 @@
* Stubbings in ascending order, most recent last
*/
public Collection<Stubbing> getStubbingsAscending() {
- List<Stubbing> result = new LinkedList<Stubbing>(stubbed);
+ List<Stubbing> result = new LinkedList<>(stubbed);
Collections.reverse(result);
return result;
}
@@ -163,7 +169,7 @@
private RegisteredInvocations createRegisteredInvocations(MockCreationSettings mockSettings) {
return mockSettings.isStubOnly()
- ? new SingleRegisteredInvocation()
- : new DefaultRegisteredInvocations();
+ ? new SingleRegisteredInvocation()
+ : new DefaultRegisteredInvocations();
}
}
diff --git a/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java b/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java
index cd27c39..a5bb086 100644
--- a/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java
+++ b/src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java
@@ -4,27 +4,28 @@
*/
package org.mockito.internal.stubbing;
+import static org.mockito.internal.exceptions.Reporter.incorrectUseOfApi;
+
+import java.util.List;
+
import org.mockito.invocation.Invocation;
import org.mockito.quality.Strictness;
import org.mockito.stubbing.Answer;
import org.mockito.stubbing.OngoingStubbing;
-import java.util.List;
-
-import static org.mockito.internal.exceptions.Reporter.incorrectUseOfApi;
-
public class OngoingStubbingImpl<T> extends BaseStubbing<T> {
private final InvocationContainerImpl invocationContainer;
private Strictness strictness;
public OngoingStubbingImpl(InvocationContainerImpl invocationContainer) {
+ super(invocationContainer.invokedMock());
this.invocationContainer = invocationContainer;
}
@Override
public OngoingStubbing<T> thenAnswer(Answer<?> answer) {
- if(!invocationContainer.hasInvocationForPotentialStubbing()) {
+ if (!invocationContainer.hasInvocationForPotentialStubbing()) {
throw incorrectUseOfApi();
}
@@ -32,25 +33,12 @@
return new ConsecutiveStubbing<T>(invocationContainer);
}
- @Override
- public OngoingStubbing<T> then(Answer<?> answer) {
- return thenAnswer(answer);
- }
-
public List<Invocation> getRegisteredInvocations() {
- //TODO interface for tests
+ // TODO interface for tests
return invocationContainer.getInvocations();
}
- @Override
- @SuppressWarnings("unchecked")
- public <M> M getMock() {
- return (M) invocationContainer.invokedMock();
- }
-
public void setStrictness(Strictness strictness) {
this.strictness = strictness;
}
}
-
-
diff --git a/src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java b/src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java
index 6009e93..6422fd5 100644
--- a/src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java
+++ b/src/main/java/org/mockito/internal/stubbing/StrictnessSelector.java
@@ -11,7 +11,7 @@
/**
* Helps determining the actual strictness given that it can be configured in multiple ways (at mock, at stubbing, in rule)
*/
-public class StrictnessSelector {
+public final class StrictnessSelector {
/**
* Determines the actual strictness in the following importance order:
@@ -25,7 +25,8 @@
*
* @return actual strictness, can be null.
*/
- public static Strictness determineStrictness(Stubbing stubbing, MockCreationSettings mockSettings, Strictness testLevelStrictness) {
+ public static Strictness determineStrictness(
+ Stubbing stubbing, MockCreationSettings mockSettings, Strictness testLevelStrictness) {
if (stubbing != null && stubbing.getStrictness() != null) {
return stubbing.getStrictness();
}
@@ -36,4 +37,6 @@
return testLevelStrictness;
}
+
+ private StrictnessSelector() {}
}
diff --git a/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java b/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java
index e7ccac4..a4ab2fd 100644
--- a/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java
+++ b/src/main/java/org/mockito/internal/stubbing/StubbedInvocationMatcher.java
@@ -4,6 +4,10 @@
*/
package org.mockito.internal.stubbing;
+import java.io.Serializable;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
import org.mockito.internal.invocation.InvocationMatcher;
import org.mockito.invocation.DescribedInvocation;
import org.mockito.invocation.InvocationOnMock;
@@ -12,28 +16,27 @@
import org.mockito.stubbing.Answer;
import org.mockito.stubbing.Stubbing;
-import java.io.Serializable;
-import java.util.Queue;
-import java.util.concurrent.ConcurrentLinkedQueue;
-
@SuppressWarnings("unchecked")
public class StubbedInvocationMatcher extends InvocationMatcher implements Serializable, Stubbing {
private static final long serialVersionUID = 4919105134123672727L;
- private final Queue<Answer> answers = new ConcurrentLinkedQueue<Answer>();
+ private final Queue<Answer> answers = new ConcurrentLinkedQueue<>();
private final Strictness strictness;
+ private final Object usedAtLock = new Object[0];
private DescribedInvocation usedAt;
- public StubbedInvocationMatcher(Answer answer, MatchableInvocation invocation, Strictness strictness) {
+ public StubbedInvocationMatcher(
+ Answer answer, MatchableInvocation invocation, Strictness strictness) {
super(invocation.getInvocation(), invocation.getMatchers());
this.strictness = strictness;
this.answers.add(answer);
}
+ @Override
public Object answer(InvocationOnMock invocation) throws Throwable {
- //see ThreadsShareGenerouslyStubbedMockTest
+ // see ThreadsShareGenerouslyStubbedMockTest
Answer a;
- synchronized(answers) {
+ synchronized (answers) {
a = answers.size() == 1 ? answers.peek() : answers.poll();
}
return a.answer(invocation);
@@ -44,11 +47,16 @@
}
public void markStubUsed(DescribedInvocation usedAt) {
- this.usedAt = usedAt;
+ synchronized (usedAtLock) {
+ this.usedAt = usedAt;
+ }
}
+ @Override
public boolean wasUsed() {
- return usedAt != null;
+ synchronized (usedAtLock) {
+ return usedAt != null;
+ }
}
@Override
diff --git a/src/main/java/org/mockito/internal/stubbing/StubberImpl.java b/src/main/java/org/mockito/internal/stubbing/StubberImpl.java
index 2172809..a357de6 100644
--- a/src/main/java/org/mockito/internal/stubbing/StubberImpl.java
+++ b/src/main/java/org/mockito/internal/stubbing/StubberImpl.java
@@ -4,24 +4,24 @@
*/
package org.mockito.internal.stubbing;
-import org.mockito.internal.stubbing.answers.CallsRealMethods;
-import org.mockito.internal.stubbing.answers.Returns;
-import org.mockito.internal.stubbing.answers.ThrowsException;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.quality.Strictness;
-import org.mockito.stubbing.Answer;
-import org.mockito.stubbing.Stubber;
-
-import java.util.LinkedList;
-import java.util.List;
-
import static org.mockito.internal.exceptions.Reporter.notAMockPassedToWhenMethod;
import static org.mockito.internal.exceptions.Reporter.notAnException;
import static org.mockito.internal.exceptions.Reporter.nullPassedToWhenMethod;
import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
import static org.mockito.internal.stubbing.answers.DoesNothing.doesNothing;
import static org.mockito.internal.util.MockUtil.isMock;
-import static org.objenesis.ObjenesisHelper.newInstance;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.mockito.internal.stubbing.answers.CallsRealMethods;
+import org.mockito.internal.stubbing.answers.Returns;
+import org.mockito.internal.stubbing.answers.ThrowsException;
+import org.mockito.internal.stubbing.answers.ThrowsExceptionForClassType;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.Stubber;
public class StubberImpl implements Stubber {
@@ -31,15 +31,17 @@
this.strictness = strictness;
}
- private final List<Answer<?>> answers = new LinkedList<Answer<?>>();
+ private final List<Answer<?>> answers = new LinkedList<>();
@Override
public <T> T when(T mock) {
if (mock == null) {
+ mockingProgress().reset();
throw nullPassedToWhenMethod();
}
if (!isMock(mock)) {
+ mockingProgress().reset();
throw notAMockPassedToWhenMethod();
}
@@ -87,18 +89,12 @@
mockingProgress().reset();
throw notAnException();
}
- Throwable e;
- try {
- e = newInstance(toBeThrown);
- } catch (RuntimeException instantiationError) {
- mockingProgress().reset();
- throw instantiationError;
- }
- return doThrow(e);
+ return doAnswer(new ThrowsExceptionForClassType(toBeThrown));
}
@Override
- public Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
+ public Stubber doThrow(
+ Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown) {
Stubber stubber = doThrow(toBeThrown);
if (nextToBeThrown == null) {
@@ -110,7 +106,6 @@
stubber = stubber.doThrow(next);
}
return stubber;
-
}
@Override
@@ -131,5 +126,3 @@
return this;
}
}
-
-
diff --git a/src/main/java/org/mockito/internal/stubbing/StubbingComparator.java b/src/main/java/org/mockito/internal/stubbing/StubbingComparator.java
index b7f7ad5..4d8e678 100644
--- a/src/main/java/org/mockito/internal/stubbing/StubbingComparator.java
+++ b/src/main/java/org/mockito/internal/stubbing/StubbingComparator.java
@@ -4,11 +4,11 @@
*/
package org.mockito.internal.stubbing;
+import java.util.Comparator;
+
import org.mockito.internal.invocation.InvocationComparator;
import org.mockito.stubbing.Stubbing;
-import java.util.Comparator;
-
/**
* Compares stubbings based on {@link InvocationComparator}
*/
@@ -16,6 +16,7 @@
private final InvocationComparator invocationComparator = new InvocationComparator();
+ @Override
public int compare(Stubbing o1, Stubbing o2) {
return invocationComparator.compare(o1.getInvocation(), o2.getInvocation());
}
diff --git a/src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java b/src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java
index 6a96592..38247a5 100644
--- a/src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java
+++ b/src/main/java/org/mockito/internal/stubbing/UnusedStubbingReporting.java
@@ -7,10 +7,8 @@
import org.mockito.quality.Strictness;
import org.mockito.stubbing.Stubbing;
-/**
- * Helps determining if stubbing should be reported as unused
- */
-public class UnusedStubbingReporting {
+/** Helps determining if stubbing should be reported as unused */
+public final class UnusedStubbingReporting {
/**
* Decides if the stubbing should be reported as unused.
@@ -19,4 +17,6 @@
public static boolean shouldBeReported(Stubbing stubbing) {
return !stubbing.wasUsed() && stubbing.getStrictness() != Strictness.LENIENT;
}
+
+ private UnusedStubbingReporting() {}
}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/AbstractThrowsException.java b/src/main/java/org/mockito/internal/stubbing/answers/AbstractThrowsException.java
new file mode 100644
index 0000000..6bcca9d
--- /dev/null
+++ b/src/main/java/org/mockito/internal/stubbing/answers/AbstractThrowsException.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.mockito.internal.exceptions.Reporter.cannotStubWithNullThrowable;
+import static org.mockito.internal.exceptions.Reporter.checkedExceptionInvalid;
+
+import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.ValidableAnswer;
+
+public abstract class AbstractThrowsException implements Answer<Object>, ValidableAnswer {
+
+ private final ConditionalStackTraceFilter filter = new ConditionalStackTraceFilter();
+
+ protected abstract Throwable getThrowable();
+
+ @Override
+ public Object answer(InvocationOnMock invocation) throws Throwable {
+ Throwable throwable = getThrowable();
+ if (throwable == null) {
+ throw new IllegalStateException(
+ "throwable is null: " + "you shall not call #answer if #validateFor fails!");
+ }
+ if (MockUtil.isMock(throwable)) {
+ throw throwable;
+ }
+ Throwable t = throwable.fillInStackTrace();
+
+ if (t == null) {
+ // Custom exceptions sometimes return null, see #866
+ throw throwable;
+ }
+ filter.filter(t);
+ throw t;
+ }
+
+ @Override
+ public void validateFor(InvocationOnMock invocation) {
+ Throwable throwable = getThrowable();
+ if (throwable == null) {
+ throw cannotStubWithNullThrowable();
+ }
+
+ if (throwable instanceof RuntimeException || throwable instanceof Error) {
+ return;
+ }
+
+ if (!new InvocationInfo(invocation).isValidException(throwable)) {
+ throw checkedExceptionInvalid(throwable);
+ }
+ }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/AnswerFunctionalInterfaces.java b/src/main/java/org/mockito/internal/stubbing/answers/AnswerFunctionalInterfaces.java
index e1a92a4..e4692f2 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/AnswerFunctionalInterfaces.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/AnswerFunctionalInterfaces.java
@@ -11,11 +11,13 @@
import org.mockito.stubbing.Answer3;
import org.mockito.stubbing.Answer4;
import org.mockito.stubbing.Answer5;
+import org.mockito.stubbing.Answer6;
import org.mockito.stubbing.VoidAnswer1;
import org.mockito.stubbing.VoidAnswer2;
import org.mockito.stubbing.VoidAnswer3;
import org.mockito.stubbing.VoidAnswer4;
import org.mockito.stubbing.VoidAnswer5;
+import org.mockito.stubbing.VoidAnswer6;
/**
* Functional interfaces to make it easy to implement answers in Java 8
@@ -23,11 +25,10 @@
* @since 2.1.0
*/
public class AnswerFunctionalInterfaces {
- /**
+ /**
* Hide constructor to avoid instantiation of class with only static methods
*/
- private AnswerFunctionalInterfaces() {
- }
+ private AnswerFunctionalInterfaces() {}
/**
* Construct an answer from a two parameter answer interface
@@ -38,9 +39,10 @@
*/
public static <T, A> Answer<T> toAnswer(final Answer1<T, A> answer) {
return new Answer<T>() {
+ @Override
@SuppressWarnings("unchecked")
public T answer(InvocationOnMock invocation) throws Throwable {
- return answer.answer((A)invocation.getArgument(0));
+ return answer.answer((A) invocation.getArgument(0));
}
};
}
@@ -53,9 +55,10 @@
*/
public static <A> Answer<Void> toAnswer(final VoidAnswer1<A> answer) {
return new Answer<Void>() {
+ @Override
@SuppressWarnings("unchecked")
public Void answer(InvocationOnMock invocation) throws Throwable {
- answer.answer((A)invocation.getArgument(0));
+ answer.answer((A) invocation.getArgument(0));
return null;
}
};
@@ -71,11 +74,10 @@
*/
public static <T, A, B> Answer<T> toAnswer(final Answer2<T, A, B> answer) {
return new Answer<T>() {
+ @Override
@SuppressWarnings("unchecked")
public T answer(InvocationOnMock invocation) throws Throwable {
- return answer.answer(
- (A)invocation.getArgument(0),
- (B)invocation.getArgument(1));
+ return answer.answer((A) invocation.getArgument(0), (B) invocation.getArgument(1));
}
};
}
@@ -89,11 +91,10 @@
*/
public static <A, B> Answer<Void> toAnswer(final VoidAnswer2<A, B> answer) {
return new Answer<Void>() {
+ @Override
@SuppressWarnings("unchecked")
public Void answer(InvocationOnMock invocation) throws Throwable {
- answer.answer(
- (A)invocation.getArgument(0),
- (B)invocation.getArgument(1));
+ answer.answer((A) invocation.getArgument(0), (B) invocation.getArgument(1));
return null;
}
};
@@ -110,12 +111,13 @@
*/
public static <T, A, B, C> Answer<T> toAnswer(final Answer3<T, A, B, C> answer) {
return new Answer<T>() {
+ @Override
@SuppressWarnings("unchecked")
public T answer(InvocationOnMock invocation) throws Throwable {
return answer.answer(
- (A)invocation.getArgument(0),
- (B)invocation.getArgument(1),
- (C)invocation.getArgument(2));
+ (A) invocation.getArgument(0),
+ (B) invocation.getArgument(1),
+ (C) invocation.getArgument(2));
}
};
}
@@ -130,12 +132,13 @@
*/
public static <A, B, C> Answer<Void> toAnswer(final VoidAnswer3<A, B, C> answer) {
return new Answer<Void>() {
+ @Override
@SuppressWarnings("unchecked")
public Void answer(InvocationOnMock invocation) throws Throwable {
answer.answer(
- (A)invocation.getArgument(0),
- (B)invocation.getArgument(1),
- (C)invocation.getArgument(2));
+ (A) invocation.getArgument(0),
+ (B) invocation.getArgument(1),
+ (C) invocation.getArgument(2));
return null;
}
};
@@ -153,13 +156,14 @@
*/
public static <T, A, B, C, D> Answer<T> toAnswer(final Answer4<T, A, B, C, D> answer) {
return new Answer<T>() {
+ @Override
@SuppressWarnings("unchecked")
public T answer(InvocationOnMock invocation) throws Throwable {
return answer.answer(
- (A)invocation.getArgument(0),
- (B)invocation.getArgument(1),
- (C)invocation.getArgument(2),
- (D)invocation.getArgument(3));
+ (A) invocation.getArgument(0),
+ (B) invocation.getArgument(1),
+ (C) invocation.getArgument(2),
+ (D) invocation.getArgument(3));
}
};
}
@@ -175,13 +179,14 @@
*/
public static <A, B, C, D> Answer<Void> toAnswer(final VoidAnswer4<A, B, C, D> answer) {
return new Answer<Void>() {
+ @Override
@SuppressWarnings("unchecked")
public Void answer(InvocationOnMock invocation) throws Throwable {
answer.answer(
- (A)invocation.getArgument(0),
- (B)invocation.getArgument(1),
- (C)invocation.getArgument(2),
- (D)invocation.getArgument(3));
+ (A) invocation.getArgument(0),
+ (B) invocation.getArgument(1),
+ (C) invocation.getArgument(2),
+ (D) invocation.getArgument(3));
return null;
}
};
@@ -200,14 +205,15 @@
*/
public static <T, A, B, C, D, E> Answer<T> toAnswer(final Answer5<T, A, B, C, D, E> answer) {
return new Answer<T>() {
+ @Override
@SuppressWarnings("unchecked")
public T answer(InvocationOnMock invocation) throws Throwable {
return answer.answer(
- (A)invocation.getArgument(0),
- (B)invocation.getArgument(1),
- (C)invocation.getArgument(2),
- (D)invocation.getArgument(3),
- (E)invocation.getArgument(4));
+ (A) invocation.getArgument(0),
+ (B) invocation.getArgument(1),
+ (C) invocation.getArgument(2),
+ (D) invocation.getArgument(3),
+ (E) invocation.getArgument(4));
}
};
}
@@ -224,14 +230,75 @@
*/
public static <A, B, C, D, E> Answer<Void> toAnswer(final VoidAnswer5<A, B, C, D, E> answer) {
return new Answer<Void>() {
+ @Override
@SuppressWarnings("unchecked")
public Void answer(InvocationOnMock invocation) throws Throwable {
answer.answer(
- (A)invocation.getArgument(0),
- (B)invocation.getArgument(1),
- (C)invocation.getArgument(2),
- (D)invocation.getArgument(3),
- (E)invocation.getArgument(4));
+ (A) invocation.getArgument(0),
+ (B) invocation.getArgument(1),
+ (C) invocation.getArgument(2),
+ (D) invocation.getArgument(3),
+ (E) invocation.getArgument(4));
+ return null;
+ }
+ };
+ }
+
+ /**
+ * Construct an answer from a six parameter answer interface
+ *
+ * @param answer answer interface
+ * @param <T> return type
+ * @param <A> input parameter 1 type
+ * @param <B> input parameter 2 type
+ * @param <C> input parameter 3 type
+ * @param <D> input parameter 4 type
+ * @param <E> input parameter 5 type
+ * @param <F> input parameter 6 type
+ * @return a new answer object
+ */
+ public static <T, A, B, C, D, E, F> Answer<T> toAnswer(
+ final Answer6<T, A, B, C, D, E, F> answer) {
+ return new Answer<T>() {
+ @Override
+ @SuppressWarnings("unchecked")
+ public T answer(InvocationOnMock invocation) throws Throwable {
+ return answer.answer(
+ (A) invocation.getArgument(0),
+ (B) invocation.getArgument(1),
+ (C) invocation.getArgument(2),
+ (D) invocation.getArgument(3),
+ (E) invocation.getArgument(4),
+ (F) invocation.getArgument(5));
+ }
+ };
+ }
+
+ /**
+ * Construct an answer from a five parameter answer interface
+ *
+ * @param answer answer interface
+ * @param <A> input parameter 1 type
+ * @param <B> input parameter 2 type
+ * @param <C> input parameter 3 type
+ * @param <D> input parameter 4 type
+ * @param <E> input parameter 5 type
+ * @param <F> input parameter 6 type
+ * @return a new answer object
+ */
+ public static <A, B, C, D, E, F> Answer<Void> toAnswer(
+ final VoidAnswer6<A, B, C, D, E, F> answer) {
+ return new Answer<Void>() {
+ @Override
+ @SuppressWarnings("unchecked")
+ public Void answer(InvocationOnMock invocation) throws Throwable {
+ answer.answer(
+ (A) invocation.getArgument(0),
+ (B) invocation.getArgument(1),
+ (C) invocation.getArgument(2),
+ (D) invocation.getArgument(3),
+ (E) invocation.getArgument(4),
+ (F) invocation.getArgument(5));
return null;
}
};
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/AnswersWithDelay.java b/src/main/java/org/mockito/internal/stubbing/answers/AnswersWithDelay.java
index 083b082..f0f23d5 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/AnswersWithDelay.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/AnswersWithDelay.java
@@ -4,13 +4,13 @@
*/
package org.mockito.internal.stubbing.answers;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import java.io.Serializable;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.mockito.stubbing.ValidableAnswer;
-import java.io.Serializable;
-import java.util.concurrent.TimeUnit;
-
/**
* Returns as the provided answer would return, after delaying the specified amount.
*
@@ -33,7 +33,7 @@
@Override
public Object answer(final InvocationOnMock invocation) throws Throwable {
- TimeUnit.MILLISECONDS.sleep(sleepyTime);
+ MILLISECONDS.sleep(sleepyTime);
return answer.answer(invocation);
}
@@ -44,4 +44,3 @@
}
}
}
-
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/CallsRealMethods.java b/src/main/java/org/mockito/internal/stubbing/answers/CallsRealMethods.java
index 59a82e6..fad1a1c 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/CallsRealMethods.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/CallsRealMethods.java
@@ -4,15 +4,16 @@
*/
package org.mockito.internal.stubbing.answers;
+import static org.mockito.Answers.RETURNS_DEFAULTS;
+import static org.mockito.internal.exceptions.Reporter.cannotCallAbstractRealMethod;
+
import java.io.Serializable;
import java.lang.reflect.Modifier;
+
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.mockito.stubbing.ValidableAnswer;
-import static org.mockito.Answers.RETURNS_DEFAULTS;
-import static org.mockito.internal.exceptions.Reporter.cannotCallAbstractRealMethod;
-
/**
* Optional Answer that adds partial mocking support
* <p>
@@ -36,6 +37,7 @@
public class CallsRealMethods implements Answer<Object>, ValidableAnswer, Serializable {
private static final long serialVersionUID = 9057165148930624087L;
+ @Override
public Object answer(InvocationOnMock invocation) throws Throwable {
if (Modifier.isAbstract(invocation.getMethod().getModifiers())) {
return RETURNS_DEFAULTS.answer(invocation);
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java b/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java
index 25e8be7..0f0c15b 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/ClonesArguments.java
@@ -4,24 +4,39 @@
*/
package org.mockito.internal.stubbing.answers;
-import org.mockito.internal.configuration.plugins.Plugins;
+import java.lang.reflect.Array;
+
import org.mockito.creation.instance.Instantiator;
+import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.stubbing.defaultanswers.ReturnsEmptyValues;
import org.mockito.internal.util.reflection.LenientCopyTool;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
-//TODO this needs documentation and further analysis - what if someone changes the answer?
-//we might think about implementing it straight on MockSettings
+// TODO this needs documentation and further analysis - what if someone changes the answer?
+// we might think about implementing it straight on MockSettings
public class ClonesArguments implements Answer<Object> {
+ @Override
public Object answer(InvocationOnMock invocation) throws Throwable {
Object[] arguments = invocation.getArguments();
for (int i = 0; i < arguments.length; i++) {
Object from = arguments[i];
- Instantiator instantiator = Plugins.getInstantiatorProvider().getInstantiator(null);
- Object newInstance = instantiator.newInstance(from.getClass());
- new LenientCopyTool().copyToRealObject(from, newInstance);
- arguments[i] = newInstance;
+ if (from != null) {
+ if (from.getClass().isArray()) {
+ int len = Array.getLength(from);
+ Object newInstance = Array.newInstance(from.getClass().getComponentType(), len);
+ for (int j = 0; j < len; ++j) {
+ Array.set(newInstance, j, Array.get(from, j));
+ }
+ arguments[i] = newInstance;
+ } else {
+ Instantiator instantiator =
+ Plugins.getInstantiatorProvider().getInstantiator(null);
+ Object newInstance = instantiator.newInstance(from.getClass());
+ new LenientCopyTool().copyToRealObject(from, newInstance);
+ arguments[i] = newInstance;
+ }
+ }
}
return new ReturnsEmptyValues().answer(invocation);
}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidator.java b/src/main/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidator.java
index da1d2a7..b6a384e 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidator.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidator.java
@@ -2,15 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.stubbing.answers;
-import org.mockito.invocation.InvocationOnMock;
-
import static org.mockito.internal.exceptions.Reporter.wrongTypeReturnedByDefaultAnswer;
+import org.mockito.invocation.InvocationOnMock;
+
public abstract class DefaultAnswerValidator {
- public static void validateReturnValueFor(InvocationOnMock invocation, Object returnedValue) throws Throwable {
+ public static void validateReturnValueFor(InvocationOnMock invocation, Object returnedValue)
+ throws Throwable {
InvocationInfo invocationInfo = new InvocationInfo(invocation);
if (returnedValue != null && !invocationInfo.isValidReturnType(returnedValue.getClass())) {
throw wrongTypeReturnedByDefaultAnswer(
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java b/src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java
index bc625fb..d044e12 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java
@@ -4,14 +4,14 @@
*/
package org.mockito.internal.stubbing.answers;
+import static org.mockito.internal.exceptions.Reporter.onlyVoidMethodsCanBeSetToDoNothing;
+
import java.io.Serializable;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.mockito.stubbing.ValidableAnswer;
-import static org.mockito.internal.exceptions.Reporter.onlyVoidMethodsCanBeSetToDoNothing;
-
public class DoesNothing implements Answer<Object>, ValidableAnswer, Serializable {
private static final long serialVersionUID = 4840880517740698416L;
@@ -20,12 +20,12 @@
private DoesNothing() {}
- public static DoesNothing doesNothing(){
+ public static DoesNothing doesNothing() {
return SINGLETON;
}
@Override
- public Object answer(InvocationOnMock invocation){
+ public Object answer(InvocationOnMock invocation) {
return null;
}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/InvocationInfo.java b/src/main/java/org/mockito/internal/stubbing/answers/InvocationInfo.java
index 11498b7..8bfffca 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/InvocationInfo.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/InvocationInfo.java
@@ -6,16 +6,22 @@
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
+
import org.mockito.internal.invocation.AbstractAwareMethod;
+import org.mockito.internal.util.MockUtil;
import org.mockito.internal.util.Primitives;
+import org.mockito.internal.util.reflection.GenericMetadataSupport;
import org.mockito.invocation.InvocationOnMock;
+import org.mockito.mock.MockCreationSettings;
public class InvocationInfo implements AbstractAwareMethod {
private final Method method;
+ private final InvocationOnMock invocation;
public InvocationInfo(InvocationOnMock theInvocation) {
this.method = theInvocation.getMethod();
+ this.invocation = theInvocation;
}
public boolean isValidException(Throwable throwable) {
@@ -32,7 +38,8 @@
public boolean isValidReturnType(Class<?> clazz) {
if (method.getReturnType().isPrimitive() || clazz.isPrimitive()) {
- return Primitives.primitiveTypeOf(clazz) == Primitives.primitiveTypeOf(method.getReturnType());
+ return Primitives.primitiveTypeOf(clazz)
+ == Primitives.primitiveTypeOf(method.getReturnType());
} else {
return method.getReturnType().isAssignableFrom(clazz);
}
@@ -43,8 +50,13 @@
* E.g: {@code void foo()} or {@code Void bar()}
*/
public boolean isVoid() {
- Class<?> returnType = this.method.getReturnType();
- return returnType == Void.TYPE|| returnType == Void.class;
+ final MockCreationSettings mockSettings =
+ MockUtil.getMockHandler(invocation.getMock()).getMockSettings();
+ Class<?> returnType =
+ GenericMetadataSupport.inferFrom(mockSettings.getTypeToMock())
+ .resolveGenericReturnType(this.method)
+ .rawType();
+ return returnType == Void.TYPE || returnType == Void.class;
}
public String printMethodReturnType() {
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/Returns.java b/src/main/java/org/mockito/internal/stubbing/answers/Returns.java
index f34003b..d4d97cb 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/Returns.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/Returns.java
@@ -4,15 +4,16 @@
*/
package org.mockito.internal.stubbing.answers;
+import static org.mockito.internal.exceptions.Reporter.cannotStubVoidMethodWithAReturnValue;
+import static org.mockito.internal.exceptions.Reporter.wrongTypeOfReturnValue;
+
import java.io.Serializable;
+import org.mockito.internal.util.KotlinInlineClassUtil;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.mockito.stubbing.ValidableAnswer;
-import static org.mockito.internal.exceptions.Reporter.cannotStubVoidMethodWithAReturnValue;
-import static org.mockito.internal.exceptions.Reporter.wrongTypeOfReturnValue;
-
public class Returns implements Answer<Object>, ValidableAnswer, Serializable {
private static final long serialVersionUID = -6245608253574215396L;
@@ -22,8 +23,9 @@
this.value = value;
}
+ @Override
public Object answer(InvocationOnMock invocation) throws Throwable {
- return value;
+ return KotlinInlineClassUtil.unboxUnderlyingValueIfNeeded(invocation, value);
}
@Override
@@ -34,11 +36,18 @@
}
if (returnsNull() && invocationInfo.returnsPrimitive()) {
- throw wrongTypeOfReturnValue(invocationInfo.printMethodReturnType(), "null", invocationInfo.getMethodName());
+ throw wrongTypeOfReturnValue(
+ invocationInfo.printMethodReturnType(), "null", invocationInfo.getMethodName());
}
- if (!returnsNull() && !invocationInfo.isValidReturnType(returnType())) {
- throw wrongTypeOfReturnValue(invocationInfo.printMethodReturnType(), printReturnType(), invocationInfo.getMethodName());
+ if (!returnsNull()
+ && !invocationInfo.isValidReturnType(returnType())
+ && !KotlinInlineClassUtil.isInlineClassWithAssignableUnderlyingType(
+ returnType(), invocationInfo.getMethod().getReturnType())) {
+ throw wrongTypeOfReturnValue(
+ invocationInfo.printMethodReturnType(),
+ printReturnType(),
+ invocationInfo.getMethodName());
}
}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java b/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java
index 5419819..cd66115 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java
@@ -10,6 +10,7 @@
import java.io.Serializable;
import java.lang.reflect.Method;
+
import org.mockito.invocation.Invocation;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
@@ -54,14 +55,14 @@
int argumentPosition = inferWantedArgumentPosition(invocation);
validateIndexWithinInvocationRange(invocation, argumentPosition);
- if (wantedArgIndexIsVarargAndSameTypeAsReturnType(invocation.getMethod(), argumentPosition)) {
+ if (wantedArgIndexIsVarargAndSameTypeAsReturnType(
+ invocation.getMethod(), argumentPosition)) {
// answer raw vararg array argument
return ((Invocation) invocation).getRawArguments()[argumentPosition];
}
// answer expanded argument at wanted position
return invocation.getArgument(argumentPosition);
-
}
@Override
@@ -72,17 +73,18 @@
}
private int inferWantedArgumentPosition(InvocationOnMock invocation) {
- if (wantedArgumentPosition == LAST_ARGUMENT)
+ if (wantedArgumentPosition == LAST_ARGUMENT) {
return invocation.getArguments().length - 1;
+ }
return wantedArgumentPosition;
}
- private void validateIndexWithinInvocationRange(InvocationOnMock invocation, int argumentPosition) {
+ private void validateIndexWithinInvocationRange(
+ InvocationOnMock invocation, int argumentPosition) {
if (!wantedArgumentPositionIsValidForInvocation(invocation, argumentPosition)) {
- throw invalidArgumentPositionRangeAtInvocationTime(invocation,
- wantedArgumentPosition == LAST_ARGUMENT,
- wantedArgumentPosition);
+ throw invalidArgumentPositionRangeAtInvocationTime(
+ invocation, wantedArgumentPosition == LAST_ARGUMENT, wantedArgumentPosition);
}
}
@@ -91,22 +93,25 @@
Class<?> inferredArgumentType = inferArgumentType(invocation, argumentPosition);
- if (!invocationInfo.isValidReturnType(inferredArgumentType)){
- throw wrongTypeOfArgumentToReturn(invocation,
- invocationInfo.printMethodReturnType(),
- inferredArgumentType,
- wantedArgumentPosition);
+ if (!invocationInfo.isValidReturnType(inferredArgumentType)) {
+ throw wrongTypeOfArgumentToReturn(
+ invocation,
+ invocationInfo.printMethodReturnType(),
+ inferredArgumentType,
+ wantedArgumentPosition);
}
}
- private boolean wantedArgIndexIsVarargAndSameTypeAsReturnType(Method method, int argumentPosition) {
+ private boolean wantedArgIndexIsVarargAndSameTypeAsReturnType(
+ Method method, int argumentPosition) {
Class<?>[] parameterTypes = method.getParameterTypes();
- return method.isVarArgs() &&
- argumentPosition == /* vararg index */ parameterTypes.length - 1 &&
- method.getReturnType().isAssignableFrom(parameterTypes[argumentPosition]);
+ return method.isVarArgs()
+ && argumentPosition == /* vararg index */ parameterTypes.length - 1
+ && method.getReturnType().isAssignableFrom(parameterTypes[argumentPosition]);
}
- private boolean wantedArgumentPositionIsValidForInvocation(InvocationOnMock invocation, int argumentPosition) {
+ private boolean wantedArgumentPositionIsValidForInvocation(
+ InvocationOnMock invocation, int argumentPosition) {
if (argumentPosition < 0) {
return false;
}
@@ -142,12 +147,11 @@
// if wanted argument is vararg
if (wantedArgIndexIsVarargAndSameTypeAsReturnType(invocation.getMethod(), argumentIndex)) {
// return the vararg array if return type is compatible
- // because the user probably want to return the array itself if the return type is compatible
+ // because the user probably want to return the array itself if the return type is
+ // compatible
return parameterTypes[argumentIndex]; // move to MethodInfo ?
}
// return the type in this vararg array
return parameterTypes[varargIndex].getComponentType();
-
}
}
-
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/ReturnsElementsOf.java b/src/main/java/org/mockito/internal/stubbing/answers/ReturnsElementsOf.java
index aaf6750..cbd8a14 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/ReturnsElementsOf.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/ReturnsElementsOf.java
@@ -6,6 +6,7 @@
import java.util.Collection;
import java.util.LinkedList;
+
import org.mockito.exceptions.base.MockitoException;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
@@ -35,16 +36,17 @@
public ReturnsElementsOf(Collection<?> elements) {
if (elements == null) {
- throw new MockitoException("ReturnsElementsOf does not accept null as constructor argument.\n" +
- "Please pass a collection instance");
+ throw new MockitoException(
+ "ReturnsElementsOf does not accept null as constructor argument.\n"
+ + "Please pass a collection instance");
}
- this.elements = new LinkedList<Object>(elements);
+ this.elements = new LinkedList<>(elements);
}
+ @Override
public Object answer(InvocationOnMock invocation) throws Throwable {
- if (elements.size() == 1)
+ if (elements.size() == 1) {
return elements.get(0);
- else
- return elements.poll();
+ } else return elements.poll();
}
}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java b/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java
index 502e359..a971201 100644
--- a/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java
+++ b/src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java
@@ -5,23 +5,17 @@
package org.mockito.internal.stubbing.answers;
import java.io.Serializable;
-import org.mockito.internal.exceptions.stacktrace.ConditionalStackTraceFilter;
-import org.mockito.internal.util.MockUtil;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-import org.mockito.stubbing.ValidableAnswer;
-import static org.mockito.internal.exceptions.Reporter.cannotStubWithNullThrowable;
-import static org.mockito.internal.exceptions.Reporter.checkedExceptionInvalid;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.ValidableAnswer;
/**
* An answer that always throws the same throwable.
*/
-public class ThrowsException implements Answer<Object>, ValidableAnswer, Serializable {
+public class ThrowsException extends AbstractThrowsException implements Serializable {
private static final long serialVersionUID = 1128820328555183980L;
private final Throwable throwable;
- private final ConditionalStackTraceFilter filter = new ConditionalStackTraceFilter();
/**
* Creates a new answer always throwing the given throwable. If it is null,
@@ -32,36 +26,8 @@
this.throwable = throwable;
}
- public Object answer(InvocationOnMock invocation) throws Throwable {
- if (throwable == null) {
- throw new IllegalStateException("throwable is null: " +
- "you shall not call #answer if #validateFor fails!");
- }
- if (MockUtil.isMock(throwable)) {
- throw throwable;
- }
- Throwable t = throwable.fillInStackTrace();
-
- if (t == null) {
- //Custom exceptions sometimes return null, see #866
- throw throwable;
- }
- filter.filter(t);
- throw t;
- }
-
@Override
- public void validateFor(InvocationOnMock invocation) {
- if (throwable == null) {
- throw cannotStubWithNullThrowable();
- }
-
- if (throwable instanceof RuntimeException || throwable instanceof Error) {
- return;
- }
-
- if (!new InvocationInfo(invocation).isValidException(throwable)) {
- throw checkedExceptionInvalid(throwable);
- }
+ protected Throwable getThrowable() {
+ return throwable;
}
}
diff --git a/src/main/java/org/mockito/internal/stubbing/answers/ThrowsExceptionForClassType.java b/src/main/java/org/mockito/internal/stubbing/answers/ThrowsExceptionForClassType.java
new file mode 100644
index 0000000..2c3d923
--- /dev/null
+++ b/src/main/java/org/mockito/internal/stubbing/answers/ThrowsExceptionForClassType.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import java.io.Serializable;
+
+import org.mockito.creation.instance.Instantiator;
+import org.mockito.internal.configuration.plugins.Plugins;
+
+public class ThrowsExceptionForClassType extends AbstractThrowsException implements Serializable {
+
+ private final Class<? extends Throwable> throwableClass;
+
+ public ThrowsExceptionForClassType(Class<? extends Throwable> throwableClass) {
+ this.throwableClass = throwableClass;
+ }
+
+ @Override
+ protected Throwable getThrowable() {
+ Instantiator instantiator = Plugins.getInstantiatorProvider().getInstantiator(null);
+ return instantiator.newInstance(throwableClass);
+ }
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java
index 9165142..5f596b7 100644
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java
+++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocations.java
@@ -11,8 +11,10 @@
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
+import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.invocation.Invocation;
import org.mockito.invocation.InvocationOnMock;
+import org.mockito.plugins.MemberAccessor;
import org.mockito.stubbing.Answer;
/**
@@ -23,26 +25,31 @@
public class ForwardsInvocations implements Answer<Object>, Serializable {
private static final long serialVersionUID = -8343690268123254910L;
- private Object delegatedObject = null ;
+ private Object delegatedObject = null;
public ForwardsInvocations(Object delegatedObject) {
- this.delegatedObject = delegatedObject ;
+ this.delegatedObject = delegatedObject;
}
+ @Override
public Object answer(InvocationOnMock invocation) throws Throwable {
Method mockMethod = invocation.getMethod();
try {
Method delegateMethod = getDelegateMethod(mockMethod);
- if (!compatibleReturnTypes(mockMethod.getReturnType(), delegateMethod.getReturnType())) {
- throw delegatedMethodHasWrongReturnType(mockMethod, delegateMethod, invocation.getMock(), delegatedObject);
+ if (!compatibleReturnTypes(
+ mockMethod.getReturnType(), delegateMethod.getReturnType())) {
+ throw delegatedMethodHasWrongReturnType(
+ mockMethod, delegateMethod, invocation.getMock(), delegatedObject);
}
+ MemberAccessor accessor = Plugins.getMemberAccessor();
Object[] rawArguments = ((Invocation) invocation).getRawArguments();
- return delegateMethod.invoke(delegatedObject, rawArguments);
+ return accessor.invoke(delegateMethod, delegatedObject, rawArguments);
} catch (NoSuchMethodException e) {
- throw delegatedMethodDoesNotExistOnDelegate(mockMethod, invocation.getMock(), delegatedObject);
+ throw delegatedMethodDoesNotExistOnDelegate(
+ mockMethod, invocation.getMock(), delegatedObject);
} catch (InvocationTargetException e) {
// propagate the original exception from the delegate
throw e.getCause();
@@ -55,7 +62,9 @@
return mockMethod;
} else {
// Return method of delegate object with the same signature as mockMethod.
- return delegatedObject.getClass().getMethod(mockMethod.getName(), mockMethod.getParameterTypes());
+ return delegatedObject
+ .getClass()
+ .getMethod(mockMethod.getName(), mockMethod.getParameterTypes());
}
}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/GloballyConfiguredAnswer.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/GloballyConfiguredAnswer.java
index a25832f..51a70aa 100644
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/GloballyConfiguredAnswer.java
+++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/GloballyConfiguredAnswer.java
@@ -20,6 +20,7 @@
private static final long serialVersionUID = 3585893470101750917L;
+ @Override
public Object answer(InvocationOnMock invocation) throws Throwable {
return new GlobalConfiguration().getDefaultAnswer().answer(invocation);
}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/RetrieveGenericsForDefaultAnswers.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/RetrieveGenericsForDefaultAnswers.java
new file mode 100644
index 0000000..5103574
--- /dev/null
+++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/RetrieveGenericsForDefaultAnswers.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.defaultanswers;
+
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+
+import org.mockito.internal.MockitoCore;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.internal.util.reflection.GenericMetadataSupport;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.mock.MockCreationSettings;
+
+final class RetrieveGenericsForDefaultAnswers {
+
+ private static final MockitoCore MOCKITO_CORE = new MockitoCore();
+
+ static Object returnTypeForMockWithCorrectGenerics(
+ InvocationOnMock invocation, AnswerCallback answerCallback) {
+ Class<?> type = invocation.getMethod().getReturnType();
+
+ final Type returnType = invocation.getMethod().getGenericReturnType();
+
+ Object defaultReturnValue = null;
+
+ if (returnType instanceof TypeVariable) {
+ type = findTypeFromGeneric(invocation, (TypeVariable) returnType);
+ if (type != null) {
+ defaultReturnValue = delegateChains(type);
+ }
+ }
+
+ if (defaultReturnValue != null) {
+ return defaultReturnValue;
+ }
+
+ if (type != null) {
+ if (!MOCKITO_CORE.isTypeMockable(type)) {
+ return null;
+ }
+
+ return answerCallback.apply(type);
+ }
+
+ return answerCallback.apply(null);
+ }
+
+ /**
+ * Try to resolve the result value using {@link ReturnsEmptyValues} and {@link ReturnsMoreEmptyValues}.
+ *
+ * This will try to use all parent class (superclass & interfaces) to retrieve the value..
+ *
+ * @param type the return type of the method
+ * @return a non-null instance if the type has been resolve. Null otherwise.
+ */
+ private static Object delegateChains(final Class<?> type) {
+ final ReturnsEmptyValues returnsEmptyValues = new ReturnsEmptyValues();
+ Object result = returnsEmptyValues.returnValueFor(type);
+
+ if (result == null) {
+ Class<?> emptyValueForClass = type;
+ while (emptyValueForClass != null && result == null) {
+ final Class<?>[] classes = emptyValueForClass.getInterfaces();
+ for (Class<?> clazz : classes) {
+ result = returnsEmptyValues.returnValueFor(clazz);
+ if (result != null) {
+ break;
+ }
+ }
+ emptyValueForClass = emptyValueForClass.getSuperclass();
+ }
+ }
+
+ if (result == null) {
+ result = new ReturnsMoreEmptyValues().returnValueFor(type);
+ }
+
+ return result;
+ }
+
+ /**
+ * Retrieve the expected type when it came from a primitive. If the type cannot be retrieve, return null.
+ *
+ * @param invocation the current invocation
+ * @param returnType the expected return type
+ * @return the type or null if not found
+ */
+ private static Class<?> findTypeFromGeneric(
+ final InvocationOnMock invocation, final TypeVariable returnType) {
+ // Class level
+ final MockCreationSettings mockSettings =
+ MockUtil.getMockHandler(invocation.getMock()).getMockSettings();
+ final GenericMetadataSupport returnTypeSupport =
+ GenericMetadataSupport.inferFrom(mockSettings.getTypeToMock())
+ .resolveGenericReturnType(invocation.getMethod());
+ final Class<?> rawType = returnTypeSupport.rawType();
+
+ // Method level
+ if (rawType == Object.class) {
+ return findTypeFromGenericInArguments(invocation, returnType);
+ }
+ return rawType;
+ }
+
+ /**
+ * Find a return type using generic arguments provided by the calling method.
+ *
+ * @param invocation the current invocation
+ * @param returnType the expected return type
+ * @return the return type or null if the return type cannot be found
+ */
+ private static Class<?> findTypeFromGenericInArguments(
+ final InvocationOnMock invocation, final TypeVariable returnType) {
+ final Type[] parameterTypes = invocation.getMethod().getGenericParameterTypes();
+ for (int i = 0; i < parameterTypes.length; i++) {
+ Type argType = parameterTypes[i];
+ if (returnType.equals(argType)) {
+ Object argument = invocation.getArgument(i);
+
+ if (argument == null) {
+ return null;
+ }
+
+ return argument.getClass();
+ }
+ if (argType instanceof GenericArrayType) {
+ argType = ((GenericArrayType) argType).getGenericComponentType();
+ if (returnType.equals(argType)) {
+ return invocation.getArgument(i).getClass();
+ }
+ }
+ }
+ return null;
+ }
+
+ interface AnswerCallback {
+ Object apply(Class<?> type);
+ }
+
+ private RetrieveGenericsForDefaultAnswers() {}
+}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java
index 3909ff0..0b5a063 100644
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java
+++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java
@@ -4,6 +4,11 @@
*/
package org.mockito.internal.stubbing.defaultanswers;
+import static org.mockito.Mockito.withSettings;
+
+import java.io.IOException;
+import java.io.Serializable;
+
import org.mockito.MockSettings;
import org.mockito.Mockito;
import org.mockito.internal.MockitoCore;
@@ -17,15 +22,10 @@
import org.mockito.stubbing.Answer;
import org.mockito.stubbing.Stubbing;
-import java.io.IOException;
-import java.io.Serializable;
-
-import static org.mockito.Mockito.withSettings;
-
/**
* Returning deep stub implementation.
*
- * Will return previously created mock if the invocation matches.
+ * <p>Will return previously created mock if the invocation matches.
*
* <p>Supports nested generic information, with this answer you can write code like this :
*
@@ -37,6 +37,8 @@
* </code></pre>
* </p>
*
+ * <p>However this answer does not support generics information when the mock has been deserialized.
+ *
* @see org.mockito.Mockito#RETURNS_DEEP_STUBS
* @see org.mockito.Answers#RETURNS_DEEP_STUBS
*/
@@ -44,19 +46,38 @@
private static final long serialVersionUID = -7105341425736035847L;
+ @Override
public Object answer(InvocationOnMock invocation) throws Throwable {
GenericMetadataSupport returnTypeGenericMetadata =
- actualParameterizedType(invocation.getMock()).resolveGenericReturnType(invocation.getMethod());
+ actualParameterizedType(invocation.getMock())
+ .resolveGenericReturnType(invocation.getMethod());
Class<?> rawType = returnTypeGenericMetadata.rawType();
if (!mockitoCore().isTypeMockable(rawType)) {
- return delegate().returnValueFor(rawType);
+ if (invocation.getMethod().getReturnType().equals(rawType)) {
+ return delegate().answer(invocation);
+ } else {
+ return delegate().returnValueFor(rawType);
+ }
+ }
+
+ // When dealing with erased generics, we only receive the Object type as rawType. At this
+ // point, there is nothing to salvage for Mockito. Instead of trying to be smart and
+ // generate
+ // a mock that would potentially match the return signature, instead return `null`. This
+ // is valid per the CheckCast JVM instruction and is better than causing a
+ // ClassCastException
+ // on runtime.
+ if (rawType.equals(Object.class) && !returnTypeGenericMetadata.hasRawExtraInterfaces()) {
+ return null;
}
return deepStub(invocation, returnTypeGenericMetadata);
}
- private Object deepStub(InvocationOnMock invocation, GenericMetadataSupport returnTypeGenericMetadata) throws Throwable {
+ private Object deepStub(
+ InvocationOnMock invocation, GenericMetadataSupport returnTypeGenericMetadata)
+ throws Throwable {
InvocationContainerImpl container = MockUtil.getInvocationContainer(invocation.getMock());
// matches invocation for verification
@@ -68,10 +89,10 @@
}
// record deep stub answer
- StubbedInvocationMatcher stubbing = recordDeepStubAnswer(
- newDeepStubMock(returnTypeGenericMetadata, invocation.getMock()),
- container
- );
+ StubbedInvocationMatcher stubbing =
+ recordDeepStubAnswer(
+ newDeepStubMock(returnTypeGenericMetadata, invocation.getMock()),
+ container);
// deep stubbing creates a stubbing and immediately uses it
// so the stubbing is actually used by the same invocation
@@ -88,50 +109,60 @@
* {@link ReturnsDeepStubs} answer in which we will store the returned type generic metadata.
*
* @param returnTypeGenericMetadata The metadata to use to create the new mock.
- * @param parentMock The parent of the current deep stub mock.
+ * @param parentMock The parent of the current deep stub mock.
* @return The mock
*/
- private Object newDeepStubMock(GenericMetadataSupport returnTypeGenericMetadata, Object parentMock) {
+ private Object newDeepStubMock(
+ GenericMetadataSupport returnTypeGenericMetadata, Object parentMock) {
MockCreationSettings parentMockSettings = MockUtil.getMockSettings(parentMock);
- return mockitoCore().mock(
- returnTypeGenericMetadata.rawType(),
- withSettingsUsing(returnTypeGenericMetadata, parentMockSettings)
- );
+ return mockitoCore()
+ .mock(
+ returnTypeGenericMetadata.rawType(),
+ withSettingsUsing(returnTypeGenericMetadata, parentMockSettings));
}
- private MockSettings withSettingsUsing(GenericMetadataSupport returnTypeGenericMetadata, MockCreationSettings parentMockSettings) {
- MockSettings mockSettings = returnTypeGenericMetadata.hasRawExtraInterfaces() ?
- withSettings().extraInterfaces(returnTypeGenericMetadata.rawExtraInterfaces())
- : withSettings();
+ private MockSettings withSettingsUsing(
+ GenericMetadataSupport returnTypeGenericMetadata,
+ MockCreationSettings parentMockSettings) {
+ MockSettings mockSettings =
+ returnTypeGenericMetadata.hasRawExtraInterfaces()
+ ? withSettings()
+ .extraInterfaces(returnTypeGenericMetadata.rawExtraInterfaces())
+ : withSettings();
return propagateSerializationSettings(mockSettings, parentMockSettings)
.defaultAnswer(returnsDeepStubsAnswerUsing(returnTypeGenericMetadata));
}
- private MockSettings propagateSerializationSettings(MockSettings mockSettings, MockCreationSettings parentMockSettings) {
+ private MockSettings propagateSerializationSettings(
+ MockSettings mockSettings, MockCreationSettings parentMockSettings) {
return mockSettings.serializable(parentMockSettings.getSerializableMode());
}
- private ReturnsDeepStubs returnsDeepStubsAnswerUsing(final GenericMetadataSupport returnTypeGenericMetadata) {
+ private ReturnsDeepStubs returnsDeepStubsAnswerUsing(
+ final GenericMetadataSupport returnTypeGenericMetadata) {
return new ReturnsDeepStubsSerializationFallback(returnTypeGenericMetadata);
}
- private StubbedInvocationMatcher recordDeepStubAnswer(final Object mock, InvocationContainerImpl container) {
+ private StubbedInvocationMatcher recordDeepStubAnswer(
+ final Object mock, InvocationContainerImpl container) {
DeeplyStubbedAnswer answer = new DeeplyStubbedAnswer(mock);
return container.addAnswer(answer, false, null);
}
protected GenericMetadataSupport actualParameterizedType(Object mock) {
- CreationSettings mockSettings = (CreationSettings) MockUtil.getMockHandler(mock).getMockSettings();
+ CreationSettings mockSettings =
+ (CreationSettings) MockUtil.getMockHandler(mock).getMockSettings();
return GenericMetadataSupport.inferFrom(mockSettings.getTypeToMock());
}
-
- private static class ReturnsDeepStubsSerializationFallback extends ReturnsDeepStubs implements Serializable {
+ private static class ReturnsDeepStubsSerializationFallback extends ReturnsDeepStubs
+ implements Serializable {
@SuppressWarnings("serial") // not gonna be serialized
private final GenericMetadataSupport returnTypeGenericMetadata;
- public ReturnsDeepStubsSerializationFallback(GenericMetadataSupport returnTypeGenericMetadata) {
+ public ReturnsDeepStubsSerializationFallback(
+ GenericMetadataSupport returnTypeGenericMetadata) {
this.returnTypeGenericMetadata = returnTypeGenericMetadata;
}
@@ -139,25 +170,35 @@
protected GenericMetadataSupport actualParameterizedType(Object mock) {
return returnTypeGenericMetadata;
}
+
+ /**
+ * Generics support and serialization with deep stubs don't work together.
+ * <p>
+ * The issue is that GenericMetadataSupport is not serializable because
+ * the type elements inferred via reflection are not serializable. Supporting
+ * serialization would require to replace all types coming from the Java reflection
+ * with our own and still managing type equality with the JDK ones.
+ */
private Object writeReplace() throws IOException {
return Mockito.RETURNS_DEEP_STUBS;
}
}
-
private static class DeeplyStubbedAnswer implements Answer<Object>, Serializable {
- @SuppressWarnings("serial") // serialization will fail with a nice message if mock not serializable
+ @SuppressWarnings(
+ "serial") // serialization will fail with a nice message if mock not serializable
private final Object mock;
DeeplyStubbedAnswer(Object mock) {
this.mock = mock;
}
+
+ @Override
public Object answer(InvocationOnMock invocation) throws Throwable {
return mock;
}
}
-
private static MockitoCore mockitoCore() {
return LazyHolder.MOCKITO_CORE;
}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java
index 8452589..ad8e7e2 100644
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java
+++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java
@@ -4,6 +4,24 @@
*/
package org.mockito.internal.stubbing.defaultanswers;
+import static org.mockito.internal.util.ObjectMethodsGuru.isCompareToMethod;
+import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.TreeMap;
+import java.util.TreeSet;
import org.mockito.internal.util.JavaEightUtil;
import org.mockito.internal.util.MockUtil;
import org.mockito.internal.util.Primitives;
@@ -11,12 +29,6 @@
import org.mockito.mock.MockName;
import org.mockito.stubbing.Answer;
-import static org.mockito.internal.util.ObjectMethodsGuru.isCompareToMethod;
-import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
-
-import java.io.Serializable;
-import java.util.*;
-
/**
* Default answer of every Mockito mock.
* <ul>
@@ -42,6 +54,9 @@
* Returns an {@code java.util.stream.Stream#empty() empty Stream} for Stream. Similarly for primitive stream variants.
* </li>
* <li>
+ * Returns an {@code java.time.Duration.ZERO zero Duration} for empty Duration and {@code java.time.Period.ZERO zero Period} for empty Period.
+ * </li>
+ * <li>
* Returns null for everything else
* </li>
* </ul>
@@ -50,23 +65,27 @@
private static final long serialVersionUID = 1998191268711234347L;
-
/* (non-Javadoc)
* @see org.mockito.stubbing.Answer#answer(org.mockito.invocation.InvocationOnMock)
*/
+ @Override
public Object answer(InvocationOnMock invocation) {
if (isToStringMethod(invocation.getMethod())) {
Object mock = invocation.getMock();
MockName name = MockUtil.getMockName(mock);
if (name.isDefault()) {
- return "Mock for " + MockUtil.getMockSettings(mock).getTypeToMock().getSimpleName() + ", hashCode: " + mock.hashCode();
+ return "Mock for "
+ + MockUtil.getMockSettings(mock).getTypeToMock().getSimpleName()
+ + ", hashCode: "
+ + mock.hashCode();
} else {
return name.toString();
}
} else if (isCompareToMethod(invocation.getMethod())) {
- //see issue 184.
- //mocks by default should return 0 if references are the same, otherwise some other value because they are not the same. Hence we return 1 (anything but 0 is good).
- //Only for compareTo() method by the Comparable interface
+ // see issue 184.
+ // mocks by default should return 0 if references are the same, otherwise some other
+ // value because they are not the same. Hence we return 1 (anything but 0 is good).
+ // Only for compareTo() method by the Comparable interface
return invocation.getMock() == invocation.getArgument(0) ? 0 : 1;
}
@@ -77,38 +96,39 @@
Object returnValueFor(Class<?> type) {
if (Primitives.isPrimitiveOrWrapper(type)) {
return Primitives.defaultValue(type);
- //new instances are used instead of Collections.emptyList(), etc.
- //to avoid UnsupportedOperationException if code under test modifies returned collection
+ // new instances are used instead of Collections.emptyList(), etc.
+ // to avoid UnsupportedOperationException if code under test modifies returned
+ // collection
} else if (type == Iterable.class) {
- return new ArrayList<Object>(0);
+ return new ArrayList<>(0);
} else if (type == Collection.class) {
- return new LinkedList<Object>();
+ return new LinkedList<>();
} else if (type == Set.class) {
- return new HashSet<Object>();
+ return new HashSet<>();
} else if (type == HashSet.class) {
- return new HashSet<Object>();
+ return new HashSet<>();
} else if (type == SortedSet.class) {
- return new TreeSet<Object>();
+ return new TreeSet<>();
} else if (type == TreeSet.class) {
- return new TreeSet<Object>();
+ return new TreeSet<>();
} else if (type == LinkedHashSet.class) {
- return new LinkedHashSet<Object>();
+ return new LinkedHashSet<>();
} else if (type == List.class) {
- return new LinkedList<Object>();
+ return new LinkedList<>();
} else if (type == LinkedList.class) {
- return new LinkedList<Object>();
+ return new LinkedList<>();
} else if (type == ArrayList.class) {
- return new ArrayList<Object>();
+ return new ArrayList<>();
} else if (type == Map.class) {
- return new HashMap<Object, Object>();
+ return new HashMap<>();
} else if (type == HashMap.class) {
- return new HashMap<Object, Object>();
+ return new HashMap<>();
} else if (type == SortedMap.class) {
- return new TreeMap<Object, Object>();
+ return new TreeMap<>();
} else if (type == TreeMap.class) {
- return new TreeMap<Object, Object>();
+ return new TreeMap<>();
} else if (type == LinkedHashMap.class) {
- return new LinkedHashMap<Object, Object>();
+ return new LinkedHashMap<>();
} else if ("java.util.Optional".equals(type.getName())) {
return JavaEightUtil.emptyOptional();
} else if ("java.util.OptionalDouble".equals(type.getName())) {
@@ -125,9 +145,13 @@
return JavaEightUtil.emptyIntStream();
} else if ("java.util.stream.LongStream".equals(type.getName())) {
return JavaEightUtil.emptyLongStream();
+ } else if ("java.time.Duration".equals(type.getName())) {
+ return JavaEightUtil.emptyDuration();
+ } else if ("java.time.Period".equals(type.getName())) {
+ return JavaEightUtil.emptyPeriod();
}
- //Let's not care about the rest of collections.
+ // Let's not care about the rest of collections.
return null;
}
}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocks.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocks.java
index 302e4df..0ef6f0d 100755
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocks.java
+++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocks.java
@@ -4,33 +4,39 @@
*/
package org.mockito.internal.stubbing.defaultanswers;
-import org.mockito.internal.MockitoCore;
+import java.io.Serializable;
+
+import org.mockito.Mockito;
import org.mockito.internal.creation.MockSettingsImpl;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
-import java.io.Serializable;
-
public class ReturnsMocks implements Answer<Object>, Serializable {
private static final long serialVersionUID = -6755257986994634579L;
- private final MockitoCore mockitoCore = new MockitoCore();
private final Answer<Object> delegate = new ReturnsMoreEmptyValues();
- public Object answer(InvocationOnMock invocation) throws Throwable {
- Object ret = delegate.answer(invocation);
- if (ret != null) {
- return ret;
+ @Override
+ public Object answer(final InvocationOnMock invocation) throws Throwable {
+ Object defaultReturnValue = delegate.answer(invocation);
+
+ if (defaultReturnValue != null) {
+ return defaultReturnValue;
}
- return returnValueFor(invocation.getMethod().getReturnType());
- }
+ return RetrieveGenericsForDefaultAnswers.returnTypeForMockWithCorrectGenerics(
+ invocation,
+ new RetrieveGenericsForDefaultAnswers.AnswerCallback() {
+ @Override
+ public Object apply(Class<?> type) {
+ if (type == null) {
+ return null;
+ }
- Object returnValueFor(Class<?> clazz) {
- if (!mockitoCore.isTypeMockable(clazz)) {
- return null;
- }
-
- return mockitoCore.mock(clazz, new MockSettingsImpl().defaultAnswer(this));
+ return Mockito.mock(
+ type,
+ new MockSettingsImpl<Object>().defaultAnswer(ReturnsMocks.this));
+ }
+ });
}
}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java
index 6111887..c39f535 100644
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java
+++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java
@@ -2,17 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.stubbing.defaultanswers;
import java.io.Serializable;
import java.lang.reflect.Array;
+
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
/**
- * It's likely this implementation will be used by default by every Mockito 3.0.0 mock.
+ * It's likely this implementation will be used by default by every Mockito 4.0.0 mock.
* <p>
* Currently <b>used only</b> by {@link Mockito#RETURNS_SMART_NULLS}
* <p>
@@ -52,6 +52,7 @@
/* (non-Javadoc)
* @see org.mockito.stubbing.Answer#answer(org.mockito.invocation.InvocationOnMock)
*/
+ @Override
public Object answer(InvocationOnMock invocation) throws Throwable {
Object ret = delegate.answer(invocation);
if (ret != null) {
@@ -65,7 +66,7 @@
Object returnValueFor(Class<?> type) {
if (type == String.class) {
return "";
- } else if (type.isArray()) {
+ } else if (type.isArray()) {
Class<?> componentType = type.getComponentType();
return Array.newInstance(componentType, 0);
}
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNulls.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNulls.java
index 7487e89..2402f36 100644
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNulls.java
+++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNulls.java
@@ -8,7 +8,6 @@
import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
import java.io.Serializable;
-import java.lang.reflect.Modifier;
import org.mockito.Mockito;
import org.mockito.internal.debugging.LocationImpl;
@@ -40,32 +39,45 @@
private final Answer<Object> delegate = new ReturnsMoreEmptyValues();
+ @Override
public Object answer(final InvocationOnMock invocation) throws Throwable {
Object defaultReturnValue = delegate.answer(invocation);
+
if (defaultReturnValue != null) {
return defaultReturnValue;
}
- Class<?> type = invocation.getMethod().getReturnType();
- if (!type.isPrimitive() && !Modifier.isFinal(type.getModifiers())) {
- final Location location = new LocationImpl();
- return Mockito.mock(type, new ThrowsSmartNullPointer(invocation, location));
- }
- return null;
+
+ return RetrieveGenericsForDefaultAnswers.returnTypeForMockWithCorrectGenerics(
+ invocation,
+ new RetrieveGenericsForDefaultAnswers.AnswerCallback() {
+ @Override
+ public Object apply(Class<?> type) {
+ if (type == null) {
+ return null;
+ }
+
+ return Mockito.mock(
+ type, new ThrowsSmartNullPointer(invocation, new LocationImpl()));
+ }
+ });
}
private static class ThrowsSmartNullPointer implements Answer {
+
private final InvocationOnMock unstubbedInvocation;
+
private final Location location;
- public ThrowsSmartNullPointer(InvocationOnMock unstubbedInvocation, Location location) {
+ ThrowsSmartNullPointer(InvocationOnMock unstubbedInvocation, Location location) {
this.unstubbedInvocation = unstubbedInvocation;
this.location = location;
}
+ @Override
public Object answer(InvocationOnMock currentInvocation) throws Throwable {
if (isToStringMethod(currentInvocation.getMethod())) {
- return "SmartNull returned by this unstubbed method call on a mock:\n" +
- unstubbedInvocation.toString();
+ return "SmartNull returned by this unstubbed method call on a mock:\n"
+ + unstubbedInvocation;
}
throw smartNullPointerException(unstubbedInvocation.toString(), location);
diff --git a/src/main/java/org/mockito/internal/stubbing/defaultanswers/TriesToReturnSelf.java b/src/main/java/org/mockito/internal/stubbing/defaultanswers/TriesToReturnSelf.java
index 27cf121..58a64d7 100644
--- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/TriesToReturnSelf.java
+++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/TriesToReturnSelf.java
@@ -4,16 +4,17 @@
*/
package org.mockito.internal.stubbing.defaultanswers;
+import java.io.Serializable;
+
import org.mockito.internal.util.MockUtil;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
-import java.io.Serializable;
-
-public class TriesToReturnSelf implements Answer<Object>, Serializable{
+public class TriesToReturnSelf implements Answer<Object>, Serializable {
private final ReturnsEmptyValues defaultReturn = new ReturnsEmptyValues();
+ @Override
public Object answer(InvocationOnMock invocation) throws Throwable {
Class<?> methodReturnType = invocation.getMethod().getReturnType();
Object mock = invocation.getMock();
@@ -25,5 +26,4 @@
return defaultReturn.returnValueFor(methodReturnType);
}
-
}
diff --git a/src/main/java/org/mockito/internal/util/Checks.java b/src/main/java/org/mockito/internal/util/Checks.java
index b672f6a..f7ed59d 100644
--- a/src/main/java/org/mockito/internal/util/Checks.java
+++ b/src/main/java/org/mockito/internal/util/Checks.java
@@ -2,20 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.util;
-/**
- * Pre-made preconditions
- */
-public class Checks {
+/** Pre-made preconditions */
+public final class Checks {
public static <T> T checkNotNull(T value, String checkedValue) {
return checkNotNull(value, checkedValue, null);
}
public static <T> T checkNotNull(T value, String checkedValue, String additionalMessage) {
- if(value == null) {
+ if (value == null) {
String message = checkedValue + " should not be null";
if (additionalMessage != null) {
message += ". " + additionalMessage;
@@ -32,4 +29,6 @@
}
return iterable;
}
+
+ private Checks() {}
}
diff --git a/src/main/java/org/mockito/internal/util/ConsoleMockitoLogger.java b/src/main/java/org/mockito/internal/util/ConsoleMockitoLogger.java
index d8df8eb..aff681c 100644
--- a/src/main/java/org/mockito/internal/util/ConsoleMockitoLogger.java
+++ b/src/main/java/org/mockito/internal/util/ConsoleMockitoLogger.java
@@ -4,9 +4,13 @@
*/
package org.mockito.internal.util;
+import org.mockito.plugins.MockitoLogger;
+
public class ConsoleMockitoLogger implements MockitoLogger {
- /* (non-Javadoc)
+ /**
+ * (non-Javadoc)
+ *
* @see org.mockito.internal.util.Logger#print(java.lang.Object)
*/
public void log(Object what) {
diff --git a/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java b/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
index 4f739cd..1ad5a75 100644
--- a/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
+++ b/src/main/java/org/mockito/internal/util/DefaultMockingDetails.java
@@ -4,6 +4,8 @@
*/
package org.mockito.internal.util;
+import java.util.Collection;
+
import org.mockito.MockingDetails;
import org.mockito.exceptions.misusing.NotAMockException;
import org.mockito.internal.debugging.InvocationsPrinter;
@@ -13,8 +15,6 @@
import org.mockito.mock.MockCreationSettings;
import org.mockito.stubbing.Stubbing;
-import java.util.Collection;
-
/**
* Class to inspect any object, and identify whether a particular object is either a mock or a spy. This is
* a wrapper for {@link org.mockito.internal.util.MockUtil}.
@@ -23,17 +23,17 @@
private final Object toInspect;
- public DefaultMockingDetails(Object toInspect){
+ public DefaultMockingDetails(Object toInspect) {
this.toInspect = toInspect;
}
@Override
- public boolean isMock(){
+ public boolean isMock() {
return MockUtil.isMock(toInspect);
}
@Override
- public boolean isSpy(){
+ public boolean isSpy() {
return MockUtil.isSpy(toInspect);
}
@@ -73,17 +73,20 @@
return toInspect;
}
- private MockHandler<Object> mockHandler() {
+ private MockHandler<?> mockHandler() {
assertGoodMock();
return MockUtil.getMockHandler(toInspect);
}
private void assertGoodMock() {
if (toInspect == null) {
- throw new NotAMockException("Argument passed to Mockito.mockingDetails() should be a mock, but is null!");
+ throw new NotAMockException(
+ "Argument passed to Mockito.mockingDetails() should be a mock, but is null!");
} else if (!isMock()) {
- throw new NotAMockException("Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of " + toInspect.getClass() + "!");
+ throw new NotAMockException(
+ "Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of "
+ + toInspect.getClass()
+ + "!");
}
}
}
-
diff --git a/src/main/java/org/mockito/internal/util/JavaEightUtil.java b/src/main/java/org/mockito/internal/util/JavaEightUtil.java
index 80ac635..20c6e80 100644
--- a/src/main/java/org/mockito/internal/util/JavaEightUtil.java
+++ b/src/main/java/org/mockito/internal/util/JavaEightUtil.java
@@ -4,10 +4,11 @@
*/
package org.mockito.internal.util;
-import org.mockito.internal.creation.instance.InstantiationException;
-
+import java.lang.reflect.Field;
import java.lang.reflect.Method;
+import org.mockito.creation.instance.InstantiationException;
+
/**
* Helper class to work with features that were introduced in Java versions after 1.5.
* This class uses reflection in most places to avoid coupling with a newer JDK.
@@ -19,6 +20,8 @@
private static Object emptyOptionalDouble;
private static Object emptyOptionalInt;
private static Object emptyOptionalLong;
+ private static Object emptyDuration;
+ private static Object emptyPeriod;
private JavaEightUtil() {
// utility class
@@ -38,7 +41,6 @@
return emptyOptional = invokeNullaryFactoryMethod("java.util.Optional", "empty");
}
-
/**
* Creates an empty OptionalDouble using reflection to stay backwards-compatible with older JDKs.
*
@@ -50,7 +52,8 @@
return emptyOptionalDouble;
}
- return emptyOptionalDouble = invokeNullaryFactoryMethod("java.util.OptionalDouble", "empty");
+ return emptyOptionalDouble =
+ invokeNullaryFactoryMethod("java.util.OptionalDouble", "empty");
}
/**
@@ -122,6 +125,34 @@
}
/**
+ * Creates an empty Duration using reflection to stay backwards-compatible with older JDKs.
+ *
+ * @return an empty (ZERO) Duration.
+ */
+ public static Object emptyDuration() {
+ // no need for double-checked locking
+ if (emptyDuration != null) {
+ return emptyDuration;
+ }
+
+ return emptyDuration = getStaticFieldValue("java.time.Duration", "ZERO");
+ }
+
+ /**
+ * Creates an empty Period using reflection to stay backwards-compatible with older JDKs.
+ *
+ * @return an empty (ZERO) Period.
+ */
+ public static Object emptyPeriod() {
+ // no need for double-checked locking
+ if (emptyPeriod != null) {
+ return emptyPeriod;
+ }
+
+ return emptyPeriod = getStaticFieldValue("java.time.Period", "ZERO");
+ }
+
+ /**
* Invokes a nullary static factory method using reflection to stay backwards-compatible with older JDKs.
*
* @param fqcn The fully qualified class name of the type to be produced.
@@ -130,9 +161,7 @@
*/
private static Object invokeNullaryFactoryMethod(final String fqcn, final String methodName) {
try {
- final Class<?> type = Class.forName(fqcn);
- final Method method = type.getMethod(methodName);
-
+ final Method method = getMethod(fqcn, methodName);
return method.invoke(null);
// any exception is really unexpected since the type name has
// already been verified
@@ -141,4 +170,59 @@
String.format("Could not create %s#%s(): %s", fqcn, methodName, e), e);
}
}
+
+ /**
+ * Gets a value of the classes' field using reflection to stay backwards-compatible with older JDKs.
+ *
+ * @param fqcn The fully qualified class name of the type to be produced.
+ * @param fieldName The name of th classes' field which value is going to be returned.
+ * @return the restored value.
+ */
+ private static Object getStaticFieldValue(final String fqcn, final String fieldName) {
+ try {
+ final Class<?> type = getClass(fqcn);
+ final Field field = type.getField(fieldName);
+ return field.get(null);
+ // any exception is really unexpected since the type name has
+ // already been verified
+ } catch (Exception e) {
+ throw new InstantiationException(
+ String.format("Could not get %s#%s(): %s", fqcn, fieldName, e), e);
+ }
+ }
+
+ /**
+ * Returns the {@code Class} object associated with the class or interface with the given string name.
+ *
+ * @param fqcn The fully qualified class name of the type to be produced.
+ * @return the Class object for the class with the specified name.
+ */
+ private static Class<?> getClass(String fqcn) {
+ try {
+ return Class.forName(fqcn);
+ // any exception is really unexpected since the type name has
+ // already been verified
+ } catch (ClassNotFoundException e) {
+ throw new InstantiationException(String.format("Could not find %s: %s", fqcn, e), e);
+ }
+ }
+
+ /**
+ * Returns a Method object that reflects the specified public member method of the class or interface represented by the fully qualified class name.
+ *
+ * @param fqcn The fully qualified class name of the type to be produced.
+ * @param methodName The name of the method.
+ * @param parameterClasses The list of parameters.
+ * @return The Method object that matches the specified name and parameterTypes.
+ */
+ private static Method getMethod(
+ final String fqcn, final String methodName, final Class<?>... parameterClasses) {
+ try {
+ final Class<?> type = getClass(fqcn);
+ return type.getMethod(methodName, parameterClasses);
+ } catch (Exception e) {
+ throw new InstantiationException(
+ String.format("Could not find %s#%s(): %s", fqcn, methodName, e), e);
+ }
+ }
}
diff --git a/src/main/java/org/mockito/internal/util/KotlinInlineClassUtil.java b/src/main/java/org/mockito/internal/util/KotlinInlineClassUtil.java
new file mode 100644
index 0000000..11bd5e8
--- /dev/null
+++ b/src/main/java/org/mockito/internal/util/KotlinInlineClassUtil.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util;
+
+import org.mockito.internal.exceptions.Reporter;
+import org.mockito.internal.stubbing.answers.InvocationInfo;
+import org.mockito.invocation.InvocationOnMock;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class KotlinInlineClassUtil {
+ private static Class<Annotation> jvmInlineAnnotation;
+
+ static {
+ try {
+ jvmInlineAnnotation = (Class<Annotation>) Class.forName("kotlin.jvm.JvmInline");
+ } catch (ClassNotFoundException e) {
+ // Do nothing: kotlin is pre 1.5.0
+ }
+ }
+
+ // When mocking function, returning inline class, its return type is
+ // underlying type.
+ // So, `thenReturn` calls fails, because of non-compatible types.
+ public static boolean isInlineClassWithAssignableUnderlyingType(
+ Class<?> inlineClass, Class<?> underlyingType) {
+ try {
+ // Since 1.5.0 inline classes have @JvmInline annotation
+ if (jvmInlineAnnotation == null
+ || !inlineClass.isAnnotationPresent(jvmInlineAnnotation)) return false;
+
+ // All inline classes have 'box-impl' method, which accepts
+ // underlying type and returns inline class.
+ // Make sure that the current inline class is also the class that is compatible with the
+ // underlying type.
+ // If we don't make this check, then we would potentially pass a mock of inline type A
+ // into a method
+ // that accepts inline type B.
+ inlineClass.getDeclaredMethod("box-impl", underlyingType);
+ return true;
+ } catch (NoSuchMethodException e) {
+ return false;
+ }
+ }
+
+ private static Object unboxInlineClassIfPossible(Object boxedValue) {
+ Class<?> inlineClass = boxedValue.getClass();
+ try {
+ Method unboxImpl = inlineClass.getDeclaredMethod("unbox-impl");
+ return unboxImpl.invoke(boxedValue);
+ } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+ throw Reporter.inlineClassWithoutUnboxImpl(inlineClass, e);
+ }
+ }
+
+ public static Object unboxUnderlyingValueIfNeeded(InvocationOnMock invocation, Object value) {
+ // Short path - Kotlin 1.5+ is not present.
+ if (value == null || jvmInlineAnnotation == null) {
+ return value;
+ }
+
+ Class<?> valueType = value.getClass();
+ InvocationInfo invocationInfo = new InvocationInfo(invocation);
+ Class<?> returnType = invocationInfo.getMethod().getReturnType();
+ if (valueType.isAssignableFrom(returnType)) return value;
+
+ if (isInlineClassWithAssignableUnderlyingType(valueType, returnType)) {
+ return unboxInlineClassIfPossible(value);
+ } else {
+ return value;
+ }
+ }
+}
diff --git a/src/main/java/org/mockito/internal/util/MockCreationValidator.java b/src/main/java/org/mockito/internal/util/MockCreationValidator.java
index 5dba346..7baa4e2 100644
--- a/src/main/java/org/mockito/internal/util/MockCreationValidator.java
+++ b/src/main/java/org/mockito/internal/util/MockCreationValidator.java
@@ -25,7 +25,8 @@
}
}
- public void validateExtraInterfaces(Class<?> classToMock, Collection<Class<?>> extraInterfaces) {
+ public void validateExtraInterfaces(
+ Class<?> classToMock, Collection<Class<?>> extraInterfaces) {
if (extraInterfaces == null) {
return;
}
diff --git a/src/main/java/org/mockito/internal/util/MockNameImpl.java b/src/main/java/org/mockito/internal/util/MockNameImpl.java
index 7759979..6374687 100644
--- a/src/main/java/org/mockito/internal/util/MockNameImpl.java
+++ b/src/main/java/org/mockito/internal/util/MockNameImpl.java
@@ -4,10 +4,10 @@
*/
package org.mockito.internal.util;
-import org.mockito.mock.MockName;
-
import java.io.Serializable;
+import org.mockito.mock.MockName;
+
public class MockNameImpl implements MockName, Serializable {
private static final long serialVersionUID = 8014974700844306925L;
@@ -15,9 +15,9 @@
private boolean defaultName;
@SuppressWarnings("unchecked")
- public MockNameImpl(String mockName, Class<?> classToMock) {
+ public MockNameImpl(String mockName, Class<?> type, boolean mockedStatic) {
if (mockName == null) {
- this.mockName = toInstanceName(classToMock);
+ this.mockName = mockedStatic ? toClassName(type) : toInstanceName(type);
this.defaultName = true;
} else {
this.mockName = mockName;
@@ -31,13 +31,23 @@
private static String toInstanceName(Class<?> clazz) {
String className = clazz.getSimpleName();
if (className.length() == 0) {
- //it's an anonymous class, let's get name from the parent
+ // it's an anonymous class, let's get name from the parent
className = clazz.getSuperclass().getSimpleName();
}
- //lower case first letter
+ // lower case first letter
return className.substring(0, 1).toLowerCase() + className.substring(1);
}
+ private static String toClassName(Class<?> clazz) {
+ String className = clazz.getSimpleName();
+ if (className.length() == 0) {
+ // it's an anonymous class, let's get name from the parent
+ className = clazz.getSuperclass().getSimpleName() + "$";
+ }
+ return className + ".class";
+ }
+
+ @Override
public boolean isDefault() {
return defaultName;
}
diff --git a/src/main/java/org/mockito/internal/util/MockUtil.java b/src/main/java/org/mockito/internal/util/MockUtil.java
index df0deb1..2159608 100644
--- a/src/main/java/org/mockito/internal/util/MockUtil.java
+++ b/src/main/java/org/mockito/internal/util/MockUtil.java
@@ -4,6 +4,7 @@
*/
package org.mockito.internal.util;
+import org.mockito.MockedConstruction;
import org.mockito.Mockito;
import org.mockito.exceptions.misusing.NotAMockException;
import org.mockito.internal.configuration.plugins.Plugins;
@@ -15,6 +16,9 @@
import org.mockito.mock.MockName;
import org.mockito.plugins.MockMaker;
import org.mockito.plugins.MockMaker.TypeMockability;
+import org.mockito.plugins.MockResolver;
+
+import java.util.function.Function;
import static org.mockito.internal.handler.MockHandlerFactory.createMockHandler;
@@ -26,37 +30,51 @@
private MockUtil() {}
public static TypeMockability typeMockabilityOf(Class<?> type) {
- return mockMaker.isTypeMockable(type);
+ return mockMaker.isTypeMockable(type);
}
public static <T> T createMock(MockCreationSettings<T> settings) {
- MockHandler mockHandler = createMockHandler(settings);
-
- T mock = mockMaker.createMock(settings, mockHandler);
+ MockHandler mockHandler = createMockHandler(settings);
Object spiedInstance = settings.getSpiedInstance();
+
+ T mock;
if (spiedInstance != null) {
- new LenientCopyTool().copyToMock(spiedInstance, mock);
+ mock =
+ mockMaker
+ .createSpy(settings, mockHandler, (T) spiedInstance)
+ .orElseGet(
+ () -> {
+ T instance = mockMaker.createMock(settings, mockHandler);
+ new LenientCopyTool().copyToMock(spiedInstance, instance);
+ return instance;
+ });
+ } else {
+ mock = mockMaker.createMock(settings, mockHandler);
}
return mock;
}
- public static <T> void resetMock(T mock) {
+ public static void resetMock(Object mock) {
MockHandler oldHandler = getMockHandler(mock);
MockCreationSettings settings = oldHandler.getMockSettings();
MockHandler newHandler = createMockHandler(settings);
+ mock = resolve(mock);
mockMaker.resetMock(mock, newHandler, settings);
}
- public static <T> MockHandler<T> getMockHandler(T mock) {
+ public static MockHandler<?> getMockHandler(Object mock) {
if (mock == null) {
throw new NotAMockException("Argument should be a mock, but is null!");
}
- if (isMock(mock)) {
- return mockMaker.getHandler(mock);
+ mock = resolve(mock);
+
+ MockHandler handler = mockMaker.getHandler(mock);
+ if (handler != null) {
+ return handler;
} else {
throw new NotAMockException("Argument should be a mock, but is: " + mock.getClass());
}
@@ -67,18 +85,43 @@
}
public static boolean isSpy(Object mock) {
- return isMock(mock) && getMockSettings(mock).getDefaultAnswer() == Mockito.CALLS_REAL_METHODS;
+ return isMock(mock)
+ && getMockSettings(mock).getDefaultAnswer() == Mockito.CALLS_REAL_METHODS;
}
public static boolean isMock(Object mock) {
- // TODO SF (perf tweak) in our codebase we call mockMaker.getHandler() multiple times unnecessarily
- // This is not ideal because getHandler() can be expensive (reflective calls inside mock maker)
- // The frequent pattern in the codebase are separate calls to: 1) isMock(mock) then 2) getMockHandler(mock)
+ // TODO SF (perf tweak) in our codebase we call mockMaker.getHandler() multiple times
+ // unnecessarily
+ // This is not ideal because getHandler() can be expensive (reflective calls inside mock
+ // maker)
+ // The frequent pattern in the codebase are separate calls to: 1) isMock(mock) then 2)
+ // getMockHandler(mock)
// We could replace it with using mockingDetails().isMock()
// Let's refactor the codebase and use new mockingDetails() in all relevant places.
- // Potentially we could also move other methods to MockitoMock, some other candidates: getInvocationContainer, isSpy, etc.
+ // Potentially we could also move other methods to MockitoMock, some other candidates:
+ // getInvocationContainer, isSpy, etc.
// This also allows us to reuse our public API MockingDetails
- return mock != null && mockMaker.getHandler(mock) != null;
+ if (mock == null) {
+ return false;
+ }
+
+ mock = resolve(mock);
+
+ return mockMaker.getHandler(mock) != null;
+ }
+
+ private static Object resolve(Object mock) {
+ if (mock instanceof Class<?>) { // static mocks are resolved by definition
+ return mock;
+ }
+ for (MockResolver mockResolver : Plugins.getMockResolvers()) {
+ mock = mockResolver.resolve(mock);
+ }
+ return mock;
+ }
+
+ public static boolean areSameMocks(Object mockA, Object mockB) {
+ return mockA == mockB || resolve(mockA) == resolve(mockB);
}
public static MockName getMockName(Object mock) {
@@ -87,9 +130,9 @@
public static void maybeRedefineMockName(Object mock, String newName) {
MockName mockName = getMockName(mock);
- //TODO SF hacky...
+ // TODO SF hacky...
MockCreationSettings mockSettings = getMockHandler(mock).getMockSettings();
- if (mockName.isDefault() && mockSettings instanceof CreationSettings) {
+ if (mockName.isDefault() && mockSettings instanceof CreationSettings) {
((CreationSettings) mockSettings).setMockName(new MockNameImpl(newName));
}
}
@@ -97,4 +140,24 @@
public static MockCreationSettings getMockSettings(Object mock) {
return getMockHandler(mock).getMockSettings();
}
+
+ public static <T> MockMaker.StaticMockControl<T> createStaticMock(
+ Class<T> type, MockCreationSettings<T> settings) {
+ MockHandler<T> handler = createMockHandler(settings);
+ return mockMaker.createStaticMock(type, settings, handler);
+ }
+
+ public static <T> MockMaker.ConstructionMockControl<T> createConstructionMock(
+ Class<T> type,
+ Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory,
+ MockedConstruction.MockInitializer<T> mockInitializer) {
+ Function<MockedConstruction.Context, MockHandler<T>> handlerFactory =
+ context -> createMockHandler(settingsFactory.apply(context));
+ return mockMaker.createConstructionMock(
+ type, settingsFactory, handlerFactory, mockInitializer);
+ }
+
+ public static void clearAllCaches() {
+ mockMaker.clearAllCaches();
+ }
}
diff --git a/src/main/java/org/mockito/internal/util/MockitoLogger.java b/src/main/java/org/mockito/internal/util/MockitoLogger.java
deleted file mode 100644
index af66cee..0000000
--- a/src/main/java/org/mockito/internal/util/MockitoLogger.java
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util;
-
-public interface MockitoLogger {
-
- void log(Object what);
-
-}
diff --git a/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java b/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java
index d2a1690..b46f29a 100644
--- a/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java
+++ b/src/main/java/org/mockito/internal/util/ObjectMethodsGuru.java
@@ -5,19 +5,19 @@
package org.mockito.internal.util;
import java.lang.reflect.Method;
+
import org.mockito.internal.creation.DelegatingMethod;
import org.mockito.internal.invocation.MockitoMethod;
-public class ObjectMethodsGuru{
+public class ObjectMethodsGuru {
- private ObjectMethodsGuru() {
- }
+ private ObjectMethodsGuru() {}
public static boolean isToStringMethod(Method method) {
MockitoMethod m = new DelegatingMethod(method);
- return m.getReturnType() == String.class &&
- m.getParameterTypes().length == 0 &&
- "toString".equals(m.getName());
+ return m.getReturnType() == String.class
+ && m.getParameterTypes().length == 0
+ && "toString".equals(m.getName());
}
public static boolean isCompareToMethod(Method method) {
diff --git a/src/main/java/org/mockito/internal/util/Platform.java b/src/main/java/org/mockito/internal/util/Platform.java
index 897ebed..946e4ff 100644
--- a/src/main/java/org/mockito/internal/util/Platform.java
+++ b/src/main/java/org/mockito/internal/util/Platform.java
@@ -4,16 +4,18 @@
*/
package org.mockito.internal.util;
+import static org.mockito.internal.util.StringUtil.join;
+
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import static org.mockito.internal.util.StringUtil.join;
-
public abstract class Platform {
- private static final Pattern JAVA_8_RELEASE_VERSION_SCHEME = Pattern.compile("1\\.8\\.0_(\\d+)(?:-ea)?(?:-b\\d+)?");
- private static final Pattern JAVA_8_DEV_VERSION_SCHEME = Pattern.compile("1\\.8\\.0b\\d+_u(\\d+)");
+ private static final Pattern JAVA_8_RELEASE_VERSION_SCHEME =
+ Pattern.compile("1\\.8\\.0_(\\d+)(?:-ea)?(?:-b\\d+)?");
+ private static final Pattern JAVA_8_DEV_VERSION_SCHEME =
+ Pattern.compile("1\\.8\\.0b\\d+_u(\\d+)");
public static final String JAVA_VERSION = System.getProperty("java.specification.version");
public static final String JVM_VERSION = System.getProperty("java.runtime.version");
public static final String JVM_VENDOR = System.getProperty("java.vm.vendor");
@@ -23,8 +25,7 @@
public static final String OS_NAME = System.getProperty("os.name");
public static final String OS_VERSION = System.getProperty("os.version");
- private Platform() {
- }
+ private Platform() {}
public static boolean isAndroid() {
return System.getProperty("java.vendor", "").toLowerCase(Locale.US).contains("android");
@@ -35,32 +36,34 @@
}
public static String describe() {
- String description = String.format("Java : %s\n" +
- "JVM vendor name : %s\n" +
- "JVM vendor version : %s\n" +
- "JVM name : %s\n" +
- "JVM version : %s\n" +
- "JVM info : %s\n" +
- "OS name : %s\n" +
- "OS version : %s\n",
- JAVA_VERSION,
- JVM_VENDOR,
- JVM_VENDOR_VERSION,
- JVM_NAME,
- JVM_VERSION,
- JVM_INFO,
- OS_NAME,
- OS_VERSION);
+ String description =
+ String.format(
+ "Java : %s\n"
+ + "JVM vendor name : %s\n"
+ + "JVM vendor version : %s\n"
+ + "JVM name : %s\n"
+ + "JVM version : %s\n"
+ + "JVM info : %s\n"
+ + "OS name : %s\n"
+ + "OS version : %s\n",
+ JAVA_VERSION,
+ JVM_VENDOR,
+ JVM_VENDOR_VERSION,
+ JVM_NAME,
+ JVM_VERSION,
+ JVM_INFO,
+ OS_NAME,
+ OS_VERSION);
if (isAndroid()) {
- description = join(
- "IMPORTANT INFORMATION FOR ANDROID USERS:",
- "",
- "The regular Byte Buddy mock makers cannot generate code on an Android VM!",
- "To resolve this, please use the 'mockito-android' dependency for your application:",
- "http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22mockito-android%22%20g%3A%22org.mockito%22",
- "",
- description
- );
+ description =
+ join(
+ "IMPORTANT INFORMATION FOR ANDROID USERS:",
+ "",
+ "The regular Byte Buddy mock makers cannot generate code on an Android VM!",
+ "To resolve this, please use the 'mockito-android' dependency for your application:",
+ "https://search.maven.org/artifact/org.mockito/mockito-android",
+ "",
+ description);
}
return description;
}
@@ -84,19 +87,19 @@
matcher = Pattern.compile("1\\.8\\.0-b\\d+").matcher(jvmVersion);
return matcher.matches();
-
}
- public static String warnForVM(String vmName1, String warnMessage1,
- String vmName2, String warnMessage2) {
- return warnForVM(JVM_NAME,
- vmName1, warnMessage1,
- vmName2, warnMessage2);
+ public static String warnForVM(
+ String vmName1, String warnMessage1, String vmName2, String warnMessage2) {
+ return warnForVM(JVM_NAME, vmName1, warnMessage1, vmName2, warnMessage2);
}
- static String warnForVM(String current,
- String vmName1, String warnMessage1,
- String vmName2, String warnMessage2) {
+ static String warnForVM(
+ String current,
+ String vmName1,
+ String warnMessage1,
+ String vmName2,
+ String warnMessage2) {
if (vmName1 != null && current.contains(vmName1)) {
return warnMessage1;
}
diff --git a/src/main/java/org/mockito/internal/util/Primitives.java b/src/main/java/org/mockito/internal/util/Primitives.java
index 80dd0af..ba7e5c7 100644
--- a/src/main/java/org/mockito/internal/util/Primitives.java
+++ b/src/main/java/org/mockito/internal/util/Primitives.java
@@ -8,11 +8,11 @@
import java.util.Map;
@SuppressWarnings("unchecked")
-public class Primitives {
+public final class Primitives {
- private static final Map<Class<?>, Class<?>> PRIMITIVE_TYPES = new HashMap<Class<?>, Class<?>>();
- private static final Map<Class<?>, Object> PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES = new HashMap<Class<?>, Object>();
-
+ private static final Map<Class<?>, Class<?>> PRIMITIVE_TYPES = new HashMap<>();
+ private static final Map<Class<?>, Object> PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES =
+ new HashMap<>();
/**
* Returns the primitive type of the given class.
@@ -43,8 +43,9 @@
}
public static boolean isAssignableFromWrapper(Class<?> valueClass, Class<?> referenceType) {
- if(isPrimitiveOrWrapper(valueClass) && isPrimitiveOrWrapper(referenceType)) {
- return Primitives.primitiveTypeOf(valueClass).isAssignableFrom(Primitives.primitiveTypeOf(referenceType));
+ if (isPrimitiveOrWrapper(valueClass) && isPrimitiveOrWrapper(referenceType)) {
+ return Primitives.primitiveTypeOf(valueClass)
+ .isAssignableFrom(Primitives.primitiveTypeOf(referenceType));
}
return false;
}
@@ -60,7 +61,6 @@
return (T) PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES.get(primitiveOrWrapperType);
}
-
static {
PRIMITIVE_TYPES.put(Boolean.class, Boolean.TYPE);
PRIMITIVE_TYPES.put(Character.class, Character.TYPE);
@@ -91,4 +91,6 @@
PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES.put(float.class, 0F);
PRIMITIVE_OR_WRAPPER_DEFAULT_VALUES.put(double.class, 0D);
}
+
+ private Primitives() {}
}
diff --git a/src/main/java/org/mockito/internal/util/StringUtil.java b/src/main/java/org/mockito/internal/util/StringUtil.java
index 3070fe6..7e55666 100644
--- a/src/main/java/org/mockito/internal/util/StringUtil.java
+++ b/src/main/java/org/mockito/internal/util/StringUtil.java
@@ -28,7 +28,7 @@
* Joins Strings with line break character. It adds line break in front, too.
* This makes it something like 'format' no really 'join'.
*/
- public static String join(Object ... linesToBreak) {
+ public static String join(Object... linesToBreak) {
return join("\n", asList(linesToBreak));
}
@@ -57,10 +57,10 @@
for (Object line : lines) {
out.append(linePrefix).append(line).append("\n");
}
- return out.substring(0, out.length() - 1); //lose last EOL
+ return out.substring(0, out.length() - 1); // lose last EOL
}
- public static String decamelizeMatcher(String className) {
+ public static String decamelizeMatcherName(String className) {
if (className.length() == 0) {
return "<custom argument matcher>";
}
diff --git a/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsMockWrapper.java b/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsMockWrapper.java
index d8b581c..50e194d 100644
--- a/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsMockWrapper.java
+++ b/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsMockWrapper.java
@@ -38,8 +38,12 @@
@Override
public boolean equals(Object o) {
- if (this == o) return true;
- if (!(o instanceof HashCodeAndEqualsMockWrapper)) return false;
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof HashCodeAndEqualsMockWrapper)) {
+ return false;
+ }
HashCodeAndEqualsMockWrapper that = (HashCodeAndEqualsMockWrapper) o;
@@ -55,13 +59,20 @@
return new HashCodeAndEqualsMockWrapper(mock);
}
- @Override public String toString() {
- return "HashCodeAndEqualsMockWrapper{" +
- "mockInstance=" + (MockUtil.isMock(mockInstance) ? MockUtil.getMockName(mockInstance) : typeInstanceString()) +
- '}';
+ @Override
+ public String toString() {
+ return "HashCodeAndEqualsMockWrapper{"
+ + "mockInstance="
+ + (MockUtil.isMock(mockInstance)
+ ? MockUtil.getMockName(mockInstance)
+ : typeInstanceString())
+ + '}';
}
private String typeInstanceString() {
- return mockInstance.getClass().getSimpleName() + "(" + System.identityHashCode(mockInstance) + ")";
+ return mockInstance.getClass().getSimpleName()
+ + "("
+ + System.identityHashCode(mockInstance)
+ + ")";
}
}
diff --git a/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSet.java b/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSet.java
index d422dba..a547067 100644
--- a/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSet.java
+++ b/src/main/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSet.java
@@ -4,7 +4,7 @@
*/
package org.mockito.internal.util.collections;
-import org.mockito.internal.util.Checks;
+import static java.lang.reflect.Array.*;
import java.util.Arrays;
import java.util.Collection;
@@ -12,7 +12,7 @@
import java.util.Iterator;
import java.util.Set;
-import static java.lang.reflect.Array.*;
+import org.mockito.internal.util.Checks;
/**
* hashCode and equals safe hash based set.
@@ -31,12 +31,15 @@
*/
public class HashCodeAndEqualsSafeSet implements Set<Object> {
- private final HashSet<HashCodeAndEqualsMockWrapper> backingHashSet = new HashSet<HashCodeAndEqualsMockWrapper>();
+ private final HashSet<HashCodeAndEqualsMockWrapper> backingHashSet = new HashSet<>();
+ @Override
public Iterator<Object> iterator() {
return new Iterator<Object>() {
- private final Iterator<HashCodeAndEqualsMockWrapper> iterator = backingHashSet.iterator();
+ private final Iterator<HashCodeAndEqualsMockWrapper> iterator =
+ backingHashSet.iterator();
+ @Override
public boolean hasNext() {
return iterator.hasNext();
}
@@ -51,35 +54,43 @@
};
}
+ @Override
public int size() {
return backingHashSet.size();
}
+ @Override
public boolean isEmpty() {
return backingHashSet.isEmpty();
}
+ @Override
public boolean contains(Object mock) {
return backingHashSet.contains(HashCodeAndEqualsMockWrapper.of(mock));
}
+ @Override
public boolean add(Object mock) {
return backingHashSet.add(HashCodeAndEqualsMockWrapper.of(mock));
}
+ @Override
public boolean remove(Object mock) {
return backingHashSet.remove(HashCodeAndEqualsMockWrapper.of(mock));
}
+ @Override
public void clear() {
backingHashSet.clear();
}
- @Override public Object clone() throws CloneNotSupportedException {
+ @Override
+ public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
- @Override public boolean equals(Object o) {
+ @Override
+ public boolean equals(Object o) {
if (!(o instanceof HashCodeAndEqualsSafeSet)) {
return false;
}
@@ -87,7 +98,8 @@
return backingHashSet.equals(that.backingHashSet);
}
- @Override public int hashCode() {
+ @Override
+ public int hashCode() {
return backingHashSet.hashCode();
}
@@ -96,6 +108,15 @@
}
@SuppressWarnings("unchecked")
+ public <T> T[] toArray(T[] typedArray) {
+ T[] array =
+ typedArray.length >= size()
+ ? typedArray
+ : (T[]) newInstance(typedArray.getClass().getComponentType(), size());
+ return unwrapTo(array);
+ }
+
+ @SuppressWarnings("unchecked")
private <T> T[] unwrapTo(T[] array) {
Iterator<Object> iterator = iterator();
for (int i = 0, objectsLength = array.length; i < objectsLength; i++) {
@@ -106,39 +127,37 @@
return array;
}
- @SuppressWarnings("unchecked")
- public <T> T[] toArray(T[] typedArray) {
- T[] array = typedArray.length >= size() ? typedArray : (T[]) newInstance(typedArray.getClass().getComponentType(), size());
- return unwrapTo(array);
- }
-
public boolean removeAll(Collection<?> mocks) {
return backingHashSet.removeAll(asWrappedMocks(mocks));
}
+ @Override
public boolean containsAll(Collection<?> mocks) {
return backingHashSet.containsAll(asWrappedMocks(mocks));
}
+ @Override
public boolean addAll(Collection<?> mocks) {
return backingHashSet.addAll(asWrappedMocks(mocks));
}
+ @Override
public boolean retainAll(Collection<?> mocks) {
return backingHashSet.retainAll(asWrappedMocks(mocks));
}
private HashSet<HashCodeAndEqualsMockWrapper> asWrappedMocks(Collection<?> mocks) {
Checks.checkNotNull(mocks, "Passed collection should notify() be null");
- HashSet<HashCodeAndEqualsMockWrapper> hashSet = new HashSet<HashCodeAndEqualsMockWrapper>();
+ HashSet<HashCodeAndEqualsMockWrapper> hashSet = new HashSet<>();
for (Object mock : mocks) {
- assert ! (mock instanceof HashCodeAndEqualsMockWrapper) : "WRONG";
+ assert !(mock instanceof HashCodeAndEqualsMockWrapper) : "WRONG";
hashSet.add(HashCodeAndEqualsMockWrapper.of(mock));
}
return hashSet;
}
- @Override public String toString() {
+ @Override
+ public String toString() {
return backingHashSet.toString();
}
diff --git a/src/main/java/org/mockito/internal/util/collections/IdentitySet.java b/src/main/java/org/mockito/internal/util/collections/IdentitySet.java
index 76c6178..e0b2359 100644
--- a/src/main/java/org/mockito/internal/util/collections/IdentitySet.java
+++ b/src/main/java/org/mockito/internal/util/collections/IdentitySet.java
@@ -12,7 +12,7 @@
private final LinkedList list = new LinkedList();
public boolean contains(Object o) {
- for(Object existing:list) {
+ for (Object existing : list) {
if (existing == o) {
return true;
}
diff --git a/src/main/java/org/mockito/internal/util/collections/Iterables.java b/src/main/java/org/mockito/internal/util/collections/Iterables.java
index 933ce89..50eb016 100644
--- a/src/main/java/org/mockito/internal/util/collections/Iterables.java
+++ b/src/main/java/org/mockito/internal/util/collections/Iterables.java
@@ -4,22 +4,20 @@
*/
package org.mockito.internal.util.collections;
+import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
-import java.util.LinkedList;
import java.util.List;
-/**
- * Utilities for Iterables
- */
-public class Iterables {
+/** Utilities for Iterables */
+public final class Iterables {
/**
* Converts enumeration into iterable
*/
public static <T> Iterable<T> toIterable(Enumeration<T> in) {
- List<T> out = new LinkedList<T>();
- while(in.hasMoreElements()) {
+ List<T> out = new ArrayList<T>();
+ while (in.hasMoreElements()) {
out.add(in.nextElement());
}
return out;
@@ -35,8 +33,11 @@
public static <T> T firstOf(Iterable<T> iterable) {
Iterator<T> iterator = iterable.iterator();
if (!iterator.hasNext()) {
- throw new IllegalArgumentException("Cannot provide 1st element from empty iterable: " + iterable);
+ throw new IllegalArgumentException(
+ "Cannot provide 1st element from empty iterable: " + iterable);
}
return iterator.next();
}
+
+ private Iterables() {}
}
diff --git a/src/main/java/org/mockito/internal/util/collections/ListUtil.java b/src/main/java/org/mockito/internal/util/collections/ListUtil.java
index 0a4d268..f94afd8 100644
--- a/src/main/java/org/mockito/internal/util/collections/ListUtil.java
+++ b/src/main/java/org/mockito/internal/util/collections/ListUtil.java
@@ -2,19 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.util.collections;
import java.util.Collection;
import java.util.LinkedList;
/**
- * Basic list/collection operators.
- * We know that there are existing libraries that implement those use cases neatly.
- * However, we want to keep Mockito dependencies minimal.
- * In Java8 we should be able to get rid of this class.
+ * Basic list/collection operators. We know that there are existing libraries that implement those
+ * use cases neatly. However, we want to keep Mockito dependencies minimal. In Java8 we should be
+ * able to get rid of this class.
*/
-public class ListUtil {
+public final class ListUtil {
public static <T> LinkedList<T> filter(Collection<T> collection, Filter<T> filter) {
LinkedList<T> filtered = new LinkedList<T>();
@@ -26,9 +24,10 @@
return filtered;
}
- public static <From, To> LinkedList<To> convert(Collection<From> collection, Converter<From, To> converter) {
+ public static <FromT, To> LinkedList<To> convert(
+ Collection<FromT> collection, Converter<FromT, To> converter) {
LinkedList<To> converted = new LinkedList<To>();
- for (From f: collection) {
+ for (FromT f : collection) {
converted.add(converter.convert(f));
}
return converted;
@@ -38,7 +37,9 @@
boolean isOut(T object);
}
- public interface Converter<From, To> {
- To convert(From from);
+ public interface Converter<FromT, To> {
+ To convert(FromT from);
}
+
+ private ListUtil() {}
}
diff --git a/src/main/java/org/mockito/internal/util/collections/Sets.java b/src/main/java/org/mockito/internal/util/collections/Sets.java
index f1972e9..f42f76a 100644
--- a/src/main/java/org/mockito/internal/util/collections/Sets.java
+++ b/src/main/java/org/mockito/internal/util/collections/Sets.java
@@ -4,11 +4,11 @@
*/
package org.mockito.internal.util.collections;
+import static java.util.Arrays.asList;
+
import java.util.LinkedHashSet;
import java.util.Set;
-import static java.util.Arrays.asList;
-
public abstract class Sets {
public static Set<Object> newMockSafeHashSet(Iterable<Object> mocks) {
return HashCodeAndEqualsSafeSet.of(mocks);
@@ -18,9 +18,10 @@
return HashCodeAndEqualsSafeSet.of(mocks);
}
- public static <T> Set<T> newSet(T ... elements) {
+ public static <T> Set<T> newSet(T... elements) {
if (elements == null) {
- throw new IllegalArgumentException("Expected an array of elements (or empty array) but received a null.");
+ throw new IllegalArgumentException(
+ "Expected an array of elements (or empty array) but received a null.");
}
return new LinkedHashSet<T>(asList(elements));
}
diff --git a/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java b/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java
index 3768a03..9a81403 100644
--- a/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java
+++ b/src/main/java/org/mockito/internal/util/concurrent/DetachedThreadLocal.java
@@ -19,20 +19,22 @@
switch (cleaner) {
case THREAD:
case MANUAL:
- map = new WeakConcurrentMap<Thread, T>(cleaner == Cleaner.THREAD) {
- @Override
- protected T defaultValue(Thread key) {
- return DetachedThreadLocal.this.initialValue(key);
- }
- };
+ map =
+ new WeakConcurrentMap<Thread, T>(cleaner == Cleaner.THREAD) {
+ @Override
+ protected T defaultValue(Thread key) {
+ return DetachedThreadLocal.this.initialValue(key);
+ }
+ };
break;
case INLINE:
- map = new WeakConcurrentMap.WithInlinedExpunction<Thread, T>() {
- @Override
- protected T defaultValue(Thread key) {
- return DetachedThreadLocal.this.initialValue(key);
- }
- };
+ map =
+ new WeakConcurrentMap.WithInlinedExpunction<Thread, T>() {
+ @Override
+ protected T defaultValue(Thread key) {
+ return DetachedThreadLocal.this.initialValue(key);
+ }
+ };
break;
default:
throw new AssertionError();
@@ -43,6 +45,14 @@
return map.get(Thread.currentThread());
}
+ /**
+ * @param thread The thread for which to set a thread-local value.
+ * @return The value associated with this thread.
+ */
+ public T get(Thread thread) {
+ return map.get(thread);
+ }
+
public void set(T value) {
map.put(Thread.currentThread(), value);
}
@@ -84,15 +94,7 @@
/**
* @param thread The thread for which to set a thread-local value.
- * @return The value associated with this thread.
- */
- public T get(Thread thread) {
- return map.get(thread);
- }
-
- /**
- * @param thread The thread for which to set a thread-local value.
- * @param value The value to set.
+ * @param value The value to set.
*/
public void define(Thread thread, T value) {
map.put(thread, value);
@@ -133,6 +135,8 @@
* ({@link Cleaner#MANUAL}).
*/
public enum Cleaner {
- THREAD, INLINE, MANUAL
+ THREAD,
+ INLINE,
+ MANUAL
}
}
diff --git a/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java b/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
index 487d223..e25c41c 100644
--- a/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
+++ b/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java
@@ -22,7 +22,8 @@
* This class does not implement the {@link java.util.Map} interface because this implementation is incompatible
* with the map contract. While iterating over a map's entries, any key that has not passed iteration is referenced non-weakly.
*/
-public class WeakConcurrentMap<K, V> extends ReferenceQueue<K> implements Runnable, Iterable<Map.Entry<K, V>> {
+public class WeakConcurrentMap<K, V> extends ReferenceQueue<K>
+ implements Runnable, Iterable<Map.Entry<K, V>> {
private static final AtomicLong ID = new AtomicLong();
@@ -34,7 +35,7 @@
* @param cleanerThread {@code true} if a thread should be started that removes stale entries.
*/
public WeakConcurrentMap(boolean cleanerThread) {
- target = new ConcurrentHashMap<WeakKey<K>, V>();
+ target = new ConcurrentHashMap<>();
if (cleanerThread) {
thread = new Thread(this);
thread.setName("weak-ref-cleaner-" + ID.getAndIncrement());
@@ -52,7 +53,9 @@
*/
@SuppressWarnings("CollectionIncompatibleType")
public V get(K key) {
- if (key == null) throw new NullPointerException();
+ if (key == null) {
+ throw new NullPointerException();
+ }
V value = target.get(new LatentKey<K>(key));
if (value == null) {
value = defaultValue(key);
@@ -72,7 +75,9 @@
*/
@SuppressWarnings("CollectionIncompatibleType")
public boolean containsKey(K key) {
- if (key == null) throw new NullPointerException();
+ if (key == null) {
+ throw new NullPointerException();
+ }
return target.containsKey(new LatentKey<K>(key));
}
@@ -82,7 +87,9 @@
* @return The previous entry or {@code null} if it does not exist.
*/
public V put(K key, V value) {
- if (key == null || value == null) throw new NullPointerException();
+ if (key == null || value == null) {
+ throw new NullPointerException();
+ }
return target.put(new WeakKey<K>(key, this), value);
}
@@ -92,7 +99,9 @@
*/
@SuppressWarnings("CollectionIncompatibleType")
public V remove(K key) {
- if (key == null) throw new NullPointerException();
+ if (key == null) {
+ throw new NullPointerException();
+ }
return target.remove(new LatentKey<K>(key));
}
@@ -360,7 +369,9 @@
@Override
public V setValue(V value) {
- if (value == null) throw new NullPointerException();
+ if (value == null) {
+ throw new NullPointerException();
+ }
return entry.setValue(value);
}
}
diff --git a/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentSet.java b/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentSet.java
index 0f1cde6..d18dc3b 100644
--- a/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentSet.java
+++ b/src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentSet.java
@@ -21,11 +21,11 @@
public WeakConcurrentSet(Cleaner cleaner) {
switch (cleaner) {
case INLINE:
- target = new WeakConcurrentMap.WithInlinedExpunction<V, Boolean>();
+ target = new WeakConcurrentMap.WithInlinedExpunction<>();
break;
case THREAD:
case MANUAL:
- target = new WeakConcurrentMap<V, Boolean>(cleaner == Cleaner.THREAD);
+ target = new WeakConcurrentMap<>(cleaner == Cleaner.THREAD);
break;
default:
throw new AssertionError();
@@ -53,7 +53,7 @@
* @return {@code true} if the value is contained in the set.
*/
public boolean remove(V value) {
- return target.remove(value);
+ return target.remove(value) != null;
}
/**
@@ -84,7 +84,9 @@
* ({@link Cleaner#MANUAL}).
*/
public enum Cleaner {
- THREAD, INLINE, MANUAL
+ THREAD,
+ INLINE,
+ MANUAL
}
/**
diff --git a/src/main/java/org/mockito/internal/util/io/IOUtil.java b/src/main/java/org/mockito/internal/util/io/IOUtil.java
index 42bbfd9..1223cbe 100644
--- a/src/main/java/org/mockito/internal/util/io/IOUtil.java
+++ b/src/main/java/org/mockito/internal/util/io/IOUtil.java
@@ -4,17 +4,24 @@
*/
package org.mockito.internal.util.io;
-import org.mockito.exceptions.base.MockitoException;
-
-import java.io.*;
+import java.io.BufferedReader;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
+import org.mockito.exceptions.base.MockitoException;
/**
- * IO utils. A bit of reinventing the wheel but we don't want extra dependencies at this stage and we want to be java.
+ * IO utils. A bit of reinventing the wheel but we don't want extra dependencies at this stage and
+ * we want to be java.
*/
-public class IOUtil {
+public final class IOUtil {
/**
* Writes text to file
@@ -32,11 +39,11 @@
}
public static Collection<String> readLines(InputStream is) {
- List<String> out = new LinkedList<String>();
+ List<String> out = new LinkedList<>();
BufferedReader r = new BufferedReader(new InputStreamReader(is));
String line;
try {
- while((line = r.readLine()) != null) {
+ while ((line = r.readLine()) != null) {
out.add(line);
}
} catch (IOException e) {
@@ -54,7 +61,7 @@
try {
close(closeable);
} catch (MockitoException ignored) {
- //ignore, for backwards compatibility
+ // ignore, for backwards compatibility
}
}
@@ -72,4 +79,6 @@
}
}
}
+
+ private IOUtil() {}
}
diff --git a/src/main/java/org/mockito/internal/util/reflection/AccessibilityChanger.java b/src/main/java/org/mockito/internal/util/reflection/AccessibilityChanger.java
index f02acbe..9d1b756 100644
--- a/src/main/java/org/mockito/internal/util/reflection/AccessibilityChanger.java
+++ b/src/main/java/org/mockito/internal/util/reflection/AccessibilityChanger.java
@@ -6,7 +6,7 @@
import java.lang.reflect.AccessibleObject;
-public class AccessibilityChanger {
+class AccessibilityChanger {
private Boolean wasAccessible = null;
diff --git a/src/main/java/org/mockito/internal/util/reflection/BeanPropertySetter.java b/src/main/java/org/mockito/internal/util/reflection/BeanPropertySetter.java
index 9ef9481..d904f62 100644
--- a/src/main/java/org/mockito/internal/util/reflection/BeanPropertySetter.java
+++ b/src/main/java/org/mockito/internal/util/reflection/BeanPropertySetter.java
@@ -4,6 +4,9 @@
*/
package org.mockito.internal.util.reflection;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.MemberAccessor;
+
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
@@ -26,7 +29,8 @@
* @param propertyField The field that should be accessed with the setter
* @param reportNoSetterFound Allow the set method to raise an Exception if the setter cannot be found
*/
- public BeanPropertySetter(final Object target, final Field propertyField, boolean reportNoSetterFound) {
+ public BeanPropertySetter(
+ final Object target, final Field propertyField, boolean reportNoSetterFound) {
this.field = propertyField;
this.target = target;
this.reportNoSetterFound = reportNoSetterFound;
@@ -50,24 +54,36 @@
*/
public boolean set(final Object value) {
- AccessibilityChanger changer = new AccessibilityChanger();
+ MemberAccessor accessor = Plugins.getMemberAccessor();
Method writeMethod = null;
try {
writeMethod = target.getClass().getMethod(setterName(field.getName()), field.getType());
-
- changer.enableAccess(writeMethod);
- writeMethod.invoke(target, value);
+ accessor.invoke(writeMethod, target, value);
return true;
} catch (InvocationTargetException e) {
- throw new RuntimeException("Setter '" + writeMethod + "' of '" + target + "' with value '" + value + "' threw exception : '" + e.getTargetException() + "'", e);
+ throw new RuntimeException(
+ "Setter '"
+ + writeMethod
+ + "' of '"
+ + target
+ + "' with value '"
+ + value
+ + "' threw exception : '"
+ + e.getTargetException()
+ + "'",
+ e);
} catch (IllegalAccessException e) {
- throw new RuntimeException("Access not authorized on field '" + field + "' of object '" + target + "' with value: '" + value + "'", e);
+ throw new RuntimeException(
+ "Access not authorized on field '"
+ + field
+ + "' of object '"
+ + target
+ + "' with value: '"
+ + value
+ + "'",
+ e);
} catch (NoSuchMethodException e) {
reportNoSetterFound();
- } finally {
- if(writeMethod != null) {
- changer.safelyDisableAccess(writeMethod);
- }
}
reportNoSetterFound();
@@ -85,14 +101,18 @@
private String setterName(String fieldName) {
return new StringBuilder(SET_PREFIX)
.append(fieldName.substring(0, 1).toUpperCase(Locale.ENGLISH))
- .append(fieldName.substring(1))
+ .append(fieldName, 1, fieldName.length())
.toString();
}
private void reportNoSetterFound() {
- if(reportNoSetterFound) {
- throw new RuntimeException("Problems setting value on object: [" + target + "] for property : [" + field.getName() + "], setter not found");
+ if (reportNoSetterFound) {
+ throw new RuntimeException(
+ "Problems setting value on object: ["
+ + target
+ + "] for property : ["
+ + field.getName()
+ + "], setter not found");
}
}
-
}
diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldCopier.java b/src/main/java/org/mockito/internal/util/reflection/FieldCopier.java
deleted file mode 100644
index 67f7203..0000000
--- a/src/main/java/org/mockito/internal/util/reflection/FieldCopier.java
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-package org.mockito.internal.util.reflection;
-
-import java.lang.reflect.Field;
-
-public class FieldCopier {
-
- public <T> void copyValue(T from, T to, Field field) throws IllegalAccessException {
- Object value = field.get(from);
- field.set(to, value);
- }
-}
diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java b/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java
index 8d04765..13d9c5d 100644
--- a/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java
+++ b/src/main/java/org/mockito/internal/util/reflection/FieldInitializationReport.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.util.reflection;
/**
@@ -13,7 +12,10 @@
private final boolean wasInitialized;
private final boolean wasInitializedUsingConstructorArgs;
- public FieldInitializationReport(Object fieldInstance, boolean wasInitialized, boolean wasInitializedUsingConstructorArgs) {
+ public FieldInitializationReport(
+ Object fieldInstance,
+ boolean wasInitialized,
+ boolean wasInitializedUsingConstructorArgs) {
this.fieldInstance = fieldInstance;
this.wasInitialized = wasInitialized;
this.wasInitializedUsingConstructorArgs = wasInitializedUsingConstructorArgs;
@@ -55,4 +57,3 @@
return fieldInstance != null ? fieldInstance.getClass() : null;
}
}
-
diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java b/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java
index 609b30e..3f104d1 100644
--- a/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java
+++ b/src/main/java/org/mockito/internal/util/reflection/FieldInitializer.java
@@ -5,10 +5,9 @@
package org.mockito.internal.util.reflection;
import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.util.MockUtil;
-
-import static java.lang.reflect.Modifier.isStatic;
-import static org.mockito.internal.util.reflection.FieldSetter.setField;
+import org.mockito.plugins.MemberAccessor;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
@@ -19,6 +18,8 @@
import java.util.Comparator;
import java.util.List;
+import static java.lang.reflect.Modifier.isStatic;
+
/**
* Initialize a field with type instance if a default constructor can be found.
*
@@ -34,7 +35,6 @@
private final Field field;
private final ConstructorInstantiator instantiator;
-
/**
* Prepare initializer with the given field on the given instance.
*
@@ -60,18 +60,21 @@
* @param field Field to be initialize.
* @param argResolver Constructor parameters resolver
*/
- public FieldInitializer(Object fieldOwner, Field field, ConstructorArgumentResolver argResolver) {
- this(fieldOwner, field, new ParameterizedConstructorInstantiator(fieldOwner, field, argResolver));
+ public FieldInitializer(
+ Object fieldOwner, Field field, ConstructorArgumentResolver argResolver) {
+ this(
+ fieldOwner,
+ field,
+ new ParameterizedConstructorInstantiator(fieldOwner, field, argResolver));
}
private FieldInitializer(Object fieldOwner, Field field, ConstructorInstantiator instantiator) {
- if(new FieldReader(fieldOwner, field).isNull()) {
+ if (new FieldReader(fieldOwner, field).isNull()) {
checkNotLocal(field);
checkNotInner(field);
checkNotInterface(field);
checkNotEnum(field);
checkNotAbstract(field);
-
}
this.fieldOwner = fieldOwner;
this.field = field;
@@ -84,53 +87,59 @@
* @return Actual field instance.
*/
public FieldInitializationReport initialize() {
- final AccessibilityChanger changer = new AccessibilityChanger();
- changer.enableAccess(field);
-
try {
return acquireFieldInstance();
- } catch(IllegalAccessException e) {
- throw new MockitoException("Problems initializing field '" + field.getName() + "' of type '" + field.getType().getSimpleName() + "'", e);
- } finally {
- changer.safelyDisableAccess(field);
+ } catch (IllegalAccessException e) {
+ throw new MockitoException(
+ "Problems initializing field '"
+ + field.getName()
+ + "' of type '"
+ + field.getType().getSimpleName()
+ + "'",
+ e);
}
}
private void checkNotLocal(Field field) {
- if(field.getType().isLocalClass()) {
- throw new MockitoException("the type '" + field.getType().getSimpleName() + "' is a local class.");
+ if (field.getType().isLocalClass()) {
+ throw new MockitoException(
+ "the type '" + field.getType().getSimpleName() + "' is a local class.");
}
}
private void checkNotInner(Field field) {
Class<?> type = field.getType();
- if(type.isMemberClass() && !isStatic(type.getModifiers())) {
- throw new MockitoException("the type '" + type.getSimpleName() + "' is an inner non static class.");
+ if (type.isMemberClass() && !isStatic(type.getModifiers())) {
+ throw new MockitoException(
+ "the type '" + type.getSimpleName() + "' is an inner non static class.");
}
}
private void checkNotInterface(Field field) {
- if(field.getType().isInterface()) {
- throw new MockitoException("the type '" + field.getType().getSimpleName() + "' is an interface.");
+ if (field.getType().isInterface()) {
+ throw new MockitoException(
+ "the type '" + field.getType().getSimpleName() + "' is an interface.");
}
}
private void checkNotAbstract(Field field) {
- if(Modifier.isAbstract(field.getType().getModifiers())) {
- throw new MockitoException("the type '" + field.getType().getSimpleName() + "' is an abstract class.");
+ if (Modifier.isAbstract(field.getType().getModifiers())) {
+ throw new MockitoException(
+ "the type '" + field.getType().getSimpleName() + "' is an abstract class.");
}
}
private void checkNotEnum(Field field) {
- if(field.getType().isEnum()) {
- throw new MockitoException("the type '" + field.getType().getSimpleName() + "' is an enum.");
+ if (field.getType().isEnum()) {
+ throw new MockitoException(
+ "the type '" + field.getType().getSimpleName() + "' is an enum.");
}
}
-
private FieldInitializationReport acquireFieldInstance() throws IllegalAccessException {
- Object fieldInstance = field.get(fieldOwner);
- if(fieldInstance != null) {
+ final MemberAccessor accessor = Plugins.getMemberAccessor();
+ Object fieldInstance = accessor.get(field, fieldOwner);
+ if (fieldInstance != null) {
return new FieldInitializationReport(fieldInstance, false, false);
}
@@ -184,30 +193,36 @@
this.field = field;
}
+ @Override
public FieldInitializationReport instantiate() {
- final AccessibilityChanger changer = new AccessibilityChanger();
- Constructor<?> constructor = null;
+ final MemberAccessor invoker = Plugins.getMemberAccessor();
try {
- constructor = field.getType().getDeclaredConstructor();
- changer.enableAccess(constructor);
+ Constructor<?> constructor = field.getType().getDeclaredConstructor();
final Object[] noArg = new Object[0];
- Object newFieldInstance = constructor.newInstance(noArg);
- setField(testClass, field,newFieldInstance);
+ Object newFieldInstance = invoker.newInstance(constructor, noArg);
+ invoker.set(field, testClass, newFieldInstance);
- return new FieldInitializationReport(field.get(testClass), true, false);
+ return new FieldInitializationReport(invoker.get(field, testClass), true, false);
} catch (NoSuchMethodException e) {
- throw new MockitoException("the type '" + field.getType().getSimpleName() + "' has no default constructor", e);
+ throw new MockitoException(
+ "the type '"
+ + field.getType().getSimpleName()
+ + "' has no default constructor",
+ e);
} catch (InvocationTargetException e) {
- throw new MockitoException("the default constructor of type '" + field.getType().getSimpleName() + "' has raised an exception (see the stack trace for cause): " + e.getTargetException().toString(), e);
+ throw new MockitoException(
+ "the default constructor of type '"
+ + field.getType().getSimpleName()
+ + "' has raised an exception (see the stack trace for cause): "
+ + e.getTargetException(),
+ e);
} catch (InstantiationException e) {
- throw new MockitoException("InstantiationException (see the stack trace for cause): " + e.toString(), e);
+ throw new MockitoException(
+ "InstantiationException (see the stack trace for cause): " + e, e);
} catch (IllegalAccessException e) {
- throw new MockitoException("IllegalAccessException (see the stack trace for cause): " + e.toString(), e);
- } finally {
- if(constructor != null) {
- changer.safelyDisableAccess(constructor);
- }
+ throw new MockitoException(
+ "IllegalAccessException (see the stack trace for cause): " + e, e);
}
}
}
@@ -226,73 +241,90 @@
private final Object testClass;
private final Field field;
private final ConstructorArgumentResolver argResolver;
- private final Comparator<Constructor<?>> byParameterNumber = new Comparator<Constructor<?>>() {
- public int compare(Constructor<?> constructorA, Constructor<?> constructorB) {
- int argLengths = constructorB.getParameterTypes().length - constructorA.getParameterTypes().length;
- if (argLengths == 0) {
- int constructorAMockableParamsSize = countMockableParams(constructorA);
- int constructorBMockableParamsSize = countMockableParams(constructorB);
- return constructorBMockableParamsSize - constructorAMockableParamsSize;
- }
- return argLengths;
- }
-
- private int countMockableParams(Constructor<?> constructor) {
- int constructorMockableParamsSize = 0;
- for (Class<?> aClass : constructor.getParameterTypes()) {
- if(MockUtil.typeMockabilityOf(aClass).mockable()){
- constructorMockableParamsSize++;
+ private final Comparator<Constructor<?>> byParameterNumber =
+ new Comparator<Constructor<?>>() {
+ @Override
+ public int compare(Constructor<?> constructorA, Constructor<?> constructorB) {
+ int argLengths =
+ constructorB.getParameterTypes().length
+ - constructorA.getParameterTypes().length;
+ if (argLengths == 0) {
+ int constructorAMockableParamsSize = countMockableParams(constructorA);
+ int constructorBMockableParamsSize = countMockableParams(constructorB);
+ return constructorBMockableParamsSize - constructorAMockableParamsSize;
+ }
+ return argLengths;
}
- }
- return constructorMockableParamsSize;
- }
- };
+
+ private int countMockableParams(Constructor<?> constructor) {
+ int constructorMockableParamsSize = 0;
+ for (Class<?> aClass : constructor.getParameterTypes()) {
+ if (MockUtil.typeMockabilityOf(aClass).mockable()) {
+ constructorMockableParamsSize++;
+ }
+ }
+ return constructorMockableParamsSize;
+ }
+ };
/**
* Internal, checks are done by FieldInitializer.
* Fields are assumed to be accessible.
*/
- ParameterizedConstructorInstantiator(Object testClass, Field field, ConstructorArgumentResolver argumentResolver) {
+ ParameterizedConstructorInstantiator(
+ Object testClass, Field field, ConstructorArgumentResolver argumentResolver) {
this.testClass = testClass;
this.field = field;
this.argResolver = argumentResolver;
}
+ @Override
public FieldInitializationReport instantiate() {
- final AccessibilityChanger changer = new AccessibilityChanger();
- Constructor<?> constructor = null;
+ final MemberAccessor accessor = Plugins.getMemberAccessor();
+ Constructor<?> constructor = biggestConstructor(field.getType());
+ final Object[] args = argResolver.resolveTypeInstances(constructor.getParameterTypes());
try {
- constructor = biggestConstructor(field.getType());
- changer.enableAccess(constructor);
+ Object newFieldInstance = accessor.newInstance(constructor, args);
+ accessor.set(field, testClass, newFieldInstance);
- final Object[] args = argResolver.resolveTypeInstances(constructor.getParameterTypes());
- Object newFieldInstance = constructor.newInstance(args);
- setField(testClass, field,newFieldInstance);
-
- return new FieldInitializationReport(field.get(testClass), false, true);
+ return new FieldInitializationReport(accessor.get(field, testClass), false, true);
} catch (IllegalArgumentException e) {
- throw new MockitoException("internal error : argResolver provided incorrect types for constructor " + constructor + " of type " + field.getType().getSimpleName(), e);
+ throw new MockitoException(
+ "internal error : argResolver provided incorrect types for constructor "
+ + constructor
+ + " of type "
+ + field.getType().getSimpleName(),
+ e);
} catch (InvocationTargetException e) {
- throw new MockitoException("the constructor of type '" + field.getType().getSimpleName() + "' has raised an exception (see the stack trace for cause): " + e.getTargetException().toString(), e);
+ throw new MockitoException(
+ "the constructor of type '"
+ + field.getType().getSimpleName()
+ + "' has raised an exception (see the stack trace for cause): "
+ + e.getTargetException(),
+ e);
} catch (InstantiationException e) {
- throw new MockitoException("InstantiationException (see the stack trace for cause): " + e.toString(), e);
+ throw new MockitoException(
+ "InstantiationException (see the stack trace for cause): " + e, e);
} catch (IllegalAccessException e) {
- throw new MockitoException("IllegalAccessException (see the stack trace for cause): " + e.toString(), e);
- } finally {
- if(constructor != null) {
- changer.safelyDisableAccess(constructor);
- }
+ throw new MockitoException(
+ "IllegalAccessException (see the stack trace for cause): " + e, e);
}
}
private void checkParameterized(Constructor<?> constructor, Field field) {
- if(constructor.getParameterTypes().length == 0) {
- throw new MockitoException("the field " + field.getName() + " of type " + field.getType() + " has no parameterized constructor");
+ if (constructor.getParameterTypes().length == 0) {
+ throw new MockitoException(
+ "the field "
+ + field.getName()
+ + " of type "
+ + field.getType()
+ + " has no parameterized constructor");
}
}
private Constructor<?> biggestConstructor(Class<?> clazz) {
- final List<? extends Constructor<?>> constructors = Arrays.asList(clazz.getDeclaredConstructors());
+ final List<? extends Constructor<?>> constructors =
+ Arrays.asList(clazz.getDeclaredConstructors());
Collections.sort(constructors, byParameterNumber);
Constructor<?> constructor = constructors.get(0);
diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldReader.java b/src/main/java/org/mockito/internal/util/reflection/FieldReader.java
index 1cae117..6c3c120 100644
--- a/src/main/java/org/mockito/internal/util/reflection/FieldReader.java
+++ b/src/main/java/org/mockito/internal/util/reflection/FieldReader.java
@@ -4,31 +4,33 @@
*/
package org.mockito.internal.util.reflection;
-import org.mockito.exceptions.base.MockitoException;
-
import java.lang.reflect.Field;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.MemberAccessor;
+
public class FieldReader {
final Object target;
final Field field;
- final AccessibilityChanger changer = new AccessibilityChanger();
+ final MemberAccessor accessor = Plugins.getMemberAccessor();
public FieldReader(Object target, Field field) {
this.target = target;
this.field = field;
- changer.enableAccess(field);
}
public boolean isNull() {
- return read() == null;
+ return read() == null;
}
public Object read() {
try {
- return field.get(target);
+ return accessor.get(field, target);
} catch (Exception e) {
- throw new MockitoException("Cannot read state from field: " + field + ", on instance: " + target);
+ throw new MockitoException(
+ "Cannot read state from field: " + field + ", on instance: " + target, e);
}
}
}
diff --git a/src/main/java/org/mockito/internal/util/reflection/FieldSetter.java b/src/main/java/org/mockito/internal/util/reflection/FieldSetter.java
index 69b5b16..35b1210 100644
--- a/src/main/java/org/mockito/internal/util/reflection/FieldSetter.java
+++ b/src/main/java/org/mockito/internal/util/reflection/FieldSetter.java
@@ -6,10 +6,14 @@
import java.lang.reflect.Field;
+/** Do not use. To be removed after last usage is gone. */
+@Deprecated
public class FieldSetter {
private FieldSetter(){}
+ /** Do not use. To be removed after last usage is gone. */
+ @Deprecated
public static void setField(Object target, Field field,Object value) {
AccessibilityChanger changer = new AccessibilityChanger();
changer.enableAccess(field);
diff --git a/src/main/java/org/mockito/internal/util/reflection/Fields.java b/src/main/java/org/mockito/internal/util/reflection/Fields.java
index 1d1befe..f749649 100644
--- a/src/main/java/org/mockito/internal/util/reflection/Fields.java
+++ b/src/main/java/org/mockito/internal/util/reflection/Fields.java
@@ -4,15 +4,15 @@
*/
package org.mockito.internal.util.reflection;
-import org.mockito.internal.util.Checks;
-import org.mockito.internal.util.collections.ListUtil;
-import org.mockito.internal.util.collections.ListUtil.Filter;
-
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
+import org.mockito.internal.util.Checks;
+import org.mockito.internal.util.collections.ListUtil;
+import org.mockito.internal.util.collections.ListUtil.Filter;
+
/**
* Small fluent reflection tools to work with fields.
*
@@ -27,8 +27,10 @@
* @return InstanceFields of this object instance.
*/
public static InstanceFields allDeclaredFieldsOf(Object instance) {
- List<InstanceField> instanceFields = new ArrayList<InstanceField>();
- for (Class<?> clazz = instance.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()) {
+ List<InstanceField> instanceFields = new ArrayList<>();
+ for (Class<?> clazz = instance.getClass();
+ clazz != Object.class;
+ clazz = clazz.getSuperclass()) {
instanceFields.addAll(instanceFieldsIn(instance, clazz.getDeclaredFields()));
}
return new InstanceFields(instance, instanceFields);
@@ -41,13 +43,13 @@
* @return InstanceFields of this object instance.
*/
public static InstanceFields declaredFieldsOf(Object instance) {
- List<InstanceField> instanceFields = new ArrayList<InstanceField>();
+ List<InstanceField> instanceFields = new ArrayList<>();
instanceFields.addAll(instanceFieldsIn(instance, instance.getClass().getDeclaredFields()));
return new InstanceFields(instance, instanceFields);
}
private static List<InstanceField> instanceFieldsIn(Object instance, Field[] fields) {
- List<InstanceField> instanceDeclaredFields = new ArrayList<InstanceField>();
+ List<InstanceField> instanceDeclaredFields = new ArrayList<>();
for (Field field : fields) {
InstanceField instanceField = new InstanceField(field, instance);
instanceDeclaredFields.add(instanceField);
@@ -62,13 +64,15 @@
* @return The filter.
*/
@SuppressWarnings({"unchecked", "vararg"})
- public static Filter<InstanceField> annotatedBy(final Class<? extends Annotation>... annotations) {
+ public static Filter<InstanceField> annotatedBy(
+ final Class<? extends Annotation>... annotations) {
return new Filter<InstanceField>() {
+ @Override
public boolean isOut(InstanceField instanceField) {
Checks.checkNotNull(annotations, "Provide at least one annotation class");
for (Class<? extends Annotation> annotation : annotations) {
- if(instanceField.isAnnotatedBy(annotation)) {
+ if (instanceField.isAnnotatedBy(annotation)) {
return false;
}
}
@@ -84,6 +88,7 @@
*/
private static Filter<InstanceField> nullField() {
return new Filter<InstanceField>() {
+ @Override
public boolean isOut(InstanceField instanceField) {
return instanceField.isNull();
}
@@ -97,6 +102,7 @@
*/
public static Filter<InstanceField> syntheticField() {
return new Filter<InstanceField>() {
+ @Override
public boolean isOut(InstanceField instanceField) {
return instanceField.isSynthetic();
}
@@ -122,11 +128,11 @@
}
public List<InstanceField> instanceFields() {
- return new ArrayList<InstanceField>(instanceFields);
+ return new ArrayList<>(instanceFields);
}
public List<Object> assignedValues() {
- List<Object> values = new ArrayList<Object>(instanceFields.size());
+ List<Object> values = new ArrayList<>(instanceFields.size());
for (InstanceField instanceField : instanceFields) {
values.add(instanceField.read());
}
@@ -134,7 +140,7 @@
}
public List<String> names() {
- List<String> fieldNames = new ArrayList<String>(instanceFields.size());
+ List<String> fieldNames = new ArrayList<>(instanceFields.size());
for (InstanceField instanceField : instanceFields) {
fieldNames.add(instanceField.name());
}
diff --git a/src/main/java/org/mockito/internal/util/reflection/GenericMaster.java b/src/main/java/org/mockito/internal/util/reflection/GenericMaster.java
index a477ba4..be3db7f 100644
--- a/src/main/java/org/mockito/internal/util/reflection/GenericMaster.java
+++ b/src/main/java/org/mockito/internal/util/reflection/GenericMaster.java
@@ -22,12 +22,11 @@
if (actual instanceof Class) {
return (Class<?>) actual;
} else if (actual instanceof ParameterizedType) {
- //in case of nested generics we don't go deep
+ // in case of nested generics we don't go deep
return (Class<?>) ((ParameterizedType) actual).getRawType();
}
}
return Object.class;
}
-
}
diff --git a/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java b/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java
index 8efd384..c7edd9c 100644
--- a/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java
+++ b/src/main/java/org/mockito/internal/util/reflection/GenericMetadataSupport.java
@@ -4,33 +4,45 @@
*/
package org.mockito.internal.util.reflection;
-
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.util.Checks;
-import java.lang.reflect.*;
-import java.util.*;
-
-
/**
* This class can retrieve generic meta-data that the compiler stores on classes
* and accessible members.
*
* <p>
- * The main idea of this code is to create a Map that will help to resolve return types.
- * In order to actually work with nested generics, this map will have to be passed along new instances
- * as a type context.
+ * The main idea of this code is to create a Map that will help to resolve return types.
+ * In order to actually work with nested generics, this map will have to be passed along new instances
+ * as a type context.
* </p>
*
* <p>
- * Hence :
- * <ul>
- * <li>A new instance representing the metadata is created using the {@link #inferFrom(Type)} method from a real
- * <code>Class</code> or from a <code>ParameterizedType</code>, other types are not yet supported.</li>
+ * Hence :
+ * <ul>
+ * <li>A new instance representing the metadata is created using the {@link #inferFrom(Type)} method from a real
+ * <code>Class</code> or from a <code>ParameterizedType</code>, other types are not yet supported.</li>
*
- * <li>Then from this metadata, we can extract meta-data for a generic return type of a method, using
- * {@link #resolveGenericReturnType(Method)}.</li>
- * </ul>
+ * <li>Then from this metadata, we can extract meta-data for a generic return type of a method, using
+ * {@link #resolveGenericReturnType(Method)}.</li>
+ * </ul>
* </p>
*
* <p>
@@ -57,10 +69,8 @@
// public static MockitoLogger logger = new ConsoleMockitoLogger();
- /**
- * Represents actual type variables resolved for current class.
- */
- protected Map<TypeVariable<?>, Type> contextualActualTypeParameters = new HashMap<TypeVariable<?>, Type>();
+ /** Represents actual type variables resolved for current class. */
+ protected Map<TypeVariable<?>, Type> contextualActualTypeParameters = new HashMap<>();
/**
* Registers the type variables for the given type and all of its superclasses and superinterfaces.
@@ -81,7 +91,7 @@
Class<?> rawType = extractRawTypeOf(typeToRegister);
typesToRegister.add(rawType.getGenericSuperclass());
- typesToRegister.addAll(Arrays.asList(rawType.getGenericInterfaces()));
+ Collections.addAll(typesToRegister, rawType.getGenericInterfaces());
}
}
@@ -97,8 +107,9 @@
}
if (type instanceof TypeVariable) {
/*
- * If type is a TypeVariable, then it is needed to gather data elsewhere. Usually TypeVariables are declared
- * on the class definition, such as such as List<E>.
+ * If type is a TypeVariable, then it is needed to gather data elsewhere.
+ * Usually TypeVariables are declared on the class definition, such as such
+ * as List<E>.
*/
return extractRawTypeOf(contextualActualTypeParameters.get(type));
}
@@ -110,18 +121,41 @@
return;
}
ParameterizedType parameterizedType = (ParameterizedType) classType;
- TypeVariable<?>[] typeParameters = ((Class<?>) parameterizedType.getRawType()).getTypeParameters();
+ TypeVariable<?>[] typeParameters =
+ ((Class<?>) parameterizedType.getRawType()).getTypeParameters();
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
for (int i = 0; i < actualTypeArguments.length; i++) {
TypeVariable<?> typeParameter = typeParameters[i];
Type actualTypeArgument = actualTypeArguments[i];
+ if (actualTypeArgument instanceof TypeVariable) {
+ /*
+ * If actualTypeArgument is a TypeVariable, and it is not present in
+ * the context map then it is needed to try harder to gather more data
+ * from the type argument itself. In some case the type argument do
+ * define upper bounds, this allow to look for them if not in the
+ * context map.
+ */
+ registerTypeVariableIfNotPresent((TypeVariable<?>) actualTypeArgument);
+
+ // Prevent registration of a cycle of TypeVariables. This can happen when we are
+ // processing
+ // type parameters in a Method, while we already processed the type parameters of a
+ // class.
+ if (contextualActualTypeParameters.containsKey(typeParameter)) {
+ continue;
+ }
+ }
+
if (actualTypeArgument instanceof WildcardType) {
- contextualActualTypeParameters.put(typeParameter, boundsOf((WildcardType) actualTypeArgument));
+ contextualActualTypeParameters.put(
+ typeParameter, boundsOf((WildcardType) actualTypeArgument));
} else if (typeParameter != actualTypeArgument) {
contextualActualTypeParameters.put(typeParameter, actualTypeArgument);
}
- // logger.log("For '" + parameterizedType + "' found type variable : { '" + typeParameter + "(" + System.identityHashCode(typeParameter) + ")" + "' : '" + actualTypeArgument + "(" + System.identityHashCode(typeParameter) + ")" + "' }");
+ // logger.log("For '" + parameterizedType + "' found type variable : { '" +
+ // typeParameter + "(" + System.identityHashCode(typeParameter) + ")" + "' : '" +
+ // actualTypeArgument + "(" + System.identityHashCode(typeParameter) + ")" + "' }");
}
}
@@ -134,14 +168,16 @@
private void registerTypeVariableIfNotPresent(TypeVariable<?> typeVariable) {
if (!contextualActualTypeParameters.containsKey(typeVariable)) {
contextualActualTypeParameters.put(typeVariable, boundsOf(typeVariable));
- // logger.log("For '" + typeVariable.getGenericDeclaration() + "' found type variable : { '" + typeVariable + "(" + System.identityHashCode(typeVariable) + ")" + "' : '" + boundsOf(typeVariable) + "' }");
+ // logger.log("For '" + typeVariable.getGenericDeclaration() + "' found type variable :
+ // { '" + typeVariable + "(" + System.identityHashCode(typeVariable) + ")" + "' : '" +
+ // boundsOf(typeVariable) + "' }");
}
}
/**
* @param typeParameter The TypeVariable parameter
* @return A {@link BoundedType} for easy bound information, if first bound is a TypeVariable
- * then retrieve BoundedType of this TypeVariable
+ * then retrieve BoundedType of this TypeVariable
*/
private BoundedType boundsOf(TypeVariable<?> typeParameter) {
if (typeParameter.getBounds()[0] instanceof TypeVariable) {
@@ -153,13 +189,17 @@
/**
* @param wildCard The WildCard type
* @return A {@link BoundedType} for easy bound information, if first bound is a TypeVariable
- * then retrieve BoundedType of this TypeVariable
+ * then retrieve BoundedType of this TypeVariable
*/
private BoundedType boundsOf(WildcardType wildCard) {
/*
- * According to JLS(http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.5.1):
- * - Lower and upper can't coexist: (for instance, this is not allowed: <? extends List<String> & super MyInterface>)
- * - Multiple bounds are not supported (for instance, this is not allowed: <? extends List<String> & MyInterface>)
+ * According to JLS(https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1):
+ * - Lower and upper can't coexist: (for instance, this is not allowed:
+ * <? extends List<String> & super MyInterface>)
+ * - Multiple concrete type bounds are not supported (for instance, this is not allowed:
+ * <? extends ArrayList<String> & MyInterface>)
+ * But the following form is possible where there is a single concrete tyep bound followed by interface type bounds
+ * <T extends List<String> & Comparable>
*/
WildCardBoundedType wildCardBoundedType = new WildCardBoundedType(wildCard);
@@ -201,14 +241,16 @@
*/
public Map<TypeVariable<?>, Type> actualTypeArguments() {
TypeVariable<?>[] typeParameters = rawType().getTypeParameters();
- LinkedHashMap<TypeVariable<?>, Type> actualTypeArguments = new LinkedHashMap<TypeVariable<?>, Type>();
+ LinkedHashMap<TypeVariable<?>, Type> actualTypeArguments = new LinkedHashMap<>();
for (TypeVariable<?> typeParameter : typeParameters) {
Type actualType = getActualTypeArgumentFor(typeParameter);
actualTypeArguments.put(typeParameter, actualType);
- // logger.log("For '" + rawType().getCanonicalName() + "' returning explicit TypeVariable : { '" + typeParameter + "(" + System.identityHashCode(typeParameter) + ")" + "' : '" + actualType +"' }");
+ // logger.log("For '" + rawType().getCanonicalName() + "' returning explicit
+ // TypeVariable : { '" + typeParameter + "(" + System.identityHashCode(typeParameter) +
+ // ")" + "' : '" + actualType +"' }");
}
return actualTypeArguments;
@@ -232,15 +274,18 @@
*/
public GenericMetadataSupport resolveGenericReturnType(Method method) {
Type genericReturnType = method.getGenericReturnType();
- // logger.log("Method '" + method.toGenericString() + "' has return type : " + genericReturnType.getClass().getInterfaces()[0].getSimpleName() + " : " + genericReturnType);
+ // logger.log("Method '" + method.toGenericString() + "' has return type : " +
+ // genericReturnType.getClass().getInterfaces()[0].getSimpleName() + " : " +
+ // genericReturnType);
int arity = 0;
- while(genericReturnType instanceof GenericArrayType) {
+ while (genericReturnType instanceof GenericArrayType) {
arity++;
genericReturnType = ((GenericArrayType) genericReturnType).getGenericComponentType();
}
- GenericMetadataSupport genericMetadataSupport = resolveGenericType(genericReturnType, method);
+ GenericMetadataSupport genericMetadataSupport =
+ resolveGenericType(genericReturnType, method);
if (arity == 0) {
return genericMetadataSupport;
} else {
@@ -254,21 +299,29 @@
return new NotGenericReturnTypeSupport(this, type);
}
if (type instanceof ParameterizedType) {
- return new ParameterizedReturnType(this, method.getTypeParameters(), (ParameterizedType) type);
+ return new ParameterizedReturnType(
+ this, method.getTypeParameters(), (ParameterizedType) type);
}
if (type instanceof TypeVariable) {
- return new TypeVariableReturnType(this, method.getTypeParameters(), (TypeVariable<?>) type);
+ return new TypeVariableReturnType(
+ this, method.getTypeParameters(), (TypeVariable<?>) type);
}
- throw new MockitoException("Ouch, it shouldn't happen, type '" + type.getClass().getCanonicalName() + "' on method : '" + method.toGenericString() + "' is not supported : " + type);
+ throw new MockitoException(
+ "Ouch, it shouldn't happen, type '"
+ + type.getClass().getCanonicalName()
+ + "' on method : '"
+ + method.toGenericString()
+ + "' is not supported : "
+ + type);
}
/**
* Create an new instance of {@link GenericMetadataSupport} inferred from a {@link Type}.
*
* <p>
- * At the moment <code>type</code> can only be a {@link Class} or a {@link ParameterizedType}, otherwise
- * it'll throw a {@link MockitoException}.
+ * At the moment <code>type</code> can only be a {@link Class} or a {@link ParameterizedType}, otherwise
+ * it'll throw a {@link MockitoException}.
* </p>
*
* @param type The class from which the {@link GenericMetadataSupport} should be built.
@@ -284,17 +337,21 @@
return new FromParameterizedTypeGenericMetadataSupport((ParameterizedType) type);
}
- throw new MockitoException("Type meta-data for this Type (" + type.getClass().getCanonicalName() + ") is not supported : " + type);
+ throw new MockitoException(
+ "Type meta-data for this Type ("
+ + type.getClass().getCanonicalName()
+ + ") is not supported : "
+ + type);
}
-
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- //// Below are specializations of GenericMetadataSupport that could handle retrieval of possible Types
+ //// Below are specializations of GenericMetadataSupport that could handle retrieval of possible
+ // Types
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Generic metadata implementation for {@link Class}.
- *
+ * <p>
* Offer support to retrieve generic metadata on a {@link Class} by reading type parameters and type variables on
* the class and its ancestors and interfaces.
*/
@@ -316,16 +373,17 @@
/**
* Generic metadata implementation for "standalone" {@link ParameterizedType}.
- *
+ * <p>
* Offer support to retrieve generic metadata on a {@link ParameterizedType} by reading type variables of
* the related raw type and declared type variable of this parameterized type.
- *
+ * <p>
* This class is not designed to work on ParameterizedType returned by {@link Method#getGenericReturnType()}, as
* the ParameterizedType instance return in these cases could have Type Variables that refer to type declaration(s).
* That's what meant the "standalone" word at the beginning of the Javadoc.
* Instead use {@link ParameterizedReturnType}.
*/
- private static class FromParameterizedTypeGenericMetadataSupport extends GenericMetadataSupport {
+ private static class FromParameterizedTypeGenericMetadataSupport
+ extends GenericMetadataSupport {
private final ParameterizedType parameterizedType;
public FromParameterizedTypeGenericMetadataSupport(ParameterizedType parameterizedType) {
@@ -350,7 +408,10 @@
private final ParameterizedType parameterizedType;
private final TypeVariable<?>[] typeParameters;
- public ParameterizedReturnType(GenericMetadataSupport source, TypeVariable<?>[] typeParameters, ParameterizedType parameterizedType) {
+ public ParameterizedReturnType(
+ GenericMetadataSupport source,
+ TypeVariable<?>[] typeParameters,
+ ParameterizedType parameterizedType) {
this.parameterizedType = parameterizedType;
this.typeParameters = typeParameters;
this.contextualActualTypeParameters = source.contextualActualTypeParameters;
@@ -371,7 +432,6 @@
public Class<?> rawType() {
return (Class<?>) parameterizedType.getRawType();
}
-
}
/**
@@ -381,8 +441,12 @@
private final TypeVariable<?> typeVariable;
private final TypeVariable<?>[] typeParameters;
private Class<?> rawType;
+ private List<Type> extraInterfaces;
- public TypeVariableReturnType(GenericMetadataSupport source, TypeVariable<?>[] typeParameters, TypeVariable<?> typeVariable) {
+ public TypeVariableReturnType(
+ GenericMetadataSupport source,
+ TypeVariable<?>[] typeParameters,
+ TypeVariable<?> typeVariable) {
this.typeParameters = typeParameters;
this.typeVariable = typeVariable;
this.contextualActualTypeParameters = source.contextualActualTypeParameters;
@@ -399,7 +463,7 @@
for (Type type : typeVariable.getBounds()) {
registerTypeVariablesOn(type);
}
- registerTypeParametersOn(new TypeVariable[] { typeVariable });
+ registerTypeParametersOn(new TypeVariable[] {typeVariable});
registerTypeVariablesOn(getActualTypeArgumentFor(typeVariable));
}
@@ -413,30 +477,36 @@
@Override
public List<Type> extraInterfaces() {
+ if (extraInterfaces != null) {
+ return extraInterfaces;
+ }
Type type = extractActualBoundedTypeOf(typeVariable);
if (type instanceof BoundedType) {
- return Arrays.asList(((BoundedType) type).interfaceBounds());
+ return extraInterfaces = Arrays.asList(((BoundedType) type).interfaceBounds());
}
if (type instanceof ParameterizedType) {
- return Collections.singletonList(type);
+ return extraInterfaces = Collections.singletonList(type);
}
if (type instanceof Class) {
- return Collections.emptyList();
+ return extraInterfaces = Collections.emptyList();
}
- throw new MockitoException("Cannot extract extra-interfaces from '" + typeVariable + "' : '" + type + "'");
+ throw new MockitoException(
+ "Cannot extract extra-interfaces from '" + typeVariable + "' : '" + type + "'");
}
/**
* @return Returns an array with the extracted raw types of {@link #extraInterfaces()}.
* @see #extractRawTypeOf(java.lang.reflect.Type)
*/
+ @Override
public Class<?>[] rawExtraInterfaces() {
List<Type> extraInterfaces = extraInterfaces();
- List<Class<?>> rawExtraInterfaces = new ArrayList<Class<?>>();
+ List<Class<?>> rawExtraInterfaces = new ArrayList<>();
for (Type extraInterface : extraInterfaces) {
Class<?> rawInterface = extractRawTypeOf(extraInterface);
- // avoid interface collision with actual raw type (with typevariables, resolution ca be quite aggressive)
- if(!rawType().equals(rawInterface)) {
+ // avoid interface collision with actual raw type (with typevariables, resolution ca
+ // be quite aggressive)
+ if (!rawType().equals(rawInterface)) {
rawExtraInterfaces.add(rawInterface);
}
}
@@ -452,9 +522,11 @@
return extractActualBoundedTypeOf(contextualActualTypeParameters.get(type));
}
if (type instanceof BoundedType) {
- Type actualFirstBound = extractActualBoundedTypeOf(((BoundedType) type).firstBound());
+ Type actualFirstBound =
+ extractActualBoundedTypeOf(((BoundedType) type).firstBound());
if (!(actualFirstBound instanceof BoundedType)) {
- return type; // avoid going one step further, ie avoid : O(TypeVar) -> K(TypeVar) -> Some ParamType
+ return type; // avoid going one step further, ie avoid : O(TypeVar) ->
+ // K(TypeVar) -> Some ParamType
}
return actualFirstBound;
}
@@ -481,9 +553,16 @@
stringBuilder.append("[");
}
try {
- return Class.forName(stringBuilder.append("L").append(rawComponentType.getName()).append(";").toString(), false, rawComponentType.getClassLoader());
+ return Class.forName(
+ stringBuilder
+ .append("L")
+ .append(rawComponentType.getName())
+ .append(";")
+ .toString(),
+ false,
+ rawComponentType.getClassLoader());
} catch (ClassNotFoundException e) {
- throw new IllegalStateException("This was not supposed to happend", e);
+ throw new IllegalStateException("This was not supposed to happen.", e);
}
}
}
@@ -507,15 +586,13 @@
}
}
-
-
/**
* Type representing bounds of a type
*
* @see TypeVarBoundedType
- * @see <a href="http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.4">http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.4</a>
+ * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4">https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4</a>
* @see WildCardBoundedType
- * @see <a href="http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.5.1">http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.5.1</a>
+ * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1">https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1</a>
*/
public interface BoundedType extends Type {
Type firstBound();
@@ -531,7 +608,7 @@
*
* <p>If upper bounds are declared with SomeClass and additional interfaces, then firstBound will be SomeClass and
* interfacesBound will be an array of the additional interfaces.
- *
+ * <p>
* i.e. <code>SomeClass</code>.
* <pre class="code"><code class="java">
* interface UpperBoundedTypeWithClass<E extends Comparable<E> & Cloneable> {
@@ -541,7 +618,7 @@
* </code></pre>
* </p>
*
- * @see <a href="http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.4">http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.4</a>
+ * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4">https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4</a>
*/
public static class TypeVarBoundedType implements BoundedType {
private final TypeVariable<?> typeVariable;
@@ -553,6 +630,7 @@
/**
* @return either a class or an interface (parameterized or not), if no bounds declared Object is returned.
*/
+ @Override
public Type firstBound() {
return typeVariable.getBounds()[0]; //
}
@@ -564,19 +642,28 @@
* @return other bounds for this type, these bounds can only be only interfaces as the JLS says,
* empty array if no other bound declared.
*/
+ @Override
public Type[] interfaceBounds() {
Type[] interfaceBounds = new Type[typeVariable.getBounds().length - 1];
- System.arraycopy(typeVariable.getBounds(), 1, interfaceBounds, 0, typeVariable.getBounds().length - 1);
+ System.arraycopy(
+ typeVariable.getBounds(),
+ 1,
+ interfaceBounds,
+ 0,
+ typeVariable.getBounds().length - 1);
return interfaceBounds;
}
@Override
public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
return typeVariable.equals(((TypeVarBoundedType) o).typeVariable);
-
}
@Override
@@ -586,7 +673,11 @@
@Override
public String toString() {
- return "{firstBound=" + firstBound() + ", interfaceBounds=" + Arrays.deepToString(interfaceBounds()) + '}';
+ return "{firstBound="
+ + firstBound()
+ + ", interfaceBounds="
+ + Arrays.deepToString(interfaceBounds())
+ + '}';
}
public TypeVariable<?> typeVariable() {
@@ -600,19 +691,17 @@
* <p>The JLS says that lower bound and upper bound are mutually exclusive, and that multiple bounds
* are not allowed.
*
- * @see <a href="http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.4">http://docs.oracle.com/javase/specs/jls/se5.0/html/typesValues.html#4.4</a>
+ * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4">https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4</a>
*/
public static class WildCardBoundedType implements BoundedType {
private final WildcardType wildcard;
-
public WildCardBoundedType(WildcardType wildcard) {
this.wildcard = wildcard;
}
- /**
- * @return The first bound, either a type or a reference to a TypeVariable
- */
+ /** @return The first bound, either a type or a reference to a TypeVariable */
+ @Override
public Type firstBound() {
Type[] lowerBounds = wildcard.getLowerBounds();
Type[] upperBounds = wildcard.getUpperBounds();
@@ -620,20 +709,22 @@
return lowerBounds.length != 0 ? lowerBounds[0] : upperBounds[0];
}
- /**
- * @return An empty array as, wildcard don't support multiple bounds.
- */
+ /** @return An empty array as, wildcard don't support multiple bounds. */
+ @Override
public Type[] interfaceBounds() {
return new Type[0];
}
@Override
public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
return wildcard.equals(((TypeVarBoundedType) o).typeVariable);
-
}
@Override
@@ -650,7 +741,4 @@
return wildcard;
}
}
-
}
-
-
diff --git a/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java b/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java
index 6d3bd70..fb56a37 100644
--- a/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java
+++ b/src/main/java/org/mockito/internal/util/reflection/GenericTypeExtractor.java
@@ -7,10 +7,8 @@
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
-/**
- * Attempts to extract generic type of given target base class or target interface
- */
-public class GenericTypeExtractor {
+/** Attempts to extract generic type of given target base class or target interface */
+public final class GenericTypeExtractor {
/**
* Extract generic type of root class either from the target base class or from target base interface.
@@ -34,20 +32,21 @@
* it will be used for generic type extraction
* @return generic interface if found, Object.class if not found.
*/
- public static Class<?> genericTypeOf(Class<?> rootClass, Class<?> targetBaseClass, Class<?> targetBaseInterface) {
- //looking for candidates in the hierarchy of rootClass
+ public static Class<?> genericTypeOf(
+ Class<?> rootClass, Class<?> targetBaseClass, Class<?> targetBaseInterface) {
+ // looking for candidates in the hierarchy of rootClass
Class<?> match = rootClass;
- while(match != Object.class) {
- //check the super class first
+ while (match != Object.class) {
+ // check the super class first
if (match.getSuperclass() == targetBaseClass) {
return extractGeneric(match.getGenericSuperclass());
}
- //check the interfaces (recursively)
+ // check the interfaces (recursively)
Type genericInterface = findGenericInterface(match, targetBaseInterface);
if (genericInterface != null) {
return extractGeneric(genericInterface);
}
- //recurse the hierarchy
+ // recurse the hierarchy
match = match.getSuperclass();
}
return Object.class;
@@ -61,7 +60,7 @@
for (int i = 0; i < sourceClass.getInterfaces().length; i++) {
Class<?> inter = sourceClass.getInterfaces()[i];
if (inter == targetBaseInterface) {
- return sourceClass.getGenericInterfaces()[0];
+ return sourceClass.getGenericInterfaces()[i];
} else {
Type deeper = findGenericInterface(inter, targetBaseInterface);
if (deeper != null) {
@@ -85,4 +84,6 @@
}
return Object.class;
}
+
+ private GenericTypeExtractor() {}
}
diff --git a/src/main/java/org/mockito/internal/util/reflection/InstanceField.java b/src/main/java/org/mockito/internal/util/reflection/InstanceField.java
index 8756e6a..ffefaec 100644
--- a/src/main/java/org/mockito/internal/util/reflection/InstanceField.java
+++ b/src/main/java/org/mockito/internal/util/reflection/InstanceField.java
@@ -4,17 +4,18 @@
*/
package org.mockito.internal.util.reflection;
-import org.mockito.internal.util.Checks;
-
-import static org.mockito.internal.util.reflection.FieldSetter.setField;
-
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.util.Checks;
+import org.mockito.plugins.MemberAccessor;
+
/**
* Represents an accessible instance field.
*
- * Contains the instance reference on which the field can be read adn write.
+ * Contains the instance reference on which the field can be read and write.
*/
public class InstanceField {
private final Field field;
@@ -47,10 +48,14 @@
* Set the given value to the field of this instance.
*
* @param value The value that should be written to the field.
- * @see FieldSetter
*/
public void set(Object value) {
- setField(instance, field,value);
+ MemberAccessor accessor = Plugins.getMemberAccessor();
+ try {
+ accessor.set(field, instance, value);
+ } catch (IllegalAccessException e) {
+ throw new MockitoException("Access to " + field + " was denied", e);
+ }
}
/**
@@ -124,8 +129,12 @@
@Override
public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
InstanceField that = (InstanceField) o;
return field.equals(that.field) && instance.equals(that.instance);
diff --git a/src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java b/src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java
new file mode 100644
index 0000000..0a972d8
--- /dev/null
+++ b/src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java
@@ -0,0 +1,422 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.agent.ByteBuddyAgent;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import net.bytebuddy.implementation.MethodCall;
+import org.mockito.exceptions.base.MockitoInitializationException;
+import org.mockito.internal.SuppressSignatureCheck;
+import org.mockito.plugins.MemberAccessor;
+
+import java.lang.instrument.Instrumentation;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.*;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static org.mockito.internal.util.StringUtil.join;
+
+@SuppressSignatureCheck
+class InstrumentationMemberAccessor implements MemberAccessor {
+
+ private static final Map<Class<?>, Class<?>> WRAPPERS = new HashMap<>();
+
+ private static final Instrumentation INSTRUMENTATION;
+ private static final Dispatcher DISPATCHER;
+
+ private static final Throwable INITIALIZATION_ERROR;
+
+ static {
+ WRAPPERS.put(boolean.class, Boolean.class);
+ WRAPPERS.put(byte.class, Byte.class);
+ WRAPPERS.put(short.class, Short.class);
+ WRAPPERS.put(char.class, Character.class);
+ WRAPPERS.put(int.class, Integer.class);
+ WRAPPERS.put(long.class, Long.class);
+ WRAPPERS.put(float.class, Float.class);
+ WRAPPERS.put(double.class, Double.class);
+ Instrumentation instrumentation;
+ Dispatcher dispatcher;
+ Throwable throwable;
+ try {
+ instrumentation = ByteBuddyAgent.install();
+ // We need to generate a dispatcher instance that is located in a distinguished class
+ // loader to create a unique (unnamed) module to which we can open other packages to.
+ // This way, we assure that classes within Mockito's module (which might be a shared,
+ // unnamed module) do not face escalated privileges where tests might pass that would
+ // otherwise fail without Mockito's opening.
+ dispatcher =
+ new ByteBuddy()
+ .subclass(Dispatcher.class)
+ .method(named("getLookup"))
+ .intercept(MethodCall.invoke(MethodHandles.class.getMethod("lookup")))
+ .method(named("getModule"))
+ .intercept(
+ MethodCall.invoke(Class.class.getMethod("getModule"))
+ .onMethodCall(
+ MethodCall.invoke(
+ Object.class.getMethod("getClass"))))
+ .method(named("setAccessible"))
+ .intercept(
+ MethodCall.invoke(
+ AccessibleObject.class.getMethod(
+ "setAccessible", boolean.class))
+ .onArgument(0)
+ .withArgument(1))
+ .method(named("invokeWithArguments"))
+ .intercept(
+ MethodCall.invoke(
+ MethodHandle.class.getMethod(
+ "invokeWithArguments", Object[].class))
+ .onArgument(0)
+ .withArgument(1))
+ .make()
+ .load(
+ InstrumentationMemberAccessor.class.getClassLoader(),
+ ClassLoadingStrategy.Default.WRAPPER)
+ .getLoaded()
+ .getConstructor()
+ .newInstance();
+ throwable = null;
+ } catch (Throwable t) {
+ instrumentation = null;
+ dispatcher = null;
+ throwable = t;
+ }
+ INSTRUMENTATION = instrumentation;
+ DISPATCHER = dispatcher;
+ INITIALIZATION_ERROR = throwable;
+ }
+
+ @SuppressWarnings(value = "unused")
+ private final MethodHandle getModule;
+
+ @SuppressWarnings(value = "unused")
+ private final MethodHandle isOpen;
+
+ @SuppressWarnings(value = "unused")
+ private final MethodHandle redefineModule;
+
+ @SuppressWarnings(value = "unused")
+ private final MethodHandle privateLookupIn;
+
+ InstrumentationMemberAccessor() {
+ if (INITIALIZATION_ERROR != null) {
+ throw new MockitoInitializationException(
+ join(
+ "Could not initialize the Mockito instrumentation member accessor",
+ "",
+ "This is unexpected on JVMs from Java 9 or later - possibly, the instrumentation API could not be resolved"),
+ INITIALIZATION_ERROR);
+ }
+ try {
+ Class<?> module = Class.forName("java.lang.Module");
+ getModule =
+ MethodHandles.publicLookup()
+ .findVirtual(Class.class, "getModule", MethodType.methodType(module));
+ isOpen =
+ MethodHandles.publicLookup()
+ .findVirtual(
+ module,
+ "isOpen",
+ MethodType.methodType(boolean.class, String.class));
+ redefineModule =
+ MethodHandles.publicLookup()
+ .findVirtual(
+ Instrumentation.class,
+ "redefineModule",
+ MethodType.methodType(
+ void.class,
+ module,
+ Set.class,
+ Map.class,
+ Map.class,
+ Set.class,
+ Map.class));
+ privateLookupIn =
+ MethodHandles.publicLookup()
+ .findStatic(
+ MethodHandles.class,
+ "privateLookupIn",
+ MethodType.methodType(
+ MethodHandles.Lookup.class,
+ Class.class,
+ MethodHandles.Lookup.class));
+ } catch (Throwable t) {
+ throw new MockitoInitializationException(
+ "Could not resolve instrumentation invoker", t);
+ }
+ }
+
+ @Override
+ public Object newInstance(Constructor<?> constructor, Object... arguments)
+ throws InstantiationException, InvocationTargetException {
+ return newInstance(constructor, ConstructionDispatcher::newInstance, arguments);
+ }
+
+ @Override
+ public Object newInstance(
+ Constructor<?> constructor, OnConstruction onConstruction, Object... arguments)
+ throws InstantiationException, InvocationTargetException {
+ if (Modifier.isAbstract(constructor.getDeclaringClass().getModifiers())) {
+ throw new InstantiationException(
+ "Cannot instantiate abstract " + constructor.getDeclaringClass().getTypeName());
+ }
+ assureArguments(constructor, null, null, arguments, constructor.getParameterTypes());
+ try {
+ Object module =
+ DISPATCHER.invokeWithArguments(
+ getModule.bindTo(constructor.getDeclaringClass()));
+ String packageName = constructor.getDeclaringClass().getPackage().getName();
+ assureOpen(module, packageName);
+ MethodHandle handle =
+ ((MethodHandles.Lookup)
+ DISPATCHER.invokeWithArguments(
+ privateLookupIn,
+ constructor.getDeclaringClass(),
+ DISPATCHER.getLookup()))
+ .unreflectConstructor(constructor);
+ AtomicBoolean thrown = new AtomicBoolean();
+ Object value =
+ onConstruction.invoke(
+ () -> {
+ try {
+ return DISPATCHER.invokeWithArguments(handle, arguments);
+ } catch (Throwable throwable) {
+ thrown.set(true);
+ return throwable;
+ }
+ });
+ if (thrown.get()) {
+ throw new InvocationTargetException((Throwable) value);
+ } else {
+ return value;
+ }
+ } catch (InvocationTargetException e) {
+ throw e;
+ } catch (Throwable t) {
+ throw new IllegalStateException(
+ "Could not construct "
+ + constructor
+ + " with arguments "
+ + Arrays.toString(arguments),
+ t);
+ }
+ }
+
+ @Override
+ public Object invoke(Method method, Object target, Object... arguments)
+ throws InvocationTargetException {
+ assureArguments(
+ method,
+ Modifier.isStatic(method.getModifiers()) ? null : target,
+ method.getDeclaringClass(),
+ arguments,
+ method.getParameterTypes());
+ try {
+ Object module =
+ DISPATCHER.invokeWithArguments(getModule.bindTo(method.getDeclaringClass()));
+ String packageName = method.getDeclaringClass().getPackage().getName();
+ assureOpen(module, packageName);
+ MethodHandle handle =
+ ((MethodHandles.Lookup)
+ DISPATCHER.invokeWithArguments(
+ privateLookupIn,
+ method.getDeclaringClass(),
+ DISPATCHER.getLookup()))
+ .unreflect(method);
+ if (!Modifier.isStatic(method.getModifiers())) {
+ handle = handle.bindTo(target);
+ }
+ try {
+ return DISPATCHER.invokeWithArguments(handle, arguments);
+ } catch (Throwable t) {
+ throw new InvocationTargetException(t);
+ }
+ } catch (InvocationTargetException e) {
+ throw e;
+ } catch (Throwable t) {
+ throw new IllegalStateException(
+ "Could not invoke "
+ + method
+ + " on "
+ + target
+ + " with arguments "
+ + Arrays.toString(arguments),
+ t);
+ }
+ }
+
+ @Override
+ public Object get(Field field, Object target) {
+ assureArguments(
+ field,
+ Modifier.isStatic(field.getModifiers()) ? null : target,
+ field.getDeclaringClass(),
+ new Object[0],
+ new Class<?>[0]);
+ try {
+ Object module =
+ DISPATCHER.invokeWithArguments(getModule.bindTo(field.getDeclaringClass()));
+ String packageName = field.getDeclaringClass().getPackage().getName();
+ assureOpen(module, packageName);
+ MethodHandle handle =
+ ((MethodHandles.Lookup)
+ DISPATCHER.invokeWithArguments(
+ privateLookupIn,
+ field.getDeclaringClass(),
+ DISPATCHER.getLookup()))
+ .unreflectGetter(field);
+ if (!Modifier.isStatic(field.getModifiers())) {
+ handle = handle.bindTo(target);
+ }
+ return DISPATCHER.invokeWithArguments(handle);
+ } catch (Throwable t) {
+ throw new IllegalStateException("Could not read " + field + " on " + target, t);
+ }
+ }
+
+ @Override
+ public void set(Field field, Object target, Object value) throws IllegalAccessException {
+ assureArguments(
+ field,
+ Modifier.isStatic(field.getModifiers()) ? null : target,
+ field.getDeclaringClass(),
+ new Object[] {value},
+ new Class<?>[] {field.getType()});
+ boolean illegalAccess = false;
+ try {
+ Object module =
+ DISPATCHER.invokeWithArguments(getModule.bindTo(field.getDeclaringClass()));
+ String packageName = field.getDeclaringClass().getPackage().getName();
+ assureOpen(module, packageName);
+ // Method handles do not allow setting final fields where setAccessible(true)
+ // is required before unreflecting.
+ boolean isFinal;
+ if (Modifier.isFinal(field.getModifiers())) {
+ isFinal = true;
+ try {
+ DISPATCHER.setAccessible(field, true);
+ } catch (Throwable ignored) {
+ illegalAccess =
+ true; // To distinguish from propagated illegal access exception.
+ throw new IllegalAccessException(
+ "Could not make final field " + field + " accessible");
+ }
+ } else {
+ isFinal = false;
+ }
+ try {
+ MethodHandle handle =
+ ((MethodHandles.Lookup)
+ DISPATCHER.invokeWithArguments(
+ privateLookupIn,
+ field.getDeclaringClass(),
+ DISPATCHER.getLookup()))
+ .unreflectSetter(field);
+ if (!Modifier.isStatic(field.getModifiers())) {
+ handle = handle.bindTo(target);
+ }
+ DISPATCHER.invokeWithArguments(handle, value);
+ } finally {
+ if (isFinal) {
+ DISPATCHER.setAccessible(field, false);
+ }
+ }
+ } catch (Throwable t) {
+ if (illegalAccess) {
+ throw (IllegalAccessException) t;
+ } else {
+ throw new IllegalStateException("Could not read " + field + " on " + target, t);
+ }
+ }
+ }
+
+ private void assureOpen(Object module, String packageName) throws Throwable {
+ // It would be more reliable to check if a module's package already is opened to
+ // the dispatcher module from before. Unfortunately, there is no reliable check
+ // for doing so since the isOpen(String, Module) method always returns true
+ // if the second argument is an unnamed module. Therefore, for now, we need
+ // to reopen packages even if they are already opened to the dispatcher module.
+ if (!(Boolean) DISPATCHER.invokeWithArguments(isOpen, module, packageName)) {
+ DISPATCHER.invokeWithArguments(
+ redefineModule.bindTo(INSTRUMENTATION),
+ module,
+ Collections.emptySet(),
+ Collections.emptyMap(),
+ Collections.singletonMap(
+ packageName, Collections.singleton(DISPATCHER.getModule())),
+ Collections.emptySet(),
+ Collections.emptyMap());
+ }
+ }
+
+ private static void assureArguments(
+ AccessibleObject target,
+ Object owner,
+ Class<?> type,
+ Object[] values,
+ Class<?>[] types) {
+ if (owner != null) {
+ if (!type.isAssignableFrom(owner.getClass())) {
+ throw new IllegalArgumentException("Cannot access " + target + " on " + owner);
+ }
+ }
+ if (types.length != values.length) {
+ throw new IllegalArgumentException(
+ "Incorrect number of arguments for "
+ + target
+ + ": expected "
+ + types.length
+ + " but recevied "
+ + values.length);
+ }
+ for (int index = 0; index < values.length; index++) {
+ if (values[index] == null) {
+ if (types[index].isPrimitive()) {
+ throw new IllegalArgumentException(
+ "Cannot assign null to primitive type "
+ + types[index].getTypeName()
+ + " for "
+ + index
+ + " parameter of "
+ + target);
+ }
+ } else {
+ Class<?> resolved = WRAPPERS.getOrDefault(types[index], types[index]);
+ if (!resolved.isAssignableFrom(values[index].getClass())) {
+ throw new IllegalArgumentException(
+ "Cannot assign value of type "
+ + values[index].getClass()
+ + " to "
+ + resolved
+ + " for "
+ + index
+ + " parameter of "
+ + target);
+ }
+ }
+ }
+ }
+
+ public interface Dispatcher {
+
+ MethodHandles.Lookup getLookup();
+
+ Object getModule();
+
+ void setAccessible(AccessibleObject target, boolean value);
+
+ // Used to avoid invoke/invokeExact being exposed to Android where this class should
+ // never be loaded. Since the invocation happens from the generated code, the Android
+ // build pipeline does not fail.
+ Object invokeWithArguments(MethodHandle handle, Object... arguments) throws Throwable;
+ }
+}
diff --git a/src/main/java/org/mockito/internal/util/reflection/LenientCopyTool.java b/src/main/java/org/mockito/internal/util/reflection/LenientCopyTool.java
index c6b9919..95b3019 100644
--- a/src/main/java/org/mockito/internal/util/reflection/LenientCopyTool.java
+++ b/src/main/java/org/mockito/internal/util/reflection/LenientCopyTool.java
@@ -4,13 +4,15 @@
*/
package org.mockito.internal.util.reflection;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.MemberAccessor;
+
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
-@SuppressWarnings("unchecked")
public class LenientCopyTool {
- FieldCopier fieldCopier = new FieldCopier();
+ MemberAccessor accessor = Plugins.getMemberAccessor();
public <T> void copyToMock(T from, T mock) {
copy(from, mock, from.getClass());
@@ -35,14 +37,11 @@
if (Modifier.isStatic(field.getModifiers())) {
continue;
}
- AccessibilityChanger accessibilityChanger = new AccessibilityChanger();
try {
- accessibilityChanger.enableAccess(field);
- fieldCopier.copyValue(from, mock, field);
+ Object value = accessor.get(field, from);
+ accessor.set(field, mock, value);
} catch (Throwable t) {
- //Ignore - be lenient - if some field cannot be copied then let's be it
- } finally {
- accessibilityChanger.safelyDisableAccess(field);
+ // Ignore - be lenient - if some field cannot be copied then let's be it
}
}
}
diff --git a/src/main/java/org/mockito/internal/util/reflection/ModuleMemberAccessor.java b/src/main/java/org/mockito/internal/util/reflection/ModuleMemberAccessor.java
new file mode 100644
index 0000000..08e55a5
--- /dev/null
+++ b/src/main/java/org/mockito/internal/util/reflection/ModuleMemberAccessor.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import net.bytebuddy.ClassFileVersion;
+import org.mockito.plugins.MemberAccessor;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class ModuleMemberAccessor implements MemberAccessor {
+
+ private final MemberAccessor delegate;
+
+ public ModuleMemberAccessor() {
+ MemberAccessor delegate;
+ try {
+ delegate = delegate();
+ } catch (Throwable ignored) {
+ // Fallback in case Byte Buddy is not used as a mock maker and not available on the
+ // class loader.
+ delegate = new ReflectionMemberAccessor();
+ }
+ this.delegate = delegate;
+ }
+
+ private static MemberAccessor delegate() {
+ if (ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V9)) {
+ return new InstrumentationMemberAccessor();
+ } else {
+ return new ReflectionMemberAccessor();
+ }
+ }
+
+ @Override
+ public Object newInstance(Constructor<?> constructor, Object... arguments)
+ throws InstantiationException, InvocationTargetException, IllegalAccessException {
+ return delegate.newInstance(constructor, arguments);
+ }
+
+ @Override
+ public Object newInstance(
+ Constructor<?> constructor, OnConstruction onConstruction, Object... arguments)
+ throws InstantiationException, InvocationTargetException, IllegalAccessException {
+ return delegate.newInstance(constructor, onConstruction, arguments);
+ }
+
+ @Override
+ public Object invoke(Method method, Object target, Object... arguments)
+ throws InvocationTargetException, IllegalAccessException {
+ return delegate.invoke(method, target, arguments);
+ }
+
+ @Override
+ public Object get(Field field, Object target) throws IllegalAccessException {
+ return delegate.get(field, target);
+ }
+
+ @Override
+ public void set(Field field, Object target, Object value) throws IllegalAccessException {
+ delegate.set(field, target, value);
+ }
+}
diff --git a/src/main/java/org/mockito/internal/util/reflection/ReflectionMemberAccessor.java b/src/main/java/org/mockito/internal/util/reflection/ReflectionMemberAccessor.java
new file mode 100644
index 0000000..deb884d
--- /dev/null
+++ b/src/main/java/org/mockito/internal/util/reflection/ReflectionMemberAccessor.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import org.mockito.plugins.MemberAccessor;
+
+public class ReflectionMemberAccessor implements MemberAccessor {
+
+ @Override
+ public Object newInstance(Constructor<?> constructor, Object... arguments)
+ throws InstantiationException, InvocationTargetException, IllegalAccessException {
+ return newInstance(constructor, ConstructionDispatcher::newInstance, arguments);
+ }
+
+ @Override
+ public Object newInstance(
+ Constructor<?> constructor, OnConstruction onConstruction, Object... arguments)
+ throws InstantiationException, InvocationTargetException, IllegalAccessException {
+ silentSetAccessible(constructor, true);
+ try {
+ return onConstruction.invoke(() -> constructor.newInstance(arguments));
+ } catch (InvocationTargetException
+ | IllegalAccessException
+ | InstantiationException
+ | IllegalArgumentException e) {
+ throw e;
+ } catch (RuntimeException e) {
+ throw new IllegalStateException(
+ "Failed to invoke " + constructor + " with " + Arrays.toString(arguments), e);
+ } finally {
+ silentSetAccessible(constructor, false);
+ }
+ }
+
+ @Override
+ public Object invoke(Method method, Object target, Object... arguments)
+ throws InvocationTargetException, IllegalAccessException {
+ silentSetAccessible(method, true);
+ try {
+ return method.invoke(target, arguments);
+ } catch (InvocationTargetException | IllegalAccessException | IllegalArgumentException e) {
+ throw e;
+ } catch (RuntimeException e) {
+ throw new IllegalStateException("Could not invoke " + method + " on " + target, e);
+ } finally {
+ silentSetAccessible(method, false);
+ }
+ }
+
+ @Override
+ public Object get(Field field, Object target) throws IllegalAccessException {
+ silentSetAccessible(field, true);
+ try {
+ return field.get(target);
+ } catch (IllegalAccessException | IllegalArgumentException e) {
+ throw e;
+ } catch (RuntimeException e) {
+ throw new IllegalStateException("Could not read " + field + " from " + target, e);
+ } finally {
+ silentSetAccessible(field, false);
+ }
+ }
+
+ @Override
+ public void set(Field field, Object target, Object value) throws IllegalAccessException {
+ silentSetAccessible(field, true);
+ try {
+ field.set(target, value);
+ } catch (IllegalAccessException | IllegalArgumentException e) {
+ throw e;
+ } catch (RuntimeException e) {
+ throw new IllegalStateException("Could not write " + field + " to " + target, e);
+ } finally {
+ silentSetAccessible(field, false);
+ }
+ }
+
+ private static void silentSetAccessible(AccessibleObject object, boolean value) {
+ try {
+ object.setAccessible(value);
+ } catch (RuntimeException ignored) {
+ }
+ }
+}
diff --git a/src/main/java/org/mockito/internal/util/reflection/SuperTypesLastSorter.java b/src/main/java/org/mockito/internal/util/reflection/SuperTypesLastSorter.java
index 8f5c161..32ed974 100644
--- a/src/main/java/org/mockito/internal/util/reflection/SuperTypesLastSorter.java
+++ b/src/main/java/org/mockito/internal/util/reflection/SuperTypesLastSorter.java
@@ -2,7 +2,6 @@
* Copyright (c) 2015 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.util.reflection;
import java.lang.reflect.Field;
@@ -18,15 +17,14 @@
*/
public class SuperTypesLastSorter {
- private SuperTypesLastSorter() {
- }
+ private SuperTypesLastSorter() {}
/**
* Return a new collection with the fields sorted first by name,
* then with any fields moved after their supertypes.
*/
public static List<Field> sortSuperTypesLast(Collection<? extends Field> unsortedFields) {
- List<Field> fields = new ArrayList<Field>(unsortedFields);
+ List<Field> fields = new ArrayList<>(unsortedFields);
Collections.sort(fields, compareFieldsByName);
@@ -55,11 +53,8 @@
return fields;
}
-
- private static final Comparator<Field> compareFieldsByName = new Comparator<Field>() {
- @Override
- public int compare(Field o1, Field o2) {
- return o1.getName().compareTo(o2.getName());
- }
- };
+ private static final Comparator<Field> compareFieldsByName =
+ (Field o1, Field o2) -> {
+ return o1.getName().compareTo(o2.getName());
+ };
}
diff --git a/src/main/java/org/mockito/internal/verification/AtLeast.java b/src/main/java/org/mockito/internal/verification/AtLeast.java
index 768cc92..5f70649 100644
--- a/src/main/java/org/mockito/internal/verification/AtLeast.java
+++ b/src/main/java/org/mockito/internal/verification/AtLeast.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification;
import static org.mockito.internal.verification.checkers.AtLeastXNumberOfInvocationsChecker.checkAtLeastNumberOfInvocations;
@@ -28,7 +27,7 @@
@Override
public void verify(VerificationData data) {
if (wantedCount == 1) {
- checkMissingInvocation(data.getAllInvocations(), data.getTarget());
+ checkMissingInvocation(data.getAllInvocations(), data.getTarget());
}
checkAtLeastNumberOfInvocations(data.getAllInvocations(), data.getTarget(), wantedCount);
}
@@ -36,18 +35,15 @@
@Override
public void verifyInOrder(VerificationDataInOrder data) {
if (wantedCount == 1) {
- checkMissingInvocation(data.getAllInvocations(), data.getWanted(), data.getOrderingContext());
+ checkMissingInvocation(
+ data.getAllInvocations(), data.getWanted(), data.getOrderingContext());
}
- checkAtLeastNumberOfInvocations(data.getAllInvocations(), data.getWanted(), wantedCount, data.getOrderingContext());
+ checkAtLeastNumberOfInvocations(
+ data.getAllInvocations(), data.getWanted(), wantedCount, data.getOrderingContext());
}
@Override
public String toString() {
return "Wanted invocations count: at least " + wantedCount;
}
-
- @Override
- public VerificationMode description(String description) {
- return VerificationModeFactory.description(this, description);
- }
}
diff --git a/src/main/java/org/mockito/internal/verification/AtMost.java b/src/main/java/org/mockito/internal/verification/AtMost.java
index 0c31878..57dedc4 100644
--- a/src/main/java/org/mockito/internal/verification/AtMost.java
+++ b/src/main/java/org/mockito/internal/verification/AtMost.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification;
import static org.mockito.internal.exceptions.Reporter.wantedAtMostX;
@@ -11,10 +10,11 @@
import java.util.Iterator;
import java.util.List;
+
import org.mockito.exceptions.base.MockitoException;
-import org.mockito.invocation.MatchableInvocation;
import org.mockito.internal.verification.api.VerificationData;
import org.mockito.invocation.Invocation;
+import org.mockito.invocation.MatchableInvocation;
import org.mockito.verification.VerificationMode;
public class AtMost implements VerificationMode {
@@ -28,6 +28,7 @@
this.maxNumberOfInvocations = maxNumberOfInvocations;
}
+ @Override
public void verify(VerificationData data) {
List<Invocation> invocations = data.getAllInvocations();
MatchableInvocation wanted = data.getTarget();
@@ -42,11 +43,6 @@
markVerified(found, wanted);
}
- @Override
- public VerificationMode description(String description) {
- return VerificationModeFactory.description(this, description);
- }
-
private void removeAlreadyVerified(List<Invocation> invocations) {
for (Iterator<Invocation> iterator = invocations.iterator(); iterator.hasNext(); ) {
Invocation i = iterator.next();
diff --git a/src/main/java/org/mockito/internal/verification/Calls.java b/src/main/java/org/mockito/internal/verification/Calls.java
index 9083752..f52fd66 100644
--- a/src/main/java/org/mockito/internal/verification/Calls.java
+++ b/src/main/java/org/mockito/internal/verification/Calls.java
@@ -2,13 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification;
import static org.mockito.internal.verification.checkers.MissingInvocationChecker.checkMissingInvocation;
import static org.mockito.internal.verification.checkers.NumberOfInvocationsChecker.checkNumberOfInvocationsNonGreedy;
import java.util.List;
+
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.verification.api.VerificationData;
import org.mockito.internal.verification.api.VerificationDataInOrder;
@@ -22,15 +22,15 @@
final int wantedCount;
public Calls(int wantedNumberOfInvocations) {
- if( wantedNumberOfInvocations <= 0 ) {
- throw new MockitoException( "Negative and zero values are not allowed here" );
+ if (wantedNumberOfInvocations <= 0) {
+ throw new MockitoException("Negative and zero values are not allowed here");
}
this.wantedCount = wantedNumberOfInvocations;
}
@Override
public void verify(VerificationData data) {
- throw new MockitoException( "calls is only intended to work with InOrder" );
+ throw new MockitoException("calls is only intended to work with InOrder");
}
@Override
@@ -38,17 +38,13 @@
List<Invocation> allInvocations = data.getAllInvocations();
MatchableInvocation wanted = data.getWanted();
- checkMissingInvocation(allInvocations, wanted, data.getOrderingContext());
- checkNumberOfInvocationsNonGreedy(allInvocations, wanted, wantedCount, data.getOrderingContext());
+ checkMissingInvocation(allInvocations, wanted, data.getOrderingContext());
+ checkNumberOfInvocationsNonGreedy(
+ allInvocations, wanted, wantedCount, data.getOrderingContext());
}
@Override
public String toString() {
return "Wanted invocations count (non-greedy): " + wantedCount;
}
-
- @Override
- public VerificationMode description(String description) {
- return VerificationModeFactory.description(this, description);
- }
}
diff --git a/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java b/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java
index 20518ae..f81a537 100644
--- a/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java
+++ b/src/main/java/org/mockito/internal/verification/DefaultRegisteredInvocations.java
@@ -2,55 +2,59 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification;
-import org.mockito.internal.util.collections.ListUtil;
-import org.mockito.internal.util.collections.ListUtil.Filter;
-import org.mockito.invocation.Invocation;
-
import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
import java.io.Serializable;
import java.util.LinkedList;
import java.util.List;
+import org.mockito.internal.util.collections.ListUtil;
+import org.mockito.internal.util.collections.ListUtil.Filter;
+import org.mockito.invocation.Invocation;
public class DefaultRegisteredInvocations implements RegisteredInvocations, Serializable {
private static final long serialVersionUID = -2674402327380736290L;
- private final LinkedList<Invocation> invocations = new LinkedList<Invocation>();
+ private final LinkedList<Invocation> invocations = new LinkedList<>();
+ @Override
public void add(Invocation invocation) {
synchronized (invocations) {
invocations.add(invocation);
}
}
+ @Override
public void removeLast() {
- //TODO: add specific test for synchronization of this block (it is tested by InvocationContainerImplTest at the moment)
+ // TODO: add specific test for synchronization of this block (it is tested by
+ // InvocationContainerImplTest at the moment)
synchronized (invocations) {
- if (! invocations.isEmpty()) {
+ if (!invocations.isEmpty()) {
invocations.removeLast();
}
}
}
+ @Override
public List<Invocation> getAll() {
List<Invocation> copiedList;
synchronized (invocations) {
- copiedList = new LinkedList<Invocation>(invocations) ;
+ copiedList = new LinkedList<>(invocations);
}
return ListUtil.filter(copiedList, new RemoveToString());
}
+ @Override
public void clear() {
synchronized (invocations) {
invocations.clear();
}
}
+ @Override
public boolean isEmpty() {
synchronized (invocations) {
return invocations.isEmpty();
@@ -58,9 +62,9 @@
}
private static class RemoveToString implements Filter<Invocation> {
+ @Override
public boolean isOut(Invocation invocation) {
return isToStringMethod(invocation.getMethod());
}
}
-
}
diff --git a/src/main/java/org/mockito/internal/verification/Description.java b/src/main/java/org/mockito/internal/verification/Description.java
index b11f99a..10651e2 100644
--- a/src/main/java/org/mockito/internal/verification/Description.java
+++ b/src/main/java/org/mockito/internal/verification/Description.java
@@ -39,13 +39,8 @@
try {
verification.verify(data);
- } catch (MockitoAssertionError e) {
+ } catch (AssertionError e) {
throw new MockitoAssertionError(e, description);
}
}
-
- @Override
- public VerificationMode description(String description) {
- return VerificationModeFactory.description(this, description);
- }
}
diff --git a/src/main/java/org/mockito/internal/verification/InOrderContextImpl.java b/src/main/java/org/mockito/internal/verification/InOrderContextImpl.java
index b7a7a96..46a0177 100644
--- a/src/main/java/org/mockito/internal/verification/InOrderContextImpl.java
+++ b/src/main/java/org/mockito/internal/verification/InOrderContextImpl.java
@@ -12,10 +12,12 @@
final IdentitySet verified = new IdentitySet();
+ @Override
public boolean isVerified(Invocation invocation) {
return verified.contains(invocation);
}
+ @Override
public void markVerified(Invocation i) {
verified.add(i);
}
diff --git a/src/main/java/org/mockito/internal/verification/InOrderWrapper.java b/src/main/java/org/mockito/internal/verification/InOrderWrapper.java
index 88a4d70..b829195 100644
--- a/src/main/java/org/mockito/internal/verification/InOrderWrapper.java
+++ b/src/main/java/org/mockito/internal/verification/InOrderWrapper.java
@@ -4,6 +4,8 @@
*/
package org.mockito.internal.verification;
+import java.util.List;
+
import org.mockito.internal.InOrderImpl;
import org.mockito.internal.invocation.finder.VerifiableInvocationsFinder;
import org.mockito.internal.verification.api.VerificationData;
@@ -12,8 +14,6 @@
import org.mockito.invocation.Invocation;
import org.mockito.verification.VerificationMode;
-import java.util.List;
-
public class InOrderWrapper implements VerificationMode {
private final VerificationInOrderMode mode;
@@ -24,14 +24,12 @@
this.inOrder = inOrder;
}
- public void verify(VerificationData data) {
- List<Invocation> invocations = VerifiableInvocationsFinder.find(inOrder.getMocksToBeVerifiedInOrder());
- VerificationDataInOrderImpl dataInOrder = new VerificationDataInOrderImpl(inOrder, invocations, data.getTarget());
- mode.verifyInOrder(dataInOrder);
- }
-
@Override
- public VerificationMode description(String description) {
- return VerificationModeFactory.description(this, description);
+ public void verify(VerificationData data) {
+ List<Invocation> invocations =
+ VerifiableInvocationsFinder.find(inOrder.getMocksToBeVerifiedInOrder());
+ VerificationDataInOrderImpl dataInOrder =
+ new VerificationDataInOrderImpl(inOrder, invocations, data.getTarget());
+ mode.verifyInOrder(dataInOrder);
}
}
diff --git a/src/main/java/org/mockito/internal/verification/MockAwareVerificationMode.java b/src/main/java/org/mockito/internal/verification/MockAwareVerificationMode.java
index af4c0e8..490f917 100644
--- a/src/main/java/org/mockito/internal/verification/MockAwareVerificationMode.java
+++ b/src/main/java/org/mockito/internal/verification/MockAwareVerificationMode.java
@@ -5,6 +5,7 @@
package org.mockito.internal.verification;
import java.util.Set;
+
import org.mockito.internal.verification.api.VerificationData;
import org.mockito.listeners.VerificationListener;
import org.mockito.verification.VerificationEvent;
@@ -16,26 +17,24 @@
private final VerificationMode mode;
private final Set<VerificationListener> listeners;
- public MockAwareVerificationMode(Object mock, VerificationMode mode, Set<VerificationListener> listeners) {
+ public MockAwareVerificationMode(
+ Object mock, VerificationMode mode, Set<VerificationListener> listeners) {
this.mock = mock;
this.mode = mode;
this.listeners = listeners;
}
+ @Override
public void verify(VerificationData data) {
try {
mode.verify(data);
notifyListeners(new VerificationEventImpl(mock, mode, data, null));
- } catch (RuntimeException e) {
- notifyListeners(new VerificationEventImpl(mock, mode, data, e));
- throw e;
- } catch (Error e) {
+ } catch (RuntimeException | Error e) {
notifyListeners(new VerificationEventImpl(mock, mode, data, e));
throw e;
}
}
-
private void notifyListeners(VerificationEvent event) {
for (VerificationListener listener : listeners) {
listener.onVerification(event);
@@ -45,8 +44,4 @@
public Object getMock() {
return mock;
}
-
- public VerificationMode description(String description) {
- return VerificationModeFactory.description(this, description);
- }
}
diff --git a/src/main/java/org/mockito/internal/verification/NoInteractions.java b/src/main/java/org/mockito/internal/verification/NoInteractions.java
new file mode 100644
index 0000000..c307abd
--- /dev/null
+++ b/src/main/java/org/mockito/internal/verification/NoInteractions.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification;
+
+import static org.mockito.internal.exceptions.Reporter.noInteractionsWanted;
+
+import java.util.List;
+
+import org.mockito.internal.verification.api.VerificationData;
+import org.mockito.invocation.Invocation;
+import org.mockito.verification.VerificationMode;
+
+public class NoInteractions implements VerificationMode {
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public void verify(VerificationData data) {
+ List<Invocation> invocations = data.getAllInvocations();
+ if (!invocations.isEmpty()) {
+ throw noInteractionsWanted(invocations.get(0).getMock(), (List) invocations);
+ }
+ }
+}
diff --git a/src/main/java/org/mockito/internal/verification/NoMoreInteractions.java b/src/main/java/org/mockito/internal/verification/NoMoreInteractions.java
index 8110849..ad8018f 100644
--- a/src/main/java/org/mockito/internal/verification/NoMoreInteractions.java
+++ b/src/main/java/org/mockito/internal/verification/NoMoreInteractions.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification;
import static org.mockito.internal.exceptions.Reporter.noMoreInteractionsWanted;
@@ -20,6 +19,7 @@
public class NoMoreInteractions implements VerificationMode, VerificationInOrderMode {
+ @Override
@SuppressWarnings("unchecked")
public void verify(VerificationData data) {
Invocation unverified = findFirstUnverified(data.getAllInvocations());
@@ -28,6 +28,7 @@
}
}
+ @Override
public void verifyInOrder(VerificationDataInOrder data) {
List<Invocation> invocations = data.getAllInvocations();
Invocation unverified = findFirstUnverifiedInOrder(data.getOrderingContext(), invocations);
@@ -36,9 +37,4 @@
throw noMoreInteractionsWantedInOrder(unverified);
}
}
-
- @Override
- public VerificationMode description(String description) {
- return VerificationModeFactory.description(this, description);
- }
}
diff --git a/src/main/java/org/mockito/internal/verification/Only.java b/src/main/java/org/mockito/internal/verification/Only.java
index 009f660..64ec47d 100644
--- a/src/main/java/org/mockito/internal/verification/Only.java
+++ b/src/main/java/org/mockito/internal/verification/Only.java
@@ -12,18 +12,19 @@
import java.util.List;
-import org.mockito.invocation.MatchableInvocation;
import org.mockito.internal.verification.api.VerificationData;
import org.mockito.invocation.Invocation;
+import org.mockito.invocation.MatchableInvocation;
import org.mockito.verification.VerificationMode;
public class Only implements VerificationMode {
+ @Override
@SuppressWarnings("unchecked")
public void verify(VerificationData data) {
MatchableInvocation target = data.getTarget();
List<Invocation> invocations = data.getAllInvocations();
- List<Invocation> chunk = findInvocations(invocations,target);
+ List<Invocation> chunk = findInvocations(invocations, target);
if (invocations.size() != 1 && !chunk.isEmpty()) {
Invocation unverified = findFirstUnverified(invocations);
throw noMoreInteractionsWanted(unverified, (List) invocations);
@@ -33,8 +34,4 @@
}
markVerified(chunk.get(0), target);
}
-
- public VerificationMode description(String description) {
- return VerificationModeFactory.description(this, description);
- }
}
diff --git a/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java b/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java
index dcc49d9..8aa088e 100644
--- a/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java
+++ b/src/main/java/org/mockito/internal/verification/RegisteredInvocations.java
@@ -2,13 +2,11 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification;
-import org.mockito.invocation.Invocation;
-
import java.util.List;
+import org.mockito.invocation.Invocation;
public interface RegisteredInvocations {
@@ -21,5 +19,4 @@
void clear();
boolean isEmpty();
-
}
diff --git a/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java b/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java
index 67ceafa..78ef006 100644
--- a/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java
+++ b/src/main/java/org/mockito/internal/verification/SingleRegisteredInvocation.java
@@ -2,35 +2,39 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification;
-import org.mockito.invocation.Invocation;
-
import java.io.Serializable;
import java.util.Collections;
import java.util.List;
+import org.mockito.invocation.Invocation;
+
public class SingleRegisteredInvocation implements RegisteredInvocations, Serializable {
private Invocation invocation;
+ @Override
public void add(Invocation invocation) {
this.invocation = invocation;
}
+ @Override
public void removeLast() {
invocation = null;
}
+ @Override
public List<Invocation> getAll() {
return Collections.emptyList();
}
+ @Override
public void clear() {
invocation = null;
}
+ @Override
public boolean isEmpty() {
return invocation == null;
}
diff --git a/src/main/java/org/mockito/internal/verification/Times.java b/src/main/java/org/mockito/internal/verification/Times.java
index e786a23..122ba64 100644
--- a/src/main/java/org/mockito/internal/verification/Times.java
+++ b/src/main/java/org/mockito/internal/verification/Times.java
@@ -2,19 +2,19 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification;
import static org.mockito.internal.verification.checkers.MissingInvocationChecker.checkMissingInvocation;
import static org.mockito.internal.verification.checkers.NumberOfInvocationsChecker.checkNumberOfInvocations;
import java.util.List;
+
import org.mockito.exceptions.base.MockitoException;
-import org.mockito.invocation.MatchableInvocation;
import org.mockito.internal.verification.api.VerificationData;
import org.mockito.internal.verification.api.VerificationDataInOrder;
import org.mockito.internal.verification.api.VerificationInOrderMode;
import org.mockito.invocation.Invocation;
+import org.mockito.invocation.MatchableInvocation;
import org.mockito.verification.VerificationMode;
public class Times implements VerificationInOrderMode, VerificationMode {
@@ -34,10 +34,11 @@
MatchableInvocation wanted = data.getTarget();
if (wantedCount > 0) {
- checkMissingInvocation(data.getAllInvocations(), data.getTarget());
+ checkMissingInvocation(data.getAllInvocations(), data.getTarget());
}
checkNumberOfInvocations(invocations, wanted, wantedCount);
}
+
@Override
public void verifyInOrder(VerificationDataInOrder data) {
List<Invocation> allInvocations = data.getAllInvocations();
diff --git a/src/main/java/org/mockito/internal/verification/VerificationDataImpl.java b/src/main/java/org/mockito/internal/verification/VerificationDataImpl.java
index d4fd127..4746130 100644
--- a/src/main/java/org/mockito/internal/verification/VerificationDataImpl.java
+++ b/src/main/java/org/mockito/internal/verification/VerificationDataImpl.java
@@ -4,17 +4,17 @@
*/
package org.mockito.internal.verification;
+import static org.mockito.internal.exceptions.Reporter.cannotVerifyToString;
+import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
+
+import java.util.List;
+
import org.mockito.internal.invocation.InvocationMatcher;
import org.mockito.internal.stubbing.InvocationContainerImpl;
import org.mockito.internal.verification.api.VerificationData;
import org.mockito.invocation.Invocation;
import org.mockito.invocation.MatchableInvocation;
-import java.util.List;
-
-import static org.mockito.internal.exceptions.Reporter.cannotVerifyToString;
-import static org.mockito.internal.util.ObjectMethodsGuru.isToStringMethod;
-
public class VerificationDataImpl implements VerificationData {
private final InvocationMatcher wanted;
diff --git a/src/main/java/org/mockito/internal/verification/VerificationEventImpl.java b/src/main/java/org/mockito/internal/verification/VerificationEventImpl.java
index bf85055..56fabce 100644
--- a/src/main/java/org/mockito/internal/verification/VerificationEventImpl.java
+++ b/src/main/java/org/mockito/internal/verification/VerificationEventImpl.java
@@ -14,26 +14,30 @@
private final VerificationData data;
private final Throwable cause;
-
- public VerificationEventImpl(Object mock, VerificationMode mode, VerificationData data, Throwable cause) {
+ public VerificationEventImpl(
+ Object mock, VerificationMode mode, VerificationData data, Throwable cause) {
this.mock = mock;
this.mode = mode;
this.data = data;
this.cause = cause;
}
+ @Override
public Object getMock() {
return mock;
}
+ @Override
public VerificationMode getMode() {
return mode;
}
+ @Override
public VerificationData getData() {
return data;
}
+ @Override
public Throwable getVerificationError() {
return cause;
}
diff --git a/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java b/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java
index 1f8e8b6..b3ba446 100644
--- a/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java
+++ b/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java
@@ -2,12 +2,11 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification;
import org.mockito.verification.VerificationMode;
-public class VerificationModeFactory {
+public final class VerificationModeFactory {
public static VerificationMode atLeastOnce() {
return atLeast(1);
@@ -18,7 +17,7 @@
}
public static VerificationMode only() {
- return new Only(); //TODO make exception message nicer
+ return new Only(); // TODO make exception message nicer
}
public static Times times(int wantedNumberOfInvocations) {
@@ -26,13 +25,21 @@
}
public static Calls calls(int wantedNumberOfInvocations) {
- return new Calls( wantedNumberOfInvocations );
+ return new Calls(wantedNumberOfInvocations);
}
public static NoMoreInteractions noMoreInteractions() {
return new NoMoreInteractions();
}
+ public static NoInteractions noInteractions() {
+ return new NoInteractions();
+ }
+
+ public static VerificationMode atMostOnce() {
+ return atMost(1);
+ }
+
public static VerificationMode atMost(int maxNumberOfInvocations) {
return new AtMost(maxNumberOfInvocations);
}
@@ -47,4 +54,6 @@
public static VerificationMode description(VerificationMode mode, String description) {
return new Description(mode, description);
}
+
+ private VerificationModeFactory() {}
}
diff --git a/src/main/java/org/mockito/internal/verification/VerificationOverTimeImpl.java b/src/main/java/org/mockito/internal/verification/VerificationOverTimeImpl.java
index aa91dab..2e7b8e7 100644
--- a/src/main/java/org/mockito/internal/verification/VerificationOverTimeImpl.java
+++ b/src/main/java/org/mockito/internal/verification/VerificationOverTimeImpl.java
@@ -32,7 +32,11 @@
* the delegate is satisfied and the full duration has passed (as in
* {@link org.mockito.verification.VerificationAfterDelay}).
*/
- public VerificationOverTimeImpl(long pollingPeriodMillis, long durationMillis, VerificationMode delegate, boolean returnOnSuccess) {
+ public VerificationOverTimeImpl(
+ long pollingPeriodMillis,
+ long durationMillis,
+ VerificationMode delegate,
+ boolean returnOnSuccess) {
this(pollingPeriodMillis, delegate, returnOnSuccess, new Timer(durationMillis));
}
@@ -47,7 +51,11 @@
* {@link org.mockito.verification.VerificationAfterDelay}).
* @param timer Checker of whether the duration of the verification is still acceptable
*/
- public VerificationOverTimeImpl(long pollingPeriodMillis, VerificationMode delegate, boolean returnOnSuccess, Timer timer) {
+ public VerificationOverTimeImpl(
+ long pollingPeriodMillis,
+ VerificationMode delegate,
+ boolean returnOnSuccess,
+ Timer timer) {
this.pollingPeriodMillis = pollingPeriodMillis;
this.delegate = delegate;
this.returnOnSuccess = returnOnSuccess;
@@ -69,6 +77,7 @@
*
* @throws MockitoAssertionError if the delegate verification mode does not succeed before the timeout
*/
+ @Override
public void verify(VerificationData data) {
AssertionError error = null;
@@ -82,10 +91,7 @@
} else {
error = null;
}
- } catch (MockitoAssertionError e) {
- error = handleVerifyException(e);
- }
- catch (AssertionError e) {
+ } catch (AssertionError e) {
error = handleVerifyException(e);
}
}
@@ -105,11 +111,13 @@
}
protected boolean canRecoverFromFailure(VerificationMode verificationMode) {
- return !(verificationMode instanceof AtMost || verificationMode instanceof NoMoreInteractions);
+ return !(verificationMode instanceof AtMost
+ || verificationMode instanceof NoMoreInteractions);
}
public VerificationOverTimeImpl copyWithVerificationMode(VerificationMode verificationMode) {
- return new VerificationOverTimeImpl(pollingPeriodMillis, timer.duration(), verificationMode, returnOnSuccess);
+ return new VerificationOverTimeImpl(
+ pollingPeriodMillis, timer.duration(), verificationMode, returnOnSuccess);
}
private void sleep(long sleep) {
@@ -120,11 +128,6 @@
}
}
- @Override
- public VerificationMode description(String description) {
- return VerificationModeFactory.description(this, description);
- }
-
public boolean isReturnOnSuccess() {
return returnOnSuccess;
}
diff --git a/src/main/java/org/mockito/internal/verification/VerificationWrapper.java b/src/main/java/org/mockito/internal/verification/VerificationWrapper.java
index b471342..6bc592a 100644
--- a/src/main/java/org/mockito/internal/verification/VerificationWrapper.java
+++ b/src/main/java/org/mockito/internal/verification/VerificationWrapper.java
@@ -7,22 +7,26 @@
import org.mockito.internal.verification.api.VerificationData;
import org.mockito.verification.VerificationMode;
-public abstract class VerificationWrapper<WrapperType extends VerificationMode> implements VerificationMode {
+public abstract class VerificationWrapper<WrapperT extends VerificationMode>
+ implements VerificationMode {
- protected final WrapperType wrappedVerification;
+ protected final WrapperT wrappedVerification;
- public VerificationWrapper(WrapperType wrappedVerification) {
+ public VerificationWrapper(WrapperT wrappedVerification) {
this.wrappedVerification = wrappedVerification;
}
+ @Override
public void verify(VerificationData data) {
wrappedVerification.verify(data);
}
- protected abstract VerificationMode copySelfWithNewVerificationMode(VerificationMode verificationMode);
+ protected abstract VerificationMode copySelfWithNewVerificationMode(
+ VerificationMode verificationMode);
public VerificationMode times(int wantedNumberOfInvocations) {
- return copySelfWithNewVerificationMode(VerificationModeFactory.times(wantedNumberOfInvocations));
+ return copySelfWithNewVerificationMode(
+ VerificationModeFactory.times(wantedNumberOfInvocations));
}
public VerificationMode never() {
@@ -34,15 +38,20 @@
}
public VerificationMode atLeast(int minNumberOfInvocations) {
- return copySelfWithNewVerificationMode(VerificationModeFactory.atLeast(minNumberOfInvocations));
+ return copySelfWithNewVerificationMode(
+ VerificationModeFactory.atLeast(minNumberOfInvocations));
+ }
+
+ public VerificationMode atMostOnce() {
+ return copySelfWithNewVerificationMode(VerificationModeFactory.atMostOnce());
}
public VerificationMode atMost(int maxNumberOfInvocations) {
- return copySelfWithNewVerificationMode(VerificationModeFactory.atMost(maxNumberOfInvocations));
+ return copySelfWithNewVerificationMode(
+ VerificationModeFactory.atMost(maxNumberOfInvocations));
}
public VerificationMode only() {
return copySelfWithNewVerificationMode(VerificationModeFactory.only());
}
-
}
diff --git a/src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java b/src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java
index 840efb7..16b8c3d 100644
--- a/src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java
+++ b/src/main/java/org/mockito/internal/verification/VerificationWrapperInOrderWrapper.java
@@ -13,12 +13,15 @@
public class VerificationWrapperInOrderWrapper implements VerificationMode {
private final VerificationMode delegate;
- public VerificationWrapperInOrderWrapper(VerificationWrapper<?> verificationWrapper, InOrderImpl inOrder) {
+ public VerificationWrapperInOrderWrapper(
+ VerificationWrapper<?> verificationWrapper, InOrderImpl inOrder) {
VerificationMode verificationMode = verificationWrapper.wrappedVerification;
- VerificationMode inOrderWrappedVerificationMode = wrapInOrder(verificationWrapper, verificationMode, inOrder);
+ VerificationMode inOrderWrappedVerificationMode =
+ wrapInOrder(verificationWrapper, verificationMode, inOrder);
- delegate = verificationWrapper.copySelfWithNewVerificationMode(inOrderWrappedVerificationMode);
+ delegate =
+ verificationWrapper.copySelfWithNewVerificationMode(inOrderWrappedVerificationMode);
}
@Override
@@ -26,30 +29,33 @@
delegate.verify(data);
}
- @Override
- public VerificationMode description(String description) {
- return VerificationModeFactory.description(this, description);
- }
-
- private VerificationMode wrapInOrder(VerificationWrapper<?> verificationWrapper, VerificationMode verificationMode, InOrderImpl inOrder) {
+ private VerificationMode wrapInOrder(
+ VerificationWrapper<?> verificationWrapper,
+ VerificationMode verificationMode,
+ InOrderImpl inOrder) {
if (verificationMode instanceof VerificationInOrderMode) {
- final VerificationInOrderMode verificationInOrderMode = (VerificationInOrderMode)verificationMode;
+ final VerificationInOrderMode verificationInOrderMode =
+ (VerificationInOrderMode) verificationMode;
return new InOrderWrapper(verificationInOrderMode, inOrder);
}
if (verificationMode instanceof VerificationOverTimeImpl) {
- final VerificationOverTimeImpl verificationOverTime = (VerificationOverTimeImpl)verificationMode;
+ final VerificationOverTimeImpl verificationOverTime =
+ (VerificationOverTimeImpl) verificationMode;
if (verificationOverTime.isReturnOnSuccess()) {
- return new VerificationOverTimeImpl(verificationOverTime.getPollingPeriodMillis(),
+ return new VerificationOverTimeImpl(
+ verificationOverTime.getPollingPeriodMillis(),
verificationOverTime.getTimer().duration(),
- wrapInOrder(verificationWrapper, verificationOverTime.getDelegate(), inOrder),
+ wrapInOrder(
+ verificationWrapper, verificationOverTime.getDelegate(), inOrder),
verificationOverTime.isReturnOnSuccess());
}
}
- //TODO ugly exception message!!!
- throw new MockitoException(verificationMode.getClass().getSimpleName() +
- " is not implemented to work with InOrder wrapped inside a " +
- verificationWrapper.getClass().getSimpleName());
+ // TODO ugly exception message!!!
+ throw new MockitoException(
+ verificationMode.getClass().getSimpleName()
+ + " is not implemented to work with InOrder wrapped inside a "
+ + verificationWrapper.getClass().getSimpleName());
}
}
diff --git a/src/main/java/org/mockito/internal/verification/api/InOrderContext.java b/src/main/java/org/mockito/internal/verification/api/InOrderContext.java
index c6953be..9672d7e 100644
--- a/src/main/java/org/mockito/internal/verification/api/InOrderContext.java
+++ b/src/main/java/org/mockito/internal/verification/api/InOrderContext.java
@@ -11,5 +11,4 @@
boolean isVerified(Invocation invocation);
void markVerified(Invocation i);
-
}
diff --git a/src/main/java/org/mockito/internal/verification/api/VerificationData.java b/src/main/java/org/mockito/internal/verification/api/VerificationData.java
index fd102ed..bc69920 100644
--- a/src/main/java/org/mockito/internal/verification/api/VerificationData.java
+++ b/src/main/java/org/mockito/internal/verification/api/VerificationData.java
@@ -4,12 +4,12 @@
*/
package org.mockito.internal.verification.api;
+import java.util.List;
+
import org.mockito.internal.invocation.InvocationMatcher;
import org.mockito.invocation.Invocation;
import org.mockito.invocation.MatchableInvocation;
-import java.util.List;
-
/**
* Data needed to perform verification of interactions.
* This interface is considered public even though it lives in private package.
diff --git a/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrder.java b/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrder.java
index 0f46063..6103f57 100644
--- a/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrder.java
+++ b/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrder.java
@@ -16,5 +16,4 @@
MatchableInvocation getWanted();
InOrderContext getOrderingContext();
-
}
diff --git a/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrderImpl.java b/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrderImpl.java
index 4013b07..838ce5b 100644
--- a/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrderImpl.java
+++ b/src/main/java/org/mockito/internal/verification/api/VerificationDataInOrderImpl.java
@@ -15,20 +15,24 @@
private final List<Invocation> allInvocations;
private final MatchableInvocation wanted;
- public VerificationDataInOrderImpl(InOrderContext inOrder, List<Invocation> allInvocations, MatchableInvocation wanted) {
+ public VerificationDataInOrderImpl(
+ InOrderContext inOrder, List<Invocation> allInvocations, MatchableInvocation wanted) {
this.inOrder = inOrder;
this.allInvocations = allInvocations;
this.wanted = wanted;
}
+ @Override
public List<Invocation> getAllInvocations() {
return allInvocations;
}
+ @Override
public InOrderContext getOrderingContext() {
return inOrder;
}
+ @Override
public MatchableInvocation getWanted() {
return 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 af31d60..060ea09 100644
--- a/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java
+++ b/src/main/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingTool.java
@@ -4,25 +4,31 @@
*/
package org.mockito.internal.verification.argumentmatching;
-import org.mockito.ArgumentMatcher;
-import org.mockito.internal.matchers.ContainsExtraTypeInfo;
-
+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;
@SuppressWarnings("unchecked")
public class ArgumentMatchingTool {
- private ArgumentMatchingTool(){}
+ private ArgumentMatchingTool() {}
/**
* Suspiciously not matching arguments are those that don't match, the toString() representation is the same but types are different.
*/
- public static Integer[] getSuspiciouslyNotMatchingArgsIndexes(List<ArgumentMatcher> matchers, Object[] arguments) {
+ public static Integer[] getSuspiciouslyNotMatchingArgsIndexes(
+ List<ArgumentMatcher> matchers, Object[] arguments) {
if (matchers.size() != arguments.length) {
return new Integer[0];
}
- List<Integer> suspicious = new LinkedList<Integer>();
+ List<Integer> suspicious = new LinkedList<>();
int i = 0;
for (ArgumentMatcher m : matchers) {
if (m instanceof ContainsExtraTypeInfo
@@ -45,6 +51,39 @@
}
private static boolean toStringEquals(ArgumentMatcher m, Object arg) {
- return m.toString().equals(arg == null ? "null" : arg.toString());
+ 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) {
+ Map<String, Set<String>> classesHavingSameName = new HashMap<>();
+ for (ArgumentMatcher m : matchers) {
+ if (m instanceof ContainsExtraTypeInfo) {
+ 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());
+ }
+ 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/AtLeastXNumberOfInvocationsChecker.java b/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java
index d0eb0b5..68a1af1 100644
--- a/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java
+++ b/src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java
@@ -2,47 +2,57 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification.checkers;
-import java.util.List;
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.Location;
-import org.mockito.invocation.MatchableInvocation;
-
-import static org.mockito.internal.exceptions.Reporter.tooLittleActualInvocations;
-import static org.mockito.internal.exceptions.Reporter.tooLittleActualInvocationsInOrder;
+import static org.mockito.internal.exceptions.Reporter.tooFewActualInvocations;
+import static org.mockito.internal.exceptions.Reporter.tooFewActualInvocationsInOrder;
import static org.mockito.internal.invocation.InvocationMarker.markVerified;
import static org.mockito.internal.invocation.InvocationMarker.markVerifiedInOrder;
import static org.mockito.internal.invocation.InvocationsFinder.findAllMatchingUnverifiedChunks;
import static org.mockito.internal.invocation.InvocationsFinder.findInvocations;
import static org.mockito.internal.invocation.InvocationsFinder.getAllLocations;
-public class AtLeastXNumberOfInvocationsChecker {
+import java.util.List;
- public static void checkAtLeastNumberOfInvocations(List<Invocation> invocations, MatchableInvocation wanted, int wantedCount) {
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.Location;
+import org.mockito.invocation.MatchableInvocation;
+
+public final class AtLeastXNumberOfInvocationsChecker {
+
+ public static void checkAtLeastNumberOfInvocations(
+ List<Invocation> invocations, MatchableInvocation wanted, int wantedCount) {
List<Invocation> actualInvocations = findInvocations(invocations, wanted);
int actualCount = actualInvocations.size();
if (wantedCount > actualCount) {
List<Location> allLocations = getAllLocations(actualInvocations);
- throw tooLittleActualInvocations(new AtLeastDiscrepancy(wantedCount, actualCount), wanted, allLocations);
+ throw tooFewActualInvocations(
+ new AtLeastDiscrepancy(wantedCount, actualCount), wanted, allLocations);
}
markVerified(actualInvocations, wanted);
}
- public static void checkAtLeastNumberOfInvocations(List<Invocation> invocations, MatchableInvocation wanted, int wantedCount,InOrderContext orderingContext) {
- List<Invocation> chunk = findAllMatchingUnverifiedChunks(invocations, wanted, orderingContext);
+ public static void checkAtLeastNumberOfInvocations(
+ List<Invocation> invocations,
+ MatchableInvocation wanted,
+ int wantedCount,
+ InOrderContext orderingContext) {
+ List<Invocation> chunk =
+ findAllMatchingUnverifiedChunks(invocations, wanted, orderingContext);
int actualCount = chunk.size();
if (wantedCount > actualCount) {
List<Location> allLocations = getAllLocations(chunk);
- throw tooLittleActualInvocationsInOrder(new AtLeastDiscrepancy(wantedCount, actualCount), wanted, allLocations);
+ throw tooFewActualInvocationsInOrder(
+ new AtLeastDiscrepancy(wantedCount, actualCount), wanted, allLocations);
}
markVerifiedInOrder(chunk, wanted, orderingContext);
}
+
+ private AtLeastXNumberOfInvocationsChecker() {}
}
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 3f89c77..aeb86b9 100644
--- a/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java
+++ b/src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification.checkers;
import static org.mockito.internal.exceptions.Reporter.argumentsAreDifferent;
@@ -12,24 +11,28 @@
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;
import org.mockito.internal.verification.api.InOrderContext;
import org.mockito.invocation.Invocation;
+import org.mockito.invocation.Location;
import org.mockito.invocation.MatchableInvocation;
public class MissingInvocationChecker {
- private MissingInvocationChecker() {
- }
+ private MissingInvocationChecker() {}
- public static void checkMissingInvocation(List<Invocation> invocations, MatchableInvocation wanted) {
+ public static void checkMissingInvocation(
+ List<Invocation> invocations, MatchableInvocation wanted) {
List<Invocation> actualInvocations = findInvocations(invocations, wanted);
- if (!actualInvocations.isEmpty()){
+ if (!actualInvocations.isEmpty()) {
return;
}
@@ -38,13 +41,29 @@
throw wantedButNotInvoked(wanted, invocations);
}
- Integer[] indexesOfSuspiciousArgs = getSuspiciouslyNotMatchingArgsIndexes(wanted.getMatchers(), similar.getArguments());
- SmartPrinter smartPrinter = new SmartPrinter(wanted, similar, indexesOfSuspiciousArgs);
- throw argumentsAreDifferent(smartPrinter.getWanted(), smartPrinter.getActual(), similar.getLocation());
+ Integer[] indexesOfSuspiciousArgs =
+ getSuspiciouslyNotMatchingArgsIndexes(wanted.getMatchers(), similar.getArguments());
+ Set<String> classesWithSameSimpleName =
+ getNotMatchingArgsWithSameName(wanted.getMatchers(), similar.getArguments());
+ SmartPrinter smartPrinter =
+ new SmartPrinter(
+ wanted, invocations, indexesOfSuspiciousArgs, classesWithSameSimpleName);
+ List<Location> actualLocations =
+ ListUtil.convert(
+ invocations,
+ new ListUtil.Converter<Invocation, Location>() {
+ @Override
+ public Location convert(Invocation invocation) {
+ return invocation.getLocation();
+ }
+ });
+ throw argumentsAreDifferent(
+ smartPrinter.getWanted(), smartPrinter.getActuals(), actualLocations);
}
- public static void checkMissingInvocation(List<Invocation> invocations, MatchableInvocation wanted, InOrderContext context) {
+ public static void checkMissingInvocation(
+ List<Invocation> invocations, MatchableInvocation wanted, InOrderContext context) {
List<Invocation> chunk = findAllMatchingUnverifiedChunks(invocations, wanted, context);
if (!chunk.isEmpty()) {
diff --git a/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java b/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java
index 1dfc2f1..78a276e 100644
--- a/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java
+++ b/src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java
@@ -2,20 +2,11 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification.checkers;
-import java.util.Arrays;
-import java.util.List;
-import org.mockito.internal.reporting.Discrepancy;
-import org.mockito.internal.verification.api.InOrderContext;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.Location;
-import org.mockito.invocation.MatchableInvocation;
-
import static org.mockito.internal.exceptions.Reporter.neverWantedButInvoked;
-import static org.mockito.internal.exceptions.Reporter.tooLittleActualInvocations;
-import static org.mockito.internal.exceptions.Reporter.tooLittleActualInvocationsInOrder;
+import static org.mockito.internal.exceptions.Reporter.tooFewActualInvocations;
+import static org.mockito.internal.exceptions.Reporter.tooFewActualInvocationsInOrder;
import static org.mockito.internal.exceptions.Reporter.tooManyActualInvocations;
import static org.mockito.internal.exceptions.Reporter.tooManyActualInvocationsInOrder;
import static org.mockito.internal.invocation.InvocationMarker.markVerified;
@@ -25,55 +16,79 @@
import static org.mockito.internal.invocation.InvocationsFinder.findMatchingChunk;
import static org.mockito.internal.invocation.InvocationsFinder.getAllLocations;
+import java.util.Arrays;
+import java.util.List;
+
+import org.mockito.internal.reporting.Discrepancy;
+import org.mockito.internal.verification.api.InOrderContext;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.Location;
+import org.mockito.invocation.MatchableInvocation;
+
public class NumberOfInvocationsChecker {
- private NumberOfInvocationsChecker() {
- }
+ private NumberOfInvocationsChecker() {}
- public static void checkNumberOfInvocations(List<Invocation> invocations, MatchableInvocation wanted, int wantedCount) {
+ public static void checkNumberOfInvocations(
+ List<Invocation> invocations, MatchableInvocation wanted, int wantedCount) {
List<Invocation> actualInvocations = findInvocations(invocations, wanted);
int actualCount = actualInvocations.size();
if (wantedCount > actualCount) {
List<Location> allLocations = getAllLocations(actualInvocations);
- throw tooLittleActualInvocations(new Discrepancy(wantedCount, actualCount), wanted, allLocations);
+ throw tooFewActualInvocations(
+ new Discrepancy(wantedCount, actualCount), wanted, allLocations);
}
if (wantedCount == 0 && actualCount > 0) {
- throw neverWantedButInvoked(wanted, getAllLocations(actualInvocations));
+ throw neverWantedButInvoked(wanted, actualInvocations);
}
if (wantedCount < actualCount) {
- throw tooManyActualInvocations(wantedCount, actualCount, wanted, getAllLocations(actualInvocations));
+ throw tooManyActualInvocations(
+ wantedCount, actualCount, wanted, getAllLocations(actualInvocations));
}
markVerified(actualInvocations, wanted);
}
- public static void checkNumberOfInvocations(List<Invocation> invocations, MatchableInvocation wanted, int wantedCount, InOrderContext context) {
+ public static void checkNumberOfInvocations(
+ List<Invocation> invocations,
+ MatchableInvocation wanted,
+ int wantedCount,
+ InOrderContext context) {
List<Invocation> chunk = findMatchingChunk(invocations, wanted, wantedCount, context);
int actualCount = chunk.size();
if (wantedCount > actualCount) {
List<Location> allLocations = getAllLocations(chunk);
- throw tooLittleActualInvocationsInOrder(new Discrepancy(wantedCount, actualCount), wanted, allLocations);
+ throw tooFewActualInvocationsInOrder(
+ new Discrepancy(wantedCount, actualCount), wanted, allLocations);
}
if (wantedCount < actualCount) {
- throw tooManyActualInvocationsInOrder(wantedCount, actualCount, wanted, getAllLocations(chunk));
+ throw tooManyActualInvocationsInOrder(
+ wantedCount, actualCount, wanted, getAllLocations(chunk));
}
markVerifiedInOrder(chunk, wanted, context);
}
- public static void checkNumberOfInvocationsNonGreedy(List<Invocation> invocations, MatchableInvocation wanted, int wantedCount, InOrderContext context) {
+ public static void checkNumberOfInvocationsNonGreedy(
+ List<Invocation> invocations,
+ MatchableInvocation wanted,
+ int wantedCount,
+ InOrderContext context) {
int actualCount = 0;
Location lastLocation = null;
- while( actualCount < wantedCount ){
- Invocation next = findFirstMatchingUnverifiedInvocation(invocations, wanted, context );
- if( next == null ){
- throw tooLittleActualInvocationsInOrder(new Discrepancy(wantedCount, actualCount), wanted, Arrays.asList(lastLocation));
+ while (actualCount < wantedCount) {
+ Invocation next = findFirstMatchingUnverifiedInvocation(invocations, wanted, context);
+ if (next == null) {
+ throw tooFewActualInvocationsInOrder(
+ new Discrepancy(wantedCount, actualCount),
+ wanted,
+ Arrays.asList(lastLocation));
}
- markVerified( next, wanted );
- context.markVerified( next );
+ markVerified(next, wanted);
+ context.markVerified(next);
lastLocation = next.getLocation();
actualCount++;
}
diff --git a/src/main/java/org/mockito/invocation/DescribedInvocation.java b/src/main/java/org/mockito/invocation/DescribedInvocation.java
index fc975ab..1c54201 100644
--- a/src/main/java/org/mockito/invocation/DescribedInvocation.java
+++ b/src/main/java/org/mockito/invocation/DescribedInvocation.java
@@ -4,7 +4,6 @@
*/
package org.mockito.invocation;
-
/**
* Provides information about the invocation, specifically a human readable description and the location.
*/
@@ -15,6 +14,7 @@
*
* @return the description of this invocation.
*/
+ @Override
String toString();
/**
diff --git a/src/main/java/org/mockito/invocation/Invocation.java b/src/main/java/org/mockito/invocation/Invocation.java
index 131db84..7aeecce 100644
--- a/src/main/java/org/mockito/invocation/Invocation.java
+++ b/src/main/java/org/mockito/invocation/Invocation.java
@@ -4,6 +4,9 @@
*/
package org.mockito.invocation;
+import java.util.List;
+
+import org.mockito.ArgumentMatcher;
import org.mockito.NotExtensible;
/**
@@ -34,9 +37,8 @@
*/
int getSequenceNumber();
- /**
- * @return the location in code of this invocation.
- */
+ /** @return the location in code of this invocation. */
+ @Override
Location getLocation();
/**
@@ -48,6 +50,16 @@
Object[] getRawArguments();
/**
+ * Wraps each argument using {@link org.mockito.ArgumentMatchers#eq(Object)} or
+ * {@link org.mockito.AdditionalMatchers#aryEq(Object[])}
+ * Used internally for the purposes of human-readable invocation printing.
+ *
+ * @return a list of {@link ArgumentMatcher} wrapping each of this invocation arguments
+ * @since 2.25.6
+ */
+ List<ArgumentMatcher> getArgumentsAsMatchers();
+
+ /**
* Returns unprocessed arguments whereas {@link #getArguments()} returns
* arguments already processed (e.g. varargs expended, etc.).
*
diff --git a/src/main/java/org/mockito/invocation/InvocationFactory.java b/src/main/java/org/mockito/invocation/InvocationFactory.java
index 1803718..3b2ef4c 100644
--- a/src/main/java/org/mockito/invocation/InvocationFactory.java
+++ b/src/main/java/org/mockito/invocation/InvocationFactory.java
@@ -4,14 +4,14 @@
*/
package org.mockito.invocation;
-import org.mockito.Incubating;
-import org.mockito.MockitoFramework;
-import org.mockito.mock.MockCreationSettings;
-
import java.io.Serializable;
import java.lang.reflect.Method;
import java.util.concurrent.Callable;
+import org.mockito.Incubating;
+import org.mockito.MockitoFramework;
+import org.mockito.mock.MockCreationSettings;
+
/**
* Available via {@link MockitoFramework#getInvocationFactory()}.
* Provides means to create instances of {@link Invocation} objects.
@@ -47,7 +47,12 @@
* @since 2.10.0
*/
@Deprecated
- Invocation createInvocation(Object target, MockCreationSettings settings, Method method, Callable realMethod, Object... args);
+ Invocation createInvocation(
+ Object target,
+ MockCreationSettings settings,
+ Method method,
+ Callable realMethod,
+ Object... args);
/**
* Behavior of the real method.
@@ -73,5 +78,10 @@
* @since 2.14.0
*/
@Incubating
- Invocation createInvocation(Object target, MockCreationSettings settings, Method method, RealMethodBehavior realMethod, Object... args);
+ Invocation createInvocation(
+ Object target,
+ MockCreationSettings settings,
+ Method method,
+ RealMethodBehavior realMethod,
+ Object... args);
}
diff --git a/src/main/java/org/mockito/invocation/InvocationOnMock.java b/src/main/java/org/mockito/invocation/InvocationOnMock.java
index 345ddb9..269926e 100644
--- a/src/main/java/org/mockito/invocation/InvocationOnMock.java
+++ b/src/main/java/org/mockito/invocation/InvocationOnMock.java
@@ -2,18 +2,20 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.invocation;
import java.io.Serializable;
import java.lang.reflect.Method;
+import org.mockito.NotExtensible;
+
/**
* An invocation on a mock.
*
* <p>
* A placeholder for mock, the method that was called and the arguments that were passed.
*/
+@NotExtensible
public interface InvocationOnMock extends Serializable {
/**
@@ -44,6 +46,10 @@
*
* Can lookup in expanded arguments form {@link #getArguments()}.
*
+ * This method is preferred over {@link #getArgument(int, Class)} for readability. Please read
+ * the documentation of {@link #getArgument(int, Class)} for an overview of situations when
+ * that method is preferred over this one.
+ *
* @param index argument index
* @return casted argument at the given index
* @since 2.1.0
@@ -51,6 +57,27 @@
<T> T getArgument(int index);
/**
+ * Returns casted argument at the given index. This method is analogous to
+ * {@link #getArgument(int)}, but is necessary to circumvent issues when dealing with generics.
+ *
+ * In general, {@link #getArgument(int)} is the appropriate function to use. This particular
+ * function is only necessary if you are doing one of the following things:
+ *
+ * <ol>
+ * <li>You want to directly invoke a method on the result of {@link #getArgument(int)}.</li>
+ * <li>You want to directly pass the result of the invocation into a function that accepts a generic parameter.</li>
+ * </ol>
+ *
+ * If you prefer to use {@link #getArgument(int)} instead, you can circumvent the compilation
+ * issues by storing the intermediate result into a local variable with the correct type.
+ *
+ * @param index argument index
+ * @param clazz class to cast the argument to
+ * @return casted argument at the given index
+ */
+ <T> T getArgument(int index, Class<T> clazz);
+
+ /**
* calls real method
* <p>
* <b>Warning:</b> depending on the real implementation it might throw exceptions
diff --git a/src/main/java/org/mockito/invocation/Location.java b/src/main/java/org/mockito/invocation/Location.java
index e362704..ea3c274 100644
--- a/src/main/java/org/mockito/invocation/Location.java
+++ b/src/main/java/org/mockito/invocation/Location.java
@@ -4,14 +4,27 @@
*/
package org.mockito.invocation;
+import org.mockito.NotExtensible;
+
/**
* Describes the location of something in the source code.
*/
+@NotExtensible
public interface Location {
/**
- * @return the location
+ * Human readable location in the source code, see {@link Invocation#getLocation()}
+ *
+ * @return location
*/
+ @Override
String toString();
+ /**
+ * Source file of this location
+ *
+ * @return source file
+ * @since 2.24.6
+ */
+ String getSourceFile();
}
diff --git a/src/main/java/org/mockito/invocation/MatchableInvocation.java b/src/main/java/org/mockito/invocation/MatchableInvocation.java
index ff0290a..96ddf9e 100644
--- a/src/main/java/org/mockito/invocation/MatchableInvocation.java
+++ b/src/main/java/org/mockito/invocation/MatchableInvocation.java
@@ -4,10 +4,10 @@
*/
package org.mockito.invocation;
-import org.mockito.ArgumentMatcher;
-
import java.util.List;
+import org.mockito.ArgumentMatcher;
+
/**
* <code>MatchableInvocation</code> wraps {@link Invocation} instance
* and holds argument matchers associated with that invocation.
diff --git a/src/main/java/org/mockito/invocation/MockHandler.java b/src/main/java/org/mockito/invocation/MockHandler.java
index 273cdb5..d20b76b 100644
--- a/src/main/java/org/mockito/invocation/MockHandler.java
+++ b/src/main/java/org/mockito/invocation/MockHandler.java
@@ -4,12 +4,12 @@
*/
package org.mockito.invocation;
+import java.io.Serializable;
+
import org.mockito.Incubating;
import org.mockito.MockSettings;
import org.mockito.mock.MockCreationSettings;
-import java.io.Serializable;
-
/**
* Mockito handler of an invocation on a mock. This is a core part of the API, the heart of Mockito.
* See also the {@link org.mockito.plugins.MockMaker}.
diff --git a/src/main/java/org/mockito/junit/MockitoJUnit.java b/src/main/java/org/mockito/junit/MockitoJUnit.java
index da9428b..825303a 100644
--- a/src/main/java/org/mockito/junit/MockitoJUnit.java
+++ b/src/main/java/org/mockito/junit/MockitoJUnit.java
@@ -4,10 +4,12 @@
*/
package org.mockito.junit;
+import org.junit.rules.TestRule;
import org.mockito.Incubating;
+import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.junit.JUnitRule;
+import org.mockito.internal.junit.JUnitTestRule;
import org.mockito.internal.junit.VerificationCollectorImpl;
-import org.mockito.internal.util.ConsoleMockitoLogger;
import org.mockito.quality.Strictness;
/**
@@ -15,12 +17,12 @@
* <li>
* <ul>JUnit Rules - see {@link MockitoRule}</ul>
* <ul>JUnit runners - see {@link MockitoJUnitRunner}</ul>
- * <ul><a href="http://javadoc.io/page/org.mockito/mockito-junit-jupiter/latest/org/mockito/junit/jupiter/MockitoExtension.html">JUnit Jupiter extension</a></ul>
+ * <ul><a href="http://javadoc.io/doc/org.mockito/mockito-junit-jupiter/latest/org/mockito/junit/jupiter/MockitoExtension.html">JUnit Jupiter extension</a></ul>
* </li>
*
* @since 1.10.17
*/
-public class MockitoJUnit {
+public final class MockitoJUnit {
/**
* Creates rule instance that initiates @Mocks
@@ -30,7 +32,21 @@
* @since 1.10.17
*/
public static MockitoRule rule() {
- return new JUnitRule(new ConsoleMockitoLogger(), Strictness.WARN);
+ return new JUnitRule(Plugins.getMockitoLogger(), Strictness.WARN);
+ }
+
+ /**
+ * Creates a rule instance that initiates @Mocks and is a {@link TestRule}. Use this method
+ * only when you need to explicitly need a {@link TestRule}, for example if you need to compose
+ * multiple rules using a {@link org.junit.rules.RuleChain}. Otherwise, always prefer {@link #rule()}
+ * See {@link MockitoRule}.
+ *
+ * @param testInstance The instance to initiate mocks for
+ * @return the rule instance
+ * @since 3.3.0
+ */
+ public static MockitoTestRule testRule(Object testInstance) {
+ return new JUnitTestRule(Plugins.getMockitoLogger(), Strictness.WARN, testInstance);
}
/**
@@ -44,4 +60,6 @@
public static VerificationCollector collector() {
return new VerificationCollectorImpl();
}
+
+ private MockitoJUnit() {}
}
diff --git a/src/main/java/org/mockito/junit/MockitoJUnitRunner.java b/src/main/java/org/mockito/junit/MockitoJUnitRunner.java
index 59bc92b..c59f972 100644
--- a/src/main/java/org/mockito/junit/MockitoJUnitRunner.java
+++ b/src/main/java/org/mockito/junit/MockitoJUnitRunner.java
@@ -4,6 +4,8 @@
*/
package org.mockito.junit;
+import java.lang.reflect.InvocationTargetException;
+
import org.junit.runner.Description;
import org.junit.runner.Runner;
import org.junit.runner.manipulation.Filter;
@@ -21,9 +23,6 @@
import org.mockito.quality.MockitoHint;
import org.mockito.quality.Strictness;
-import java.lang.reflect.InvocationTargetException;
-
-
/**
* Mockito JUnit Runner keeps tests clean and improves debugging experience.
* Make sure to try out {@link MockitoJUnitRunner.StrictStubs} which automatically
@@ -38,7 +37,7 @@
* To opt-out from this feature, use {@code}@RunWith(MockitoJUnitRunner.Silent.class){@code}
* <li>
* Initializes mocks annotated with {@link Mock},
- * so that explicit usage of {@link MockitoAnnotations#initMocks(Object)} is not necessary.
+ * so that explicit usage of {@link MockitoAnnotations#openMocks(Object)} is not necessary.
* Mocks are initialized before each test method.
* <li>
* Validates framework usage after each test method. See javadoc for {@link Mockito#validateMockitoUsage()}.
@@ -47,7 +46,7 @@
* It drives cleaner tests and improves debugging experience.
* The only reason this feature is not turned on by default
* is because it would have been an incompatible change
- * and Mockito strictly follows <a href="http://semver.org">semantic versioning</a>.
+ * and Mockito strictly follows <a href="https://semver.org">semantic versioning</a>.
* </ul>
*
* Runner is completely optional - there are other ways you can get @Mock working, for example by writing a base class.
@@ -70,7 +69,7 @@
* </code></pre>
*
* If you would like to take advantage of Mockito JUnit runner features
- * but you cannot use the runner because, for example, you use TestNG, there is a solution!
+ * but you cannot use the runner there is a solution!
* {@link MockitoSession} API is intended to offer cleaner tests and improved debuggability
* to users that cannot use Mockito's built-in JUnit support (runner or the rule).
*/
@@ -150,7 +149,8 @@
private final InternalRunner runner;
public MockitoJUnitRunner(Class<?> klass) throws InvocationTargetException {
- //by default, StrictRunner is used. We can change that potentially based on feedback from users
+ // by default, StrictRunner is used. We can change that potentially based on feedback from
+ // users
this(new StrictRunner(new RunnerFactory().createStrict(klass), klass));
}
@@ -168,8 +168,9 @@
return runner.getDescription();
}
+ @Override
public void filter(Filter filter) throws NoTestsRemainException {
- //filter is required because without it UnrootedTests show up in Eclipse
+ // filter is required because without it UnrootedTests show up in Eclipse
runner.filter(filter);
}
}
diff --git a/src/main/java/org/mockito/junit/MockitoRule.java b/src/main/java/org/mockito/junit/MockitoRule.java
index 561fff7..0869d01 100644
--- a/src/main/java/org/mockito/junit/MockitoRule.java
+++ b/src/main/java/org/mockito/junit/MockitoRule.java
@@ -10,9 +10,9 @@
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.MockitoSession;
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
import org.mockito.quality.MockitoHint;
import org.mockito.quality.Strictness;
-import org.mockito.exceptions.misusing.PotentialStubbingProblem;
/**
* Mockito JUnit Rule helps keeping tests clean.
@@ -37,7 +37,7 @@
* See also {@link MockitoHint}.
* <li>
* Initializes mocks annotated with {@link org.mockito.Mock},
- * so that explicit usage of {@link MockitoAnnotations#initMocks(Object)} is not necessary.
+ * so that explicit usage of {@link MockitoAnnotations#openMocks(Object)} is not necessary.
* Mocks are initialized before each test method.
* <li>
* Validates framework usage after each test method. See javadoc for {@link org.mockito.Mockito#validateMockitoUsage()}.
@@ -46,7 +46,7 @@
* It drives cleaner tests and improves debugging experience.
* The only reason this feature is not turned on by default
* is because it would have been an incompatible change
- * and Mockito strictly follows <a href="http://semver.org">semantic versioning</a>.
+ * and Mockito strictly follows <a href="https://semver.org">semantic versioning</a>.
*
* </ul>
* Example use:
@@ -67,7 +67,7 @@
* </code></pre>
*
* If you would like to take advantage of Mockito JUnit rule features
- * but you cannot use the rule because, for example, you use TestNG, there is a solution!
+ * but you cannot use the rule there is a solution!
* {@link MockitoSession} API is intended to offer cleaner tests and improved debuggability
* to users that cannot use Mockito's built-in JUnit support (runner or the rule).
*
diff --git a/src/main/java/org/mockito/junit/MockitoTestRule.java b/src/main/java/org/mockito/junit/MockitoTestRule.java
new file mode 100644
index 0000000..33c15e4
--- /dev/null
+++ b/src/main/java/org/mockito/junit/MockitoTestRule.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.junit;
+
+import org.junit.rules.TestRule;
+import org.mockito.Incubating;
+import org.mockito.quality.Strictness;
+
+/**
+ * Equivalent to {@link MockitoRule}, but inherits a different JUnit4 base interface {@link TestRule}.
+ * For more information, please see the documentation on {@link MockitoRule}.
+ *
+ * @since 3.3.0
+ */
+public interface MockitoTestRule extends TestRule {
+
+ /**
+ * Equivalent to {@link MockitoRule#silent()}.
+ *
+ * @since 3.3.0
+ */
+ MockitoTestRule silent();
+
+ /**
+ * Equivalent to {@link MockitoRule#strictness(Strictness)}.
+ *
+ * @since 3.3.0
+ */
+ @Incubating
+ MockitoTestRule strictness(Strictness strictness);
+}
diff --git a/src/main/java/org/mockito/listeners/MockCreationListener.java b/src/main/java/org/mockito/listeners/MockCreationListener.java
index 24a1904..7ab15f8 100644
--- a/src/main/java/org/mockito/listeners/MockCreationListener.java
+++ b/src/main/java/org/mockito/listeners/MockCreationListener.java
@@ -19,4 +19,12 @@
* @param settings the settings used for creation
*/
void onMockCreated(Object mock, MockCreationSettings settings);
+
+ /**
+ * Static mock object was just created.
+ *
+ * @param mock the type being mocked
+ * @param settings the settings used for creation
+ */
+ default void onStaticMockCreated(Class<?> mock, MockCreationSettings settings) {}
}
diff --git a/src/main/java/org/mockito/listeners/MockitoListener.java b/src/main/java/org/mockito/listeners/MockitoListener.java
index ea8dcb6..b5a4e5e 100644
--- a/src/main/java/org/mockito/listeners/MockitoListener.java
+++ b/src/main/java/org/mockito/listeners/MockitoListener.java
@@ -8,5 +8,4 @@
* Marker interface for all types of Mockito listeners.
* For more information, see {@link org.mockito.MockitoFramework#addListener(MockitoListener)}.
*/
-public interface MockitoListener {
-}
+public interface MockitoListener {}
diff --git a/src/main/java/org/mockito/internal/listeners/StubbingLookupEvent.java b/src/main/java/org/mockito/listeners/StubbingLookupEvent.java
similarity index 86%
rename from src/main/java/org/mockito/internal/listeners/StubbingLookupEvent.java
rename to src/main/java/org/mockito/listeners/StubbingLookupEvent.java
index 0d45edd..30642cc 100644
--- a/src/main/java/org/mockito/internal/listeners/StubbingLookupEvent.java
+++ b/src/main/java/org/mockito/listeners/StubbingLookupEvent.java
@@ -2,35 +2,42 @@
* Copyright (c) 2018 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-package org.mockito.internal.listeners;
+package org.mockito.listeners;
+
+import java.util.Collection;
import org.mockito.invocation.Invocation;
import org.mockito.mock.MockCreationSettings;
import org.mockito.stubbing.Stubbing;
-import java.util.Collection;
-
/**
* Represent an information about the looked up stubbing
+ *
+ * @since 2.24.6
*/
public interface StubbingLookupEvent {
+
/**
* @return The invocation that causes stubbing lookup
+ * @since 2.24.6
*/
Invocation getInvocation();
/**
* @return Looked up stubbing. It can be <code>null</code>, which indicates that the invocation was not stubbed
+ * @since 2.24.6
*/
Stubbing getStubbingFound();
/**
* @return All stubbings declared on the mock object that we are invoking
+ * @since 2.24.6
*/
Collection<Stubbing> getAllStubbings();
/**
* @return Settings of the mock object that we are invoking
+ * @since 2.24.6
*/
MockCreationSettings getMockSettings();
}
diff --git a/src/main/java/org/mockito/listeners/StubbingLookupListener.java b/src/main/java/org/mockito/listeners/StubbingLookupListener.java
new file mode 100644
index 0000000..b33e063
--- /dev/null
+++ b/src/main/java/org/mockito/listeners/StubbingLookupListener.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.listeners;
+
+import org.mockito.MockSettings;
+import org.mockito.mock.MockCreationSettings;
+
+/**
+ * When a method is called on a mock object Mockito looks up any stubbings recorded on that mock.
+ * This listener gets notified on stubbing lookup.
+ * Register listener via {@link MockSettings#stubbingLookupListeners(StubbingLookupListener...)}.
+ * This API is used by Mockito to implement {@link org.mockito.exceptions.misusing.PotentialStubbingProblem}
+ * (part of Mockito {@link org.mockito.quality.Strictness}).
+ * <p>
+ * Details: When method is called on the mock object, Mockito looks for any answer (stubbing) declared on that mock.
+ * If the stubbed answer is found, that answer is then invoked (value returned, thrown exception, etc.).
+ * If the answer is not found (e.g. that invocation was not stubbed on the mock), mock's default answer is used.
+ * This listener implementation is notified when Mockito attempts to find an answer for invocation on a mock.
+ * <p>
+ * The listeners can be accessed via {@link MockCreationSettings#getStubbingLookupListeners()}.
+ *
+ * @since 2.24.6
+ */
+public interface StubbingLookupListener {
+
+ /**
+ * Called by the framework when Mockito looked up an answer for invocation on a mock.
+ * For details, see {@link StubbingLookupListener}.
+ *
+ * @param stubbingLookupEvent - Information about the looked up stubbing
+ * @since 2.24.6
+ */
+ void onStubbingLookup(StubbingLookupEvent stubbingLookupEvent);
+}
diff --git a/src/main/java/org/mockito/mock/MockCreationSettings.java b/src/main/java/org/mockito/mock/MockCreationSettings.java
index 7e74be8..7264286 100644
--- a/src/main/java/org/mockito/mock/MockCreationSettings.java
+++ b/src/main/java/org/mockito/mock/MockCreationSettings.java
@@ -2,20 +2,20 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.mock;
+import java.util.List;
+import java.util.Set;
+
import org.mockito.Incubating;
import org.mockito.MockSettings;
import org.mockito.NotExtensible;
import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.StubbingLookupListener;
import org.mockito.listeners.VerificationStartedListener;
import org.mockito.quality.Strictness;
import org.mockito.stubbing.Answer;
-import java.util.List;
-import java.util.Set;
-
/**
* Informs about the mock settings. An immutable view of {@link org.mockito.MockSettings}.
*/
@@ -70,7 +70,17 @@
boolean isStripAnnotations();
/**
- * {@link InvocationListener} instances attached to this mock, see {@link org.mockito.MockSettings#invocationListeners}.
+ * Returns {@link StubbingLookupListener} instances attached to this mock via {@link MockSettings#stubbingLookupListeners(StubbingLookupListener...)}.
+ * The resulting list is mutable, you can add/remove listeners even after the mock was created.
+ * <p>
+ * For more details see {@link StubbingLookupListener}.
+ *
+ * @since 2.24.6
+ */
+ List<StubbingLookupListener> getStubbingLookupListeners();
+
+ /**
+ * {@link InvocationListener} instances attached to this mock, see {@link org.mockito.MockSettings#invocationListeners(InvocationListener...)}.
*/
List<InvocationListener> getInvocationListeners();
diff --git a/src/main/java/org/mockito/mock/MockName.java b/src/main/java/org/mockito/mock/MockName.java
index d3f6e7d..64ce8f7 100644
--- a/src/main/java/org/mockito/mock/MockName.java
+++ b/src/main/java/org/mockito/mock/MockName.java
@@ -9,9 +9,8 @@
*/
public interface MockName {
- /**
- * the name
- */
+ /** the name */
+ @Override
String toString();
/**
diff --git a/src/main/java/org/mockito/plugins/AnnotationEngine.java b/src/main/java/org/mockito/plugins/AnnotationEngine.java
index c60f477..c6365e9 100644
--- a/src/main/java/org/mockito/plugins/AnnotationEngine.java
+++ b/src/main/java/org/mockito/plugins/AnnotationEngine.java
@@ -13,7 +13,7 @@
* or replace mockito default engine.
*
* <p>
- * If you are interested then see implementations or source code of {@link org.mockito.MockitoAnnotations#initMocks(Object)}
+ * If you are interested then see implementations or source code of {@link org.mockito.MockitoAnnotations#openMocks(Object)}
*
* <p>This plugin mechanism supersedes the {@link org.mockito.configuration.IMockitoConfiguration}
* in regard of switching mockito components.
@@ -25,5 +25,11 @@
* @param clazz Class where to extract field information, check implementation for details
* @param testInstance Test instance
*/
- void process(Class<?> clazz, Object testInstance);
+ AutoCloseable process(Class<?> clazz, Object testInstance);
+
+ class NoAction implements AutoCloseable {
+
+ @Override
+ public void close() {}
+ }
}
diff --git a/src/main/java/org/mockito/plugins/InlineMockMaker.java b/src/main/java/org/mockito/plugins/InlineMockMaker.java
index ddc3ff6..f271d52 100644
--- a/src/main/java/org/mockito/plugins/InlineMockMaker.java
+++ b/src/main/java/org/mockito/plugins/InlineMockMaker.java
@@ -2,7 +2,6 @@
* Copyright (c) 2019 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.plugins;
import org.mockito.Incubating;
@@ -48,6 +47,4 @@
*/
@Incubating
void clearAllMocks();
-
}
-
diff --git a/src/main/java/org/mockito/plugins/MemberAccessor.java b/src/main/java/org/mockito/plugins/MemberAccessor.java
new file mode 100644
index 0000000..caccb65
--- /dev/null
+++ b/src/main/java/org/mockito/plugins/MemberAccessor.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+import org.mockito.Incubating;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * A member accessor is responsible for invoking methods, constructors and for setting
+ * and reading field values.
+ */
+@Incubating
+public interface MemberAccessor {
+
+ Object newInstance(Constructor<?> constructor, Object... arguments)
+ throws InstantiationException, InvocationTargetException, IllegalAccessException;
+
+ default Object newInstance(
+ Constructor<?> constructor, OnConstruction onConstruction, Object... arguments)
+ throws InstantiationException, InvocationTargetException, IllegalAccessException {
+ return onConstruction.invoke(() -> newInstance(constructor, arguments));
+ }
+
+ Object invoke(Method method, Object target, Object... arguments)
+ throws InvocationTargetException, IllegalAccessException;
+
+ Object get(Field field, Object target) throws IllegalAccessException;
+
+ void set(Field field, Object target, Object value) throws IllegalAccessException;
+
+ interface OnConstruction {
+
+ Object invoke(ConstructionDispatcher dispatcher)
+ throws InstantiationException, InvocationTargetException, IllegalAccessException;
+ }
+
+ interface ConstructionDispatcher {
+
+ Object newInstance()
+ throws InstantiationException, InvocationTargetException, IllegalAccessException;
+ }
+}
diff --git a/src/main/java/org/mockito/plugins/MockMaker.java b/src/main/java/org/mockito/plugins/MockMaker.java
index e4b0ca8..7e06e32 100644
--- a/src/main/java/org/mockito/plugins/MockMaker.java
+++ b/src/main/java/org/mockito/plugins/MockMaker.java
@@ -5,9 +5,17 @@
package org.mockito.plugins;
import org.mockito.Incubating;
+import org.mockito.MockedConstruction;
+import org.mockito.exceptions.base.MockitoException;
import org.mockito.invocation.MockHandler;
import org.mockito.mock.MockCreationSettings;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+
+import static org.mockito.internal.util.StringUtil.join;
+
/**
* The facility to create mocks.
*
@@ -31,7 +39,7 @@
* A file "<code>mockito-extensions/org.mockito.plugins.MockMaker</code>". The content of this file is
* exactly a <strong>one</strong> line with the qualified name:
* <code>org.awesome.mockito.AwesomeMockMaker</code>.
-* </li>
+ * </li>
* </ol>
* </p>
*
@@ -64,10 +72,26 @@
* @return The mock instance.
* @since 1.9.5
*/
- <T> T createMock(
- MockCreationSettings<T> settings,
- MockHandler handler
- );
+ <T> T createMock(MockCreationSettings<T> settings, MockHandler handler);
+
+ /**
+ * By implementing this method, a mock maker can optionally support the creation of spies where all fields
+ * are set within a constructor. This avoids problems when creating spies of classes that declare
+ * effectively final instance fields where setting field values from outside the constructor is prohibited.
+ *
+ * @param settings Mock creation settings like type to mock, extra interfaces and so on.
+ * @param handler See {@link org.mockito.invocation.MockHandler}.
+ * <b>Do not</b> provide your own implementation at this time. Make sure your implementation of
+ * {@link #getHandler(Object)} will return this instance.
+ * @param instance The object to spy upon.
+ * @param <T> Type of the mock to return, actually the <code>settings.getTypeToMock</code>.
+ * @return The spy instance, if this mock maker supports direct spy creation.
+ * @since 3.5.0
+ */
+ default <T> Optional<T> createSpy(
+ MockCreationSettings<T> settings, MockHandler handler, T instance) {
+ return Optional.empty();
+ }
/**
* Returns the handler for the {@code mock}. <b>Do not</b> provide your own implementations at this time
@@ -95,11 +119,7 @@
* @param settings The mock settings - should you need to access some of the mock creation details.
* @since 1.9.5
*/
- void resetMock(
- Object mock,
- MockHandler newHandler,
- MockCreationSettings settings
- );
+ void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings);
/**
* Indicates if the given type can be mocked by this mockmaker.
@@ -116,6 +136,75 @@
TypeMockability isTypeMockable(Class<?> type);
/**
+ * If you want to provide your own implementation of {@code MockMaker} this method should:
+ * <ul>
+ * <li>Alter the supplied class to only change its behavior in the current thread.</li>
+ * <li>Only alters the static method's behavior after being enabled.</li>
+ * <li>Stops the altered behavior when disabled.</li>
+ * </ul>
+ *
+ * @param settings Mock creation settings like type to mock, extra interfaces and so on.
+ * @param handler See {@link org.mockito.invocation.MockHandler}.
+ * <b>Do not</b> provide your own implementation at this time. Make sure your implementation of
+ * {@link #getHandler(Object)} will return this instance.
+ * @param <T> Type of the mock to return, actually the <code>settings.getTypeToMock</code>.
+ * @return A control for the static mock.
+ * @since 3.4.0
+ */
+ @Incubating
+ default <T> StaticMockControl<T> createStaticMock(
+ Class<T> type, MockCreationSettings<T> settings, MockHandler handler) {
+ throw new MockitoException(
+ join(
+ "The used MockMaker "
+ + getClass().getSimpleName()
+ + " does not support the creation of static mocks",
+ "",
+ "Mockito's inline mock maker supports static mocks based on the Instrumentation API.",
+ "You can simply enable this mock mode, by placing the 'mockito-inline' artifact where you are currently using 'mockito-core'.",
+ "Note that Mockito's inline mock maker is not supported on Android."));
+ }
+
+ /**
+ * If you want to provide your own implementation of {@code MockMaker} this method should:
+ * <ul>
+ * <li>Intercept all constructions of the specified type in the current thread</li>
+ * <li>Only intercept the construction after being enabled.</li>
+ * <li>Stops the interception when disabled.</li>
+ * </ul>
+ *
+ * @param settingsFactory Factory for mock creation settings like type to mock, extra interfaces and so on.
+ * @param handlerFactory Factory for settings. See {@link org.mockito.invocation.MockHandler}.
+ * <b>Do not</b> provide your own implementation at this time. Make sure your implementation of
+ * {@link #getHandler(Object)} will return this instance.
+ * @param <T> Type of the mock to return, actually the <code>settings.getTypeToMock</code>.
+ * @return A control for the mocked construction.
+ * @since 3.5.0
+ */
+ @Incubating
+ default <T> ConstructionMockControl<T> createConstructionMock(
+ Class<T> type,
+ Function<MockedConstruction.Context, MockCreationSettings<T>> settingsFactory,
+ Function<MockedConstruction.Context, MockHandler<T>> handlerFactory,
+ MockedConstruction.MockInitializer<T> mockInitializer) {
+ throw new MockitoException(
+ join(
+ "The used MockMaker "
+ + getClass().getSimpleName()
+ + " does not support the creation of construction mocks",
+ "",
+ "Mockito's inline mock maker supports construction mocks based on the Instrumentation API.",
+ "You can simply enable this mock mode, by placing the 'mockito-inline' artifact where you are currently using 'mockito-core'.",
+ "Note that Mockito's inline mock maker is not supported on Android."));
+ }
+
+ /**
+ * Clears all cashes for mocked types and removes all byte code alterations, if possible.
+ */
+ @Incubating
+ default void clearAllCaches() {}
+
+ /**
* Carries the mockability information
*
* @since 2.1.0
@@ -132,4 +221,26 @@
*/
String nonMockableReason();
}
+
+ @Incubating
+ interface StaticMockControl<T> {
+
+ Class<T> getType();
+
+ void enable();
+
+ void disable();
+ }
+
+ @Incubating
+ interface ConstructionMockControl<T> {
+
+ Class<T> getType();
+
+ void enable();
+
+ void disable();
+
+ List<T> getMocks();
+ }
}
diff --git a/src/main/java/org/mockito/plugins/MockResolver.java b/src/main/java/org/mockito/plugins/MockResolver.java
new file mode 100644
index 0000000..6eaa756
--- /dev/null
+++ b/src/main/java/org/mockito/plugins/MockResolver.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+/**
+ * A mock resolver offers an opportunity to resolve a mock from any instance that is
+ * provided to the {@link org.mockito.Mockito}-DSL. This mechanism can be used by
+ * frameworks that provide mocks that are implemented by Mockito but which are wrapped
+ * by other instances to enhance the proxy further.
+ */
+public interface MockResolver {
+
+ /**
+ * Returns the provided instance or the unwrapped mock that the provided
+ * instance represents. This method must not return {@code null}.
+ * @param instance The instance passed to the {@link org.mockito.Mockito}-DSL.
+ * @return The provided instance or the unwrapped mock.
+ */
+ Object resolve(Object instance);
+}
diff --git a/src/main/java/org/mockito/plugins/MockitoLogger.java b/src/main/java/org/mockito/plugins/MockitoLogger.java
new file mode 100644
index 0000000..38ca4a8
--- /dev/null
+++ b/src/main/java/org/mockito/plugins/MockitoLogger.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.plugins;
+
+import org.mockito.Incubating;
+
+/**
+ * Mockito logger.
+ *
+ * <p>By default logs to console</p>
+ *
+ * <p>All mockito logging goes through this class and could be customized as usual Mockito plugin.</p>
+ *
+ * <h3>Using the extension point</h3>
+ *
+ * <p>Suppose you wrote an extension to customize logging, in order to tell Mockito to use it you need to put
+ * in your <strong>classpath</strong>:
+ * <ol style="list-style-type: lower-alpha">
+ * <li>
+ * The implementation itself, for example <code>org.awesome.mockito.AwesomeLogger</code> that
+ * extends the <code>MockitoLogger</code>.
+ * </li>
+ * <li>
+ * A file "<code>mockito-extensions/org.mockito.plugins.MockitoLogger</code>". The content of this file is
+ * exactly a <strong>one</strong> line with the qualified name:
+ * <code>org.awesome.mockito.AwesomeLogger</code>.
+ * </li>
+ * </ol>
+ * </p>
+ *
+ * <p>Note that if several <code>mockito-extensions/org.mockito.plugins.MockitoLogger</code> files exists in the
+ * classpath Mockito will only use the first returned by the standard {@link ClassLoader#getResource} mechanism.
+ *
+ * @since 2.23.19
+ */
+@Incubating
+public interface MockitoLogger {
+ /**
+ * Log specified object.
+ *
+ * @param what to be logged
+ */
+ @Incubating
+ void log(Object what);
+}
diff --git a/src/main/java/org/mockito/quality/MockitoHint.java b/src/main/java/org/mockito/quality/MockitoHint.java
index f261ac1..cf36a6c 100644
--- a/src/main/java/org/mockito/quality/MockitoHint.java
+++ b/src/main/java/org/mockito/quality/MockitoHint.java
@@ -75,5 +75,4 @@
*
* @since 2.1.0
*/
-public interface MockitoHint {
-}
+public interface MockitoHint {}
diff --git a/src/main/java/org/mockito/quality/Strictness.java b/src/main/java/org/mockito/quality/Strictness.java
index ea9fed8..20ce8cb 100644
--- a/src/main/java/org/mockito/quality/Strictness.java
+++ b/src/main/java/org/mockito/quality/Strictness.java
@@ -22,7 +22,7 @@
* <ol>
* <li>{@link Strictness#STRICT_STUBS} - ensures clean tests, reduces test code duplication, improves debuggability.
* Best combination of flexibility and productivity. Highly recommended.
- * Planned as default for Mockito v3.
+ * Planned as default for Mockito v4.
* Enable it via {@link MockitoRule}, {@link MockitoJUnitRunner} or {@link MockitoSession}.
* See {@link #STRICT_STUBS} for the details.</li>
* <li>{@link Strictness#LENIENT} - no added behavior.
@@ -69,7 +69,7 @@
* Ensures clean tests, reduces test code duplication, improves debuggability.
* Offers best combination of flexibility and productivity.
* Highly recommended.
- * Planned as default for Mockito v3.
+ * Planned as default for Mockito v4.
* Enable it via our JUnit support ({@link MockitoJUnit}) or {@link MockitoSession}.
* <p>
* Adds following behavior:
diff --git a/src/main/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunner.java b/src/main/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunner.java
index 522b795..d169dd7 100644
--- a/src/main/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunner.java
+++ b/src/main/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunner.java
@@ -4,6 +4,8 @@
*/
package org.mockito.runners;
+import java.lang.reflect.InvocationTargetException;
+
import org.junit.runner.Description;
import org.junit.runner.Runner;
import org.junit.runner.manipulation.Filter;
@@ -12,13 +14,11 @@
import org.junit.runner.notification.Failure;
import org.junit.runner.notification.RunListener;
import org.junit.runner.notification.RunNotifier;
+import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.debugging.WarningsCollector;
-import org.mockito.internal.runners.RunnerFactory;
import org.mockito.internal.runners.InternalRunner;
-import org.mockito.internal.util.ConsoleMockitoLogger;
-import org.mockito.internal.util.MockitoLogger;
-
-import java.lang.reflect.InvocationTargetException;
+import org.mockito.internal.runners.RunnerFactory;
+import org.mockito.plugins.MockitoLogger;
/**
* @deprecated as of 2.1.0. Use the {@link org.mockito.junit.MockitoJUnitRunner} runner instead
@@ -33,7 +33,7 @@
private final InternalRunner runner;
public ConsoleSpammingMockitoJUnitRunner(Class<?> klass) throws InvocationTargetException {
- this(new ConsoleMockitoLogger(), new RunnerFactory().create(klass));
+ this(Plugins.getMockitoLogger(), new RunnerFactory().create(klass));
}
ConsoleSpammingMockitoJUnitRunner(MockitoLogger logger, InternalRunner runner) {
@@ -43,18 +43,20 @@
@Override
public void run(RunNotifier notifier) {
- RunListener listener = new RunListener() {
- WarningsCollector warningsCollector;
+ RunListener listener =
+ new RunListener() {
+ WarningsCollector warningsCollector;
- @Override
- public void testStarted(Description description) throws Exception {
- warningsCollector = new WarningsCollector();
- }
+ @Override
+ public void testStarted(Description description) throws Exception {
+ warningsCollector = new WarningsCollector();
+ }
- @Override public void testFailure(Failure failure) throws Exception {
- logger.log(warningsCollector.getWarnings());
- }
- };
+ @Override
+ public void testFailure(Failure failure) throws Exception {
+ logger.log(warningsCollector.getWarnings());
+ }
+ };
notifier.addListener(listener);
@@ -66,8 +68,9 @@
return runner.getDescription();
}
+ @Override
public void filter(Filter filter) throws NoTestsRemainException {
- //filter is required because without it UnrootedTests show up in Eclipse
+ // filter is required because without it UnrootedTests show up in Eclipse
runner.filter(filter);
}
}
diff --git a/src/main/java/org/mockito/runners/MockitoJUnitRunner.java b/src/main/java/org/mockito/runners/MockitoJUnitRunner.java
index 74f025c..b906fdd 100644
--- a/src/main/java/org/mockito/runners/MockitoJUnitRunner.java
+++ b/src/main/java/org/mockito/runners/MockitoJUnitRunner.java
@@ -5,16 +5,16 @@
package org.mockito.runners;
import java.lang.reflect.InvocationTargetException;
+
import org.junit.runner.Description;
import org.junit.runner.manipulation.Filter;
import org.junit.runner.manipulation.NoTestsRemainException;
import org.junit.runner.notification.RunNotifier;
-
/**
* Runner moved to a new place see {@link org.mockito.junit.MockitoJUnitRunner}
*
- * @deprecated Moved to {@link org.mockito.junit.MockitoJUnitRunner}, this class will be removed with Mockito 3
+ * @deprecated Moved to {@link org.mockito.junit.MockitoJUnitRunner}, this class will be removed with Mockito 4
*/
@Deprecated
public class MockitoJUnitRunner extends org.mockito.junit.MockitoJUnitRunner {
@@ -22,7 +22,7 @@
/**
* Silent runner moved to a new place see {@link org.mockito.junit.MockitoJUnitRunner.Silent}
*
- * @deprecated Moved to {@link org.mockito.junit.MockitoJUnitRunner.Silent}, this class will be removed with Mockito 3
+ * @deprecated Moved to {@link org.mockito.junit.MockitoJUnitRunner.Silent}, this class will be removed with Mockito 4
*/
@Deprecated
public static class Silent extends MockitoJUnitRunner {
@@ -34,7 +34,7 @@
/**
* Silent runner moved to a new place see {@link org.mockito.junit.MockitoJUnitRunner.Strict}
*
- * @deprecated Moved to {@link org.mockito.junit.MockitoJUnitRunner.Strict}, this class will be removed with Mockito 3
+ * @deprecated Moved to {@link org.mockito.junit.MockitoJUnitRunner.Strict}, this class will be removed with Mockito 4
*/
@Deprecated
public static class Strict extends MockitoJUnitRunner {
@@ -59,6 +59,7 @@
return super.getDescription();
}
+ @Override
@Deprecated
public void filter(Filter filter) throws NoTestsRemainException {
super.filter(filter);
diff --git a/src/main/java/org/mockito/runners/VerboseMockitoJUnitRunner.java b/src/main/java/org/mockito/runners/VerboseMockitoJUnitRunner.java
index b86a891..0a29c19 100644
--- a/src/main/java/org/mockito/runners/VerboseMockitoJUnitRunner.java
+++ b/src/main/java/org/mockito/runners/VerboseMockitoJUnitRunner.java
@@ -5,6 +5,7 @@
package org.mockito.runners;
import java.lang.reflect.InvocationTargetException;
+
import org.junit.runner.Description;
import org.junit.runner.Runner;
import org.junit.runner.manipulation.Filter;
@@ -15,8 +16,8 @@
import org.junit.runner.notification.RunNotifier;
import org.mockito.internal.debugging.WarningsCollector;
import org.mockito.internal.junit.util.JUnitFailureHacker;
-import org.mockito.internal.runners.RunnerFactory;
import org.mockito.internal.runners.InternalRunner;
+import org.mockito.internal.runners.RunnerFactory;
/**
* @deprecated as of 2.1.0. Use the {@link org.mockito.junit.MockitoJUnitRunner} runner instead
@@ -40,23 +41,24 @@
@Override
public void run(RunNotifier notifier) {
- //a listener that changes the failure's exception in a very hacky way...
- RunListener listener = new RunListener() {
+ // a listener that changes the failure's exception in a very hacky way...
+ RunListener listener =
+ new RunListener() {
- WarningsCollector warningsCollector;
+ WarningsCollector warningsCollector;
- @Override
- public void testStarted(Description description) throws Exception {
- warningsCollector = new WarningsCollector();
- }
+ @Override
+ public void testStarted(Description description) throws Exception {
+ warningsCollector = new WarningsCollector();
+ }
- @Override
- @SuppressWarnings("deprecation")
- public void testFailure(final Failure failure) throws Exception {
- String warnings = warningsCollector.getWarnings();
- new JUnitFailureHacker().appendWarnings(failure, warnings);
- }
- };
+ @Override
+ @SuppressWarnings("deprecation")
+ public void testFailure(final Failure failure) throws Exception {
+ String warnings = warningsCollector.getWarnings();
+ new JUnitFailureHacker().appendWarnings(failure, warnings);
+ }
+ };
notifier.addFirstListener(listener);
@@ -68,8 +70,9 @@
return runner.getDescription();
}
+ @Override
public void filter(Filter filter) throws NoTestsRemainException {
- //filter is required because without it UnrootedTests show up in Eclipse
+ // filter is required because without it UnrootedTests show up in Eclipse
runner.filter(filter);
}
}
diff --git a/src/main/java/org/mockito/session/MockitoSessionBuilder.java b/src/main/java/org/mockito/session/MockitoSessionBuilder.java
index b3a758b..648ca9d 100644
--- a/src/main/java/org/mockito/session/MockitoSessionBuilder.java
+++ b/src/main/java/org/mockito/session/MockitoSessionBuilder.java
@@ -7,6 +7,7 @@
import org.mockito.Incubating;
import org.mockito.MockitoAnnotations;
import org.mockito.MockitoSession;
+import org.mockito.NotExtensible;
import org.mockito.exceptions.misusing.UnfinishedMockingSessionException;
import org.mockito.quality.Strictness;
@@ -17,6 +18,7 @@
* @since 2.7.0
*/
@Incubating
+@NotExtensible
public interface MockitoSessionBuilder {
/**
@@ -24,10 +26,10 @@
* like {@link org.mockito.Mock}.
* When this method is invoked it <strong>does not perform</strong> initialization of mocks on the spot!
* Only when {@link #startMocking()} is invoked then annotated fields will be initialized.
- * Traditional API to initialize mocks, the {@link MockitoAnnotations#initMocks(Object)} method
+ * Traditional API to initialize mocks, the {@link MockitoAnnotations#openMocks(Object)} method
* has limited support for driving cleaner tests because it does not support configuring {@link Strictness}.
* Want cleaner tests and better productivity?
- * Migrate from {@link MockitoAnnotations#initMocks(Object)}
+ * Migrate from {@link MockitoAnnotations#openMocks(Object)}
* to {@link MockitoSession}!
* <p>
* This method may be called multiple times to add multiple, e.g. nested, test class instances.
diff --git a/src/main/java/org/mockito/session/MockitoSessionLogger.java b/src/main/java/org/mockito/session/MockitoSessionLogger.java
index e5f40ad..bf365d5 100644
--- a/src/main/java/org/mockito/session/MockitoSessionLogger.java
+++ b/src/main/java/org/mockito/session/MockitoSessionLogger.java
@@ -6,6 +6,7 @@
import org.mockito.Incubating;
import org.mockito.MockitoSession;
+import org.mockito.NotExtensible;
/**
* Logger for {@linkplain org.mockito.quality.MockitoHint hints} emitted when
@@ -17,6 +18,7 @@
* @since 2.15.0
*/
@Incubating
+@NotExtensible
public interface MockitoSessionLogger {
/**
@@ -26,5 +28,4 @@
*/
@Incubating
void log(String hint);
-
}
diff --git a/src/main/java/org/mockito/stubbing/Answer6.java b/src/main/java/org/mockito/stubbing/Answer6.java
new file mode 100644
index 0000000..11a95c1
--- /dev/null
+++ b/src/main/java/org/mockito/stubbing/Answer6.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.stubbing;
+
+import org.mockito.Incubating;
+
+/**
+ * Generic interface to be used for configuring mock's answer for a six argument invocation.
+ *
+ * Answer specifies an action that is executed and a return value that is returned when you interact with the mock.
+ * <p>
+ * Example of stubbing a mock with this custom answer:
+ *
+ * <pre class="code"><code class="java">
+ * import static org.mockito.AdditionalAnswers.answer;
+ *
+ * when(mock.someMethod(anyInt(), anyString(), anyChar(), any(), any(), anyBoolean())).then(answer(
+ * new Answer6<StringBuilder, Integer, String, Character, Object, Object, Boolean>() {
+ * public StringBuilder answer(Integer i, String s, Character c, Object o1, Object o2, Boolean isIt) {
+ * return new StringBuilder().append(i).append(s).append(c).append(o1.hashCode()).append(o2.hashCode()).append(isIt);
+ * }
+ * }));
+ *
+ * //Following will print a string like "3xyz131635550true"
+ * System.out.println(mock.someMethod(3, "xy", 'z', new Object(), new Object(), true));
+ * </code></pre>
+ *
+ * @param <T> return type
+ * @param <A0> type of the first argument
+ * @param <A1> type of the second argument
+ * @param <A2> type of the third argument
+ * @param <A3> type of the fourth argument
+ * @param <A4> type of the fifth argument
+ * @param <A5> type of the sixth argument
+ * @see Answer
+ */
+@Incubating
+public interface Answer6<T, A0, A1, A2, A3, A4, A5> {
+ /**
+ * @param argument0 the first argument.
+ * @param argument1 the second argument.
+ * @param argument2 the third argument.
+ * @param argument3 the fourth argument.
+ * @param argument4 the fifth argument.
+ * @param argument5 the sixth argument.
+ *
+ * @return the value to be returned.
+ *
+ * @throws Throwable the throwable to be thrown
+ */
+ T answer(A0 argument0, A1 argument1, A2 argument2, A3 argument3, A4 argument4, A5 argument5)
+ throws Throwable;
+}
diff --git a/src/main/java/org/mockito/stubbing/BaseStubber.java b/src/main/java/org/mockito/stubbing/BaseStubber.java
index 8c31928..7ac714d 100644
--- a/src/main/java/org/mockito/stubbing/BaseStubber.java
+++ b/src/main/java/org/mockito/stubbing/BaseStubber.java
@@ -61,9 +61,11 @@
*
* @since 2.1.0
*/
- // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array creation
- @SuppressWarnings ({"unchecked", "varargs"})
- Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown);
+ // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array
+ // creation
+ @SuppressWarnings({"unchecked", "varargs"})
+ Stubber doThrow(
+ Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown);
/**
* Use it for stubbing consecutive calls in {@link Mockito#doAnswer(Answer)} style:
diff --git a/src/main/java/org/mockito/stubbing/OngoingStubbing.java b/src/main/java/org/mockito/stubbing/OngoingStubbing.java
index e2d298b..cb0429b 100644
--- a/src/main/java/org/mockito/stubbing/OngoingStubbing.java
+++ b/src/main/java/org/mockito/stubbing/OngoingStubbing.java
@@ -5,6 +5,7 @@
package org.mockito.stubbing;
import org.mockito.Mockito;
+import org.mockito.NotExtensible;
/**
* Simply put: "<b>When</b> the x method is called <b>then</b> return y". E.g:
@@ -31,6 +32,7 @@
*
* See examples in javadoc for {@link Mockito#when}
*/
+@NotExtensible
public interface OngoingStubbing<T> {
/**
@@ -62,8 +64,9 @@
*
* @return object that allows stubbing consecutive calls
*/
- // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array creation warnings (on call site)
- @SuppressWarnings ({"unchecked", "varargs"})
+ // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array
+ // creation warnings (on call site)
+ @SuppressWarnings({"unchecked", "varargs"})
OngoingStubbing<T> thenReturn(T value, T... values);
/**
@@ -144,9 +147,11 @@
* @return object that allows stubbing consecutive calls
* @since 2.1.0
*/
- // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array creation warnings (on call site)
- @SuppressWarnings ({"unchecked", "varargs"})
- OngoingStubbing<T> thenThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown);
+ // Additional method helps users of JDK7+ to hide heap pollution / unchecked generics array
+ // creation warnings (on call site)
+ @SuppressWarnings({"unchecked", "varargs"})
+ OngoingStubbing<T> thenThrow(
+ Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... nextToBeThrown);
/**
* Sets the real implementation to be called when the method is called on a mock object.
@@ -234,5 +239,4 @@
* @since 1.9.0
*/
<M> M getMock();
-
}
diff --git a/src/main/java/org/mockito/stubbing/Stubber.java b/src/main/java/org/mockito/stubbing/Stubber.java
index 5de954b..6b860db 100644
--- a/src/main/java/org/mockito/stubbing/Stubber.java
+++ b/src/main/java/org/mockito/stubbing/Stubber.java
@@ -4,6 +4,7 @@
*/
package org.mockito.stubbing;
+import org.mockito.CheckReturnValue;
import org.mockito.Mockito;
import org.mockito.NotExtensible;
@@ -39,6 +40,7 @@
*
* See examples in javadoc for {@link Mockito}
*/
+@CheckReturnValue
@SuppressWarnings("unchecked")
@NotExtensible
public interface Stubber extends BaseStubber {
diff --git a/src/main/java/org/mockito/stubbing/ValidableAnswer.java b/src/main/java/org/mockito/stubbing/ValidableAnswer.java
index 382beab..9d0bde1 100644
--- a/src/main/java/org/mockito/stubbing/ValidableAnswer.java
+++ b/src/main/java/org/mockito/stubbing/ValidableAnswer.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.stubbing;
import org.mockito.Incubating;
@@ -89,5 +88,4 @@
* @since 2.3.8
*/
void validateFor(InvocationOnMock invocation);
-
}
diff --git a/src/main/java/org/mockito/stubbing/VoidAnswer5.java b/src/main/java/org/mockito/stubbing/VoidAnswer5.java
index 1ac667c..87db613 100644
--- a/src/main/java/org/mockito/stubbing/VoidAnswer5.java
+++ b/src/main/java/org/mockito/stubbing/VoidAnswer5.java
@@ -45,5 +45,6 @@
*
* @throws Throwable the throwable to be thrown
*/
- void answer(A0 argument0, A1 argument1, A2 argument2, A3 argument3, A4 argument4) throws Throwable;
+ void answer(A0 argument0, A1 argument1, A2 argument2, A3 argument3, A4 argument4)
+ throws Throwable;
}
diff --git a/src/main/java/org/mockito/stubbing/VoidAnswer6.java b/src/main/java/org/mockito/stubbing/VoidAnswer6.java
new file mode 100644
index 0000000..545ca3f
--- /dev/null
+++ b/src/main/java/org/mockito/stubbing/VoidAnswer6.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2016 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.stubbing;
+
+import org.mockito.Incubating;
+
+/**
+ * Generic interface to be used for configuring mock's answer for a six argument invocation that returns nothing.
+ *
+ * Answer specifies an action that is executed when you interact with the mock.
+ * <p>
+ * Example of stubbing a mock with this custom answer:
+ *
+ * <pre class="code"><code class="java">
+ * import static org.mockito.AdditionalAnswers.answerVoid;
+ *
+ * doAnswer(answerVoid(
+ * new VoidAnswer5<String, Integer, String, Character, Object, String>() {
+ * public void answer(String msg, Integer count, String another, Character c, Object o, String subject) throws Exception {
+ * throw new Exception(String.format(msg, another, c, o, count, subject));
+ * }
+ * })).when(mock).someMethod(anyString(), anyInt(), anyString(), anyChar(), any(), anyString());
+ *
+ * // The following will raise an exception with the message "ka-boom <3 mockito"
+ * mock.someMethod("%s-boom %c%d %s", 3, "ka", '<', new Object(), "mockito");
+ * </code></pre>
+ *
+ * @param <A0> type of the first argument
+ * @param <A1> type of the second argument
+ * @param <A2> type of the third argument
+ * @param <A3> type of the fourth argument
+ * @param <A4> type of the fifth argument
+ * @param <A5> type of the sixth argument
+ * @see Answer
+ */
+@Incubating
+public interface VoidAnswer6<A0, A1, A2, A3, A4, A5> {
+ /**
+ * @param argument0 the first argument.
+ * @param argument1 the second argument.
+ * @param argument2 the third argument.
+ * @param argument3 the fourth argument.
+ * @param argument4 the fifth argument.
+ * @param argument5 the sixth argument.
+ *
+ * @throws Throwable the throwable to be thrown
+ */
+ void answer(A0 argument0, A1 argument1, A2 argument2, A3 argument3, A4 argument4, A5 argument5)
+ throws Throwable;
+}
diff --git a/src/main/java/org/mockito/verification/After.java b/src/main/java/org/mockito/verification/After.java
index a8eeafa..5e7a0b8 100644
--- a/src/main/java/org/mockito/verification/After.java
+++ b/src/main/java/org/mockito/verification/After.java
@@ -4,7 +4,6 @@
*/
package org.mockito.verification;
-import org.mockito.internal.verification.VerificationModeFactory;
import org.mockito.internal.verification.VerificationOverTimeImpl;
import org.mockito.internal.verification.VerificationWrapper;
@@ -14,7 +13,8 @@
* Typically, you won't use this class explicitly. Instead use timeout() method on Mockito class.
* See javadoc for {@link VerificationWithTimeout}
*/
-public class After extends VerificationWrapper<VerificationOverTimeImpl> implements VerificationAfterDelay {
+public class After extends VerificationWrapper<VerificationOverTimeImpl>
+ implements VerificationAfterDelay {
/**
* See the javadoc for {@link VerificationAfterDelay}
@@ -38,9 +38,4 @@
protected VerificationMode copySelfWithNewVerificationMode(VerificationMode verificationMode) {
return new After(wrappedVerification.copyWithVerificationMode(verificationMode));
}
-
- @Override
- public VerificationMode description(String description) {
- return VerificationModeFactory.description(this, description);
- }
}
diff --git a/src/main/java/org/mockito/verification/Timeout.java b/src/main/java/org/mockito/verification/Timeout.java
index c918d0f..502bb9f 100644
--- a/src/main/java/org/mockito/verification/Timeout.java
+++ b/src/main/java/org/mockito/verification/Timeout.java
@@ -7,7 +7,6 @@
import static org.mockito.internal.exceptions.Reporter.atMostAndNeverShouldNotBeUsedWithTimeout;
import org.mockito.internal.util.Timer;
-import org.mockito.internal.verification.VerificationModeFactory;
import org.mockito.internal.verification.VerificationOverTimeImpl;
import org.mockito.internal.verification.VerificationWrapper;
@@ -17,7 +16,8 @@
* Typically, you won't use this class explicitly. Instead use timeout() method on Mockito class.
* See javadoc for {@link VerificationWithTimeout}
*/
-public class Timeout extends VerificationWrapper<VerificationOverTimeImpl> implements VerificationWithTimeout {
+public class Timeout extends VerificationWrapper<VerificationOverTimeImpl>
+ implements VerificationWithTimeout {
/**
* See the javadoc for {@link VerificationWithTimeout}
@@ -48,21 +48,18 @@
}
@Override
- protected VerificationMode copySelfWithNewVerificationMode(VerificationMode newVerificationMode) {
+ protected VerificationMode copySelfWithNewVerificationMode(
+ VerificationMode newVerificationMode) {
return new Timeout(wrappedVerification.copyWithVerificationMode(newVerificationMode));
}
+ @Override
public VerificationMode atMost(int maxNumberOfInvocations) {
throw atMostAndNeverShouldNotBeUsedWithTimeout();
}
+ @Override
public VerificationMode never() {
throw atMostAndNeverShouldNotBeUsedWithTimeout();
}
-
- @Override
- public VerificationMode description(String description) {
- return VerificationModeFactory.description(this, description);
- }
-
}
diff --git a/src/main/java/org/mockito/verification/VerificationAfterDelay.java b/src/main/java/org/mockito/verification/VerificationAfterDelay.java
index b48cb6b..c99a34d 100644
--- a/src/main/java/org/mockito/verification/VerificationAfterDelay.java
+++ b/src/main/java/org/mockito/verification/VerificationAfterDelay.java
@@ -2,12 +2,10 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.verification;
import org.mockito.Mockito;
-
/**
* VerificationAfterDelay is a {@link VerificationMode} that allows combining existing verification modes with an initial delay, e.g.
* <pre class="code"><code class="java">
@@ -50,6 +48,12 @@
VerificationMode atLeast(int minNumberOfInvocations);
/**
+ * Verifies that there is most 1 invocation during the given period. This will wait the full period given,
+ * unless too many invocations occur (in which case there will be an immediate failure)
+ */
+ VerificationMode atMostOnce();
+
+ /**
* Verifies that there is are most N invocations during the given period. This will wait the full period given,
* unless too many invocations occur (in which case there will be an immediate failure)
*/
@@ -60,5 +64,4 @@
* period given, unless another method is invoked (in which case there will be an immediate failure)
*/
VerificationMode only();
-
}
diff --git a/src/main/java/org/mockito/verification/VerificationMode.java b/src/main/java/org/mockito/verification/VerificationMode.java
index 2a04ad5..6ca3804 100644
--- a/src/main/java/org/mockito/verification/VerificationMode.java
+++ b/src/main/java/org/mockito/verification/VerificationMode.java
@@ -2,10 +2,10 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.verification;
import org.mockito.Mockito;
+import org.mockito.internal.verification.VerificationModeFactory;
import org.mockito.internal.verification.api.VerificationData;
/**
@@ -42,5 +42,7 @@
* @return VerificationMode
* @since 2.1.0
*/
- VerificationMode description(String description);
+ default VerificationMode description(String description) {
+ return VerificationModeFactory.description(this, description);
+ }
}
diff --git a/src/main/java/org/mockito/verification/VerificationWithTimeout.java b/src/main/java/org/mockito/verification/VerificationWithTimeout.java
index 0a4f533..ad110d0 100644
--- a/src/main/java/org/mockito/verification/VerificationWithTimeout.java
+++ b/src/main/java/org/mockito/verification/VerificationWithTimeout.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.verification;
import org.mockito.Mockito;
diff --git a/src/test/java/org/concurrentmockito/ThreadVerifiesContinuoslyInteractingMockTest.java b/src/test/java/org/concurrentmockito/ThreadVerifiesContinuoslyInteractingMockTest.java
deleted file mode 100644
index 0f91bb3..0000000
--- a/src/test/java/org/concurrentmockito/ThreadVerifiesContinuoslyInteractingMockTest.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-
-package org.concurrentmockito;
-
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.verify;
-
-//this test exposes the problem most of the time
-public class ThreadVerifiesContinuoslyInteractingMockTest extends TestBase {
-
- @Mock private IMethods mock;
-
- @Test
- public void shouldAllowVerifyingInThreads() throws Exception {
- for(int i = 0; i < 100; i++) {
- performTest();
- }
- }
-
- private void performTest() throws InterruptedException {
- mock.simpleMethod();
- final Thread[] listeners = new Thread[2];
- for (int i = 0; i < listeners.length; i++) {
- final int x = i;
- listeners[i] = new Thread() {
- @Override
- public void run() {
- try {
- Thread.sleep(x * 10);
- } catch (InterruptedException e) {
- throw new RuntimeException(e);
- }
- mock.simpleMethod();
- }
- };
- listeners[i].start();
- }
-
- verify(mock, atLeastOnce()).simpleMethod();
-
- for (Thread listener : listeners) {
- listener.join();
- }
- }
-}
diff --git a/src/test/java/org/concurrentmockito/ThreadVerifiesContinuouslyInteractingMockTest.java b/src/test/java/org/concurrentmockito/ThreadVerifiesContinuouslyInteractingMockTest.java
new file mode 100644
index 0000000..4e2d8b9
--- /dev/null
+++ b/src/test/java/org/concurrentmockito/ThreadVerifiesContinuouslyInteractingMockTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.concurrentmockito;
+
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.verify;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+// this test exposes the problem most of the time
+public class ThreadVerifiesContinuouslyInteractingMockTest extends TestBase {
+
+ @Mock private IMethods mock;
+
+ @Test
+ public void shouldAllowVerifyingInThreads() throws Exception {
+ for (int i = 0; i < 100; i++) {
+ performTest();
+ }
+ }
+
+ private void performTest() throws InterruptedException {
+ mock.simpleMethod();
+ final Thread[] listeners = new Thread[2];
+ for (int i = 0; i < listeners.length; i++) {
+ final int x = i;
+ listeners[i] =
+ new Thread() {
+ @Override
+ public void run() {
+ try {
+ Thread.sleep(x * 10);
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ mock.simpleMethod();
+ }
+ };
+ listeners[i].start();
+ }
+
+ verify(mock, atLeastOnce()).simpleMethod();
+
+ for (Thread listener : listeners) {
+ listener.join();
+ }
+ }
+}
diff --git a/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java b/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java
index e9862b3..aa15ca4 100644
--- a/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java
+++ b/src/test/java/org/concurrentmockito/ThreadsRunAllTestsHalfManualTest.java
@@ -4,6 +4,14 @@
*/
package org.concurrentmockito;
+import static org.junit.Assert.assertEquals;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
import org.junit.Test;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
@@ -52,14 +60,6 @@
import org.mockitousage.verification.*;
import org.mockitoutil.TestBase;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
-import static org.junit.Assert.assertEquals;
-
public class ThreadsRunAllTestsHalfManualTest extends TestBase {
private static class AllTestsRunner extends Thread {
@@ -67,74 +67,74 @@
private Set<Class<?>> failed = new HashSet<Class<?>>();
public void run() {
- Result result = JUnitCore.runClasses(
- EqualsTest.class,
- ListUtilTest.class,
- MockingProgressImplTest.class,
- TimesTest.class,
- MockHandlerImplTest.class,
- AllInvocationsFinderTest.class,
- ReturnsEmptyValuesTest.class,
- NumberOfInvocationsCheckerTest.class,
- DefaultRegisteredInvocationsTest.class,
- MissingInvocationCheckerTest.class,
- NumberOfInvocationsInOrderCheckerTest.class,
- MissingInvocationInOrderCheckerTest.class,
- TypeCachingMockBytecodeGeneratorTest.class,
- InvocationMatcherTest.class,
- InvocationsFinderTest.class,
- MockitoTest.class,
- MockUtilTest.class,
- ReporterTest.class,
- MockitoAssertionErrorTest.class,
- MockitoExceptionTest.class,
- StackTraceFilteringTest.class,
- BridgeMethodPuzzleTest.class,
- OverloadingPuzzleTest.class,
- InvalidUsageTest.class,
- UsingVarargsTest.class,
- CustomMatchersTest.class,
- ComparableMatchersTest.class,
- InvalidUseOfMatchersTest.class,
- MatchersTest.class,
- MatchersToStringTest.class,
- VerificationAndStubbingUsingMatchersTest.class,
- BasicStubbingTest.class,
- ReturningDefaultValuesTest.class,
- StubbingWithThrowablesTest.class,
- AtMostXVerificationTest.class,
- BasicVerificationTest.class,
- ExactNumberOfTimesVerificationTest.class,
- VerificationInOrderTest.class,
- NoMoreInteractionsVerificationTest.class,
- SelectedMocksInOrderVerificationTest.class,
- VerificationOnMultipleMocksUsingMatchersTest.class,
- VerificationUsingMatchersTest.class,
- RelaxedVerificationInOrderTest.class,
- DescriptiveMessagesWhenVerificationFailsTest.class,
- DescriptiveMessagesWhenTimesXVerificationFailsTest.class,
- BasicVerificationInOrderTest.class,
- VerificationInOrderMixedWithOrdiraryVerificationTest.class,
- DescriptiveMessagesOnVerificationInOrderErrorsTest.class,
- InvalidStateDetectionTest.class,
- ReplacingObjectMethodsTest.class,
- ClickableStackTracesTest.class,
- ExampleTest.class,
- PointingStackTraceToActualInvocationTest.class,
- VerificationInOrderFromMultipleThreadsTest.class,
- ResetTest.class,
- ReturnsGenericDeepStubsTest.class
- );
+ Result result =
+ JUnitCore.runClasses(
+ EqualsTest.class,
+ ListUtilTest.class,
+ MockingProgressImplTest.class,
+ TimesTest.class,
+ MockHandlerImplTest.class,
+ AllInvocationsFinderTest.class,
+ ReturnsEmptyValuesTest.class,
+ NumberOfInvocationsCheckerTest.class,
+ DefaultRegisteredInvocationsTest.class,
+ MissingInvocationCheckerTest.class,
+ NumberOfInvocationsInOrderCheckerTest.class,
+ MissingInvocationInOrderCheckerTest.class,
+ TypeCachingMockBytecodeGeneratorTest.class,
+ InvocationMatcherTest.class,
+ InvocationsFinderTest.class,
+ MockitoTest.class,
+ MockUtilTest.class,
+ ReporterTest.class,
+ MockitoAssertionErrorTest.class,
+ MockitoExceptionTest.class,
+ StackTraceFilteringTest.class,
+ BridgeMethodPuzzleTest.class,
+ OverloadingPuzzleTest.class,
+ InvalidUsageTest.class,
+ UsingVarargsTest.class,
+ CustomMatchersTest.class,
+ ComparableMatchersTest.class,
+ InvalidUseOfMatchersTest.class,
+ MatchersTest.class,
+ MatchersToStringTest.class,
+ VerificationAndStubbingUsingMatchersTest.class,
+ BasicStubbingTest.class,
+ ReturningDefaultValuesTest.class,
+ StubbingWithThrowablesTest.class,
+ AtMostXVerificationTest.class,
+ BasicVerificationTest.class,
+ ExactNumberOfTimesVerificationTest.class,
+ VerificationInOrderTest.class,
+ NoMoreInteractionsVerificationTest.class,
+ SelectedMocksInOrderVerificationTest.class,
+ VerificationOnMultipleMocksUsingMatchersTest.class,
+ VerificationUsingMatchersTest.class,
+ RelaxedVerificationInOrderTest.class,
+ DescriptiveMessagesWhenVerificationFailsTest.class,
+ DescriptiveMessagesWhenTimesXVerificationFailsTest.class,
+ BasicVerificationInOrderTest.class,
+ VerificationInOrderMixedWithOrdiraryVerificationTest.class,
+ DescriptiveMessagesOnVerificationInOrderErrorsTest.class,
+ InvalidStateDetectionTest.class,
+ ReplacingObjectMethodsTest.class,
+ ClickableStackTracesTest.class,
+ ExampleTest.class,
+ PointingStackTraceToActualInvocationTest.class,
+ VerificationInOrderFromMultipleThreadsTest.class,
+ ResetTest.class,
+ ReturnsGenericDeepStubsTest.class);
- if (!result.wasSuccessful()) {
- System.err.println("Thread[" + Thread.currentThread().getId() + "]: error!");
- List<Failure> failures = result.getFailures();
- System.err.println(failures.size());
- for (Failure failure : failures) {
- System.err.println(failure.getTrace());
- failed.add(failure.getDescription().getTestClass());
- }
+ if (!result.wasSuccessful()) {
+ System.err.println("Thread[" + Thread.currentThread().getId() + "]: error!");
+ List<Failure> failures = result.getFailures();
+ System.err.println(failures.size());
+ for (Failure failure : failures) {
+ System.err.println(failure.getTrace());
+ failed.add(failure.getDescription().getTestClass());
}
+ }
}
public Set<Class<?>> getFailed() {
@@ -144,8 +144,11 @@
@Test
public void shouldRunInMultipleThreads() throws Exception {
- //this test ALWAYS fails if there is a single failing unit
- assertEquals("Run in multiple thread failed for tests", Collections.emptySet(), runInMultipleThreads(3));
+ // this test ALWAYS fails if there is a single failing unit
+ assertEquals(
+ "Run in multiple thread failed for tests",
+ Collections.emptySet(),
+ runInMultipleThreads(3));
}
public static Set<Class<?>> runInMultipleThreads(int numberOfThreads) throws Exception {
@@ -172,7 +175,14 @@
long before = System.currentTimeMillis();
Set<Class<?>> failed = runInMultipleThreads(numberOfThreads);
long after = System.currentTimeMillis();
- long executionTime = (after-before)/1000;
- System.out.println("Finished tests in " + numberOfThreads + " threads in " + executionTime + " seconds. (" + failed.size() + " tests failed)");
+ long executionTime = (after - before) / 1000;
+ System.out.println(
+ "Finished tests in "
+ + numberOfThreads
+ + " threads in "
+ + executionTime
+ + " seconds. ("
+ + failed.size()
+ + " tests failed)");
}
}
diff --git a/src/test/java/org/concurrentmockito/ThreadsShareAMockTest.java b/src/test/java/org/concurrentmockito/ThreadsShareAMockTest.java
index 8854789..d27276a 100644
--- a/src/test/java/org/concurrentmockito/ThreadsShareAMockTest.java
+++ b/src/test/java/org/concurrentmockito/ThreadsShareAMockTest.java
@@ -2,22 +2,21 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.concurrentmockito;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.mockito.Mockito.*;
-
public class ThreadsShareAMockTest extends TestBase {
private IMethods mock;
@Test
public void shouldAllowVerifyingInThreads() throws Exception {
- for(int i = 0; i < 100; i++) {
+ for (int i = 0; i < 100; i++) {
performTest();
}
}
@@ -26,12 +25,13 @@
mock = mock(IMethods.class);
final Thread[] listeners = new Thread[3];
for (int i = 0; i < listeners.length; i++) {
- listeners[i] = new Thread() {
- @Override
- public void run() {
- mock.simpleMethod("foo");
- }
- };
+ listeners[i] =
+ new Thread() {
+ @Override
+ public void run() {
+ mock.simpleMethod("foo");
+ }
+ };
listeners[i].start();
}
for (Thread listener : listeners) {
diff --git a/src/test/java/org/concurrentmockito/ThreadsShareGenerouslyStubbedMockTest.java b/src/test/java/org/concurrentmockito/ThreadsShareGenerouslyStubbedMockTest.java
index 502e205..f937674 100644
--- a/src/test/java/org/concurrentmockito/ThreadsShareGenerouslyStubbedMockTest.java
+++ b/src/test/java/org/concurrentmockito/ThreadsShareGenerouslyStubbedMockTest.java
@@ -2,25 +2,24 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.concurrentmockito;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
import org.junit.Test;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-//this test always passes but please keep looking sys err
-//this test should be run 10 times, manually
+// this test always passes but please keep looking sys err
+// this test should be run 10 times, manually
public class ThreadsShareGenerouslyStubbedMockTest extends TestBase {
private IMethods mock;
@Test
public void shouldAllowVerifyingInThreads() throws Exception {
- for(int i = 0; i < 50; i++) {
+ for (int i = 0; i < 50; i++) {
performTest();
}
}
@@ -29,30 +28,31 @@
mock = mock(IMethods.class);
when(mock.simpleMethod("foo"))
- .thenReturn("foo")
- .thenReturn("bar")
- .thenReturn("baz")
- .thenReturn("foo")
- .thenReturn("bar")
- .thenReturn("baz");
+ .thenReturn("foo")
+ .thenReturn("bar")
+ .thenReturn("baz")
+ .thenReturn("foo")
+ .thenReturn("bar")
+ .thenReturn("baz");
final Thread[] listeners = new Thread[100];
for (int i = 0; i < listeners.length; i++) {
- listeners[i] = new Thread() {
- @Override
- public void run() {
- try {
- mock.simpleMethod("foo");
- mock.simpleMethod("foo");
- mock.simpleMethod("foo");
- mock.simpleMethod("foo");
- mock.simpleMethod("foo");
- mock.simpleMethod("foo");
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
- }
- };
+ listeners[i] =
+ new Thread() {
+ @Override
+ public void run() {
+ try {
+ mock.simpleMethod("foo");
+ mock.simpleMethod("foo");
+ mock.simpleMethod("foo");
+ mock.simpleMethod("foo");
+ mock.simpleMethod("foo");
+ mock.simpleMethod("foo");
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+ };
listeners[i].start();
}
for (Thread listener : listeners) {
diff --git a/src/test/java/org/concurrentmockito/VerificationInOrderFromMultipleThreadsTest.java b/src/test/java/org/concurrentmockito/VerificationInOrderFromMultipleThreadsTest.java
index 055da2d..8f2c5e8 100644
--- a/src/test/java/org/concurrentmockito/VerificationInOrderFromMultipleThreadsTest.java
+++ b/src/test/java/org/concurrentmockito/VerificationInOrderFromMultipleThreadsTest.java
@@ -2,35 +2,38 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.concurrentmockito;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+
import org.junit.Test;
import org.mockito.InOrder;
import org.mockitoutil.TestBase;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-
public class VerificationInOrderFromMultipleThreadsTest extends TestBase {
@Test
public void shouldVerifyInOrderWhenMultipleThreadsInteractWithMock() throws Exception {
final Foo testInf = mock(Foo.class);
- Thread threadOne = new Thread(new Runnable(){
- public void run() {
- testInf.methodOne();
- }
- });
+ Thread threadOne =
+ new Thread(
+ new Runnable() {
+ public void run() {
+ testInf.methodOne();
+ }
+ });
threadOne.start();
threadOne.join();
- Thread threadTwo = new Thread(new Runnable(){
- public void run() {
- testInf.methodTwo();
- }
- });
+ Thread threadTwo =
+ new Thread(
+ new Runnable() {
+ public void run() {
+ testInf.methodTwo();
+ }
+ });
threadTwo.start();
threadTwo.join();
@@ -41,6 +44,7 @@
public interface Foo {
void methodOne();
+
void methodTwo();
}
}
diff --git a/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java b/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java
index 1d9dfbb..6a017d5 100644
--- a/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java
+++ b/src/test/java/org/mockito/AnnotationsAreCopiedFromMockedTypeTest.java
@@ -4,8 +4,10 @@
*/
package org.mockito;
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
+import static java.lang.annotation.ElementType.*;
+
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.Mockito.mock;
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
@@ -15,18 +17,21 @@
import java.lang.reflect.Field;
import java.lang.reflect.Method;
-import static java.lang.annotation.ElementType.*;
-import static org.junit.Assume.assumeTrue;
-import static org.mockito.Mockito.mock;
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
public class AnnotationsAreCopiedFromMockedTypeTest {
@Test
public void mock_should_have_annotations_copied_from_mocked_type_at_class_level() {
- AnnotationWithDefaultValue onClassDefaultValue = mock(OnClass.class).getClass().getAnnotation(AnnotationWithDefaultValue.class);
- AnnotationWithCustomValue onClassCustomValue = mock(OnClass.class).getClass().getAnnotation(AnnotationWithCustomValue.class);
+ AnnotationWithDefaultValue onClassDefaultValue =
+ mock(OnClass.class).getClass().getAnnotation(AnnotationWithDefaultValue.class);
+ AnnotationWithCustomValue onClassCustomValue =
+ mock(OnClass.class).getClass().getAnnotation(AnnotationWithCustomValue.class);
- assumeTrue("Annotation copying does not apply for inline mocks", mock(OnClass.class).getClass() != OnClass.class);
+ assumeTrue(
+ "Annotation copying does not apply for inline mocks",
+ mock(OnClass.class).getClass() != OnClass.class);
Assertions.assertThat(onClassDefaultValue.value()).isEqualTo("yup");
Assertions.assertThat(onClassCustomValue.value()).isEqualTo("yay");
@@ -34,8 +39,12 @@
@Test
public void mock_should_have_annotations_copied_from_mocked_type_on_methods() {
- AnnotationWithDefaultValue onClassDefaultValue = method("method", mock(OnMethod.class)).getAnnotation(AnnotationWithDefaultValue.class);
- AnnotationWithCustomValue onClassCustomValue = method("method", mock(OnMethod.class)).getAnnotation(AnnotationWithCustomValue.class);
+ AnnotationWithDefaultValue onClassDefaultValue =
+ method("method", mock(OnMethod.class))
+ .getAnnotation(AnnotationWithDefaultValue.class);
+ AnnotationWithCustomValue onClassCustomValue =
+ method("method", mock(OnMethod.class))
+ .getAnnotation(AnnotationWithCustomValue.class);
Assertions.assertThat(onClassDefaultValue.value()).isEqualTo("yup");
Assertions.assertThat(onClassCustomValue.value()).isEqualTo("yay");
@@ -43,8 +52,12 @@
@Test
public void mock_should_have_annotations_copied_from_mocked_type_on_method_parameters() {
- AnnotationWithDefaultValue onClassDefaultValue = firstParamOf(method("method", mock(OnMethod.class))).getAnnotation(AnnotationWithDefaultValue.class);
- AnnotationWithCustomValue onClassCustomValue = firstParamOf(method("method", mock(OnMethod.class))).getAnnotation(AnnotationWithCustomValue.class);
+ AnnotationWithDefaultValue onClassDefaultValue =
+ firstParamOf(method("method", mock(OnMethod.class)))
+ .getAnnotation(AnnotationWithDefaultValue.class);
+ AnnotationWithCustomValue onClassCustomValue =
+ firstParamOf(method("method", mock(OnMethod.class)))
+ .getAnnotation(AnnotationWithCustomValue.class);
Assertions.assertThat(onClassDefaultValue.value()).isEqualTo("yup");
Assertions.assertThat(onClassCustomValue.value()).isEqualTo("yay");
@@ -84,7 +97,7 @@
private Method method(String methodName, Object mock) {
for (Method method : mock.getClass().getDeclaredMethods()) {
- if(methodName.equals(method.getName())) {
+ if (methodName.equals(method.getName())) {
return method;
}
}
@@ -93,7 +106,7 @@
private Field field(String fieldName, Object mock) {
for (Field field : mock.getClass().getDeclaredFields()) {
- if(fieldName.equals(field.getName())) {
+ if (fieldName.equals(field.getName())) {
return field;
}
}
@@ -102,17 +115,15 @@
@AnnotationWithDefaultValue
@AnnotationWithCustomValue("yay")
- public class OnClass { }
-
+ public class OnClass {}
public class OnMethod {
@AnnotationWithDefaultValue
@AnnotationWithCustomValue("yay")
public String method(
- @AnnotationWithDefaultValue
- @AnnotationWithCustomValue("yay")
- String ignored
- ) { return ""; }
+ @AnnotationWithDefaultValue @AnnotationWithCustomValue("yay") String ignored) {
+ return "";
+ }
}
@Retention(RetentionPolicy.RUNTIME)
diff --git a/src/test/java/org/mockito/ArgumentCaptorTest.java b/src/test/java/org/mockito/ArgumentCaptorTest.java
index 0ab5ff7..13b37c8 100644
--- a/src/test/java/org/mockito/ArgumentCaptorTest.java
+++ b/src/test/java/org/mockito/ArgumentCaptorTest.java
@@ -4,33 +4,30 @@
*/
package org.mockito;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.validateMockitoUsage;
+
import org.junit.After;
import org.junit.Test;
import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.validateMockitoUsage;
-
public class ArgumentCaptorTest {
- /**
- * Clean up the internal Mockito-Stubbing state
- */
- @After
- public void tearDown() {
- try {
- validateMockitoUsage();
- } catch (InvalidUseOfMatchersException ignore) {
- }
+ /**
+ * Clean up the internal Mockito-Stubbing state
+ */
+ @After
+ public void tearDown() {
+ try {
+ validateMockitoUsage();
+ } catch (InvalidUseOfMatchersException ignore) {
+ }
+ }
- }
+ @Test
+ public void tell_handy_return_values_to_return_value_for() throws Exception {
- @Test
- public void tell_handy_return_values_to_return_value_for() throws Exception {
-
- ArgumentCaptor<Object> captor = ArgumentCaptor.forClass(Object.class);
- assertThat(captor.capture()).isNull();
-
- }
-
+ ArgumentCaptor<Object> captor = ArgumentCaptor.forClass(Object.class);
+ assertThat(captor.capture()).isNull();
+ }
}
diff --git a/src/test/java/org/mockito/DescriptionTest.java b/src/test/java/org/mockito/DescriptionTest.java
new file mode 100644
index 0000000..32565e4
--- /dev/null
+++ b/src/test/java/org/mockito/DescriptionTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import static org.mockito.Mockito.*;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.exceptions.base.MockitoAssertionError;
+
+/**
+ * Tests for https://github.com/mockito/mockito/issues/1712
+ */
+public class DescriptionTest {
+ @Rule public ExpectedException expectedException = ExpectedException.none();
+
+ @Test
+ public void verify_method_not_called_should_include_description_in_report() {
+ final String description = "Failed to call doSomethingElse";
+ expectedException.expect(MockitoAssertionError.class);
+ expectedException.expectMessage(description);
+
+ Dependency dependency = spy(Dependency.class);
+ SystemUnderTest systemUnderTest = new SystemUnderTest();
+ systemUnderTest.doNothing(dependency);
+ verify(dependency, description(description)).doSomethingElse(false);
+ }
+
+ @Test
+ public void
+ verify_method_called_with_unexpected_argument_should_include_description_in_report() {
+ final String description = "Failed to call doSomethingElse with expected argument";
+ expectedException.expect(MockitoAssertionError.class);
+ expectedException.expectMessage(description);
+
+ Dependency dependency = spy(Dependency.class);
+ SystemUnderTest systemUnderTest = new SystemUnderTest();
+ systemUnderTest.doSomething(dependency);
+ verify(dependency, description(description)).doSomethingElse(false);
+ }
+
+ static class SystemUnderTest {
+ @SuppressWarnings("unused")
+ void doNothing(Dependency dependency) {}
+
+ void doSomething(Dependency dependency) {
+ dependency.doSomethingElse(true);
+ }
+ }
+
+ static class Dependency {
+ @SuppressWarnings("unused")
+ void doSomethingElse(boolean value) {}
+ }
+}
diff --git a/src/test/java/org/mockito/InvocationFactoryTest.java b/src/test/java/org/mockito/InvocationFactoryTest.java
index 893f95f..5837a7d 100644
--- a/src/test/java/org/mockito/InvocationFactoryTest.java
+++ b/src/test/java/org/mockito/InvocationFactoryTest.java
@@ -2,21 +2,20 @@
* Copyright (c) 2018 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito;
-import org.junit.Test;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.InvocationFactory;
-import org.mockitoutil.TestBase;
-
-import java.util.concurrent.Callable;
-
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.withSettings;
+import java.util.concurrent.Callable;
+
+import org.junit.Test;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationFactory;
+import org.mockitoutil.TestBase;
+
public class InvocationFactoryTest extends TestBase {
static class TestClass {
public String testMethod() throws Throwable {
@@ -28,15 +27,19 @@
@Test
public void call_method_that_throws_a_throwable() throws Throwable {
- Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock,
- withSettings().build(TestClass.class),
- TestClass.class.getDeclaredMethod("testMethod"),
- new InvocationFactory.RealMethodBehavior() {
- @Override
- public Object call() throws Throwable {
- throw new Throwable("mocked");
- }
- });
+ Invocation invocation =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(TestClass.class),
+ TestClass.class.getDeclaredMethod("testMethod"),
+ new InvocationFactory.RealMethodBehavior() {
+ @Override
+ public Object call() throws Throwable {
+ throw new Throwable("mocked");
+ }
+ });
try {
Mockito.mockingDetails(mock).getMockHandler().handle(invocation);
@@ -50,15 +53,19 @@
@Test
public void call_method_that_returns_a_string() throws Throwable {
- Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock,
- withSettings().build(TestClass.class),
- TestClass.class.getDeclaredMethod("testMethod"),
- new InvocationFactory.RealMethodBehavior() {
- @Override
- public Object call() throws Throwable {
- return "mocked";
- }
- });
+ Invocation invocation =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(TestClass.class),
+ TestClass.class.getDeclaredMethod("testMethod"),
+ new InvocationFactory.RealMethodBehavior() {
+ @Override
+ public Object call() throws Throwable {
+ return "mocked";
+ }
+ });
Object ret = Mockito.mockingDetails(mock).getMockHandler().handle(invocation);
assertEquals("mocked", ret);
@@ -66,14 +73,18 @@
@Test
public void deprecated_api_still_works() throws Throwable {
- Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock,
- withSettings().build(TestClass.class),
- TestClass.class.getDeclaredMethod("testMethod"),
- new Callable() {
- public Object call() throws Exception {
- return "mocked";
- }
- });
+ Invocation invocation =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(TestClass.class),
+ TestClass.class.getDeclaredMethod("testMethod"),
+ new Callable() {
+ public Object call() throws Exception {
+ return "mocked";
+ }
+ });
Object ret = Mockito.mockingDetails(mock).getMockHandler().handle(invocation);
assertEquals("mocked", ret);
diff --git a/src/test/java/org/mockito/MockitoClearTest.java b/src/test/java/org/mockito/MockitoClearTest.java
new file mode 100644
index 0000000..26b7f76
--- /dev/null
+++ b/src/test/java/org/mockito/MockitoClearTest.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class MockitoClearTest {
+
+ @Test
+ public void can_clear_mock() {
+ Base mock = Mockito.mock(Base.class);
+ assertThat(Mockito.mock(Base.class).getClass()).isEqualTo(mock.getClass());
+
+ Mockito.clearAllCaches();
+
+ assertThat(Mockito.mock(Base.class).getClass()).isNotEqualTo(mock.getClass());
+ }
+
+ abstract static class Base {}
+}
diff --git a/src/test/java/org/mockito/MockitoTest.java b/src/test/java/org/mockito/MockitoTest.java
index ca8c4d4..b41dd20 100644
--- a/src/test/java/org/mockito/MockitoTest.java
+++ b/src/test/java/org/mockito/MockitoTest.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito;
import static org.assertj.core.api.Assertions.assertThat;
@@ -10,8 +9,11 @@
import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
import java.util.List;
+
import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.exceptions.misusing.NullInsteadOfMockException;
import org.mockito.internal.creation.MockSettingsImpl;
@SuppressWarnings("unchecked")
@@ -21,45 +23,66 @@
public void shouldRemoveStubbableFromProgressAfterStubbing() {
List mock = Mockito.mock(List.class);
Mockito.when(mock.add("test")).thenReturn(true);
- //TODO Consider to move to separate test
+ // TODO Consider to move to separate test
assertThat(mockingProgress().pullOngoingStubbing()).isNull();
}
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
- @Test(expected=NotAMockException.class)
+ @Test(expected = NotAMockException.class)
public void shouldValidateMockWhenVerifying() {
Mockito.verify("notMock");
}
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
- @Test(expected=NotAMockException.class)
+ @Test(expected = NotAMockException.class)
public void shouldValidateMockWhenVerifyingWithExpectedNumberOfInvocations() {
Mockito.verify("notMock", times(19));
}
- @Test(expected=NotAMockException.class)
+ @Test(expected = NotAMockException.class)
public void shouldValidateMockWhenVerifyingNoMoreInteractions() {
Mockito.verifyNoMoreInteractions("notMock");
}
- @Test(expected=NotAMockException.class)
+ @Test(expected = NotAMockException.class)
public void shouldValidateMockWhenVerifyingZeroInteractions() {
Mockito.verifyZeroInteractions("notMock");
}
+ @Test(expected = NotAMockException.class)
+ public void shouldValidateMockWhenVerifyingNoInteractions() {
+ Mockito.verifyNoInteractions("notMock");
+ }
+
+ @Test(expected = NullInsteadOfMockException.class)
+ public void shouldValidateNullMockWhenVerifyingNoInteractions() {
+ Mockito.verifyNoInteractions(new Object[] {null});
+ }
+
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
- @Test(expected=NotAMockException.class)
+ @Test(expected = NotAMockException.class)
public void shouldValidateMockWhenCreatingInOrderObject() {
Mockito.inOrder("notMock");
}
- @Test
- public void shouldStartingMockSettingsContainDefaultBehavior() {
- //when
- MockSettingsImpl<?> settings = (MockSettingsImpl<?>) Mockito.withSettings();
-
- //then
- assertThat(Mockito.RETURNS_DEFAULTS).isEqualTo(settings.getDefaultAnswer());
+ @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+ @Test(expected = MockitoException.class)
+ public void shouldGiveExplantionOnStaticMockingWithoutInlineMockMaker() {
+ Mockito.mockStatic(Object.class);
}
+ @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+ @Test(expected = MockitoException.class)
+ public void shouldGiveExplantionOnConstructionMockingWithoutInlineMockMaker() {
+ Mockito.mockConstruction(Object.class);
+ }
+
+ @Test
+ public void shouldStartingMockSettingsContainDefaultBehavior() {
+ // when
+ MockSettingsImpl<?> settings = (MockSettingsImpl<?>) Mockito.withSettings();
+
+ // then
+ assertThat(Mockito.RETURNS_DEFAULTS).isEqualTo(settings.getDefaultAnswer());
+ }
}
diff --git a/src/test/java/org/mockito/PrematureGarbageCollectionTest.java b/src/test/java/org/mockito/PrematureGarbageCollectionTest.java
new file mode 100644
index 0000000..cb10a92
--- /dev/null
+++ b/src/test/java/org/mockito/PrematureGarbageCollectionTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import org.junit.Test;
+
+public class PrematureGarbageCollectionTest {
+
+ @Test
+ public void provoke_premature_garbage_collection() {
+ for (int i = 0; i < 500; i++) {
+ populateNodeList();
+ }
+ }
+
+ private static void populateNodeList() {
+ Node node = nodes();
+ while (node != null) {
+ Node next = node.next;
+ node.object.run();
+ node = next;
+ }
+ }
+
+ private static Node nodes() {
+ Node node = null;
+ for (int i = 0; i < 1_000; ++i) {
+ Node next = new Node();
+ next.next = node;
+ node = next;
+ }
+ return node;
+ }
+
+ private static class Node {
+
+ private Node next;
+
+ private final Runnable object = Mockito.mock(Runnable.class);
+ }
+}
diff --git a/src/test/java/org/mockito/StateMaster.java b/src/test/java/org/mockito/StateMaster.java
index c0100e7..e58edc2 100644
--- a/src/test/java/org/mockito/StateMaster.java
+++ b/src/test/java/org/mockito/StateMaster.java
@@ -2,13 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito;
-import org.mockito.listeners.MockitoListener;
-
import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+import org.mockito.listeners.MockitoListener;
+
public class StateMaster {
public void reset() {
diff --git a/src/test/java/org/mockito/StaticMockingExperimentTest.java b/src/test/java/org/mockito/StaticMockingExperimentTest.java
index cc8a598..361ac13 100644
--- a/src/test/java/org/mockito/StaticMockingExperimentTest.java
+++ b/src/test/java/org/mockito/StaticMockingExperimentTest.java
@@ -4,19 +4,6 @@
*/
package org.mockito;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.InvocationFactory;
-import org.mockito.invocation.MockHandler;
-import org.mockitoutil.TestBase;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
@@ -27,6 +14,19 @@
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.withSettings;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationFactory;
+import org.mockito.invocation.MockHandler;
+import org.mockitoutil.TestBase;
+
/**
* This test is an experimental use of Mockito API to simulate static mocking.
* Other frameworks can use it to build good support for static mocking.
@@ -43,119 +43,197 @@
Foo mock = Mockito.mock(Foo.class);
MockHandler handler = Mockito.mockingDetails(mock).getMockHandler();
Method staticMethod;
- InvocationFactory.RealMethodBehavior realMethod = new InvocationFactory.RealMethodBehavior() {
- @Override
- public Object call() throws Throwable {
- return null;
- }
- };
+ InvocationFactory.RealMethodBehavior realMethod =
+ new InvocationFactory.RealMethodBehavior() {
+ @Override
+ public Object call() throws Throwable {
+ return null;
+ }
+ };
- @Before public void before() throws Throwable {
+ @Before
+ public void before() throws Throwable {
staticMethod = Foo.class.getDeclaredMethod("staticMethod", String.class);
}
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
@Test
public void verify_static_method() throws Throwable {
- //register staticMethod call on mock
- Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
- "some arg");
+ // register staticMethod call on mock
+ Invocation invocation =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ staticMethod,
+ realMethod,
+ "some arg");
handler.handle(invocation);
- //verify staticMethod on mock
- //Mockito cannot capture static methods so we will simulate this scenario in 3 steps:
- //1. Call standard 'verify' method. Internally, it will add verificationMode to the thread local state.
- // Effectively, we indicate to Mockito that right now we are about to verify a method call on this mock.
+ // verify staticMethod on mock
+ // Mockito cannot capture static methods so we will simulate this scenario in 3 steps:
+ // 1. Call standard 'verify' method. Internally, it will add verificationMode to the thread
+ // local state.
+ // Effectively, we indicate to Mockito that right now we are about to verify a method call
+ // on this mock.
verify(mock);
- //2. Create the invocation instance using the new public API
- // Mockito cannot capture static methods but we can create an invocation instance of that static invocation
- Invocation verification = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
- "some arg");
- //3. Make Mockito handle the static method invocation
- // Mockito will find verification mode in thread local state and will try verify the invocation
+ // 2. Create the invocation instance using the new public API
+ // Mockito cannot capture static methods but we can create an invocation instance of that
+ // static invocation
+ Invocation verification =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ staticMethod,
+ realMethod,
+ "some arg");
+ // 3. Make Mockito handle the static method invocation
+ // Mockito will find verification mode in thread local state and will try verify the
+ // invocation
handler.handle(verification);
- //verify zero times, method with different argument
+ // verify zero times, method with different argument
verify(mock, times(0));
- Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
- "different arg");
+ Invocation differentArg =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ staticMethod,
+ realMethod,
+ "different arg");
handler.handle(differentArg);
}
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
@Test
public void verification_failure_static_method() throws Throwable {
- //register staticMethod call on mock
- Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
- "foo");
+ // register staticMethod call on mock
+ Invocation invocation =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ staticMethod,
+ realMethod,
+ "foo");
handler.handle(invocation);
- //verify staticMethod on mock
+ // verify staticMethod on mock
verify(mock);
- Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
- "different arg");
+ Invocation differentArg =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ staticMethod,
+ realMethod,
+ "different arg");
try {
handler.handle(differentArg);
fail();
- } catch (ArgumentsAreDifferent e) {}
+ } catch (ArgumentsAreDifferent e) {
+ }
}
@Test
public void stubbing_static_method() throws Throwable {
- //register staticMethod call on mock
- Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
- "foo");
+ // register staticMethod call on mock
+ Invocation invocation =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ staticMethod,
+ realMethod,
+ "foo");
handler.handle(invocation);
- //register stubbing
+ // register stubbing
when(null).thenReturn("hey");
- //validate stubbed return value
+ // validate stubbed return value
assertEquals("hey", handler.handle(invocation));
assertEquals("hey", handler.handle(invocation));
- //default null value is returned if invoked with different argument
- Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
- "different arg");
+ // default null value is returned if invoked with different argument
+ Invocation differentArg =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ staticMethod,
+ realMethod,
+ "different arg");
assertEquals(null, handler.handle(differentArg));
}
@Test
public void do_answer_stubbing_static_method() throws Throwable {
- //register stubbed return value
- doReturn("hey").when(mock);
+ // register stubbed return value
+ Object ignored = doReturn("hey").when(mock);
- //complete stubbing by triggering an invocation that needs to be stubbed
- Invocation invocation = Mockito.framework().getInvocationFactory()
- .createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod, "foo");
+ // complete stubbing by triggering an invocation that needs to be stubbed
+ Invocation invocation =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ staticMethod,
+ realMethod,
+ "foo");
handler.handle(invocation);
- //validate stubbed return value
+ // validate stubbed return value
assertEquals("hey", handler.handle(invocation));
assertEquals("hey", handler.handle(invocation));
- //default null value is returned if invoked with different argument
- Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
- "different arg");
+ // default null value is returned if invoked with different argument
+ Invocation differentArg =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ staticMethod,
+ realMethod,
+ "different arg");
assertEquals(null, handler.handle(differentArg));
}
@Test
public void verify_no_more_interactions() throws Throwable {
- //works for now because there are not interactions
+ // works for now because there are not interactions
verifyNoMoreInteractions(mock);
- //register staticMethod call on mock
- Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
- "foo");
+ // register staticMethod call on mock
+ Invocation invocation =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ staticMethod,
+ realMethod,
+ "foo");
handler.handle(invocation);
- //fails now because we have one static invocation recorded
+ // fails now because we have one static invocation recorded
try {
verifyNoMoreInteractions(mock);
fail();
- } catch (NoInteractionsWanted e) {}
+ } catch (NoInteractionsWanted e) {
+ }
}
@Test
@@ -163,19 +241,35 @@
Constructor<Foo> ctr = Foo.class.getConstructor(String.class);
Method adapter = ConstructorMethodAdapter.class.getDeclaredMethods()[0];
- //stub constructor
- doReturn(new Foo("hey!")).when(mock);
- Invocation constructor = Mockito.framework().getInvocationFactory().createInvocation(
- mock, withSettings().build(Foo.class), adapter, realMethod, ctr, "foo");
+ // stub constructor
+ Object ignored = doReturn(new Foo("hey!")).when(mock);
+ Invocation constructor =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ adapter,
+ realMethod,
+ ctr,
+ "foo");
handler.handle(constructor);
- //test stubbing
+ // test stubbing
Object result = handler.handle(constructor);
assertEquals("foo:hey!", result.toString());
- //stubbing miss
- Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class),
- adapter, realMethod, ctr, "different arg");
+ // stubbing miss
+ Invocation differentArg =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ adapter,
+ realMethod,
+ ctr,
+ "different arg");
Object result2 = handler.handle(differentArg);
assertEquals(null, result2);
}
@@ -186,26 +280,40 @@
Constructor<Foo> ctr = Foo.class.getConstructor(String.class);
Method adapter = ConstructorMethodAdapter.class.getDeclaredMethods()[0];
- //invoke constructor
- Invocation constructor = Mockito.framework().getInvocationFactory().createInvocation(
- mock, withSettings().build(Foo.class), adapter, realMethod, ctr, "matching arg");
+ // invoke constructor
+ Invocation constructor =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ adapter,
+ realMethod,
+ ctr,
+ "matching arg");
handler.handle(constructor);
- //verify successfully
+ // verify successfully
verify(mock);
handler.handle(constructor);
- //verification failure
+ // verification failure
verify(mock);
- Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class),
- adapter, realMethod, ctr, "different arg");
+ Invocation differentArg =
+ Mockito.framework()
+ .getInvocationFactory()
+ .createInvocation(
+ mock,
+ withSettings().build(Foo.class),
+ adapter,
+ realMethod,
+ ctr,
+ "different arg");
try {
handler.handle(differentArg);
fail();
} catch (WantedButNotInvoked e) {
- assertThat(e.getMessage())
- .contains("matching arg")
- .contains("different arg");
+ assertThat(e.getMessage()).contains("matching arg").contains("different arg");
}
}
diff --git a/src/test/java/org/mockito/configuration/MockitoConfiguration.java b/src/test/java/org/mockito/configuration/MockitoConfiguration.java
index bc7df84..5834485 100644
--- a/src/test/java/org/mockito/configuration/MockitoConfiguration.java
+++ b/src/test/java/org/mockito/configuration/MockitoConfiguration.java
@@ -7,7 +7,8 @@
import org.mockito.stubbing.Answer;
import org.mockitousage.configuration.CustomizedAnnotationForSmartMockTest;
-public class MockitoConfiguration extends DefaultMockitoConfiguration implements IMockitoConfiguration {
+public class MockitoConfiguration extends DefaultMockitoConfiguration
+ implements IMockitoConfiguration {
private Answer<Object> overriddenDefaultAnswer = null;
@@ -17,22 +18,22 @@
private boolean enableClassCache = true;
- //for testing purposes, allow to override the configuration
+ // for testing purposes, allow to override the configuration
public void overrideDefaultAnswer(Answer<Object> defaultAnswer) {
this.overriddenDefaultAnswer = defaultAnswer;
}
- //for testing purposes, allow to override the configuration
+ // for testing purposes, allow to override the configuration
public void overrideCleansStackTrace(boolean cleansStackTrace) {
this.cleansStackTrace = cleansStackTrace;
}
- //for testing purposes, allow to override the annotation engine
+ // for testing purposes, allow to override the annotation engine
public void overrideAnnotationEngine(AnnotationEngine engine) {
this.overriddenEngine = engine;
}
- //for testing purposes, allow to override the annotation engine
+ // for testing purposes, allow to override the annotation engine
public void overrideEnableClassCache(boolean enableClassCache) {
this.enableClassCache = enableClassCache;
}
@@ -63,5 +64,4 @@
public boolean enableClassCache() {
return enableClassCache;
}
-
}
diff --git a/src/test/java/org/mockito/exceptions/base/MockitoAssertionErrorTest.java b/src/test/java/org/mockito/exceptions/base/MockitoAssertionErrorTest.java
index 515ed9f..d54e740 100644
--- a/src/test/java/org/mockito/exceptions/base/MockitoAssertionErrorTest.java
+++ b/src/test/java/org/mockito/exceptions/base/MockitoAssertionErrorTest.java
@@ -2,15 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.base;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
public class MockitoAssertionErrorTest extends TestBase {
private void throwIt() {
@@ -30,7 +29,8 @@
@Test
public void should_prepend_message_to_original() {
MockitoAssertionError original = new MockitoAssertionError("original message");
- MockitoAssertionError errorWithPrependedMessage = new MockitoAssertionError(original, "new message");
+ MockitoAssertionError errorWithPrependedMessage =
+ new MockitoAssertionError(original, "new message");
assertEquals("new message\noriginal message", errorWithPrependedMessage.getMessage());
}
}
diff --git a/src/test/java/org/mockito/exceptions/base/MockitoExceptionTest.java b/src/test/java/org/mockito/exceptions/base/MockitoExceptionTest.java
index 00d4033..ea9833b 100644
--- a/src/test/java/org/mockito/exceptions/base/MockitoExceptionTest.java
+++ b/src/test/java/org/mockito/exceptions/base/MockitoExceptionTest.java
@@ -2,15 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.base;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
public class MockitoExceptionTest extends TestBase {
private void throwIt() {
diff --git a/src/test/java/org/mockito/exceptions/base/MockitoSerializationIssueTest.java b/src/test/java/org/mockito/exceptions/base/MockitoSerializationIssueTest.java
index 47db7b1..edd6af4 100644
--- a/src/test/java/org/mockito/exceptions/base/MockitoSerializationIssueTest.java
+++ b/src/test/java/org/mockito/exceptions/base/MockitoSerializationIssueTest.java
@@ -2,15 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.base;
-import org.junit.Test;
-import org.mockito.internal.configuration.ConfigurationAccess;
+import static org.assertj.core.api.Assertions.assertThat;
import java.util.Arrays;
-import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+import org.mockito.internal.configuration.ConfigurationAccess;
public class MockitoSerializationIssueTest {
@@ -20,11 +19,14 @@
ConfigurationAccess.getConfig().overrideCleansStackTrace(true);
// when
- MockitoSerializationIssue issue = new MockitoSerializationIssue("msg", new Exception("cause"));
+ MockitoSerializationIssue issue =
+ new MockitoSerializationIssue("msg", new Exception("cause"));
// then
- assertThat(Arrays.toString(issue.getUnfilteredStackTrace())).contains("MockitoSerializationIssueTest");
- assertThat(Arrays.toString(issue.getStackTrace())).doesNotContain("MockitoSerializationIssueTest");
+ assertThat(Arrays.toString(issue.getUnfilteredStackTrace()))
+ .contains("MockitoSerializationIssueTest");
+ assertThat(Arrays.toString(issue.getStackTrace()))
+ .doesNotContain("MockitoSerializationIssueTest");
}
@Test
@@ -33,10 +35,13 @@
ConfigurationAccess.getConfig().overrideCleansStackTrace(false);
// when
- MockitoSerializationIssue issue = new MockitoSerializationIssue("msg", new Exception("cause"));
+ MockitoSerializationIssue issue =
+ new MockitoSerializationIssue("msg", new Exception("cause"));
// then
- assertThat(Arrays.toString(issue.getUnfilteredStackTrace())).contains("MockitoSerializationIssueTest");
- assertThat(Arrays.toString(issue.getStackTrace())).contains("MockitoSerializationIssueTest");
+ assertThat(Arrays.toString(issue.getUnfilteredStackTrace()))
+ .contains("MockitoSerializationIssueTest");
+ assertThat(Arrays.toString(issue.getStackTrace()))
+ .contains("MockitoSerializationIssueTest");
}
}
diff --git a/src/test/java/org/mockito/exceptions/base/StackTraceBuilder.java b/src/test/java/org/mockito/exceptions/base/StackTraceBuilder.java
index a0bbced..d7bf186 100644
--- a/src/test/java/org/mockito/exceptions/base/StackTraceBuilder.java
+++ b/src/test/java/org/mockito/exceptions/base/StackTraceBuilder.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.base;
import java.util.Arrays;
@@ -12,7 +11,7 @@
private String[] methods;
- public StackTraceBuilder methods(String ... methods) {
+ public StackTraceBuilder methods(String... methods) {
this.methods = methods;
return this;
}
diff --git a/src/test/java/org/mockito/exceptions/base/TraceBuilder.java b/src/test/java/org/mockito/exceptions/base/TraceBuilder.java
index 247ad38..7763913 100644
--- a/src/test/java/org/mockito/exceptions/base/TraceBuilder.java
+++ b/src/test/java/org/mockito/exceptions/base/TraceBuilder.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.exceptions.base;
import java.util.Collections;
@@ -39,12 +38,12 @@
return toTraceList().toArray(new StackTraceElement[0]);
}
- public TraceBuilder classes(String ... classes) {
+ public TraceBuilder classes(String... classes) {
this.classes = classes;
return this;
}
- public TraceBuilder methods(String ... methods) {
+ public TraceBuilder methods(String... methods) {
this.methods = methods;
return this;
}
diff --git a/src/test/java/org/mockito/exceptions/stacktrace/StackTraceCleanerTest.java b/src/test/java/org/mockito/exceptions/stacktrace/StackTraceCleanerTest.java
index e0f051e..832d6d7 100644
--- a/src/test/java/org/mockito/exceptions/stacktrace/StackTraceCleanerTest.java
+++ b/src/test/java/org/mockito/exceptions/stacktrace/StackTraceCleanerTest.java
@@ -4,14 +4,14 @@
*/
package org.mockito.exceptions.stacktrace;
+import static org.assertj.core.api.Assertions.assertThat;
+
import org.junit.Test;
import org.mockito.internal.exceptions.stacktrace.DefaultStackTraceCleaner;
-import static org.assertj.core.api.Assertions.assertThat;
-
public class StackTraceCleanerTest {
- private DefaultStackTraceCleaner cleaner= new DefaultStackTraceCleaner();
+ private DefaultStackTraceCleaner cleaner = new DefaultStackTraceCleaner();
@Test
public void allow_or_disallow_mockito_mockito_objects_in_stacktrace() throws Exception {
@@ -34,11 +34,15 @@
}
private void assertAcceptedInStackTrace(String className) {
- assertThat(cleaner.isIn(stackTraceElementWith(className))).describedAs("Must be accepted in stacktrace %s", className).isTrue();
+ assertThat(cleaner.isIn(stackTraceElementWith(className)))
+ .describedAs("Must be accepted in stacktrace %s", className)
+ .isTrue();
}
private void assertRejectedInStackTrace(String className) {
- assertThat(cleaner.isIn(stackTraceElementWith(className))).describedAs("Must be rejected in stacktrace %s", className).isFalse();
+ assertThat(cleaner.isIn(stackTraceElementWith(className)))
+ .describedAs("Must be rejected in stacktrace %s", className)
+ .isFalse();
}
private StackTraceElement stackTraceElementWith(String className) {
diff --git a/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java b/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java
index 7022672..dac34c0 100644
--- a/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java
+++ b/src/test/java/org/mockito/internal/AllInvocationsFinderTest.java
@@ -2,20 +2,10 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.stubbing.Stubbing;
-import org.mockito.invocation.Invocation;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-import java.util.ArrayList;
-import java.util.List;
-
import static java.util.Arrays.asList;
+
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
@@ -23,6 +13,16 @@
import static org.mockito.internal.invocation.finder.AllInvocationsFinder.find;
import static org.mockito.internal.invocation.finder.AllInvocationsFinder.findStubbings;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.invocation.Invocation;
+import org.mockito.stubbing.Stubbing;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
public class AllInvocationsFinderTest extends TestBase {
private IMethods mockTwo;
@@ -36,22 +36,22 @@
@Test
public void no_interactions() throws Exception {
- //expect
+ // expect
assertTrue(find(asList(mockOne, mockTwo)).isEmpty());
assertTrue(findStubbings(asList(mockOne, mockTwo)).isEmpty());
}
@Test
public void provides_invocations_in_order() throws Exception {
- //given
+ // given
mockOne.simpleMethod(100);
mockTwo.simpleMethod(200);
mockOne.simpleMethod(300);
- //when
+ // when
List<Invocation> invocations = find(asList(mockOne, mockTwo));
- //then
+ // then
assertEquals(3, invocations.size());
assertArgumentEquals(100, invocations.get(0));
assertArgumentEquals(200, invocations.get(1));
@@ -60,28 +60,29 @@
@Test
public void deduplicates_interactions_from_the_same_mock() throws Exception {
- //given
+ // given
mockOne.simpleMethod(100);
- //when
+ // when
List<Invocation> invocations = find(asList(mockOne, mockOne, mockOne));
- //then
+ // then
assertEquals(1, invocations.size());
}
@Test
public void provides_stubbings_in_order() throws Exception {
- //given
- mockOne.simpleMethod(50); //ignored, not a stubbing
+ // given
+ mockOne.simpleMethod(50); // ignored, not a stubbing
when(mockOne.simpleMethod(100)).thenReturn("100");
when(mockOne.simpleMethod(200)).thenReturn("200");
when(mockTwo.simpleMethod(300)).thenReturn("300");
- //when
- List<Stubbing> stubbings = new ArrayList<Stubbing>(findStubbings(asList(mockOne, mockOne, mockTwo)));
+ // when
+ List<Stubbing> stubbings =
+ new ArrayList<Stubbing>(findStubbings(asList(mockOne, mockOne, mockTwo)));
- //then
+ // then
assertEquals(3, stubbings.size());
assertArgumentEquals(100, stubbings.get(0).getInvocation());
assertArgumentEquals(200, stubbings.get(1).getInvocation());
diff --git a/src/test/java/org/mockito/internal/InOrderImplTest.java b/src/test/java/org/mockito/internal/InOrderImplTest.java
index 9fccd27..5224a4f 100644
--- a/src/test/java/org/mockito/internal/InOrderImplTest.java
+++ b/src/test/java/org/mockito/internal/InOrderImplTest.java
@@ -4,6 +4,11 @@
*/
package org.mockito.internal;
+import static java.util.Collections.singletonList;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.internal.invocation.InvocationBuilder;
@@ -11,10 +16,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static java.util.Collections.singletonList;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
@SuppressWarnings("unchecked")
public class InOrderImplTest extends TestBase {
@@ -22,15 +23,15 @@
@Test
public void shouldMarkVerifiedInOrder() throws Exception {
- //given
+ // given
InOrderImpl impl = new InOrderImpl(singletonList(mock));
Invocation i = new InvocationBuilder().toInvocation();
assertFalse(impl.isVerified(i));
- //when
+ // when
impl.markVerified(i);
- //then
+ // then
assertTrue(impl.isVerified(i));
}
}
diff --git a/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java b/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
index 6baae82..ae31893 100644
--- a/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
+++ b/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
@@ -2,9 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
import org.junit.After;
import org.junit.Test;
import org.mockito.Mock;
@@ -15,10 +18,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
/**
* invalid state happens if:
*
@@ -68,6 +67,9 @@
detectsAndCleansUp(new OnVerifyNoMoreInteractions(), UnfinishedStubbingException.class);
when(mock.simpleMethod());
+ detectsAndCleansUp(new OnVerifyNoInteractions(), UnfinishedStubbingException.class);
+
+ when(mock.simpleMethod());
detectsAndCleansUp(new OnDoAnswer(), UnfinishedStubbingException.class);
}
@@ -93,6 +95,9 @@
detectsAndCleansUp(new OnVerifyNoMoreInteractions(), UnfinishedStubbingException.class);
doAnswer(null);
+ detectsAndCleansUp(new OnVerifyNoInteractions(), UnfinishedStubbingException.class);
+
+ doAnswer(null);
detectsAndCleansUp(new OnDoAnswer(), UnfinishedStubbingException.class);
}
@@ -115,41 +120,49 @@
detectsAndCleansUp(new OnVerifyNoMoreInteractions(), UnfinishedVerificationException.class);
verify(mock);
+ detectsAndCleansUp(new OnVerifyNoInteractions(), UnfinishedVerificationException.class);
+
+ verify(mock);
detectsAndCleansUp(new OnDoAnswer(), UnfinishedVerificationException.class);
}
@Test
public void shouldDetectMisplacedArgumentMatcher() {
- anyObject();
+ Object ignored = anyObject();
detectsAndCleansUp(new OnVerify(), InvalidUseOfMatchersException.class);
- anyObject();
+ ignored = anyObject();
detectsAndCleansUp(new OnVerifyInOrder(), InvalidUseOfMatchersException.class);
- anyObject();
+ ignored = anyObject();
detectsAndCleansUp(new OnVerifyZeroInteractions(), InvalidUseOfMatchersException.class);
- anyObject();
+ ignored = anyObject();
detectsAndCleansUp(new OnVerifyNoMoreInteractions(), InvalidUseOfMatchersException.class);
- anyObject();
+ ignored = anyObject();
+ detectsAndCleansUp(new OnVerifyNoInteractions(), InvalidUseOfMatchersException.class);
+
+ ignored = anyObject();
detectsAndCleansUp(new OnDoAnswer(), InvalidUseOfMatchersException.class);
}
@Test
public void shouldCorrectStateAfterDetectingUnfinishedStubbing() {
- doThrow(new RuntimeException()).when(mock);
+ Object ignored = doThrow(new RuntimeException()).when(mock);
try {
- doThrow(new RuntimeException()).when(mock).oneArg(true);
+ doThrow(new RuntimeException()).when(mock).oneArg(true);
fail();
- } catch (UnfinishedStubbingException e) {}
+ } catch (UnfinishedStubbingException e) {
+ }
doThrow(new RuntimeException()).when(mock).oneArg(true);
try {
mock.oneArg(true);
fail();
- } catch (RuntimeException e) {}
+ } catch (RuntimeException e) {
+ }
}
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
@@ -161,7 +174,8 @@
try {
verify(mock).simpleMethod();
fail();
- } catch (UnfinishedVerificationException e) {}
+ } catch (UnfinishedVerificationException e) {
+ }
verify(mock).simpleMethod();
}
@@ -198,6 +212,13 @@
}
}
+ private static class OnVerifyNoInteractions implements DetectsInvalidState {
+ @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+ public void detect(IMethods mock) {
+ verifyNoInteractions(mock);
+ }
+ }
+
private static class OnDoAnswer implements DetectsInvalidState {
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
public void detect(IMethods mock) {
@@ -239,7 +260,7 @@
} catch (Exception e) {
assertEquals(expected, e.getClass());
}
- //Make sure state is cleaned up
+ // Make sure state is cleaned up
new StateMaster().validate();
}
}
diff --git a/src/test/java/org/mockito/internal/configuration/ClassPathLoaderTest.java b/src/test/java/org/mockito/internal/configuration/ClassPathLoaderTest.java
index 5b5c710..faf86d7 100644
--- a/src/test/java/org/mockito/internal/configuration/ClassPathLoaderTest.java
+++ b/src/test/java/org/mockito/internal/configuration/ClassPathLoaderTest.java
@@ -4,23 +4,26 @@
*/
package org.mockito.internal.configuration;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+
import org.junit.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
-
public class ClassPathLoaderTest extends TestBase {
@Test
public void shouldReadConfigurationClassFromClassPath() {
- ConfigurationAccess.getConfig().overrideDefaultAnswer(new Answer<Object>() {
- public Object answer(InvocationOnMock invocation) {
- return "foo";
- }});
+ ConfigurationAccess.getConfig()
+ .overrideDefaultAnswer(
+ new Answer<Object>() {
+ public Object answer(InvocationOnMock invocation) {
+ return "foo";
+ }
+ });
IMethods mock = mock(IMethods.class);
assertEquals("foo", mock.simpleMethod());
diff --git a/src/test/java/org/mockito/internal/configuration/GlobalConfigurationTest.java b/src/test/java/org/mockito/internal/configuration/GlobalConfigurationTest.java
index 5725670..d5590cc 100644
--- a/src/test/java/org/mockito/internal/configuration/GlobalConfigurationTest.java
+++ b/src/test/java/org/mockito/internal/configuration/GlobalConfigurationTest.java
@@ -4,6 +4,8 @@
*/
package org.mockito.internal.configuration;
+import static org.assertj.core.api.Assertions.assertThat;
+
import net.bytebuddy.ByteBuddy;
import org.assertj.core.api.Assertions;
import org.junit.After;
@@ -14,34 +16,40 @@
import org.mockitoutil.ClassLoaders;
import org.objenesis.Objenesis;
-import static org.assertj.core.api.Assertions.assertThat;
-
public class GlobalConfigurationTest {
@Test
public void returns_mockito_configuration_annotation_engine_if_non_default() throws Exception {
ConfigurationAccess.getConfig().overrideAnnotationEngine(new CustomAnnotationEngine());
- assertThat(new GlobalConfiguration().getAnnotationEngine()).isInstanceOf(CustomAnnotationEngine.class);
- assertThat(new GlobalConfiguration().tryGetPluginAnnotationEngine()).isInstanceOf(CustomAnnotationEngine.class);
+ assertThat(new GlobalConfiguration().getAnnotationEngine())
+ .isInstanceOf(CustomAnnotationEngine.class);
+ assertThat(new GlobalConfiguration().tryGetPluginAnnotationEngine())
+ .isInstanceOf(CustomAnnotationEngine.class);
}
@Test
- public void returns_mockito_annotation_engine_of_Plugins_if_no_MockitoConfiguration() throws Throwable {
- ClassLoader anotherWorld = ClassLoaders.isolatedClassLoader()
- .withCurrentCodeSourceUrls()
- .withCodeSourceUrlOf(Mockito.class, ByteBuddy.class, Objenesis.class)
- .withPrivateCopyOf("org.mockito", "net.bytebuddy", "org.objenesis")
- .withCodeSourceUrlOf(Assertions.class)
- .withPrivateCopyOf("org.assertj")
- .without("org.mockito.configuration.MockitoConfiguration")
- .build();
+ public void returns_mockito_annotation_engine_of_Plugins_if_no_MockitoConfiguration()
+ throws Throwable {
+ ClassLoader anotherWorld =
+ ClassLoaders.isolatedClassLoader()
+ .withCurrentCodeSourceUrls()
+ .withCodeSourceUrlOf(Mockito.class, ByteBuddy.class, Objenesis.class)
+ .withPrivateCopyOf("org.mockito", "net.bytebuddy", "org.objenesis")
+ .withCodeSourceUrlOf(Assertions.class)
+ .withPrivateCopyOf("org.assertj")
+ .without("org.mockito.configuration.MockitoConfiguration")
+ .build();
- ClassLoaders.using(anotherWorld).execute(new Runnable() {
- @Override
- public void run() {
- assertThat(new GlobalConfiguration().getAnnotationEngine()).isInstanceOf(Plugins.getAnnotationEngine().getClass());
- assertThat(new GlobalConfiguration().tryGetPluginAnnotationEngine()).isInstanceOf(Plugins.getAnnotationEngine().getClass());
- }
- });
+ ClassLoaders.using(anotherWorld)
+ .execute(
+ new Runnable() {
+ @Override
+ public void run() {
+ assertThat(new GlobalConfiguration().getAnnotationEngine())
+ .isInstanceOf(Plugins.getAnnotationEngine().getClass());
+ assertThat(new GlobalConfiguration().tryGetPluginAnnotationEngine())
+ .isInstanceOf(Plugins.getAnnotationEngine().getClass());
+ }
+ });
}
@After
@@ -50,6 +58,9 @@
}
private static class CustomAnnotationEngine implements AnnotationEngine {
- @Override public void process(Class<?> clazz, Object testInstance) { }
+ @Override
+ public AutoCloseable process(Class<?> clazz, Object testInstance) {
+ return new NoAction();
+ }
}
}
diff --git a/src/test/java/org/mockito/internal/configuration/InjectingAnnotationEngineTest.java b/src/test/java/org/mockito/internal/configuration/InjectingAnnotationEngineTest.java
new file mode 100644
index 0000000..274db3b
--- /dev/null
+++ b/src/test/java/org/mockito/internal/configuration/InjectingAnnotationEngineTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.junit.MockitoJUnitRunner;
+
+class I {}
+
+@RunWith(MockitoJUnitRunner.class)
+public class InjectingAnnotationEngineTest extends I {
+ @InjectMocks Target target;
+ @Mock Foo foo;
+ @Spy Bar bar = new Bar();
+
+ /*
+ If the test case has super classes, the @InjectMocks field has a field that not listed in the constructor argument
+ will fill by setter/property injection .
+
+ https://github.com/mockito/mockito/issues/1631
+ */
+ @Test
+ public void injectMocks() {
+ Assert.assertEquals(foo, target.getFoo());
+ Assert.assertNotNull(target.getBar());
+ }
+
+ public static class Target {
+ private final Foo foo;
+ private Bar bar;
+
+ public Target(Foo foo) {
+ this.foo = foo;
+ }
+
+ public Foo getFoo() {
+ return foo;
+ }
+
+ public Bar getBar() {
+ return bar;
+ }
+ }
+
+ public static class Foo {}
+
+ public static class Bar {}
+}
diff --git a/src/test/java/org/mockito/internal/configuration/MockAnnotationProcessorTest.java b/src/test/java/org/mockito/internal/configuration/MockAnnotationProcessorTest.java
new file mode 100644
index 0000000..9c4ef88
--- /dev/null
+++ b/src/test/java/org/mockito/internal/configuration/MockAnnotationProcessorTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.configuration;
+
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.MockedStatic;
+import org.mockito.exceptions.base.MockitoException;
+
+import static org.assertj.core.api.Assertions.*;
+
+public class MockAnnotationProcessorTest {
+
+ @SuppressWarnings("unused")
+ private MockedStatic<Void> nonGeneric;
+
+ @SuppressWarnings("unused")
+ private MockedStatic<List<?>> generic;
+
+ @SuppressWarnings({"raw", "unused"})
+ private MockedStatic raw;
+
+ @Test
+ public void testNonGeneric() throws Exception {
+ Class<?> type =
+ MockAnnotationProcessor.inferParameterizedType(
+ MockAnnotationProcessorTest.class
+ .getDeclaredField("nonGeneric")
+ .getGenericType(),
+ "nonGeneric",
+ "Sample");
+ assertThat(type).isEqualTo(Void.class);
+ }
+
+ @Test(expected = MockitoException.class)
+ public void testGeneric() throws Exception {
+ MockAnnotationProcessor.inferParameterizedType(
+ MockAnnotationProcessorTest.class.getDeclaredField("generic").getGenericType(),
+ "generic",
+ "Sample");
+ }
+
+ @Test(expected = MockitoException.class)
+ public void testRaw() throws Exception {
+ MockAnnotationProcessor.inferParameterizedType(
+ MockAnnotationProcessorTest.class.getDeclaredField("raw").getGenericType(),
+ "raw",
+ "Sample");
+ }
+}
diff --git a/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java b/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java
index 4abb528..83012b2 100644
--- a/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java
+++ b/src/test/java/org/mockito/internal/configuration/MockInjectionTest.java
@@ -2,20 +2,19 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.configuration;
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.internal.configuration.injection.MockInjection;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
import java.lang.reflect.Field;
import java.util.Collections;
import java.util.Observer;
import java.util.Set;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.internal.configuration.injection.MockInjection;
@SuppressWarnings("unchecked")
public class MockInjectionTest {
@@ -49,31 +48,42 @@
MockInjection.onField(field("withConstructor"), this).withMocks(null);
}
-
@Test
public void can_try_constructor_injection() throws Exception {
- MockInjection.onField(field("withConstructor"), this).withMocks(oneSetMock()).tryConstructorInjection().apply();
+ MockInjection.onField(field("withConstructor"), this)
+ .withMocks(oneSetMock())
+ .tryConstructorInjection()
+ .apply();
assertThat(withConstructor.initializedWithConstructor).isEqualTo(true);
}
@Test
public void should_not_fail_if_constructor_injection_is_not_possible() throws Exception {
- MockInjection.onField(field("withoutConstructor"), this).withMocks(otherKindOfMocks()).tryConstructorInjection().apply();
+ MockInjection.onField(field("withoutConstructor"), this)
+ .withMocks(otherKindOfMocks())
+ .tryConstructorInjection()
+ .apply();
assertThat(withoutConstructor).isNull();
}
@Test
public void can_try_property_or_setter_injection() throws Exception {
- MockInjection.onField(field("withoutConstructor"), this).withMocks(oneSetMock()).tryPropertyOrFieldInjection().apply();
+ MockInjection.onField(field("withoutConstructor"), this)
+ .withMocks(oneSetMock())
+ .tryPropertyOrFieldInjection()
+ .apply();
assertThat(withoutConstructor.theSet).isNotNull();
}
@Test
public void should_not_fail_if_property_or_field_injection_is_not_possible() throws Exception {
- MockInjection.onField(field("withoutConstructor"), this).withMocks(otherKindOfMocks()).tryPropertyOrFieldInjection().apply();
+ MockInjection.onField(field("withoutConstructor"), this)
+ .withMocks(otherKindOfMocks())
+ .tryPropertyOrFieldInjection()
+ .apply();
assertThat(withoutConstructor.theSet).isNull();
}
@@ -90,9 +100,9 @@
return getClass().getDeclaredField(field);
}
-
public static class AnObjectWithConstructor {
public boolean initializedWithConstructor = false;
+
public AnObjectWithConstructor(Set<String> strings) {
initializedWithConstructor = true;
}
diff --git a/src/test/java/org/mockito/internal/configuration/injection/ConstructorInjectionTest.java b/src/test/java/org/mockito/internal/configuration/injection/ConstructorInjectionTest.java
index 335d2e4..4023160 100644
--- a/src/test/java/org/mockito/internal/configuration/injection/ConstructorInjectionTest.java
+++ b/src/test/java/org/mockito/internal/configuration/injection/ConstructorInjectionTest.java
@@ -2,22 +2,21 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.configuration.injection;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import java.lang.reflect.Field;
import java.util.HashSet;
import java.util.Observer;
import java.util.Set;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
@RunWith(MockitoJUnitRunner.class)
public class ConstructorInjectionTest {
diff --git a/src/test/java/org/mockito/internal/configuration/injection/SimpleArgumentResolverTest.java b/src/test/java/org/mockito/internal/configuration/injection/SimpleArgumentResolverTest.java
index 4f3017d..4b4da06 100644
--- a/src/test/java/org/mockito/internal/configuration/injection/SimpleArgumentResolverTest.java
+++ b/src/test/java/org/mockito/internal/configuration/injection/SimpleArgumentResolverTest.java
@@ -2,25 +2,29 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.configuration.injection;
-import org.junit.Test;
+import static org.junit.Assert.*;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.util.*;
-import static org.junit.Assert.*;
+import org.junit.Test;
public class SimpleArgumentResolverTest {
@Test
public void should_return_object_matching_given_types() throws Exception {
ConstructorInjection.SimpleArgumentResolver resolver =
- new ConstructorInjection.SimpleArgumentResolver(newSetOf(new HashSet<Long>(), new ByteArrayOutputStream(), new HashMap<String, String>()));
+ new ConstructorInjection.SimpleArgumentResolver(
+ newSetOf(
+ new HashSet<Long>(),
+ new ByteArrayOutputStream(),
+ new HashMap<String, String>()));
- Object[] resolvedInstance = resolver.resolveTypeInstances(Set.class, Map.class, OutputStream.class);
+ Object[] resolvedInstance =
+ resolver.resolveTypeInstances(Set.class, Map.class, OutputStream.class);
assertEquals(3, resolvedInstance.length);
assertTrue(resolvedInstance[0] instanceof Set);
@@ -31,9 +35,11 @@
@Test
public void should_return_null_when_match_is_not_possible_on_given_types() throws Exception {
ConstructorInjection.SimpleArgumentResolver resolver =
- new ConstructorInjection.SimpleArgumentResolver(newSetOf(new HashSet<Float>(), new ByteArrayOutputStream()));
+ new ConstructorInjection.SimpleArgumentResolver(
+ newSetOf(new HashSet<Float>(), new ByteArrayOutputStream()));
- Object[] resolvedInstance = resolver.resolveTypeInstances(Set.class, Map.class, OutputStream.class);
+ Object[] resolvedInstance =
+ resolver.resolveTypeInstances(Set.class, Map.class, OutputStream.class);
assertEquals(3, resolvedInstance.length);
assertTrue(resolvedInstance[0] instanceof Set);
@@ -44,9 +50,11 @@
@Test
public void should_return_null_when_types_are_primitives() throws Exception {
ConstructorInjection.SimpleArgumentResolver resolver =
- new ConstructorInjection.SimpleArgumentResolver(newSetOf(new HashMap<Integer, String>(), new TreeSet<Integer>()));
+ new ConstructorInjection.SimpleArgumentResolver(
+ newSetOf(new HashMap<Integer, String>(), new TreeSet<Integer>()));
- Object[] resolvedInstance = resolver.resolveTypeInstances(Set.class, Map.class, Boolean.class);
+ Object[] resolvedInstance =
+ resolver.resolveTypeInstances(Set.class, Map.class, Boolean.class);
assertEquals(3, resolvedInstance.length);
assertTrue(resolvedInstance[0] instanceof Set);
@@ -57,6 +65,4 @@
private Set<Object> newSetOf(Object... objects) {
return new HashSet<Object>(Arrays.asList(objects));
}
-
-
}
diff --git a/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java b/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java
index 5935eae..ab97bc5 100644
--- a/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java
+++ b/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java
@@ -4,28 +4,40 @@
*/
package org.mockito.internal.configuration.plugins;
+import static org.junit.Assert.*;
+import static org.mockito.internal.configuration.plugins.DefaultMockitoPlugins.INLINE_ALIAS;
+import static org.mockito.internal.configuration.plugins.DefaultMockitoPlugins.PROXY_ALIAS;
+
import org.junit.Test;
import org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker;
import org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker;
+import org.mockito.internal.util.ConsoleMockitoLogger;
import org.mockito.plugins.InstantiatorProvider;
import org.mockito.plugins.InstantiatorProvider2;
import org.mockito.plugins.MockMaker;
+import org.mockito.plugins.MockitoLogger;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.*;
-import static org.mockito.internal.configuration.plugins.DefaultMockitoPlugins.INLINE_ALIAS;
-
public class DefaultMockitoPluginsTest extends TestBase {
private DefaultMockitoPlugins plugins = new DefaultMockitoPlugins();
@Test
+ @SuppressWarnings("deprecation")
public void provides_plugins() throws Exception {
- assertEquals("org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker",
- plugins.getDefaultPluginClass(INLINE_ALIAS));
+ assertEquals(
+ "org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker",
+ plugins.getDefaultPluginClass(INLINE_ALIAS));
assertEquals(InlineByteBuddyMockMaker.class, plugins.getInlineMockMaker().getClass());
- assertEquals(ByteBuddyMockMaker.class, plugins.getDefaultPlugin(MockMaker.class).getClass());
+ assertEquals(
+ "org.mockito.internal.creation.proxy.ProxyMockMaker",
+ plugins.getDefaultPluginClass(PROXY_ALIAS));
+ assertEquals(
+ ByteBuddyMockMaker.class, plugins.getDefaultPlugin(MockMaker.class).getClass());
assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider.class));
assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider2.class));
+ assertEquals(
+ ConsoleMockitoLogger.class,
+ plugins.getDefaultPlugin(MockitoLogger.class).getClass());
}
}
diff --git a/src/test/java/org/mockito/internal/configuration/plugins/PluginFileReaderTest.java b/src/test/java/org/mockito/internal/configuration/plugins/PluginFileReaderTest.java
index 5892931..e33e302 100644
--- a/src/test/java/org/mockito/internal/configuration/plugins/PluginFileReaderTest.java
+++ b/src/test/java/org/mockito/internal/configuration/plugins/PluginFileReaderTest.java
@@ -4,15 +4,15 @@
*/
package org.mockito.internal.configuration.plugins;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
public class PluginFileReaderTest extends TestBase {
@@ -20,12 +20,12 @@
@Test
public void no_class_in_resource() throws IOException {
- //no class
+ // no class
assertNull(reader.readPluginClass(impl("")));
assertNull(reader.readPluginClass(impl(" ")));
assertNull(reader.readPluginClass(impl(" \n ")));
- //commented out
+ // commented out
assertNull(reader.readPluginClass(impl("#foo")));
assertNull(reader.readPluginClass(impl(" # foo ")));
assertNull(reader.readPluginClass(impl(" # # # java.langString # ")));
@@ -41,7 +41,8 @@
assertEquals("java.lang.String", reader.readPluginClass(impl("java.lang.String")));
assertEquals("x", reader.readPluginClass(impl("x")));
assertEquals("x y z", reader.readPluginClass(impl(" x y z ")));
- assertEquals("foo.Foo", reader.readPluginClass(impl(" #my class\n foo.Foo \n #other class ")));
+ assertEquals(
+ "foo.Foo", reader.readPluginClass(impl(" #my class\n foo.Foo \n #other class ")));
assertEquals("foo.Foo", reader.readPluginClass(impl("foo.Foo # cool class")));
}
}
diff --git a/src/test/java/org/mockito/internal/configuration/plugins/PluginFinderTest.java b/src/test/java/org/mockito/internal/configuration/plugins/PluginFinderTest.java
index 7af3e5b..dcfc7f6 100644
--- a/src/test/java/org/mockito/internal/configuration/plugins/PluginFinderTest.java
+++ b/src/test/java/org/mockito/internal/configuration/plugins/PluginFinderTest.java
@@ -4,6 +4,17 @@
*/
package org.mockito.internal.configuration.plugins;
+import static java.util.Arrays.asList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.when;
+
+import java.io.File;
+import java.net.URL;
+import java.util.Collections;
+
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
@@ -13,106 +24,115 @@
import org.mockito.plugins.PluginSwitch;
import org.mockitoutil.TestBase;
-import java.io.File;
-import java.net.URL;
-import java.util.Collections;
-
-import static java.util.Arrays.asList;
-import static org.junit.Assert.*;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.when;
-
public class PluginFinderTest extends TestBase {
- @Mock
- PluginSwitch switcher;
+ @Mock PluginSwitch switcher;
@InjectMocks PluginFinder finder;
public @Rule TemporaryFolder tmp = new TemporaryFolder();
- @Test public void empty_resources() {
+ @Test
+ public void empty_resources() {
assertNull(finder.findPluginClass(Collections.<URL>emptyList()));
}
- @Test public void no_valid_impl() throws Exception {
+ @Test
+ public void no_valid_impl() throws Exception {
File f = tmp.newFile();
- //when
+ // when
IOUtil.writeText(" \n ", f);
- //then
+ // then
assertNull(finder.findPluginClass(asList(f.toURI().toURL())));
}
- @Test public void single_implementation() throws Exception {
+ @Test
+ public void single_implementation() throws Exception {
File f = tmp.newFile();
when(switcher.isEnabled("foo.Foo")).thenReturn(true);
- //when
+ // when
IOUtil.writeText(" foo.Foo ", f);
- //then
+ // then
assertEquals("foo.Foo", finder.findPluginClass(asList(f.toURI().toURL())));
}
- @Test public void single_implementation_disabled() throws Exception {
+ @Test
+ public void single_implementation_disabled() throws Exception {
File f = tmp.newFile();
when(switcher.isEnabled("foo.Foo")).thenReturn(false);
- //when
+ // when
IOUtil.writeText(" foo.Foo ", f);
- //then
+ // then
assertEquals(null, finder.findPluginClass(asList(f.toURI().toURL())));
}
- @Test public void multiple_implementations_only_one_enabled() throws Exception {
- File f1 = tmp.newFile(); File f2 = tmp.newFile();
+ @Test
+ public void multiple_implementations_only_one_enabled() throws Exception {
+ File f1 = tmp.newFile();
+ File f2 = tmp.newFile();
when(switcher.isEnabled("Bar")).thenReturn(true);
- //when
- IOUtil.writeText("Foo", f1); IOUtil.writeText("Bar", f2);
+ // when
+ IOUtil.writeText("Foo", f1);
+ IOUtil.writeText("Bar", f2);
- //then
+ // then
assertEquals("Bar", finder.findPluginClass(asList(f1.toURI().toURL(), f2.toURI().toURL())));
}
- @Test public void multiple_implementations_only_one_useful() throws Exception {
- File f1 = tmp.newFile(); File f2 = tmp.newFile();
+ @Test
+ public void multiple_implementations_only_one_useful() throws Exception {
+ File f1 = tmp.newFile();
+ File f2 = tmp.newFile();
when(switcher.isEnabled(anyString())).thenReturn(true);
- //when
- IOUtil.writeText(" ", f1); IOUtil.writeText("X", f2);
+ // when
+ IOUtil.writeText(" ", f1);
+ IOUtil.writeText("X", f2);
- //then
+ // then
assertEquals("X", finder.findPluginClass(asList(f1.toURI().toURL(), f2.toURI().toURL())));
}
- @Test public void multiple_empty_implementations() throws Exception {
- File f1 = tmp.newFile(); File f2 = tmp.newFile();
+ @Test
+ public void multiple_empty_implementations() throws Exception {
+ File f1 = tmp.newFile();
+ File f2 = tmp.newFile();
when(switcher.isEnabled(anyString())).thenReturn(true);
- //when
- IOUtil.writeText(" ", f1); IOUtil.writeText("\n", f2);
+ // when
+ IOUtil.writeText(" ", f1);
+ IOUtil.writeText("\n", f2);
- //then
+ // then
assertEquals(null, finder.findPluginClass(asList(f1.toURI().toURL(), f2.toURI().toURL())));
}
- @Test public void problems_loading_impl() throws Exception {
+ @Test
+ public void problems_loading_impl() throws Exception {
+ String fileName = "xxx";
+ File f = tmp.newFile(fileName);
+
+ // when
+ IOUtil.writeText("Bar", f);
+
when(switcher.isEnabled(anyString())).thenThrow(new RuntimeException("Boo!"));
try {
- //when
- finder.findPluginClass(asList(new File("xxx").toURI().toURL()));
- //then
+ // when
+ finder.findPluginClass(asList(f.toURI().toURL()));
+ // then
fail();
- } catch(Exception e) {
- assertThat(e).hasMessageContaining("xxx");
- e.getCause().getMessage().equals("Boo!");
+ } catch (Exception e) {
+ assertThat(e).hasMessageContaining(fileName);
+ assertThat(e.getCause()).hasMessage("Boo!");
}
}
}
diff --git a/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java b/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java
index ab01858..543af68 100644
--- a/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java
+++ b/src/test/java/org/mockito/internal/configuration/plugins/PluginLoaderTest.java
@@ -4,6 +4,11 @@
*/
package org.mockito.internal.configuration.plugins;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.BDDMockito.willReturn;
+import static org.mockito.Mockito.when;
+
import org.assertj.core.api.Assertions;
import org.assertj.core.api.ThrowableAssert;
import org.junit.Rule;
@@ -14,11 +19,6 @@
import org.mockito.junit.MockitoRule;
import org.mockito.quality.Strictness;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertSame;
-import static org.mockito.BDDMockito.willReturn;
-import static org.mockito.Mockito.when;
-
public class PluginLoaderTest {
@Rule public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
@@ -31,10 +31,10 @@
public void loads_plugin() {
when(initializer.loadImpl(FooPlugin.class)).thenReturn(new FooPlugin());
- //when
+ // when
FooPlugin plugin = loader.loadPlugin(FooPlugin.class);
- //then
+ // then
assertNotNull(plugin);
}
@@ -44,10 +44,10 @@
BarPlugin expected = new BarPlugin();
willReturn(expected).given(initializer).loadImpl(BarPlugin.class);
- //when
+ // when
Object plugin = loader.loadPlugin(FooPlugin.class, BarPlugin.class);
- //then
+ // then
assertSame(plugin, expected);
}
@@ -58,10 +58,10 @@
FooPlugin expected = new FooPlugin();
willReturn(expected).given(plugins).getDefaultPlugin(FooPlugin.class);
- //when
+ // when
Object plugin = loader.loadPlugin(FooPlugin.class, BarPlugin.class);
- //then
+ // then
assertSame(plugin, expected);
}
@@ -70,21 +70,26 @@
RuntimeException cause = new RuntimeException("Boo!");
when(initializer.loadImpl(Foo.class)).thenThrow(cause);
- //when
+ // when
final Foo plugin = loader.loadPlugin(Foo.class);
- //then
- Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() throws Throwable {
- plugin.toString(); //call any method on the plugin
- }
- }).isInstanceOf(IllegalStateException.class)
- .hasMessage("Could not initialize plugin: interface org.mockito.internal.configuration.plugins.PluginLoaderTest$Foo (alternate: null)")
- .hasCause(cause);
+ // then
+ Assertions.assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ @Override
+ public void call() throws Throwable {
+ plugin.toString(); // call any method on the plugin
+ }
+ })
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessage(
+ "Could not initialize plugin: interface org.mockito.internal.configuration.plugins.PluginLoaderTest$Foo (alternate: null)")
+ .hasCause(cause);
}
static class FooPlugin {}
+
static class BarPlugin {}
+
static interface Foo {}
}
diff --git a/src/test/java/org/mockito/internal/creation/AbstractMockMakerTest.java b/src/test/java/org/mockito/internal/creation/AbstractMockMakerTest.java
new file mode 100644
index 0000000..d594778
--- /dev/null
+++ b/src/test/java/org/mockito/internal/creation/AbstractMockMakerTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation;
+
+import org.junit.Test;
+import org.mockito.internal.handler.MockHandlerImpl;
+import org.mockito.internal.stubbing.answers.CallsRealMethods;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationContainer;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.SerializableMode;
+import org.mockito.plugins.MockMaker;
+import org.mockito.stubbing.Answer;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public abstract class AbstractMockMakerTest<MM extends MockMaker, C> {
+
+ protected final MM mockMaker;
+
+ private final Class<C> target;
+
+ protected AbstractMockMakerTest(MM mockMaker, Class<C> target) {
+ this.mockMaker = mockMaker;
+ this.target = target;
+ }
+
+ @Test
+ public void should_mocks_have_different_interceptors() throws Exception {
+ C mockOne = mockMaker.createMock(settingsFor(target), dummyHandler());
+ C mockTwo = mockMaker.createMock(settingsFor(target), dummyHandler());
+
+ MockHandler handlerOne = mockMaker.getHandler(mockOne);
+ MockHandler handlerTwo = mockMaker.getHandler(mockTwo);
+
+ assertThat(handlerOne).isNotSameAs(handlerTwo);
+ }
+
+ @Test
+ public void should_reset_mock_and_set_new_handler() throws Throwable {
+ MockCreationSettings<C> settings = settingsWithSuperCall(target);
+ C proxy = mockMaker.createMock(settings, new MockHandlerImpl<C>(settings));
+
+ MockHandler handler = new MockHandlerImpl<C>(settings);
+ mockMaker.resetMock(proxy, handler, settings);
+ assertThat(mockMaker.getHandler(proxy)).isSameAs(handler);
+ }
+
+ protected static <T> MockCreationSettings<T> settingsFor(
+ Class<T> type, Class<?>... extraInterfaces) {
+ MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
+ mockSettings.setTypeToMock(type);
+ if (extraInterfaces.length > 0) mockSettings.extraInterfaces(extraInterfaces);
+ return mockSettings;
+ }
+
+ protected static <T> MockCreationSettings<T> serializableSettingsFor(
+ Class<T> type, SerializableMode serializableMode) {
+ MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
+ mockSettings.serializable(serializableMode);
+ mockSettings.setTypeToMock(type);
+ return mockSettings;
+ }
+
+ protected static <T> MockCreationSettings<T> settingsWithConstructorFor(Class<T> type) {
+ MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
+ mockSettings.setTypeToMock(type);
+ return mockSettings;
+ }
+
+ protected static <T> MockCreationSettings<T> settingsWithSuperCall(Class<T> type) {
+ MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
+ mockSettings.setTypeToMock(type);
+ mockSettings.defaultAnswer(new CallsRealMethods());
+ return mockSettings;
+ }
+
+ protected static MockHandler dummyHandler() {
+ return new DummyMockHandler();
+ }
+
+ private static class DummyMockHandler implements MockHandler<Object> {
+ public Object handle(Invocation invocation) throws Throwable {
+ return null;
+ }
+
+ public MockCreationSettings<Object> getMockSettings() {
+ return null;
+ }
+
+ public InvocationContainer getInvocationContainer() {
+ return null;
+ }
+
+ public void setAnswersForStubbing(List<Answer<?>> list) {}
+ }
+}
diff --git a/src/test/java/org/mockito/internal/creation/DelegatingMethodTest.java b/src/test/java/org/mockito/internal/creation/DelegatingMethodTest.java
index ff46656..e78e96f 100644
--- a/src/test/java/org/mockito/internal/creation/DelegatingMethodTest.java
+++ b/src/test/java/org/mockito/internal/creation/DelegatingMethodTest.java
@@ -4,14 +4,14 @@
*/
package org.mockito.internal.creation;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.lang.reflect.Method;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
public class DelegatingMethodTest extends TestBase {
diff --git a/src/test/java/org/mockito/internal/creation/InterfaceOverrideTest.java b/src/test/java/org/mockito/internal/creation/InterfaceOverrideTest.java
index e1261fb..8b3e35e 100644
--- a/src/test/java/org/mockito/internal/creation/InterfaceOverrideTest.java
+++ b/src/test/java/org/mockito/internal/creation/InterfaceOverrideTest.java
@@ -4,11 +4,11 @@
*/
package org.mockito.internal.creation;
+import static org.junit.Assert.assertEquals;
+
import org.junit.Test;
import org.mockito.Mockito;
-import static org.junit.Assert.assertEquals;
-
public class InterfaceOverrideTest {
public interface CloneableInterface extends Cloneable {
diff --git a/src/test/java/org/mockito/internal/creation/MockSettingsImplTest.java b/src/test/java/org/mockito/internal/creation/MockSettingsImplTest.java
index 18911e4..2efbc50 100644
--- a/src/test/java/org/mockito/internal/creation/MockSettingsImplTest.java
+++ b/src/test/java/org/mockito/internal/creation/MockSettingsImplTest.java
@@ -4,52 +4,58 @@
*/
package org.mockito.internal.creation;
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.debugging.VerboseMockInvocationLogger;
-import org.mockito.listeners.InvocationListener;
-import org.mockitoutil.TestBase;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
-import static org.junit.Assert.*;
-import static org.assertj.core.api.Assertions.assertThat;
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.debugging.VerboseMockInvocationLogger;
+import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.StubbingLookupListener;
+import org.mockitoutil.TestBase;
public class MockSettingsImplTest extends TestBase {
private MockSettingsImpl<?> mockSettingsImpl = new MockSettingsImpl<Object>();
@Mock private InvocationListener invocationListener;
+ @Mock private StubbingLookupListener stubbingLookupListener;
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
@SuppressWarnings("unchecked")
public void shouldNotAllowSettingNullInterface() {
mockSettingsImpl.extraInterfaces(List.class, null);
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
@SuppressWarnings("unchecked")
public void shouldNotAllowNonInterfaces() {
mockSettingsImpl.extraInterfaces(List.class, LinkedList.class);
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
@SuppressWarnings("unchecked")
public void shouldNotAllowUsingTheSameInterfaceAsExtra() {
mockSettingsImpl.extraInterfaces(List.class, LinkedList.class);
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
@SuppressWarnings("unchecked")
public void shouldNotAllowEmptyExtraInterfaces() {
mockSettingsImpl.extraInterfaces();
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
@SuppressWarnings("unchecked")
public void shouldNotAllowNullArrayOfExtraInterfaces() {
mockSettingsImpl.extraInterfaces((Class<?>[]) null);
@@ -58,10 +64,10 @@
@Test
@SuppressWarnings("unchecked")
public void shouldAllowMultipleInterfaces() {
- //when
+ // when
mockSettingsImpl.extraInterfaces(List.class, Set.class);
- //then
+ // then
assertEquals(2, mockSettingsImpl.getExtraInterfaces().size());
assertTrue(mockSettingsImpl.getExtraInterfaces().contains(List.class));
assertTrue(mockSettingsImpl.getExtraInterfaces().contains(Set.class));
@@ -69,98 +75,201 @@
@Test
public void shouldSetMockToBeSerializable() throws Exception {
- //when
+ // when
mockSettingsImpl.serializable();
- //then
+ // then
assertTrue(mockSettingsImpl.isSerializable());
}
@Test
public void shouldKnowIfIsSerializable() throws Exception {
- //given
+ // given
assertFalse(mockSettingsImpl.isSerializable());
- //when
+ // when
mockSettingsImpl.serializable();
- //then
+ // then
assertTrue(mockSettingsImpl.isSerializable());
}
@Test
public void shouldAddVerboseLoggingListener() {
- //given
+ // given
assertFalse(mockSettingsImpl.hasInvocationListeners());
- //when
+ // when
mockSettingsImpl.verboseLogging();
- //then
- assertThat(mockSettingsImpl.getInvocationListeners()).extracting("class").contains(VerboseMockInvocationLogger.class);
+ // then
+ assertThat(mockSettingsImpl.getInvocationListeners())
+ .extracting("class")
+ .contains(VerboseMockInvocationLogger.class);
}
@Test
public void shouldAddVerboseLoggingListenerOnlyOnce() {
- //given
+ // given
assertFalse(mockSettingsImpl.hasInvocationListeners());
- //when
+ // when
mockSettingsImpl.verboseLogging().verboseLogging();
- //then
+ // then
Assertions.assertThat(mockSettingsImpl.getInvocationListeners()).hasSize(1);
}
- @SuppressWarnings("unchecked")
- @Test(expected=MockitoException.class)
- public void shouldNotAllowNullListener() {
- mockSettingsImpl.invocationListeners((InvocationListener[])null);
- }
-
@Test
@SuppressWarnings("unchecked")
public void shouldAddInvocationListener() {
- //given
+ // given
assertFalse(mockSettingsImpl.hasInvocationListeners());
- //when
+ // when
mockSettingsImpl.invocationListeners(invocationListener);
- //then
- Assertions.assertThat(mockSettingsImpl.getInvocationListeners()).contains(invocationListener);
+ // then
+ Assertions.assertThat(mockSettingsImpl.getInvocationListeners())
+ .contains(invocationListener);
}
@Test
@SuppressWarnings("unchecked")
public void canAddDuplicateInvocationListeners_ItsNotOurBusinessThere() {
- //given
+ // given
assertFalse(mockSettingsImpl.hasInvocationListeners());
- //when
- mockSettingsImpl.invocationListeners(invocationListener, invocationListener).invocationListeners(invocationListener);
+ // when
+ mockSettingsImpl
+ .invocationListeners(invocationListener, invocationListener)
+ .invocationListeners(invocationListener);
- //then
- Assertions.assertThat(mockSettingsImpl.getInvocationListeners()).containsSequence(invocationListener, invocationListener, invocationListener);
+ // then
+ Assertions.assertThat(mockSettingsImpl.getInvocationListeners())
+ .containsSequence(invocationListener, invocationListener, invocationListener);
}
@Test
- public void shouldReportErrorWhenAddingNoInvocationListeners() throws Exception {
- try {
- mockSettingsImpl.invocationListeners();
- fail();
- } catch (Exception e) {
- Assertions.assertThat(e.getMessage()).contains("at least one listener");
- }
+ public void validates_listeners() {
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mockSettingsImpl.addListeners(
+ new Object[] {}, new LinkedList<Object>(), "myListeners");
+ }
+ })
+ .hasMessageContaining("myListeners() requires at least one listener");
+
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mockSettingsImpl.addListeners(
+ null, new LinkedList<Object>(), "myListeners");
+ }
+ })
+ .hasMessageContaining("myListeners() does not accept null vararg array");
+
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mockSettingsImpl.addListeners(
+ new Object[] {null},
+ new LinkedList<Object>(),
+ "myListeners");
+ }
+ })
+ .hasMessageContaining("myListeners() does not accept null listeners");
}
@Test
- public void shouldReportErrorWhenAddingANullInvocationListener() throws Exception {
- try {
- mockSettingsImpl.invocationListeners(invocationListener, null);
- fail();
- } catch (Exception e) {
- Assertions.assertThat(e.getMessage()).contains("does not accept null");
- }
+ public void validates_stubbing_lookup_listeners() {
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mockSettingsImpl.stubbingLookupListeners(
+ new StubbingLookupListener[] {});
+ }
+ })
+ .hasMessageContaining("stubbingLookupListeners() requires at least one listener");
+
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mockSettingsImpl.stubbingLookupListeners(null);
+ }
+ })
+ .hasMessageContaining(
+ "stubbingLookupListeners() does not accept null vararg array");
+
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mockSettingsImpl.stubbingLookupListeners(
+ new StubbingLookupListener[] {null});
+ }
+ })
+ .hasMessageContaining("stubbingLookupListeners() does not accept null listeners");
+ }
+
+ @Test
+ public void validates_invocation_listeners() {
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mockSettingsImpl.invocationListeners(new InvocationListener[] {});
+ }
+ })
+ .hasMessageContaining("invocationListeners() requires at least one listener");
+
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mockSettingsImpl.invocationListeners(null);
+ }
+ })
+ .hasMessageContaining("invocationListeners() does not accept null vararg array");
+
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mockSettingsImpl.invocationListeners(
+ new InvocationListener[] {null});
+ }
+ })
+ .hasMessageContaining("invocationListeners() does not accept null listeners");
+ }
+
+ @Test
+ public void addListeners_has_empty_listeners_by_default() {
+ assertTrue(mockSettingsImpl.getInvocationListeners().isEmpty());
+ assertTrue(mockSettingsImpl.getStubbingLookupListeners().isEmpty());
+ }
+
+ @Test
+ public void addListeners_shouldAddMockObjectListeners() {
+ // when
+ mockSettingsImpl.invocationListeners(invocationListener);
+ mockSettingsImpl.stubbingLookupListeners(stubbingLookupListener);
+
+ // then
+ assertThat(mockSettingsImpl.getInvocationListeners()).contains(invocationListener);
+ assertThat(mockSettingsImpl.getStubbingLookupListeners()).contains(stubbingLookupListener);
+ }
+
+ @Test
+ public void addListeners_canAddDuplicateMockObjectListeners_ItsNotOurBusinessThere() {
+ // when
+ mockSettingsImpl
+ .stubbingLookupListeners(stubbingLookupListener)
+ .stubbingLookupListeners(stubbingLookupListener)
+ .invocationListeners(invocationListener)
+ .invocationListeners(invocationListener);
+
+ // then
+ assertThat(mockSettingsImpl.getInvocationListeners())
+ .containsSequence(invocationListener, invocationListener);
+ assertThat(mockSettingsImpl.getStubbingLookupListeners())
+ .containsSequence(stubbingLookupListener, stubbingLookupListener);
}
}
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java
index 2b08c10..93c8913 100644
--- a/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java
+++ b/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java
@@ -4,52 +4,47 @@
*/
package org.mockito.internal.creation.bytebuddy;
-import net.bytebuddy.ByteBuddy;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.internal.creation.MockSettingsImpl;
-import org.mockito.internal.handler.MockHandlerImpl;
-import org.mockito.invocation.InvocationContainer;
-import org.mockito.internal.stubbing.answers.CallsRealMethods;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.MockHandler;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.mock.SerializableMode;
-import org.mockito.plugins.MockMaker;
-import org.mockito.stubbing.Answer;
-import org.mockitoutil.ClassLoaders;
-import org.mockitoutil.SimpleSerializationUtil;
-import org.objenesis.ObjenesisStd;
-
-import java.io.Serializable;
-import java.util.List;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
import static org.mockitoutil.ClassLoaders.coverageTool;
-public abstract class AbstractByteBuddyMockMakerTest<MM extends MockMaker> {
+import java.io.Serializable;
- protected final MM mockMaker;
+import net.bytebuddy.ByteBuddy;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.internal.creation.AbstractMockMakerTest;
+import org.mockito.internal.handler.MockHandlerImpl;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.SerializableMode;
+import org.mockito.plugins.MockMaker;
+import org.mockitoutil.ClassLoaders;
+import org.mockitoutil.SimpleSerializationUtil;
+import org.objenesis.ObjenesisStd;
- public AbstractByteBuddyMockMakerTest(MM mockMaker) {
- this.mockMaker = mockMaker;
+public abstract class AbstractByteBuddyMockMakerTest<MM extends MockMaker>
+ extends AbstractMockMakerTest<MM, AbstractByteBuddyMockMakerTest.SomeClass> {
+
+ protected AbstractByteBuddyMockMakerTest(MM mockMaker) {
+ super(mockMaker, SomeClass.class);
}
protected abstract Class<?> mockTypeOf(Class<?> type);
@Test
public void should_create_mock_from_interface() throws Exception {
- SomeInterface proxy = mockMaker.createMock(settingsFor(SomeInterface.class), dummyHandler());
+ SomeInterface proxy =
+ mockMaker.createMock(settingsFor(SomeInterface.class), dummyHandler());
Class<?> superClass = proxy.getClass().getSuperclass();
assertThat(superClass).isEqualTo(Object.class);
}
-
@Test
public void should_create_mock_from_class() throws Exception {
- ClassWithoutConstructor proxy = mockMaker.createMock(settingsFor(ClassWithoutConstructor.class), dummyHandler());
+ ClassWithoutConstructor proxy =
+ mockMaker.createMock(settingsFor(ClassWithoutConstructor.class), dummyHandler());
Class<?> superClass = mockTypeOf(proxy.getClass());
assertThat(superClass).isEqualTo(ClassWithoutConstructor.class);
@@ -60,40 +55,36 @@
try {
new ClassWithDodgyConstructor();
fail();
- } catch (Exception expected) {}
+ } catch (Exception expected) {
+ }
- ClassWithDodgyConstructor mock = mockMaker.createMock(settingsFor(ClassWithDodgyConstructor.class), dummyHandler());
+ ClassWithDodgyConstructor mock =
+ mockMaker.createMock(settingsFor(ClassWithDodgyConstructor.class), dummyHandler());
assertThat(mock).isNotNull();
}
@Test
- public void should_mocks_have_different_interceptors() throws Exception {
- SomeClass mockOne = mockMaker.createMock(settingsFor(SomeClass.class), dummyHandler());
- SomeClass mockTwo = mockMaker.createMock(settingsFor(SomeClass.class), dummyHandler());
-
- MockHandler handlerOne = mockMaker.getHandler(mockOne);
- MockHandler handlerTwo = mockMaker.getHandler(mockTwo);
-
-
- assertThat(handlerOne).isNotSameAs(handlerTwo);
- }
-
- @Test
public void should_use_ancillary_Types() {
- SomeClass mock = mockMaker.createMock(settingsFor(SomeClass.class, SomeInterface.class), dummyHandler());
+ SomeClass mock =
+ mockMaker.createMock(
+ settingsFor(SomeClass.class, SomeInterface.class), dummyHandler());
assertThat(mock).isInstanceOf(SomeInterface.class);
}
@Test
public void should_create_class_by_constructor() {
- OtherClass mock = mockMaker.createMock(settingsWithConstructorFor(OtherClass.class), dummyHandler());
+ OtherClass mock =
+ mockMaker.createMock(settingsWithConstructorFor(OtherClass.class), dummyHandler());
assertThat(mock).isNotNull();
}
@Test
public void should_allow_serialization() throws Exception {
- SerializableClass proxy = mockMaker.createMock(serializableSettingsFor(SerializableClass.class, SerializableMode.BASIC), dummyHandler());
+ SerializableClass proxy =
+ mockMaker.createMock(
+ serializableSettingsFor(SerializableClass.class, SerializableMode.BASIC),
+ dummyHandler());
SerializableClass serialized = SimpleSerializationUtil.serializeAndBack(proxy);
assertThat(serialized).isNotNull();
@@ -106,24 +97,20 @@
@Test
public void should_create_mock_from_class_with_super_call_to_final_method() throws Exception {
- MockCreationSettings<CallingSuperMethodClass> settings = settingsWithSuperCall(CallingSuperMethodClass.class);
- SampleClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<CallingSuperMethodClass>(settings));
+ MockCreationSettings<CallingSuperMethodClass> settings =
+ settingsWithSuperCall(CallingSuperMethodClass.class);
+ SampleClass proxy =
+ mockMaker.createMock(
+ settings, new MockHandlerImpl<CallingSuperMethodClass>(settings));
assertThat(proxy.foo()).isEqualTo("foo");
}
- @Test
- public void should_reset_mock_and_set_new_handler() throws Throwable {
- MockCreationSettings<SampleClass> settings = settingsWithSuperCall(SampleClass.class);
- SampleClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<SampleClass>(settings));
-
- MockHandler handler = new MockHandlerImpl<SampleClass>(settings);
- mockMaker.resetMock(proxy, handler, settings);
- assertThat(mockMaker.getHandler(proxy)).isSameAs(handler);
- }
-
class SomeClass {}
+
interface SomeInterface {}
+
static class OtherClass {}
+
static class SerializableClass implements Serializable {}
private class ClassWithoutConstructor {}
@@ -137,61 +124,24 @@
@Test
public void instantiate_fine_when_objenesis_on_the_classpath() throws Exception {
// given
- ClassLoader classpath_with_objenesis = ClassLoaders.excludingClassLoader()
- .withCodeSourceUrlOf(Mockito.class, ByteBuddy.class, ObjenesisStd.class)
- .withCodeSourceUrlOf(coverageTool())
- .build();
+ ClassLoader classpath_with_objenesis =
+ ClassLoaders.excludingClassLoader()
+ .withCodeSourceUrlOf(Mockito.class, ByteBuddy.class, ObjenesisStd.class)
+ .withCodeSourceUrlOf(coverageTool())
+ .build();
- Class<?> mock_maker_class_loaded_fine_until = Class.forName(
- "org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker",
- true,
- classpath_with_objenesis
- );
+ Class<?> mock_maker_class_loaded_fine_until =
+ Class.forName(
+ "org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker",
+ true,
+ classpath_with_objenesis);
// when
- mock_maker_class_loaded_fine_until.newInstance();
+ mock_maker_class_loaded_fine_until.getConstructor().newInstance();
// then everything went fine
}
- private static <T> MockCreationSettings<T> settingsFor(Class<T> type, Class<?>... extraInterfaces) {
- MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
- mockSettings.setTypeToMock(type);
- if(extraInterfaces.length > 0) mockSettings.extraInterfaces(extraInterfaces);
- return mockSettings;
- }
-
- private static <T> MockCreationSettings<T> serializableSettingsFor(Class<T> type, SerializableMode serializableMode) {
- MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
- mockSettings.serializable(serializableMode);
- mockSettings.setTypeToMock(type);
- return mockSettings;
- }
-
- private static <T> MockCreationSettings<T> settingsWithConstructorFor(Class<T> type) {
- MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
- mockSettings.setTypeToMock(type);
- return mockSettings;
- }
-
- private static <T> MockCreationSettings<T> settingsWithSuperCall(Class<T> type) {
- MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
- mockSettings.setTypeToMock(type);
- mockSettings.defaultAnswer(new CallsRealMethods());
- return mockSettings;
- }
-
- protected static MockHandler dummyHandler() {
- return new DummyMockHandler();
- }
-
- private static class DummyMockHandler implements MockHandler<Object> {
- public Object handle(Invocation invocation) throws Throwable { return null; }
- public MockCreationSettings<Object> getMockSettings() { return null; }
- public InvocationContainer getInvocationContainer() { return null; }
- public void setAnswersForStubbing(List<Answer<?>> list) { }
- }
-
private static class SampleClass {
public String foo() {
return "foo";
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java
index 858f623..1a9eebe 100644
--- a/src/test/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java
+++ b/src/test/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMakerTest.java
@@ -4,25 +4,22 @@
*/
package org.mockito.internal.creation.bytebuddy;
+import static org.mockito.Mockito.verify;
+
import org.junit.Test;
-import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.internal.creation.settings.CreationSettings;
import org.mockito.internal.handler.MockHandlerImpl;
import org.mockitoutil.TestBase;
-import static org.mockito.Mockito.verify;
-
public class ByteBuddyMockMakerTest extends TestBase {
- @InjectMocks
- private ByteBuddyMockMaker mockMaker = new ByteBuddyMockMaker();
-
- @Mock
- private ClassCreatingMockMaker delegate;
+ @Mock private SubclassByteBuddyMockMaker delegate;
@Test
public void should_delegate_call() {
+ ByteBuddyMockMaker mockMaker = new ByteBuddyMockMaker(delegate);
+
CreationSettings<Object> creationSettings = new CreationSettings<Object>();
MockHandlerImpl<Object> handler = new MockHandlerImpl<Object>(creationSettings);
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java
index 3613b5f..9069e50 100644
--- a/src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java
+++ b/src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java
@@ -4,398 +4,45 @@
*/
package org.mockito.internal.creation.bytebuddy;
-import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.ClassFileVersion;
-import net.bytebuddy.description.modifier.Visibility;
-import net.bytebuddy.description.type.TypeDescription;
-import net.bytebuddy.implementation.StubMethod;
import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.Mock;
import org.mockito.internal.creation.settings.CreationSettings;
import org.mockito.internal.handler.MockHandlerImpl;
-import org.mockito.internal.stubbing.answers.Returns;
-import org.mockito.internal.util.collections.Sets;
-import org.mockito.mock.MockCreationSettings;
-import org.mockito.mock.SerializableMode;
-import org.mockito.plugins.MockMaker;
+import org.mockitoutil.TestBase;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Observable;
-import java.util.Observer;
-import java.util.Set;
-import java.util.regex.Pattern;
+import static org.mockito.Mockito.verify;
-import static net.bytebuddy.ClassFileVersion.JAVA_V8;
-import static net.bytebuddy.matcher.ElementMatchers.named;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-import static org.junit.Assume.assumeTrue;
+public class InlineByteBuddyMockMakerTest extends TestBase {
-public class InlineByteBuddyMockMakerTest extends AbstractByteBuddyMockMakerTest<InlineByteBuddyMockMaker> {
-
- public InlineByteBuddyMockMakerTest() {
- super(new InlineByteBuddyMockMaker());
- }
-
- @Override
- protected Class<?> mockTypeOf(Class<?> type) {
- return type;
- }
+ @Mock private InlineDelegateByteBuddyMockMaker delegate;
@Test
- public void should_create_mock_from_final_class() throws Exception {
- MockCreationSettings<FinalClass> settings = settingsFor(FinalClass.class);
- FinalClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<FinalClass>(settings));
- assertThat(proxy.foo()).isEqualTo("bar");
- }
+ public void should_delegate_call() {
+ InlineByteBuddyMockMaker mockMaker = new InlineByteBuddyMockMaker(delegate);
- @Test
- public void should_create_mock_from_final_class_in_the_JDK() throws Exception {
- MockCreationSettings<Pattern> settings = settingsFor(Pattern.class);
- Pattern proxy = mockMaker.createMock(settings, new MockHandlerImpl<Pattern>(settings));
- assertThat(proxy.pattern()).isEqualTo("bar");
- }
+ CreationSettings<Object> creationSettings = new CreationSettings<Object>();
+ MockHandlerImpl<Object> handler = new MockHandlerImpl<Object>(creationSettings);
- @Test
- public void should_create_mock_from_abstract_class_with_final_method() throws Exception {
- MockCreationSettings<FinalMethodAbstractType> settings = settingsFor(FinalMethodAbstractType.class);
- FinalMethodAbstractType proxy = mockMaker.createMock(settings, new MockHandlerImpl<FinalMethodAbstractType>(settings));
- assertThat(proxy.foo()).isEqualTo("bar");
- assertThat(proxy.bar()).isEqualTo("bar");
- }
-
- @Test
- public void should_create_mock_from_final_class_with_interface_methods() throws Exception {
- MockCreationSettings<FinalMethod> settings = settingsFor(FinalMethod.class, SampleInterface.class);
- FinalMethod proxy = mockMaker.createMock(settings, new MockHandlerImpl<FinalMethod>(settings));
- assertThat(proxy.foo()).isEqualTo("bar");
- assertThat(((SampleInterface) proxy).bar()).isEqualTo("bar");
- }
-
- @Test
- public void should_detect_non_overridden_generic_method_of_supertype() throws Exception {
- MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
- GenericSubClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
- assertThat(proxy.value()).isEqualTo("bar");
- }
-
- @Test
- public void should_create_mock_from_hashmap() throws Exception {
- MockCreationSettings<HashMap> settings = settingsFor(HashMap.class);
- HashMap proxy = mockMaker.createMock(settings, new MockHandlerImpl<HashMap>(settings));
- assertThat(proxy.get(null)).isEqualTo("bar");
- }
-
- @Test
- @SuppressWarnings("unchecked")
- public void should_throw_exception_redefining_unmodifiable_class() {
- MockCreationSettings settings = settingsFor(int.class);
- try {
- mockMaker.createMock(settings, new MockHandlerImpl(settings));
- fail("Expected a MockitoException");
- } catch (MockitoException e) {
- e.printStackTrace();
- assertThat(e).hasMessageContaining("Could not modify all classes");
- }
- }
-
- @Test
- @SuppressWarnings("unchecked")
- public void should_throw_exception_redefining_array() {
- int[] array = new int[5];
- MockCreationSettings<? extends int[]> settings = settingsFor(array.getClass());
- try {
- mockMaker.createMock(settings, new MockHandlerImpl(settings));
- fail("Expected a MockitoException");
- } catch (MockitoException e) {
- assertThat(e).hasMessageContaining("Arrays cannot be mocked");
- }
- }
-
- @Test
- public void should_create_mock_from_enum() throws Exception {
- MockCreationSettings<EnumClass> settings = settingsFor(EnumClass.class);
- EnumClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<EnumClass>(settings));
- assertThat(proxy.foo()).isEqualTo("bar");
- }
-
- @Test
- public void should_fail_at_creating_a_mock_of_a_final_class_with_explicit_serialization() throws Exception {
- MockCreationSettings<FinalClass> settings = new CreationSettings<FinalClass>()
- .setTypeToMock(FinalClass.class)
- .setSerializableMode(SerializableMode.BASIC);
-
- try {
- mockMaker.createMock(settings, new MockHandlerImpl<FinalClass>(settings));
- fail("Expected a MockitoException");
- } catch (MockitoException e) {
- assertThat(e)
- .hasMessageContaining("Unsupported settings")
- .hasMessageContaining("serialization")
- .hasMessageContaining("extra interfaces");
- }
- }
-
- @Test
- public void should_fail_at_creating_a_mock_of_a_final_class_with_extra_interfaces() throws Exception {
- MockCreationSettings<FinalClass> settings = new CreationSettings<FinalClass>()
- .setTypeToMock(FinalClass.class)
- .setExtraInterfaces(Sets.<Class<?>>newSet(List.class));
-
- try {
- mockMaker.createMock(settings, new MockHandlerImpl<FinalClass>(settings));
- fail("Expected a MockitoException");
- } catch (MockitoException e) {
- assertThat(e)
- .hasMessageContaining("Unsupported settings")
- .hasMessageContaining("serialization")
- .hasMessageContaining("extra interfaces");
- }
- }
-
- @Test
- public void should_mock_interface() {
- MockSettingsImpl<Set> mockSettings = new MockSettingsImpl<Set>();
- mockSettings.setTypeToMock(Set.class);
- mockSettings.defaultAnswer(new Returns(10));
- Set<?> proxy = mockMaker.createMock(mockSettings, new MockHandlerImpl<Set>(mockSettings));
-
- assertThat(proxy.size()).isEqualTo(10);
- }
-
- @Test
- public void should_mock_interface_to_string() {
- MockSettingsImpl<Set> mockSettings = new MockSettingsImpl<Set>();
- mockSettings.setTypeToMock(Set.class);
- mockSettings.defaultAnswer(new Returns("foo"));
- Set<?> proxy = mockMaker.createMock(mockSettings, new MockHandlerImpl<Set>(mockSettings));
-
- assertThat(proxy.toString()).isEqualTo("foo");
- }
-
- @Test
- public void should_remove_recursive_self_call_from_stack_trace() throws Exception {
- StackTraceElement[] stack = new StackTraceElement[]{
- new StackTraceElement("foo", "", "", -1),
- new StackTraceElement(SampleInterface.class.getName(), "", "", -1),
- new StackTraceElement("qux", "", "", -1),
- new StackTraceElement("bar", "", "", -1),
- new StackTraceElement("baz", "", "", -1)
- };
-
- Throwable throwable = new Throwable();
- throwable.setStackTrace(stack);
- throwable = MockMethodAdvice.hideRecursiveCall(throwable, 2, SampleInterface.class);
-
- assertThat(throwable.getStackTrace()).isEqualTo(new StackTraceElement[]{
- new StackTraceElement("foo", "", "", -1),
- new StackTraceElement("bar", "", "", -1),
- new StackTraceElement("baz", "", "", -1)
- });
- }
-
- @Test
- public void should_handle_missing_or_inconsistent_stack_trace() throws Exception {
- Throwable throwable = new Throwable();
- throwable.setStackTrace(new StackTraceElement[0]);
- assertThat(MockMethodAdvice.hideRecursiveCall(throwable, 0, SampleInterface.class)).isSameAs(throwable);
- }
-
- @Test
- public void should_provide_reason_for_wrapper_class() {
- MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Integer.class);
- assertThat(mockable.nonMockableReason()).isEqualTo("Cannot mock wrapper types, String.class or Class.class");
- }
-
- @Test
- public void should_provide_reason_for_vm_unsupported() {
- MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(int[].class);
- assertThat(mockable.nonMockableReason()).isEqualTo("VM does not not support modification of given type");
- }
-
- @Test
- public void should_mock_method_of_package_private_class() throws Exception {
- MockCreationSettings<NonPackagePrivateSubClass> settings = settingsFor(NonPackagePrivateSubClass.class);
- NonPackagePrivateSubClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<NonPackagePrivateSubClass>(settings));
- assertThat(proxy.value()).isEqualTo("bar");
- }
-
- @Test
- public void is_type_mockable_excludes_String() {
- MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(String.class);
- assertThat(mockable.mockable()).isFalse();
- assertThat(mockable.nonMockableReason()).contains("Cannot mock wrapper types, String.class or Class.class");
- }
-
- @Test
- public void is_type_mockable_excludes_Class() {
- MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Class.class);
- assertThat(mockable.mockable()).isFalse();
- assertThat(mockable.nonMockableReason()).contains("Cannot mock wrapper types, String.class or Class.class");
- }
-
- @Test
- public void is_type_mockable_excludes_primitive_classes() {
- MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(int.class);
- assertThat(mockable.mockable()).isFalse();
- assertThat(mockable.nonMockableReason()).contains("primitive");
- }
-
- @Test
- public void is_type_mockable_allows_anonymous() {
- Observer anonymous = new Observer() {
- @Override
- public void update(Observable o, Object arg) {
- }
- };
- MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(anonymous.getClass());
- assertThat(mockable.mockable()).isTrue();
- assertThat(mockable.nonMockableReason()).contains("");
- }
-
- @Test
- public void is_type_mockable_give_empty_reason_if_type_is_mockable() {
- MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(SomeClass.class);
- assertThat(mockable.mockable()).isTrue();
- assertThat(mockable.nonMockableReason()).isEqualTo("");
- }
-
- @Test
- public void is_type_mockable_give_allow_final_mockable_from_JDK() {
- MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Pattern.class);
- assertThat(mockable.mockable()).isTrue();
- assertThat(mockable.nonMockableReason()).isEqualTo("");
- }
-
- @Test
- public void test_parameters_retention() throws Exception {
- assumeTrue(ClassFileVersion.ofThisVm().isAtLeast(JAVA_V8));
-
- Class<?> typeWithParameters = new ByteBuddy()
- .subclass(Object.class)
- .defineMethod("foo", void.class, Visibility.PUBLIC)
- .withParameter(String.class, "bar")
- .intercept(StubMethod.INSTANCE)
- .make()
- .load(null)
- .getLoaded();
-
- MockCreationSettings<?> settings = settingsFor(typeWithParameters);
- @SuppressWarnings("unchecked")
- Object proxy = mockMaker.createMock(settings, new MockHandlerImpl(settings));
-
- assertThat(proxy.getClass()).isEqualTo(typeWithParameters);
- assertThat(new TypeDescription.ForLoadedType(typeWithParameters).getDeclaredMethods().filter(named("foo"))
- .getOnly().getParameters().getOnly().getName()).isEqualTo("bar");
- }
-
- @Test
- public void test_clear_mock_clears_handler() {
- MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
- GenericSubClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
- assertThat(mockMaker.getHandler(proxy)).isNotNull();
-
- //when
- mockMaker.clearMock(proxy);
-
- //then
- assertThat(mockMaker.getHandler(proxy)).isNull();
- }
-
- @Test
- public void test_clear_all_mock_clears_handler() {
- MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
- GenericSubClass proxy1 = mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
- assertThat(mockMaker.getHandler(proxy1)).isNotNull();
-
- settings = settingsFor(GenericSubClass.class);
- GenericSubClass proxy2 = mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
- assertThat(mockMaker.getHandler(proxy1)).isNotNull();
-
- //when
+ mockMaker.createMockType(creationSettings);
+ mockMaker.createMock(creationSettings, handler);
+ mockMaker.createStaticMock(Object.class, creationSettings, handler);
+ mockMaker.createConstructionMock(Object.class, null, null, null);
+ mockMaker.getHandler(this);
+ mockMaker.isTypeMockable(Object.class);
+ mockMaker.resetMock(this, handler, creationSettings);
+ mockMaker.clearMock(this);
mockMaker.clearAllMocks();
+ mockMaker.clearAllCaches();
- //then
- assertThat(mockMaker.getHandler(proxy1)).isNull();
- assertThat(mockMaker.getHandler(proxy2)).isNull();
- }
-
- private static <T> MockCreationSettings<T> settingsFor(Class<T> type, Class<?>... extraInterfaces) {
- MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
- mockSettings.setTypeToMock(type);
- mockSettings.defaultAnswer(new Returns("bar"));
- if (extraInterfaces.length > 0) mockSettings.extraInterfaces(extraInterfaces);
- return mockSettings;
- }
-
- @Test
- public void testMockDispatcherIsRelocated() throws Exception {
- assertThat(InlineByteBuddyMockMaker.class.getClassLoader().getResource("org/mockito/internal/creation/bytebuddy/MockMethodDispatcher.raw")).isNotNull();
- }
-
- private static final class FinalClass {
-
- public String foo() {
- return "foo";
- }
- }
-
- private enum EnumClass {
-
- INSTANCE;
-
- public String foo() {
- return "foo";
- }
- }
-
- private abstract static class FinalMethodAbstractType {
-
- public final String foo() {
- return "foo";
- }
-
- public abstract String bar();
- }
-
- private static class FinalMethod {
-
- public final String foo() {
- return "foo";
- }
- }
-
- private interface SampleInterface {
-
- String bar();
- }
-
- /*package-private*/ abstract class PackagePrivateSuperClass {
-
- public abstract String indirect();
-
- public String value() {
- return indirect() + "qux";
- }
- }
-
- public class NonPackagePrivateSubClass extends PackagePrivateSuperClass {
-
- @Override
- public String indirect() {
- return "foo";
- }
- }
-
- public static class GenericClass<T> {
-
- public T value() {
- return null;
- }
- }
-
- public static class GenericSubClass extends GenericClass<String> {
+ verify(delegate).createMock(creationSettings, handler);
+ verify(delegate).createStaticMock(Object.class, creationSettings, handler);
+ verify(delegate).createConstructionMock(Object.class, null, null, null);
+ verify(delegate).createMockType(creationSettings);
+ verify(delegate).getHandler(this);
+ verify(delegate).isTypeMockable(Object.class);
+ verify(delegate).resetMock(this, handler, creationSettings);
+ verify(delegate).clearMock(this);
+ verify(delegate).clearAllMocks();
+ verify(delegate).clearAllCaches();
}
}
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java
new file mode 100644
index 0000000..e276056
--- /dev/null
+++ b/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java
@@ -0,0 +1,606 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.bytebuddy;
+
+import static net.bytebuddy.ClassFileVersion.JAVA_V11;
+import static net.bytebuddy.ClassFileVersion.JAVA_V8;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assume.assumeTrue;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Observable;
+import java.util.Observer;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.regex.Pattern;
+
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.ClassFileVersion;
+import net.bytebuddy.description.modifier.Visibility;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.implementation.FixedValue;
+import net.bytebuddy.implementation.StubMethod;
+import net.bytebuddy.utility.JavaConstant;
+import org.junit.Test;
+import org.mockito.Answers;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.internal.handler.MockHandlerImpl;
+import org.mockito.internal.stubbing.answers.Returns;
+import org.mockito.internal.util.collections.Sets;
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.mock.SerializableMode;
+import org.mockito.plugins.MockMaker;
+
+public class InlineDelegateByteBuddyMockMakerTest
+ extends AbstractByteBuddyMockMakerTest<InlineByteBuddyMockMaker> {
+
+ public InlineDelegateByteBuddyMockMakerTest() {
+ super(new InlineByteBuddyMockMaker());
+ }
+
+ @Override
+ protected Class<?> mockTypeOf(Class<?> type) {
+ return type;
+ }
+
+ @Test
+ public void should_create_mock_from_final_class() throws Exception {
+ MockCreationSettings<FinalClass> settings = settingsFor(FinalClass.class);
+ FinalClass proxy =
+ mockMaker.createMock(settings, new MockHandlerImpl<FinalClass>(settings));
+ assertThat(proxy.foo()).isEqualTo("bar");
+ }
+
+ @Test
+ public void should_create_mock_from_final_spy() throws Exception {
+ MockCreationSettings<FinalSpy> settings = settingsFor(FinalSpy.class);
+ Optional<FinalSpy> proxy =
+ mockMaker.createSpy(
+ settings,
+ new MockHandlerImpl<>(settings),
+ new FinalSpy("value", true, (byte) 1, (short) 1, (char) 1, 1, 1L, 1f, 1d));
+ assertThat(proxy)
+ .hasValueSatisfying(
+ spy -> {
+ assertThat(spy.aString).isEqualTo("value");
+ assertThat(spy.aBoolean).isTrue();
+ assertThat(spy.aByte).isEqualTo((byte) 1);
+ assertThat(spy.aShort).isEqualTo((short) 1);
+ assertThat(spy.aChar).isEqualTo((char) 1);
+ assertThat(spy.anInt).isEqualTo(1);
+ assertThat(spy.aLong).isEqualTo(1L);
+ assertThat(spy.aFloat).isEqualTo(1f);
+ assertThat(spy.aDouble).isEqualTo(1d);
+ });
+ }
+
+ @Test
+ public void should_create_mock_from_non_constructable_class() throws Exception {
+ MockCreationSettings<NonConstructableClass> settings =
+ settingsFor(NonConstructableClass.class);
+ NonConstructableClass proxy =
+ mockMaker.createMock(
+ settings, new MockHandlerImpl<NonConstructableClass>(settings));
+ assertThat(proxy.foo()).isEqualTo("bar");
+ }
+
+ @Test
+ public void should_create_mock_from_final_class_in_the_JDK() throws Exception {
+ MockCreationSettings<Pattern> settings = settingsFor(Pattern.class);
+ Pattern proxy = mockMaker.createMock(settings, new MockHandlerImpl<Pattern>(settings));
+ assertThat(proxy.pattern()).isEqualTo("bar");
+ }
+
+ @Test
+ public void should_create_mock_from_abstract_class_with_final_method() throws Exception {
+ MockCreationSettings<FinalMethodAbstractType> settings =
+ settingsFor(FinalMethodAbstractType.class);
+ FinalMethodAbstractType proxy =
+ mockMaker.createMock(
+ settings, new MockHandlerImpl<FinalMethodAbstractType>(settings));
+ assertThat(proxy.foo()).isEqualTo("bar");
+ assertThat(proxy.bar()).isEqualTo("bar");
+ }
+
+ @Test
+ public void should_create_mock_from_final_class_with_interface_methods() throws Exception {
+ MockCreationSettings<FinalMethod> settings =
+ settingsFor(FinalMethod.class, SampleInterface.class);
+ FinalMethod proxy =
+ mockMaker.createMock(settings, new MockHandlerImpl<FinalMethod>(settings));
+ assertThat(proxy.foo()).isEqualTo("bar");
+ assertThat(((SampleInterface) proxy).bar()).isEqualTo("bar");
+ }
+
+ @Test
+ public void should_detect_non_overridden_generic_method_of_supertype() throws Exception {
+ MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
+ GenericSubClass proxy =
+ mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
+ assertThat(proxy.value()).isEqualTo("bar");
+ }
+
+ @Test
+ public void should_create_mock_from_hashmap() throws Exception {
+ MockCreationSettings<HashMap> settings = settingsFor(HashMap.class);
+ HashMap proxy = mockMaker.createMock(settings, new MockHandlerImpl<HashMap>(settings));
+ assertThat(proxy.get(null)).isEqualTo("bar");
+ }
+
+ @Test
+ @SuppressWarnings("unchecked")
+ public void should_throw_exception_redefining_unmodifiable_class() {
+ MockCreationSettings settings = settingsFor(int.class);
+ try {
+ mockMaker.createMock(settings, new MockHandlerImpl(settings));
+ fail("Expected a MockitoException");
+ } catch (MockitoException e) {
+ e.printStackTrace();
+ assertThat(e).hasMessageContaining("Could not modify all classes");
+ }
+ }
+
+ @Test
+ @SuppressWarnings("unchecked")
+ public void should_throw_exception_redefining_array() {
+ int[] array = new int[5];
+ MockCreationSettings<? extends int[]> settings = settingsFor(array.getClass());
+ try {
+ mockMaker.createMock(settings, new MockHandlerImpl(settings));
+ fail("Expected a MockitoException");
+ } catch (MockitoException e) {
+ assertThat(e).hasMessageContaining("Arrays cannot be mocked");
+ }
+ }
+
+ @Test
+ public void should_create_mock_from_enum() throws Exception {
+ MockCreationSettings<EnumClass> settings = settingsFor(EnumClass.class);
+ EnumClass proxy = mockMaker.createMock(settings, new MockHandlerImpl<EnumClass>(settings));
+ assertThat(proxy.foo()).isEqualTo("bar");
+ }
+
+ @Test
+ public void should_fail_at_creating_a_mock_of_a_final_class_with_explicit_serialization()
+ throws Exception {
+ MockCreationSettings<FinalClass> settings =
+ new CreationSettings<FinalClass>()
+ .setTypeToMock(FinalClass.class)
+ .setSerializableMode(SerializableMode.BASIC);
+
+ try {
+ mockMaker.createMock(settings, new MockHandlerImpl<FinalClass>(settings));
+ fail("Expected a MockitoException");
+ } catch (MockitoException e) {
+ assertThat(e)
+ .hasMessageContaining("Unsupported settings")
+ .hasMessageContaining("serialization")
+ .hasMessageContaining("extra interfaces");
+ }
+ }
+
+ @Test
+ public void should_fail_at_creating_a_mock_of_a_final_class_with_extra_interfaces()
+ throws Exception {
+ MockCreationSettings<FinalClass> settings =
+ new CreationSettings<FinalClass>()
+ .setTypeToMock(FinalClass.class)
+ .setExtraInterfaces(Sets.<Class<?>>newSet(List.class));
+
+ try {
+ mockMaker.createMock(settings, new MockHandlerImpl<FinalClass>(settings));
+ fail("Expected a MockitoException");
+ } catch (MockitoException e) {
+ assertThat(e)
+ .hasMessageContaining("Unsupported settings")
+ .hasMessageContaining("serialization")
+ .hasMessageContaining("extra interfaces");
+ }
+ }
+
+ @Test
+ public void should_mock_interface() {
+ MockSettingsImpl<Set> mockSettings = new MockSettingsImpl<Set>();
+ mockSettings.setTypeToMock(Set.class);
+ mockSettings.defaultAnswer(new Returns(10));
+ Set<?> proxy = mockMaker.createMock(mockSettings, new MockHandlerImpl<Set>(mockSettings));
+
+ assertThat(proxy.size()).isEqualTo(10);
+ }
+
+ @Test
+ public void should_mock_interface_to_string() {
+ MockSettingsImpl<Set> mockSettings = new MockSettingsImpl<Set>();
+ mockSettings.setTypeToMock(Set.class);
+ mockSettings.defaultAnswer(new Returns("foo"));
+ Set<?> proxy = mockMaker.createMock(mockSettings, new MockHandlerImpl<Set>(mockSettings));
+
+ assertThat(proxy.toString()).isEqualTo("foo");
+ }
+
+ /**
+ * @see <a href="https://github.com/mockito/mockito/issues/2154">https://github.com/mockito/mockito/issues/2154</a>
+ */
+ @Test
+ public void should_mock_class_to_string() {
+ MockSettingsImpl<Object> mockSettings = new MockSettingsImpl<Object>();
+ mockSettings.setTypeToMock(Object.class);
+ mockSettings.defaultAnswer(new Returns("foo"));
+ Object proxy =
+ mockMaker.createMock(mockSettings, new MockHandlerImpl<Object>(mockSettings));
+
+ assertThat(proxy.toString()).isEqualTo("foo");
+ }
+
+ @Test
+ public void should_leave_causing_stack() throws Exception {
+ MockSettingsImpl<ExceptionThrowingClass> settings = new MockSettingsImpl<>();
+ settings.setTypeToMock(ExceptionThrowingClass.class);
+ settings.defaultAnswer(Answers.CALLS_REAL_METHODS);
+
+ Optional<ExceptionThrowingClass> proxy =
+ mockMaker.createSpy(
+ settings, new MockHandlerImpl<>(settings), new ExceptionThrowingClass());
+
+ StackTraceElement[] returnedStack = null;
+ try {
+ proxy.get().throwException();
+ } catch (IOException ex) {
+ returnedStack = ex.getStackTrace();
+ }
+
+ assertNotNull("Stack trace from mockito expected", returnedStack);
+
+ assertEquals(ExceptionThrowingClass.class.getName(), returnedStack[0].getClassName());
+ assertEquals("internalThrowException", returnedStack[0].getMethodName());
+ }
+
+ @Test
+ public void should_remove_recursive_self_call_from_stack_trace() throws Exception {
+ StackTraceElement[] stack =
+ new StackTraceElement[] {
+ new StackTraceElement("foo", "", "", -1),
+ new StackTraceElement(SampleInterface.class.getName(), "", "", -1),
+ new StackTraceElement("qux", "", "", -1),
+ new StackTraceElement("bar", "", "", -1),
+ new StackTraceElement("baz", "", "", -1)
+ };
+
+ Throwable throwable = new Throwable();
+ throwable.setStackTrace(stack);
+ throwable = MockMethodAdvice.hideRecursiveCall(throwable, 2, SampleInterface.class);
+
+ assertThat(throwable.getStackTrace())
+ .isEqualTo(
+ new StackTraceElement[] {
+ new StackTraceElement("foo", "", "", -1),
+ new StackTraceElement("bar", "", "", -1),
+ new StackTraceElement("baz", "", "", -1)
+ });
+ }
+
+ @Test
+ public void should_handle_missing_or_inconsistent_stack_trace() throws Exception {
+ Throwable throwable = new Throwable();
+ throwable.setStackTrace(new StackTraceElement[0]);
+ assertThat(MockMethodAdvice.hideRecursiveCall(throwable, 0, SampleInterface.class))
+ .isSameAs(throwable);
+ }
+
+ @Test
+ public void should_provide_reason_for_wrapper_class() {
+ MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Integer.class);
+ assertThat(mockable.nonMockableReason())
+ .isEqualTo("Cannot mock wrapper types, String.class or Class.class");
+ }
+
+ @Test
+ public void should_provide_reason_for_vm_unsupported() {
+ MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(int[].class);
+ assertThat(mockable.nonMockableReason())
+ .isEqualTo("VM does not support modification of given type");
+ }
+
+ @Test
+ public void should_mock_method_of_package_private_class() throws Exception {
+ MockCreationSettings<NonPackagePrivateSubClass> settings =
+ settingsFor(NonPackagePrivateSubClass.class);
+ NonPackagePrivateSubClass proxy =
+ mockMaker.createMock(
+ settings, new MockHandlerImpl<NonPackagePrivateSubClass>(settings));
+ assertThat(proxy.value()).isEqualTo("bar");
+ }
+
+ @Test
+ public void is_type_mockable_excludes_String() {
+ MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(String.class);
+ assertThat(mockable.mockable()).isFalse();
+ assertThat(mockable.nonMockableReason())
+ .contains("Cannot mock wrapper types, String.class or Class.class");
+ }
+
+ @Test
+ public void is_type_mockable_excludes_Class() {
+ MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Class.class);
+ assertThat(mockable.mockable()).isFalse();
+ assertThat(mockable.nonMockableReason())
+ .contains("Cannot mock wrapper types, String.class or Class.class");
+ }
+
+ @Test
+ public void is_type_mockable_excludes_primitive_classes() {
+ MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(int.class);
+ assertThat(mockable.mockable()).isFalse();
+ assertThat(mockable.nonMockableReason()).contains("primitive");
+ }
+
+ @Test
+ public void is_type_mockable_allows_anonymous() {
+ Observer anonymous =
+ new Observer() {
+ @Override
+ public void update(Observable o, Object arg) {}
+ };
+ MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(anonymous.getClass());
+ assertThat(mockable.mockable()).isTrue();
+ assertThat(mockable.nonMockableReason()).contains("");
+ }
+
+ @Test
+ public void is_type_mockable_give_empty_reason_if_type_is_mockable() {
+ MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(SomeClass.class);
+ assertThat(mockable.mockable()).isTrue();
+ assertThat(mockable.nonMockableReason()).isEqualTo("");
+ }
+
+ @Test
+ public void is_type_mockable_give_allow_final_mockable_from_JDK() {
+ MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(Pattern.class);
+ assertThat(mockable.mockable()).isTrue();
+ assertThat(mockable.nonMockableReason()).isEqualTo("");
+ }
+
+ @Test
+ public void test_parameters_retention() throws Exception {
+ assumeTrue(ClassFileVersion.ofThisVm().isAtLeast(JAVA_V8));
+
+ Class<?> typeWithParameters =
+ new ByteBuddy()
+ .subclass(Object.class)
+ .defineMethod("foo", void.class, Visibility.PUBLIC)
+ .withParameter(String.class, "bar")
+ .intercept(StubMethod.INSTANCE)
+ .make()
+ .load(null)
+ .getLoaded();
+
+ MockCreationSettings<?> settings = settingsFor(typeWithParameters);
+ @SuppressWarnings("unchecked")
+ Object proxy = mockMaker.createMock(settings, new MockHandlerImpl(settings));
+
+ assertThat(proxy.getClass()).isEqualTo(typeWithParameters);
+ assertThat(
+ new TypeDescription.ForLoadedType(typeWithParameters)
+ .getDeclaredMethods()
+ .filter(named("foo"))
+ .getOnly()
+ .getParameters()
+ .getOnly()
+ .getName())
+ .isEqualTo("bar");
+ }
+
+ @Test
+ public void test_constant_dynamic_compatibility() throws Exception {
+ assumeTrue(ClassFileVersion.ofThisVm().isAtLeast(JAVA_V11));
+
+ Class<?> typeWithCondy =
+ new ByteBuddy()
+ .subclass(Callable.class)
+ .method(named("call"))
+ .intercept(FixedValue.value(JavaConstant.Dynamic.ofNullConstant()))
+ .make()
+ .load(null)
+ .getLoaded();
+
+ MockCreationSettings<?> settings = settingsFor(typeWithCondy);
+ @SuppressWarnings("unchecked")
+ Object proxy = mockMaker.createMock(settings, new MockHandlerImpl(settings));
+
+ assertThat(proxy.getClass()).isEqualTo(typeWithCondy);
+ }
+
+ @Test
+ public void test_clear_mock_clears_handler() {
+ MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
+ GenericSubClass proxy =
+ mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
+ assertThat(mockMaker.getHandler(proxy)).isNotNull();
+
+ // when
+ mockMaker.clearMock(proxy);
+
+ // then
+ assertThat(mockMaker.getHandler(proxy)).isNull();
+ }
+
+ @Test
+ public void test_clear_all_mock_clears_handler() {
+ MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
+ GenericSubClass proxy1 =
+ mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
+ assertThat(mockMaker.getHandler(proxy1)).isNotNull();
+
+ settings = settingsFor(GenericSubClass.class);
+ GenericSubClass proxy2 =
+ mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
+ assertThat(mockMaker.getHandler(proxy1)).isNotNull();
+
+ // when
+ mockMaker.clearAllMocks();
+
+ // then
+ assertThat(mockMaker.getHandler(proxy1)).isNull();
+ assertThat(mockMaker.getHandler(proxy2)).isNull();
+ }
+
+ protected static <T> MockCreationSettings<T> settingsFor(
+ Class<T> type, Class<?>... extraInterfaces) {
+ MockSettingsImpl<T> mockSettings = new MockSettingsImpl<T>();
+ mockSettings.setTypeToMock(type);
+ mockSettings.defaultAnswer(new Returns("bar"));
+ if (extraInterfaces.length > 0) mockSettings.extraInterfaces(extraInterfaces);
+ return mockSettings;
+ }
+
+ @Test
+ public void testMockDispatcherIsRelocated() throws Exception {
+ assertThat(
+ InlineByteBuddyMockMaker.class
+ .getClassLoader()
+ .getResource(
+ "org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.raw"))
+ .isNotNull();
+ }
+
+ private static final class FinalClass {
+
+ public String foo() {
+ return "foo";
+ }
+ }
+
+ private static final class FinalSpy {
+
+ private final String aString;
+ private final boolean aBoolean;
+ private final byte aByte;
+ private final short aShort;
+ private final char aChar;
+ private final int anInt;
+ private final long aLong;
+ private final float aFloat;
+ private final double aDouble;
+
+ private FinalSpy(
+ String aString,
+ boolean aBoolean,
+ byte aByte,
+ short aShort,
+ char aChar,
+ int anInt,
+ long aLong,
+ float aFloat,
+ double aDouble) {
+ this.aString = aString;
+ this.aBoolean = aBoolean;
+ this.aByte = aByte;
+ this.aShort = aShort;
+ this.aChar = aChar;
+ this.anInt = anInt;
+ this.aLong = aLong;
+ this.aFloat = aFloat;
+ this.aDouble = aDouble;
+ }
+ }
+
+ private static class NonConstructableClass {
+
+ private NonConstructableClass() {
+ throw new AssertionError();
+ }
+
+ public String foo() {
+ return "foo";
+ }
+ }
+
+ private enum EnumClass {
+ INSTANCE;
+
+ public String foo() {
+ return "foo";
+ }
+ }
+
+ private abstract static class FinalMethodAbstractType {
+
+ public final String foo() {
+ return "foo";
+ }
+
+ public abstract String bar();
+ }
+
+ private static class FinalMethod {
+
+ public final String foo() {
+ return "foo";
+ }
+ }
+
+ private interface SampleInterface {
+
+ String bar();
+ }
+
+ /*package-private*/ abstract class PackagePrivateSuperClass {
+
+ public abstract String indirect();
+
+ public String value() {
+ return indirect() + "qux";
+ }
+ }
+
+ public class NonPackagePrivateSubClass extends PackagePrivateSuperClass {
+
+ @Override
+ public String indirect() {
+ return "foo";
+ }
+ }
+
+ public static class GenericClass<T> {
+
+ public T value() {
+ return null;
+ }
+ }
+
+ public static class GenericSubClass extends GenericClass<String> {}
+
+ public static class ExceptionThrowingClass {
+ public IOException getException() {
+ try {
+ throwException();
+ } catch (IOException ex) {
+ return ex;
+ }
+ return null;
+ }
+
+ public void throwException() throws IOException {
+ internalThrowException(1);
+ }
+
+ void internalThrowException(int test) throws IOException {
+ // some lines of code, so the exception is not thrown in the first line of the method
+ int i = 0;
+ if (test != i) {
+ throw new IOException("fatal");
+ }
+ }
+ }
+}
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMakerTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMakerTest.java
index 6b79640..154fc9a 100644
--- a/src/test/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMakerTest.java
+++ b/src/test/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMakerTest.java
@@ -4,18 +4,23 @@
*/
package org.mockito.internal.creation.bytebuddy;
-import org.junit.Test;
-import org.mockito.internal.creation.MockSettingsImpl;
-import org.mockito.plugins.MockMaker;
+import static org.assertj.core.api.Assertions.assertThat;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Observable;
import java.util.Observer;
-import static org.assertj.core.api.Assertions.assertThat;
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.ClassFileVersion;
+import net.bytebuddy.description.modifier.TypeManifestation;
+import net.bytebuddy.dynamic.DynamicType;
+import org.junit.Test;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.plugins.MockMaker;
-public class SubclassByteBuddyMockMakerTest extends AbstractByteBuddyMockMakerTest<SubclassByteBuddyMockMaker> {
+public class SubclassByteBuddyMockMakerTest
+ extends AbstractByteBuddyMockMakerTest<SubclassByteBuddyMockMaker> {
public SubclassByteBuddyMockMakerTest() {
super(new SubclassByteBuddyMockMaker());
@@ -29,6 +34,31 @@
}
@Test
+ public void is_type_mockable_excludes_sealed_classes() {
+ // is only supported on Java 17 and later
+ if (ClassFileVersion.ofThisVm().isAtMost(ClassFileVersion.JAVA_V16)) {
+ return;
+ }
+ DynamicType.Builder<Object> base = new ByteBuddy().subclass(Object.class);
+ DynamicType.Unloaded<Object> dynamic =
+ new ByteBuddy()
+ .subclass(Object.class)
+ .permittedSubclass(base.toTypeDescription())
+ .make();
+ Class<?> type =
+ new ByteBuddy()
+ .subclass(base.toTypeDescription())
+ .merge(TypeManifestation.FINAL)
+ .make()
+ .include(dynamic)
+ .load(null)
+ .getLoaded();
+ MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(type);
+ assertThat(mockable.mockable()).isFalse();
+ assertThat(mockable.nonMockableReason()).contains("sealed");
+ }
+
+ @Test
public void is_type_mockable_excludes_primitive_classes() {
MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(int.class);
assertThat(mockable.mockable()).isFalse();
@@ -37,9 +67,11 @@
@Test
public void is_type_mockable_allow_anonymous() {
- Observer anonymous = new Observer() {
- @Override public void update(Observable o, Object arg) { }
- };
+ Observer anonymous =
+ new Observer() {
+ @Override
+ public void update(Observable o, Object arg) {}
+ };
MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(anonymous.getClass());
assertThat(mockable.mockable()).isTrue();
assertThat(mockable.nonMockableReason()).contains("");
@@ -54,7 +86,8 @@
@Test
public void mock_type_with_annotations() throws Exception {
- MockSettingsImpl<ClassWithAnnotation> mockSettings = new MockSettingsImpl<ClassWithAnnotation>();
+ MockSettingsImpl<ClassWithAnnotation> mockSettings =
+ new MockSettingsImpl<ClassWithAnnotation>();
mockSettings.setTypeToMock(ClassWithAnnotation.class);
ClassWithAnnotation proxy = mockMaker.createMock(mockSettings, dummyHandler());
@@ -62,20 +95,34 @@
assertThat(proxy.getClass().isAnnotationPresent(SampleAnnotation.class)).isTrue();
assertThat(proxy.getClass().getAnnotation(SampleAnnotation.class).value()).isEqualTo("foo");
- assertThat(proxy.getClass().getMethod("sampleMethod").isAnnotationPresent(SampleAnnotation.class)).isTrue();
- assertThat(proxy.getClass().getMethod("sampleMethod").getAnnotation(SampleAnnotation.class).value()).isEqualTo("bar");
+ assertThat(
+ proxy.getClass()
+ .getMethod("sampleMethod")
+ .isAnnotationPresent(SampleAnnotation.class))
+ .isTrue();
+ assertThat(
+ proxy.getClass()
+ .getMethod("sampleMethod")
+ .getAnnotation(SampleAnnotation.class)
+ .value())
+ .isEqualTo("bar");
}
@Test
public void mock_type_without_annotations() throws Exception {
- MockSettingsImpl<ClassWithAnnotation> mockSettings = new MockSettingsImpl<ClassWithAnnotation>();
+ MockSettingsImpl<ClassWithAnnotation> mockSettings =
+ new MockSettingsImpl<ClassWithAnnotation>();
mockSettings.setTypeToMock(ClassWithAnnotation.class);
mockSettings.withoutAnnotations();
ClassWithAnnotation proxy = mockMaker.createMock(mockSettings, dummyHandler());
assertThat(proxy.getClass().isAnnotationPresent(SampleAnnotation.class)).isFalse();
- assertThat(proxy.getClass().getMethod("sampleMethod").isAnnotationPresent(SampleAnnotation.class)).isFalse();
+ assertThat(
+ proxy.getClass()
+ .getMethod("sampleMethod")
+ .isAnnotationPresent(SampleAnnotation.class))
+ .isFalse();
}
@Override
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/TypeCachingMockBytecodeGeneratorTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/TypeCachingMockBytecodeGeneratorTest.java
index 54c503e..026fba3 100644
--- a/src/test/java/org/mockito/internal/creation/bytebuddy/TypeCachingMockBytecodeGeneratorTest.java
+++ b/src/test/java/org/mockito/internal/creation/bytebuddy/TypeCachingMockBytecodeGeneratorTest.java
@@ -4,22 +4,25 @@
*/
package org.mockito.internal.creation.bytebuddy;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.mock.SerializableMode;
-import org.mockitoutil.VmArgAssumptions;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.internal.creation.bytebuddy.MockFeatures.withMockFeatures;
+import static org.mockitoutil.ClassLoaders.inMemoryClassLoader;
+import static org.mockitoutil.SimpleClassGenerator.makeMarkerInterface;
import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.Set;
import java.util.WeakHashMap;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.internal.creation.bytebuddy.MockFeatures.withMockFeatures;
-import static org.mockitoutil.ClassLoaders.inMemoryClassLoader;
-import static org.mockitoutil.SimpleClassGenerator.makeMarkerInterface;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Answers;
+import org.mockito.mock.SerializableMode;
+import org.mockitoutil.VmArgAssumptions;
public class TypeCachingMockBytecodeGeneratorTest {
@@ -29,23 +32,29 @@
}
@Test
- public void ensure_cache_is_cleared_if_no_reference_to_classloader_and_classes() throws Exception {
+ public void ensure_cache_is_cleared_if_no_reference_to_classloader_and_classes()
+ throws Exception {
// given
- ClassLoader classloader_with_life_shorter_than_cache = inMemoryClassLoader()
- .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
- .build();
+ ClassLoader classloader_with_life_shorter_than_cache =
+ inMemoryClassLoader()
+ .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
+ .build();
- TypeCachingBytecodeGenerator cachingMockBytecodeGenerator = new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
+ TypeCachingBytecodeGenerator cachingMockBytecodeGenerator =
+ new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
- Class<?> the_mock_type = cachingMockBytecodeGenerator.mockClass(withMockFeatures(
- classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
- Collections.<Class<?>>emptySet(),
- SerializableMode.NONE,
- false
- ));
+ Class<?> the_mock_type =
+ cachingMockBytecodeGenerator.mockClass(
+ withMockFeatures(
+ classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+ Collections.<Class<?>>emptySet(),
+ SerializableMode.NONE,
+ false,
+ Answers.RETURNS_DEFAULTS));
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
- Reference<Object> typeReference = new PhantomReference<Object>(the_mock_type, referenceQueue);
+ Reference<Object> typeReference =
+ new PhantomReference<Object>(the_mock_type, referenceQueue);
// when
classloader_with_life_shorter_than_cache = is_no_more_referenced();
@@ -61,29 +70,36 @@
@Test
public void ensure_cache_returns_same_instance() throws Exception {
// given
- ClassLoader classloader_with_life_shorter_than_cache = inMemoryClassLoader()
- .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
- .build();
+ ClassLoader classloader_with_life_shorter_than_cache =
+ inMemoryClassLoader()
+ .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
+ .build();
- TypeCachingBytecodeGenerator cachingMockBytecodeGenerator = new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
- Class<?> the_mock_type = cachingMockBytecodeGenerator.mockClass(withMockFeatures(
- classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
- Collections.<Class<?>>emptySet(),
- SerializableMode.NONE,
- false
- ));
+ TypeCachingBytecodeGenerator cachingMockBytecodeGenerator =
+ new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
+ Class<?> the_mock_type =
+ cachingMockBytecodeGenerator.mockClass(
+ withMockFeatures(
+ classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+ Collections.<Class<?>>emptySet(),
+ SerializableMode.NONE,
+ false,
+ Answers.RETURNS_DEFAULTS));
- Class<?> other_mock_type = cachingMockBytecodeGenerator.mockClass(withMockFeatures(
- classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
- Collections.<Class<?>>emptySet(),
- SerializableMode.NONE,
- false
- ));
+ Class<?> other_mock_type =
+ cachingMockBytecodeGenerator.mockClass(
+ withMockFeatures(
+ classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+ Collections.<Class<?>>emptySet(),
+ SerializableMode.NONE,
+ false,
+ Answers.RETURNS_DEFAULTS));
assertThat(other_mock_type).isSameAs(the_mock_type);
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
- Reference<Object> typeReference = new PhantomReference<Object>(the_mock_type, referenceQueue);
+ Reference<Object> typeReference =
+ new PhantomReference<Object>(the_mock_type, referenceQueue);
// when
classloader_with_life_shorter_than_cache = is_no_more_referenced();
@@ -100,37 +116,85 @@
@Test
public void ensure_cache_returns_different_instance_serializableMode() throws Exception {
// given
- ClassLoader classloader_with_life_shorter_than_cache = inMemoryClassLoader()
- .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
- .build();
+ ClassLoader classloader_with_life_shorter_than_cache =
+ inMemoryClassLoader()
+ .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
+ .build();
- TypeCachingBytecodeGenerator cachingMockBytecodeGenerator = new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
- Class<?> the_mock_type = cachingMockBytecodeGenerator.mockClass(withMockFeatures(
- classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
- Collections.<Class<?>>emptySet(),
- SerializableMode.NONE,
- false
- ));
+ TypeCachingBytecodeGenerator cachingMockBytecodeGenerator =
+ new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
+ Class<?> the_mock_type =
+ cachingMockBytecodeGenerator.mockClass(
+ withMockFeatures(
+ classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+ Collections.<Class<?>>emptySet(),
+ SerializableMode.NONE,
+ false,
+ Answers.RETURNS_DEFAULTS));
- Class<?> other_mock_type = cachingMockBytecodeGenerator.mockClass(withMockFeatures(
- classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
- Collections.<Class<?>>emptySet(),
- SerializableMode.BASIC,
- false
- ));
+ Class<?> other_mock_type =
+ cachingMockBytecodeGenerator.mockClass(
+ withMockFeatures(
+ classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+ Collections.<Class<?>>emptySet(),
+ SerializableMode.BASIC,
+ false,
+ Answers.RETURNS_DEFAULTS));
assertThat(other_mock_type).isNotSameAs(the_mock_type);
}
@Test
- public void validate_simple_code_idea_where_weakhashmap_with_classloader_as_key_get_GCed_when_no_more_references() throws Exception {
+ public void ensure_cache_returns_same_instance_defaultAnswer() throws Exception {
+ // given
+ ClassLoader classloader_with_life_shorter_than_cache =
+ inMemoryClassLoader()
+ .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
+ .build();
+
+ TypeCachingBytecodeGenerator cachingMockBytecodeGenerator =
+ new TypeCachingBytecodeGenerator(new SubclassBytecodeGenerator(), true);
+
+ Answers[] answers = Answers.values();
+ Set<Class<?>> classes = Collections.newSetFromMap(new IdentityHashMap<>());
+ classes.add(
+ cachingMockBytecodeGenerator.mockClass(
+ withMockFeatures(
+ classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+ Collections.<Class<?>>emptySet(),
+ SerializableMode.NONE,
+ false,
+ null)));
+ for (Answers answer : answers) {
+ Class<?> klass =
+ cachingMockBytecodeGenerator.mockClass(
+ withMockFeatures(
+ classloader_with_life_shorter_than_cache.loadClass("foo.Bar"),
+ Collections.<Class<?>>emptySet(),
+ SerializableMode.NONE,
+ false,
+ answer));
+ assertThat(classes.add(klass)).isFalse();
+ }
+
+ assertThat(classes).hasSize(1);
+ }
+
+ @Test
+ public void
+ validate_simple_code_idea_where_weakhashmap_with_classloader_as_key_get_GCed_when_no_more_references()
+ throws Exception {
// given
WeakHashMap<ClassLoader, Object> cache = new WeakHashMap<ClassLoader, Object>();
- ClassLoader short_lived_classloader = inMemoryClassLoader()
- .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
- .build();
+ ClassLoader short_lived_classloader =
+ inMemoryClassLoader()
+ .withClassDefinition("foo.Bar", makeMarkerInterface("foo.Bar"))
+ .build();
- cache.put(short_lived_classloader, new HoldingAReference(new WeakReference<Class<?>>(short_lived_classloader.loadClass("foo.Bar"))));
+ cache.put(
+ short_lived_classloader,
+ new HoldingAReference(
+ new WeakReference<Class<?>>(short_lived_classloader.loadClass("foo.Bar"))));
assertThat(cache).hasSize(1);
@@ -152,7 +216,6 @@
}
}
-
private static <T> T is_no_more_referenced() {
return null;
}
diff --git a/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java b/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java
index 320287c..d576116 100644
--- a/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java
+++ b/src/test/java/org/mockito/internal/creation/instance/ConstructorInstantiatorTest.java
@@ -5,69 +5,85 @@
package org.mockito.internal.creation.instance;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
import org.junit.Test;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-
public class ConstructorInstantiatorTest extends TestBase {
- static class SomeClass {
+ static class SomeClass {}
- }
+ class SomeInnerClass {}
- class SomeInnerClass {
-
- }
-
- class ChildOfThis extends ConstructorInstantiatorTest {
-
- }
+ class ChildOfThis extends ConstructorInstantiatorTest {}
static class SomeClass2 {
- SomeClass2(String x) {
- }
+ SomeClass2(String x) {}
}
static class SomeClass3 {
- SomeClass3(int i) {
-
- }
+ SomeClass3(int i) {}
}
@Test
public void creates_instances() {
- assertEquals(new ConstructorInstantiator(false, new Object[0]).newInstance(SomeClass.class).getClass(), SomeClass.class);
+ assertEquals(
+ new ConstructorInstantiator(false, new Object[0])
+ .newInstance(SomeClass.class)
+ .getClass(),
+ SomeClass.class);
}
@Test
public void creates_instances_of_inner_classes() {
- assertEquals(new ConstructorInstantiator(true, this).newInstance(SomeInnerClass.class).getClass(), SomeInnerClass.class);
- assertEquals(new ConstructorInstantiator(true, new ChildOfThis()).newInstance(SomeInnerClass.class).getClass(), SomeInnerClass.class);
+ assertEquals(
+ new ConstructorInstantiator(true, this)
+ .newInstance(SomeInnerClass.class)
+ .getClass(),
+ SomeInnerClass.class);
+ assertEquals(
+ new ConstructorInstantiator(true, new ChildOfThis())
+ .newInstance(SomeInnerClass.class)
+ .getClass(),
+ SomeInnerClass.class);
}
@Test
public void creates_instances_with_arguments() {
- assertEquals(new ConstructorInstantiator(false, "someString").newInstance(SomeClass2.class).getClass(), SomeClass2.class);
+ assertEquals(
+ new ConstructorInstantiator(false, "someString")
+ .newInstance(SomeClass2.class)
+ .getClass(),
+ SomeClass2.class);
}
@Test
public void creates_instances_with_null_arguments() {
- assertEquals(new ConstructorInstantiator(false, new Object[]{null}).newInstance(SomeClass2.class).getClass(), SomeClass2.class);
+ assertEquals(
+ new ConstructorInstantiator(false, new Object[] {null})
+ .newInstance(SomeClass2.class)
+ .getClass(),
+ SomeClass2.class);
}
@Test
public void creates_instances_with_primitive_arguments() {
- assertEquals(new ConstructorInstantiator(false, 123).newInstance(SomeClass3.class).getClass(), SomeClass3.class);
+ assertEquals(
+ new ConstructorInstantiator(false, 123).newInstance(SomeClass3.class).getClass(),
+ SomeClass3.class);
}
@Test(expected = org.mockito.creation.instance.InstantiationException.class)
public void fails_when_null_is_passed_for_a_primitive() {
- assertEquals(new ConstructorInstantiator(false, new Object[]{null}).newInstance(SomeClass3.class).getClass(), SomeClass3.class);
+ assertEquals(
+ new ConstructorInstantiator(false, new Object[] {null})
+ .newInstance(SomeClass3.class)
+ .getClass(),
+ SomeClass3.class);
}
@Test
@@ -76,8 +92,10 @@
new ConstructorInstantiator(false, new Object[0]).newInstance(SomeClass2.class);
fail();
} catch (org.mockito.creation.instance.InstantiationException e) {
- assertThat(e).hasMessageContaining("Unable to create instance of 'SomeClass2'.\n" +
- "Please ensure that the target class has a 0-arg constructor.");
+ assertThat(e)
+ .hasMessageContaining(
+ "Unable to create instance of 'SomeClass2'.\n"
+ + "Please ensure that the target class has a 0-arg constructor.");
}
}
}
diff --git a/src/test/java/org/mockito/internal/creation/proxy/ProxyMockMakerTest.java b/src/test/java/org/mockito/internal/creation/proxy/ProxyMockMakerTest.java
new file mode 100644
index 0000000..f113d5e
--- /dev/null
+++ b/src/test/java/org/mockito/internal/creation/proxy/ProxyMockMakerTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.creation.proxy;
+
+import org.junit.Test;
+import org.mockito.internal.creation.AbstractMockMakerTest;
+
+import java.io.Serializable;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ProxyMockMakerTest
+ extends AbstractMockMakerTest<ProxyMockMaker, ProxyMockMakerTest.SomeInterface> {
+
+ public ProxyMockMakerTest() {
+ super(new ProxyMockMaker(), SomeInterface.class);
+ }
+
+ @Test
+ public void should_create_mock_from_interface() {
+ SomeInterface proxy =
+ mockMaker.createMock(settingsFor(SomeInterface.class), dummyHandler());
+
+ Class<?> superClass = proxy.getClass().getSuperclass();
+ assertThat(superClass).isEqualTo(Proxy.class);
+ }
+
+ @Test
+ public void should_create_mock_from_interface_with_extra_interface() {
+ SomeInterface proxy =
+ mockMaker.createMock(
+ settingsFor(SomeInterface.class, Serializable.class), dummyHandler());
+
+ Class<?> superClass = proxy.getClass().getSuperclass();
+ assertThat(superClass).isEqualTo(Proxy.class);
+ assertThat(proxy).isInstanceOf(Serializable.class);
+ }
+
+ @Test
+ public void should_discover_mockable_input() {
+ assertThat(mockMaker.isTypeMockable(Object.class).mockable()).isFalse();
+ assertThat(mockMaker.isTypeMockable(Object.class).nonMockableReason())
+ .isEqualTo("non-interface");
+ assertThat(mockMaker.isTypeMockable(SomeInterface.class).mockable()).isTrue();
+ }
+
+ @Test
+ public void can_compute_hash_code() throws Throwable {
+ SomeInterface proxy =
+ mockMaker.createMock(settingsFor(SomeInterface.class), dummyHandler());
+
+ InvocationHandler handler = Proxy.getInvocationHandler(proxy);
+
+ assertThat(handler.invoke(proxy, Object.class.getMethod("hashCode"), null))
+ .isEqualTo(System.identityHashCode(proxy));
+ }
+
+ @Test
+ public void can_compute_equality() throws Throwable {
+ SomeInterface proxy =
+ mockMaker.createMock(settingsFor(SomeInterface.class), dummyHandler());
+
+ InvocationHandler handler = Proxy.getInvocationHandler(proxy);
+
+ assertThat(
+ handler.invoke(
+ proxy,
+ Object.class.getMethod("equals", Object.class),
+ new Object[] {proxy}))
+ .isEqualTo(true);
+ assertThat(
+ handler.invoke(
+ proxy,
+ Object.class.getMethod("equals", Object.class),
+ new Object[] {null}))
+ .isEqualTo(false);
+ assertThat(
+ handler.invoke(
+ proxy,
+ Object.class.getMethod("equals", Object.class),
+ new Object[] {new Object()}))
+ .isEqualTo(false);
+ }
+
+ @Test
+ public void can_invoke_toString() throws Throwable {
+ SomeInterface proxy =
+ mockMaker.createMock(settingsFor(SomeInterface.class), dummyHandler());
+
+ InvocationHandler handler = Proxy.getInvocationHandler(proxy);
+
+ assertThat(handler.invoke(proxy, Object.class.getMethod("toString"), null)).isNull();
+ }
+
+ interface SomeInterface {}
+}
diff --git a/src/test/java/org/mockito/internal/debugging/LoggingListenerTest.java b/src/test/java/org/mockito/internal/debugging/LoggingListenerTest.java
index e2ae6e5..54c5bec 100644
--- a/src/test/java/org/mockito/internal/debugging/LoggingListenerTest.java
+++ b/src/test/java/org/mockito/internal/debugging/LoggingListenerTest.java
@@ -4,41 +4,41 @@
*/
package org.mockito.internal.debugging;
+import static org.junit.Assert.assertEquals;
import org.junit.Test;
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-
public class LoggingListenerTest extends TestBase {
@Test
public void may_not_have_any_information() {
- //given
+ // given
LoggingListener listener = new LoggingListener(true);
- //expect
+ // expect
assertEquals("", listener.getStubbingInfo());
}
@Test
public void informs_about_unused_stubs() {
- //given
+ // given
LoggingListener listener = new LoggingListener(false);
- //when
+ // when
listener.foundUnusedStub(invocationAt("at com.FooTest:30"));
listener.foundUnusedStub(invocationAt("at com.FooTest:32"));
- //then
+ // then
assertEquals(
- "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n" +
- "[Mockito]\n" +
- "[Mockito] Unused stubbing (perhaps can be removed from the test?):\n" +
- "[Mockito]\n" +
- "[Mockito] 1. at com.FooTest:30\n" +
- "[Mockito] 2. at com.FooTest:32", listener.getStubbingInfo());
+ "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n"
+ + "[Mockito]\n"
+ + "[Mockito] Unused stubbing (perhaps can be removed from the test?):\n"
+ + "[Mockito]\n"
+ + "[Mockito] 1. at com.FooTest:30\n"
+ + "[Mockito] 2. at com.FooTest:32",
+ listener.getStubbingInfo());
}
@Test
@@ -51,79 +51,85 @@
@Test
public void informs_about_unused_stubs_due_arg_mismatch() {
- //given
+ // given
LoggingListener listener = new LoggingListener(false);
- //when
- listener.foundStubCalledWithDifferentArgs(invocationAt("at com.FooTest:20"), invocationMatcherAt("at com.Foo:100"));
- listener.foundStubCalledWithDifferentArgs(invocationAt("at com.FooTest:21"), invocationMatcherAt("at com.Foo:121"));
+ // when
+ listener.foundStubCalledWithDifferentArgs(
+ invocationAt("at com.FooTest:20"), invocationMatcherAt("at com.Foo:100"));
+ listener.foundStubCalledWithDifferentArgs(
+ invocationAt("at com.FooTest:21"), invocationMatcherAt("at com.Foo:121"));
- //then
+ // then
assertEquals(
- "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n" +
- "[Mockito]\n" +
- "[Mockito] Argument mismatch between stubbing and actual invocation (is stubbing correct in the test?):\n" +
- "[Mockito]\n" +
- "[Mockito] 1. Stubbed at com.FooTest:20\n" +
- "[Mockito] Invoked at com.Foo:100\n" +
- "[Mockito] 2. Stubbed at com.FooTest:21\n" +
- "[Mockito] Invoked at com.Foo:121", listener.getStubbingInfo());
+ "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n"
+ + "[Mockito]\n"
+ + "[Mockito] Argument mismatch between stubbing and actual invocation (is stubbing correct in the test?):\n"
+ + "[Mockito]\n"
+ + "[Mockito] 1. Stubbed at com.FooTest:20\n"
+ + "[Mockito] Invoked at com.Foo:100\n"
+ + "[Mockito] 2. Stubbed at com.FooTest:21\n"
+ + "[Mockito] Invoked at com.Foo:121",
+ listener.getStubbingInfo());
}
@Test
public void informs_about_various_kinds_of_stubs() {
- //given
+ // given
LoggingListener listener = new LoggingListener(true);
- //when
+ // when
listener.foundUnusedStub(invocationAt("at com.FooTest:30"));
- listener.foundStubCalledWithDifferentArgs(invocationAt("at com.FooTest:20"), invocationMatcherAt("at com.Foo:100"));
+ listener.foundStubCalledWithDifferentArgs(
+ invocationAt("at com.FooTest:20"), invocationMatcherAt("at com.Foo:100"));
listener.foundUnstubbed(invocationMatcherAt("at com.Foo:96"));
- //then
+ // then
assertEquals(
- "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n" +
- "[Mockito]\n" +
- "[Mockito] Argument mismatch between stubbing and actual invocation (is stubbing correct in the test?):\n" +
- "[Mockito]\n" +
- "[Mockito] 1. Stubbed at com.FooTest:20\n" +
- "[Mockito] Invoked at com.Foo:100\n" +
- "[Mockito]\n" +
- "[Mockito] Unused stubbing (perhaps can be removed from the test?):\n" +
- "[Mockito]\n" +
- "[Mockito] 1. at com.FooTest:30\n" +
- "[Mockito]\n" +
- "[Mockito] Unstubbed method invocations (perhaps missing stubbing in the test?):\n" +
- "[Mockito]\n" +
- "[Mockito] 1. at com.Foo:96", listener.getStubbingInfo());
+ "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n"
+ + "[Mockito]\n"
+ + "[Mockito] Argument mismatch between stubbing and actual invocation (is stubbing correct in the test?):\n"
+ + "[Mockito]\n"
+ + "[Mockito] 1. Stubbed at com.FooTest:20\n"
+ + "[Mockito] Invoked at com.Foo:100\n"
+ + "[Mockito]\n"
+ + "[Mockito] Unused stubbing (perhaps can be removed from the test?):\n"
+ + "[Mockito]\n"
+ + "[Mockito] 1. at com.FooTest:30\n"
+ + "[Mockito]\n"
+ + "[Mockito] Unstubbed method invocations (perhaps missing stubbing in the test?):\n"
+ + "[Mockito]\n"
+ + "[Mockito] 1. at com.Foo:96",
+ listener.getStubbingInfo());
}
@Test
public void hides_unstubbed() {
- //given
+ // given
LoggingListener listener = new LoggingListener(false);
- //when
+ // when
listener.foundUnstubbed(new InvocationBuilder().toInvocationMatcher());
- //then
+ // then
assertEquals("", listener.getStubbingInfo());
}
@Test
public void informs_about_unstubbed() {
- //given
+ // given
LoggingListener listener = new LoggingListener(true);
- //when
+ // when
listener.foundUnstubbed(invocationMatcherAt("com.Foo:20"));
- //then
+ // then
assertEquals(
- "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n" +
- "[Mockito]\n" +
- "[Mockito] Unstubbed method invocations (perhaps missing stubbing in the test?):\n" +
- "[Mockito]\n" +
- "[Mockito] 1. com.Foo:20", listener.getStubbingInfo());
+ "[Mockito] Additional stubbing information (see javadoc for StubbingInfo class):\n"
+ + "[Mockito]\n"
+ + "[Mockito] Unstubbed method invocations (perhaps missing stubbing in the test?):\n"
+ + "[Mockito]\n"
+ + "[Mockito] 1. com.Foo:20",
+ listener.getStubbingInfo());
}
}
diff --git a/src/test/java/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java b/src/test/java/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java
index 83ef473..2fb7a0d 100644
--- a/src/test/java/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java
+++ b/src/test/java/org/mockito/internal/debugging/VerboseMockInvocationLoggerTest.java
@@ -4,6 +4,11 @@
*/
package org.mockito.internal.debugging;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -13,11 +18,6 @@
import org.mockito.invocation.DescribedInvocation;
import org.mockito.invocation.Invocation;
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
public class VerboseMockInvocationLoggerTest {
private VerboseMockInvocationLogger listener;
@@ -57,7 +57,8 @@
@Test
public void should_print_invocation_with_exception() {
// when
- listener.reportInvocation(new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
+ listener.reportInvocation(
+ new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
// then
assertThat(printed())
@@ -87,13 +88,16 @@
@Test
public void should_log_count_of_interactions() {
// when & then
- listener.reportInvocation(new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
+ listener.reportInvocation(
+ new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
assertThat(printed()).contains("#1");
- listener.reportInvocation(new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
+ listener.reportInvocation(
+ new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
assertThat(printed()).contains("#2");
- listener.reportInvocation(new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
+ listener.reportInvocation(
+ new NotifiedMethodInvocationReport(invocation, new ThirdPartyException()));
assertThat(printed()).contains("#3");
}
diff --git a/src/test/java/org/mockito/internal/debugging/WarningsFinderTest.java b/src/test/java/org/mockito/internal/debugging/WarningsFinderTest.java
index e0a6352..c8fd02f 100644
--- a/src/test/java/org/mockito/internal/debugging/WarningsFinderTest.java
+++ b/src/test/java/org/mockito/internal/debugging/WarningsFinderTest.java
@@ -4,6 +4,13 @@
*/
package org.mockito.internal.debugging;
+import static java.util.Arrays.asList;
+
+import static org.mockito.Mockito.only;
+import static org.mockito.Mockito.verify;
+
+import java.util.Arrays;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.internal.invocation.InvocationBuilder;
@@ -12,12 +19,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.util.Arrays;
-
-import static java.util.Arrays.asList;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.verify;
-
public class WarningsFinderTest extends TestBase {
@Mock private IMethods mock;
@@ -29,7 +30,8 @@
Invocation unusedStub = new InvocationBuilder().simpleMethod().toInvocation();
// when
- WarningsFinder finder = new WarningsFinder(asList(unusedStub), Arrays.<InvocationMatcher>asList());
+ WarningsFinder finder =
+ new WarningsFinder(asList(unusedStub), Arrays.<InvocationMatcher>asList());
finder.find(listener);
// then
@@ -39,10 +41,14 @@
@Test
public void shouldPrintUnstubbedInvocation() {
// given
- InvocationMatcher unstubbedInvocation = new InvocationBuilder().differentMethod().toInvocationMatcher();
+ InvocationMatcher unstubbedInvocation =
+ new InvocationBuilder().differentMethod().toInvocationMatcher();
// when
- WarningsFinder finder = new WarningsFinder(Arrays.<Invocation>asList(), Arrays.<InvocationMatcher>asList(unstubbedInvocation));
+ WarningsFinder finder =
+ new WarningsFinder(
+ Arrays.<Invocation>asList(),
+ Arrays.<InvocationMatcher>asList(unstubbedInvocation));
finder.find(listener);
// then
@@ -53,10 +59,14 @@
public void shouldPrintStubWasUsedWithDifferentArgs() {
// given
Invocation stub = new InvocationBuilder().arg("foo").mock(mock).toInvocation();
- InvocationMatcher wrongArg = new InvocationBuilder().arg("bar").mock(mock).toInvocationMatcher();
+ InvocationMatcher wrongArg =
+ new InvocationBuilder().arg("bar").mock(mock).toInvocationMatcher();
// when
- WarningsFinder finder = new WarningsFinder(Arrays.<Invocation> asList(stub), Arrays.<InvocationMatcher> asList(wrongArg));
+ WarningsFinder finder =
+ new WarningsFinder(
+ Arrays.<Invocation>asList(stub),
+ Arrays.<InvocationMatcher>asList(wrongArg));
finder.find(listener);
// then
diff --git a/src/test/java/org/mockito/internal/exceptions/ReporterTest.java b/src/test/java/org/mockito/internal/exceptions/ReporterTest.java
index c0bb512..3b71be3 100644
--- a/src/test/java/org/mockito/internal/exceptions/ReporterTest.java
+++ b/src/test/java/org/mockito/internal/exceptions/ReporterTest.java
@@ -2,14 +2,18 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.exceptions;
+import static org.mockito.Mockito.mock;
+
+import java.lang.reflect.Field;
+import java.util.Collections;
+
import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.TooLittleActualInvocations;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
import org.mockito.exceptions.verification.VerificationInOrderFailure;
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockito.internal.stubbing.answers.Returns;
@@ -17,16 +21,14 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.lang.reflect.Field;
-import java.util.Collections;
-
-import static org.mockito.Mockito.mock;
-
public class ReporterTest extends TestBase {
- @Test(expected = TooLittleActualInvocations.class)
+ @Test(expected = TooFewActualInvocations.class)
public void should_let_passing_null_last_actual_stack_trace() throws Exception {
- throw Reporter.tooLittleActualInvocations(new org.mockito.internal.reporting.Discrepancy(1, 2), new InvocationBuilder().toInvocation(), null);
+ throw Reporter.tooFewActualInvocations(
+ new org.mockito.internal.reporting.Discrepancy(1, 2),
+ new InvocationBuilder().toInvocation(),
+ null);
}
@Test(expected = MockitoException.class)
@@ -35,51 +37,86 @@
}
@Test(expected = NoInteractionsWanted.class)
- public void can_use_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_no_more_interaction_wanted() throws Exception {
- Invocation invocation_with_bogus_default_answer = new InvocationBuilder().mock(mock(IMethods.class, new Returns(false))).toInvocation();
- throw Reporter.noMoreInteractionsWanted(invocation_with_bogus_default_answer, Collections.<VerificationAwareInvocation>emptyList());
+ public void
+ can_use_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_no_more_interaction_wanted()
+ throws Exception {
+ Invocation invocation_with_bogus_default_answer =
+ new InvocationBuilder()
+ .mock(mock(IMethods.class, new Returns(false)))
+ .toInvocation();
+ throw Reporter.noMoreInteractionsWanted(
+ invocation_with_bogus_default_answer,
+ Collections.<VerificationAwareInvocation>emptyList());
}
@Test(expected = VerificationInOrderFailure.class)
- public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_no_more_interaction_wanted_in_order() throws Exception {
- Invocation invocation_with_bogus_default_answer = new InvocationBuilder().mock(mock(IMethods.class, new Returns(false))).toInvocation();
+ public void
+ can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_no_more_interaction_wanted_in_order()
+ throws Exception {
+ Invocation invocation_with_bogus_default_answer =
+ new InvocationBuilder()
+ .mock(mock(IMethods.class, new Returns(false)))
+ .toInvocation();
throw Reporter.noMoreInteractionsWantedInOrder(invocation_with_bogus_default_answer);
}
@Test(expected = MockitoException.class)
- public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_invalid_argument_position() throws Exception {
- Invocation invocation_with_bogus_default_answer = new InvocationBuilder().mock(mock(IMethods.class, new Returns(false))).toInvocation();
- throw Reporter.invalidArgumentPositionRangeAtInvocationTime(invocation_with_bogus_default_answer, true, 0);
+ public void
+ can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_invalid_argument_position()
+ throws Exception {
+ Invocation invocation_with_bogus_default_answer =
+ new InvocationBuilder()
+ .mock(mock(IMethods.class, new Returns(false)))
+ .toInvocation();
+ throw Reporter.invalidArgumentPositionRangeAtInvocationTime(
+ invocation_with_bogus_default_answer, true, 0);
}
@Test(expected = MockitoException.class)
- public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_wrong_argument_to_return() throws Exception {
- Invocation invocation_with_bogus_default_answer = new InvocationBuilder().mock(mock(IMethods.class, new Returns(false))).toInvocation();
- throw Reporter.wrongTypeOfArgumentToReturn(invocation_with_bogus_default_answer, "", String.class, 0);
+ public void
+ can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_wrong_argument_to_return()
+ throws Exception {
+ Invocation invocation_with_bogus_default_answer =
+ new InvocationBuilder()
+ .mock(mock(IMethods.class, new Returns(false)))
+ .toInvocation();
+ throw Reporter.wrongTypeOfArgumentToReturn(
+ invocation_with_bogus_default_answer, "", String.class, 0);
}
@Test(expected = MockitoException.class)
- public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_delegate_method_dont_exists() throws Exception {
+ public void
+ can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_delegate_method_dont_exists()
+ throws Exception {
Invocation dumb_invocation = new InvocationBuilder().toInvocation();
IMethods mock_with_bogus_default_answer = mock(IMethods.class, new Returns(false));
- throw Reporter.delegatedMethodDoesNotExistOnDelegate(dumb_invocation.getMethod(), mock_with_bogus_default_answer, String.class);
+ throw Reporter.delegatedMethodDoesNotExistOnDelegate(
+ dumb_invocation.getMethod(), mock_with_bogus_default_answer, String.class);
}
@Test(expected = MockitoException.class)
- public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_delegate_method_has_wrong_return_type() throws Exception {
+ public void
+ can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_delegate_method_has_wrong_return_type()
+ throws Exception {
Invocation dumb_invocation = new InvocationBuilder().toInvocation();
IMethods mock_with_bogus_default_answer = mock(IMethods.class, new Returns(false));
- throw Reporter.delegatedMethodHasWrongReturnType(dumb_invocation.getMethod(), dumb_invocation.getMethod(), mock_with_bogus_default_answer, String.class);
+ throw Reporter.delegatedMethodHasWrongReturnType(
+ dumb_invocation.getMethod(),
+ dumb_invocation.getMethod(),
+ mock_with_bogus_default_answer,
+ String.class);
}
@Test(expected = MockitoException.class)
- public void can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_injection_failure() throws Exception {
+ public void
+ can_use_print_mock_name_even_when_mock_bogus_default_answer_and_when_reporting_injection_failure()
+ throws Exception {
IMethods mock_with_bogus_default_answer = mock(IMethods.class, new Returns(false));
- throw Reporter.cannotInjectDependency(someField(), mock_with_bogus_default_answer, new Exception());
+ throw Reporter.cannotInjectDependency(
+ someField(), mock_with_bogus_default_answer, new Exception());
}
private Field someField() {
return Mockito.class.getDeclaredFields()[0];
}
-
}
diff --git a/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java b/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java
index a92bf1f..064bca5 100644
--- a/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java
+++ b/src/test/java/org/mockito/internal/exceptions/stacktrace/ConditionalStackTraceFilterTest.java
@@ -4,14 +4,14 @@
*/
package org.mockito.internal.exceptions.stacktrace;
+import static org.mockitoutil.Conditions.onlyThoseClassesInStackTrace;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.exceptions.base.TraceBuilder;
import org.mockito.internal.configuration.ConfigurationAccess;
import org.mockitoutil.TestBase;
-import static org.mockitoutil.Conditions.onlyThoseClassesInStackTrace;
-
public class ConditionalStackTraceFilterTest extends TestBase {
private ConditionalStackTraceFilter filter = new ConditionalStackTraceFilter();
@@ -20,24 +20,27 @@
public void shouldNotFilterWhenConfigurationSaysNo() {
ConfigurationAccess.getConfig().overrideCleansStackTrace(false);
- Throwable t = new TraceBuilder().classes(
- "org.test.MockitoSampleTest",
- "org.mockito.Mockito"
- ).toThrowable();
+ Throwable t =
+ new TraceBuilder()
+ .classes("org.test.MockitoSampleTest", "org.mockito.Mockito")
+ .toThrowable();
filter.filter(t);
- Assertions.assertThat(t).has(onlyThoseClassesInStackTrace("org.mockito.Mockito", "org.test.MockitoSampleTest"));
+ Assertions.assertThat(t)
+ .has(
+ onlyThoseClassesInStackTrace(
+ "org.mockito.Mockito", "org.test.MockitoSampleTest"));
}
@Test
public void shouldFilterWhenConfigurationSaysYes() {
ConfigurationAccess.getConfig().overrideCleansStackTrace(true);
- Throwable t = new TraceBuilder().classes(
- "org.test.MockitoSampleTest",
- "org.mockito.Mockito"
- ).toThrowable();
+ Throwable t =
+ new TraceBuilder()
+ .classes("org.test.MockitoSampleTest", "org.mockito.Mockito")
+ .toThrowable();
filter.filter(t);
diff --git a/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java b/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java
index a039bb4..589c03c 100644
--- a/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java
+++ b/src/test/java/org/mockito/internal/exceptions/stacktrace/StackTraceFilterTest.java
@@ -2,27 +2,26 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.exceptions.stacktrace;
+import static org.junit.Assert.assertEquals;
+import static org.mockitoutil.Conditions.onlyThoseClasses;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.exceptions.base.TraceBuilder;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.mockitoutil.Conditions.onlyThoseClasses;
-
public class StackTraceFilterTest extends TestBase {
private final StackTraceFilter filter = new StackTraceFilter();
@Test
public void shouldFilterOutCglibGarbage() {
- StackTraceElement[] t = new TraceBuilder().classes(
- "MockitoExampleTest",
- "List$$EnhancerByMockitoWithCGLIB$$2c406024"
- ).toTraceArray();
+ StackTraceElement[] t =
+ new TraceBuilder()
+ .classes("MockitoExampleTest", "List$$EnhancerByMockitoWithCGLIB$$2c406024")
+ .toTraceArray();
StackTraceElement[] filtered = filter.filter(t, false);
@@ -31,23 +30,24 @@
@Test
public void shouldFilterOutByteBuddyGarbage() {
- StackTraceElement[] t = new TraceBuilder().classes(
- "MockitoExampleTest",
- "org.testcase.MockedClass$MockitoMock$1882975947.doSomething(Unknown Source)"
- ).toTraceArray();
+ StackTraceElement[] t =
+ new TraceBuilder()
+ .classes(
+ "MockitoExampleTest",
+ "org.testcase.MockedClass$MockitoMock$1882975947.doSomething(Unknown Source)")
+ .toTraceArray();
StackTraceElement[] filtered = filter.filter(t, false);
Assertions.assertThat(filtered).has(onlyThoseClasses("MockitoExampleTest"));
}
-
@Test
public void shouldFilterOutMockitoPackage() {
- StackTraceElement[] t = new TraceBuilder().classes(
- "org.test.MockitoSampleTest",
- "org.mockito.Mockito"
- ).toTraceArray();
+ StackTraceElement[] t =
+ new TraceBuilder()
+ .classes("org.test.MockitoSampleTest", "org.mockito.Mockito")
+ .toTraceArray();
StackTraceElement[] filtered = filter.filter(t, false);
@@ -56,100 +56,134 @@
@Test
public void shouldNotFilterOutTracesMiddleGoodTraces() {
- StackTraceElement[] t = new TraceBuilder().classes(
- "org.test.MockitoSampleTest",
- "org.test.TestSupport",
- "org.mockito.Mockito",
- "org.test.TestSupport",
- "org.mockito.Mockito"
- ).toTraceArray();
+ StackTraceElement[] t =
+ new TraceBuilder()
+ .classes(
+ "org.test.MockitoSampleTest",
+ "org.test.TestSupport",
+ "org.mockito.Mockito",
+ "org.test.TestSupport",
+ "org.mockito.Mockito")
+ .toTraceArray();
StackTraceElement[] filtered = filter.filter(t, false);
- Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.TestSupport", "org.test.TestSupport", "org.test.MockitoSampleTest"));
+ Assertions.assertThat(filtered)
+ .has(
+ onlyThoseClasses(
+ "org.test.TestSupport",
+ "org.test.TestSupport",
+ "org.test.MockitoSampleTest"));
}
@Test
public void shouldKeepRunners() {
- StackTraceElement[] t = new TraceBuilder().classes(
- "org.mockito.runners.Runner",
- "junit.stuff",
- "org.test.MockitoSampleTest",
- "org.mockito.Mockito"
- ).toTraceArray();
+ StackTraceElement[] t =
+ new TraceBuilder()
+ .classes(
+ "org.mockito.runners.Runner",
+ "junit.stuff",
+ "org.test.MockitoSampleTest",
+ "org.mockito.Mockito")
+ .toTraceArray();
StackTraceElement[] filtered = filter.filter(t, false);
- Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest", "junit.stuff", "org.mockito.runners.Runner"));
+ Assertions.assertThat(filtered)
+ .has(
+ onlyThoseClasses(
+ "org.test.MockitoSampleTest",
+ "junit.stuff",
+ "org.mockito.runners.Runner"));
}
@Test
public void shouldNotFilterElementsAboveMockitoJUnitRule() {
- StackTraceElement[] t = new TraceBuilder().classes(
- "org.mockito.internal.junit.JUnitRule$1.evaluate(JUnitRule.java:16)",
- "org.mockito.runners.Runner",
- "junit.stuff",
- "org.test.MockitoSampleTest",
- "org.mockito.internal.MockitoCore.verifyNoMoreInteractions",
- "org.mockito.internal.debugging.LocationImpl"
- ).toTraceArray();
+ StackTraceElement[] t =
+ new TraceBuilder()
+ .classes(
+ "org.mockito.internal.junit.JUnitRule$1.evaluate(JUnitRule.java:16)",
+ "org.mockito.runners.Runner",
+ "junit.stuff",
+ "org.test.MockitoSampleTest",
+ "org.mockito.internal.MockitoCore.verifyNoMoreInteractions",
+ "org.mockito.internal.debugging.LocationImpl")
+ .toTraceArray();
StackTraceElement[] filtered = filter.filter(t, false);
- Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest", "junit.stuff", "org.mockito.runners.Runner","org.mockito.internal.junit.JUnitRule$1.evaluate(JUnitRule.java:16)"));
+ Assertions.assertThat(filtered)
+ .has(
+ onlyThoseClasses(
+ "org.test.MockitoSampleTest",
+ "junit.stuff",
+ "org.mockito.runners.Runner",
+ "org.mockito.internal.junit.JUnitRule$1.evaluate(JUnitRule.java:16)"));
}
@Test
public void shouldKeepInternalRunners() {
- StackTraceElement[] t = new TraceBuilder().classes(
- "org.mockito.internal.runners.Runner",
- "org.test.MockitoSampleTest"
- ).toTraceArray();
+ StackTraceElement[] t =
+ new TraceBuilder()
+ .classes(
+ "org.mockito.internal.runners.Runner", "org.test.MockitoSampleTest")
+ .toTraceArray();
StackTraceElement[] filtered = filter.filter(t, false);
- Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest", "org.mockito.internal.runners.Runner"));
+ Assertions.assertThat(filtered)
+ .has(
+ onlyThoseClasses(
+ "org.test.MockitoSampleTest",
+ "org.mockito.internal.runners.Runner"));
}
@Test
public void shouldStartFilteringAndKeepTop() {
- //given
- StackTraceElement[] t = new TraceBuilder().classes(
- "org.test.Good",
- "org.mockito.internal.Bad",
- "org.test.MockitoSampleTest"
- ).toTraceArray();
+ // given
+ StackTraceElement[] t =
+ new TraceBuilder()
+ .classes(
+ "org.test.Good",
+ "org.mockito.internal.Bad",
+ "org.test.MockitoSampleTest")
+ .toTraceArray();
- //when
+ // when
StackTraceElement[] filtered = filter.filter(t, true);
- //then
- Assertions.assertThat(filtered).has(onlyThoseClasses("org.test.MockitoSampleTest", "org.test.Good"));
+ // then
+ Assertions.assertThat(filtered)
+ .has(onlyThoseClasses("org.test.MockitoSampleTest", "org.test.Good"));
}
@Test
- public void shouldKeepGoodTraceFromTheTopBecauseRealImplementationsOfSpiesSometimesThrowExceptions() {
- StackTraceElement[] t = new TraceBuilder().classes(
- "org.good.Trace",
- "org.yet.another.good.Trace",
- "org.mockito.internal.to.be.Filtered",
- "org.test.MockitoSampleTest"
- ).toTraceArray();
+ public void
+ shouldKeepGoodTraceFromTheTopBecauseRealImplementationsOfSpiesSometimesThrowExceptions() {
+ StackTraceElement[] t =
+ new TraceBuilder()
+ .classes(
+ "org.good.Trace",
+ "org.yet.another.good.Trace",
+ "org.mockito.internal.to.be.Filtered",
+ "org.test.MockitoSampleTest")
+ .toTraceArray();
StackTraceElement[] filtered = filter.filter(t, true);
- Assertions.assertThat(filtered).has(onlyThoseClasses(
- "org.test.MockitoSampleTest",
- "org.yet.another.good.Trace",
- "org.good.Trace"
- ));
+ Assertions.assertThat(filtered)
+ .has(
+ onlyThoseClasses(
+ "org.test.MockitoSampleTest",
+ "org.yet.another.good.Trace",
+ "org.good.Trace"));
}
@Test
public void shouldReturnEmptyArrayWhenInputIsEmpty() throws Exception {
- //when
+ // when
StackTraceElement[] filtered = filter.filter(new StackTraceElement[0], false);
- //then
+ // then
assertEquals(0, filtered.length);
}
}
diff --git a/src/test/java/org/mockito/internal/exceptions/util/ScenarioPrinterTest.java b/src/test/java/org/mockito/internal/exceptions/util/ScenarioPrinterTest.java
index f0e22d4..68df193 100644
--- a/src/test/java/org/mockito/internal/exceptions/util/ScenarioPrinterTest.java
+++ b/src/test/java/org/mockito/internal/exceptions/util/ScenarioPrinterTest.java
@@ -4,16 +4,17 @@
*/
package org.mockito.internal.exceptions.util;
+import static java.util.Arrays.asList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+
import org.junit.Test;
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockito.invocation.Invocation;
import org.mockitoutil.TestBase;
-import java.util.List;
-
-import static java.util.Arrays.asList;
-import static org.assertj.core.api.Assertions.assertThat;
-
@SuppressWarnings("unchecked")
public class ScenarioPrinterTest extends TestBase {
@@ -21,28 +22,26 @@
@Test
public void shouldPrintInvocations() {
- //given
+ // given
Invocation verified = new InvocationBuilder().simpleMethod().verified().toInvocation();
Invocation unverified = new InvocationBuilder().differentMethod().toInvocation();
- //when
+ // when
String out = sp.print((List) asList(verified, unverified));
- //then
- assertThat(out)
- .contains("1. -> at")
- .contains("2. [?]-> at");
+ // then
+ assertThat(out).contains("1. -> at").contains("2. [?]-> at");
}
@Test
public void shouldNotPrintInvocationsWhenSingleUnwanted() {
- //given
+ // given
Invocation unverified = new InvocationBuilder().differentMethod().toInvocation();
- //when
+ // when
String out = sp.print((List) asList(unverified));
- //then
+ // then
assertThat(out).contains("Actually, above is the only interaction with this mock.");
}
}
diff --git a/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java b/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
index ae21488..344621e 100644
--- a/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
+++ b/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
@@ -4,6 +4,21 @@
*/
package org.mockito.internal.framework;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.withSettings;
+import static org.mockitoutil.ThrowableAssert.assertThat;
+
+import java.util.List;
+import java.util.Set;
+
import org.junit.After;
import org.junit.Test;
import org.mockito.ArgumentMatchers;
@@ -17,26 +32,12 @@
import org.mockito.plugins.InlineMockMaker;
import org.mockitoutil.TestBase;
-import java.util.List;
-import java.util.Set;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockingDetails;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.withSettings;
-import static org.mockitoutil.ThrowableAssert.assertThat;
-
public class DefaultMockitoFrameworkTest extends TestBase {
private DefaultMockitoFramework framework = new DefaultMockitoFramework();
- @After public void clearListeners() {
+ @After
+ public void clearListeners() {
new StateMaster().clearMockitoListeners();
}
@@ -52,7 +53,7 @@
@Test
public void ok_to_remove_unknown_listener() {
- //it is safe to remove listener that was not added before
+ // it is safe to remove listener that was not added before
framework.removeListener(new MockitoListener() {});
}
@@ -60,26 +61,26 @@
public void ok_to_remove_listener_multiple_times() {
MockitoListener listener = new MockitoListener() {};
- //when
+ // when
framework.addListener(listener);
- //then it is ok to:
+ // then it is ok to:
framework.removeListener(listener);
framework.removeListener(listener);
}
@Test
public void adds_creation_listener() {
- //given creation listener is added
+ // given creation listener is added
MockCreationListener listener = mock(MockCreationListener.class);
framework.addListener(listener);
- //when
+ // when
MockSettings settings = withSettings().name("my list");
List mock = mock(List.class, settings);
Set mock2 = mock(Set.class);
- //then
+ // then
verify(listener).onMockCreated(eq(mock), any(MockCreationSettings.class));
verify(listener).onMockCreated(eq(mock2), any(MockCreationSettings.class));
verifyNoMoreInteractions(listener);
@@ -88,84 +89,88 @@
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
@Test
public void removes_creation_listener() {
- //given creation listener is added
+ // given creation listener is added
MockCreationListener listener = mock(MockCreationListener.class);
framework.addListener(listener);
- //and hooked up correctly
+ // and hooked up correctly
mock(List.class);
verify(listener).onMockCreated(ArgumentMatchers.any(), any(MockCreationSettings.class));
- //when
+ // when
framework.removeListener(listener);
mock(Set.class);
- //then
+ // then
verifyNoMoreInteractions(listener);
}
- @Test public void prevents_duplicate_listeners_of_the_same_type() {
- //given creation listener is added
+ @Test
+ public void prevents_duplicate_listeners_of_the_same_type() {
+ // given creation listener is added
framework.addListener(new MyListener());
- assertThat(new Runnable() {
- @Override
- public void run() {
- framework.addListener(new MyListener());
- }
- }) .throwsException(RedundantListenerException.class)
- .throwsMessage("\n" +
- "Problems adding Mockito listener.\n" +
- "Listener of type 'MyListener' has already been added and not removed.\n" +
- "It indicates that previous listener was not removed according to the API.\n" +
- "When you add a listener, don't forget to remove the listener afterwards:\n" +
- " Mockito.framework().removeListener(myListener);\n" +
- "For more information, see the javadoc for RedundantListenerException class.");
+ assertThat(
+ new Runnable() {
+ @Override
+ public void run() {
+ framework.addListener(new MyListener());
+ }
+ })
+ .throwsException(RedundantListenerException.class)
+ .throwsMessage(
+ "\n"
+ + "Problems adding Mockito listener.\n"
+ + "Listener of type 'MyListener' has already been added and not removed.\n"
+ + "It indicates that previous listener was not removed according to the API.\n"
+ + "When you add a listener, don't forget to remove the listener afterwards:\n"
+ + " Mockito.framework().removeListener(myListener);\n"
+ + "For more information, see the javadoc for RedundantListenerException class.");
}
@Test
public void clearing_all_mocks_is_safe_regardless_of_mock_maker_type() {
List mock = mock(List.class);
- //expect
+ // expect
assertTrue(mockingDetails(mock).isMock());
framework.clearInlineMocks();
}
@Test
public void clears_all_mocks() {
- //clearing mocks only works with inline mocking
+ // clearing mocks only works with inline mocking
assumeTrue(Plugins.getMockMaker() instanceof InlineMockMaker);
- //given
+ // given
List list1 = mock(List.class);
assertTrue(mockingDetails(list1).isMock());
List list2 = mock(List.class);
assertTrue(mockingDetails(list2).isMock());
- //when
+ // when
framework.clearInlineMocks();
- //then
+ // then
assertFalse(mockingDetails(list1).isMock());
assertFalse(mockingDetails(list2).isMock());
}
@Test
public void clears_mock() {
- //clearing mocks only works with inline mocking
+ // clearing mocks only works with inline mocking
assumeTrue(Plugins.getMockMaker() instanceof InlineMockMaker);
- //given
+ // given
List list1 = mock(List.class);
assertTrue(mockingDetails(list1).isMock());
List list2 = mock(List.class);
assertTrue(mockingDetails(list2).isMock());
- //when
+ // when
framework.clearInlineMock(list1);
- //then
+ // then
assertFalse(mockingDetails(list1).isMock());
assertTrue(mockingDetails(list2).isMock());
}
diff --git a/src/test/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractorTest.java b/src/test/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractorTest.java
index 1ae96ed..154a7bc 100644
--- a/src/test/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractorTest.java
+++ b/src/test/java/org/mockito/internal/hamcrest/MatcherGenericTypeExtractorTest.java
@@ -4,93 +4,106 @@
*/
package org.mockito.internal.hamcrest;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.internal.hamcrest.MatcherGenericTypeExtractor.genericTypeOfMatcher;
+
+import java.io.Serializable;
+import java.util.HashMap;
+
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.junit.Test;
import org.mockitoutil.TestBase;
-import java.io.Serializable;
-import java.util.HashMap;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.internal.hamcrest.MatcherGenericTypeExtractor.genericTypeOfMatcher;
-
public class MatcherGenericTypeExtractorTest extends TestBase {
- //traditional inner class for matcher
+ // traditional inner class for matcher
private class IntMatcher extends BaseMatcher<Integer> {
public boolean matches(Object o) {
return true;
}
+
public void describeTo(Description description) {}
}
- //static class with matcher
+ // static class with matcher
private static class StaticIntMatcher extends BaseMatcher<Integer> {
public boolean matches(Object o) {
return true;
}
+
public void describeTo(Description description) {}
}
- //static subclass
+ // static subclass
private static class StaticIntMatcherSubclass extends StaticIntMatcher {
public boolean matches(Object o) {
return true;
}
+
public void describeTo(Description description) {}
}
- //non-generic
+ // non-generic
@SuppressWarnings("rawtypes")
private static class NonGenericMatcher extends BaseMatcher {
public boolean matches(Object o) {
return true;
}
+
public void describeTo(Description description) {}
}
- //Matcher interface implementation (instead of the BaseMatcher)
+ // Matcher interface implementation (instead of the BaseMatcher)
private class IntMatcherFromInterface extends BaseMatcher<Integer> {
public boolean matches(Object o) {
return true;
}
+
public void describeMismatch(Object item, Description mismatchDescription) {}
+
public void describeTo(Description description) {}
}
- //Static Matcher interface implementation (instead of the BaseMatcher)
+ // Static Matcher interface implementation (instead of the BaseMatcher)
private static class StaticIntMatcherFromInterface extends BaseMatcher<Integer> {
public boolean matches(Object o) {
return true;
}
+
public void describeMismatch(Object item, Description mismatchDescription) {}
+
public void describeTo(Description description) {}
}
- //non-generic matcher implementing the interface
+ // non-generic matcher implementing the interface
@SuppressWarnings("rawtypes")
private static class NonGenericMatcherFromInterface extends BaseMatcher {
public boolean matches(Object o) {
return true;
}
+
public void describeMismatch(Object item, Description mismatchDescription) {}
+
public void describeTo(Description description) {}
}
private interface IMatcher extends Matcher<Integer> {}
- //non-generic matcher implementing the interface
- private static class SubclassGenericMatcherFromInterface extends BaseMatcher<Integer> implements Serializable, Cloneable, IMatcher {
+ // non-generic matcher implementing the interface
+ private static class SubclassGenericMatcherFromInterface extends BaseMatcher<Integer>
+ implements Serializable, Cloneable, IMatcher {
public boolean matches(Object o) {
return true;
}
+
public void describeMismatch(Object item, Description mismatchDescription) {}
+
public void describeTo(Description description) {}
}
- //I refuse to comment on the sanity of this case
+ // I refuse to comment on the sanity of this case
private static class InsaneEdgeCase extends SubclassGenericMatcherFromInterface {}
@Test
@@ -101,34 +114,39 @@
assertEquals(Integer.class, genericTypeOfMatcher(StaticIntMatcherSubclass.class));
assertEquals(Integer.class, genericTypeOfMatcher(IntMatcherFromInterface.class));
assertEquals(Integer.class, genericTypeOfMatcher(StaticIntMatcherFromInterface.class));
- assertEquals(Integer.class, genericTypeOfMatcher(SubclassGenericMatcherFromInterface.class));
+ assertEquals(
+ Integer.class, genericTypeOfMatcher(SubclassGenericMatcherFromInterface.class));
assertEquals(Integer.class, genericTypeOfMatcher(InsaneEdgeCase.class));
- assertEquals(Integer.class, genericTypeOfMatcher(new BaseMatcher<Integer>() {
- public void describeTo(Description description) {
- }
+ assertEquals(
+ Integer.class,
+ genericTypeOfMatcher(
+ new BaseMatcher<Integer>() {
+ public void describeTo(Description description) {}
- public boolean matches(Object o) {
- return false;
- }
- }.getClass()));
- assertEquals(Integer.class, genericTypeOfMatcher(new BaseMatcher<Integer>() {
- public void describeTo(Description description) {
- }
+ public boolean matches(Object o) {
+ return false;
+ }
+ }.getClass()));
+ assertEquals(
+ Integer.class,
+ genericTypeOfMatcher(
+ new BaseMatcher<Integer>() {
+ public void describeTo(Description description) {}
- public boolean matches(Object o) {
- return false;
- }
+ public boolean matches(Object o) {
+ return false;
+ }
- public void describeMismatch(Object item, Description mismatchDescription) {
- }
- }.getClass()));
+ public void describeMismatch(
+ Object item, Description mismatchDescription) {}
+ }.getClass()));
assertEquals(Object.class, genericTypeOfMatcher(Object.class));
assertEquals(Object.class, genericTypeOfMatcher(String.class));
assertEquals(Object.class, genericTypeOfMatcher(HashMap.class));
- assertEquals(Object.class, genericTypeOfMatcher(new HashMap<String, String>() {
- }.getClass()));
+ assertEquals(
+ Object.class, genericTypeOfMatcher(new HashMap<String, String>() {}.getClass()));
assertEquals(Object.class, genericTypeOfMatcher(NonGenericMatcher.class));
assertEquals(Object.class, genericTypeOfMatcher(NonGenericMatcherFromInterface.class));
}
diff --git a/src/test/java/org/mockito/internal/handler/InvocationNotifierHandlerTest.java b/src/test/java/org/mockito/internal/handler/InvocationNotifierHandlerTest.java
index 8fe818d..a95921b 100644
--- a/src/test/java/org/mockito/internal/handler/InvocationNotifierHandlerTest.java
+++ b/src/test/java/org/mockito/internal/handler/InvocationNotifierHandlerTest.java
@@ -4,6 +4,17 @@
*/
package org.mockito.internal.handler;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.willThrow;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import java.text.ParseException;
+import java.util.ArrayList;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -18,18 +29,6 @@
import org.mockito.mock.MockCreationSettings;
import org.mockito.stubbing.Answer;
-import java.text.ParseException;
-import java.util.ArrayList;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.BDDMockito.willThrow;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-
@RunWith(MockitoJUnitRunner.class)
@SuppressWarnings("unchecked")
public class InvocationNotifierHandlerTest {
@@ -38,7 +37,6 @@
private static final OutOfMemoryError SOME_ERROR = new OutOfMemoryError();
private static final Answer<?> SOME_ANSWER = mock(Answer.class);
-
@Mock private InvocationListener listener1;
@Mock private InvocationListener listener2;
@Spy private CustomListener customListener;
@@ -50,10 +48,12 @@
@Before
public void setUp() throws Exception {
- notifier = new InvocationNotifierHandler<ArrayList<Answer<?>>>(
- mockHandler,
- (MockCreationSettings<ArrayList<Answer<?>>>) new MockSettingsImpl<ArrayList<Answer<?>>>().invocationListeners(customListener, listener1, listener2)
- );
+ notifier =
+ new InvocationNotifierHandler<ArrayList<Answer<?>>>(
+ mockHandler,
+ (MockCreationSettings<ArrayList<Answer<?>>>)
+ new MockSettingsImpl<ArrayList<Answer<?>>>()
+ .invocationListeners(customListener, listener1, listener2));
}
@Test
@@ -65,12 +65,15 @@
notifier.handle(invocation);
// then
- verify(listener1).reportInvocation(new NotifiedMethodInvocationReport(invocation, "returned value"));
- verify(listener2).reportInvocation(new NotifiedMethodInvocationReport(invocation, "returned value"));
+ verify(listener1)
+ .reportInvocation(new NotifiedMethodInvocationReport(invocation, "returned value"));
+ verify(listener2)
+ .reportInvocation(new NotifiedMethodInvocationReport(invocation, "returned value"));
}
@Test
- public void should_notify_all_listeners_when_called_delegate_handler_returns_ex() throws Throwable {
+ public void should_notify_all_listeners_when_called_delegate_handler_returns_ex()
+ throws Throwable {
// given
Exception computedException = new Exception("computed");
given(mockHandler.handle(invocation)).willReturn(computedException);
@@ -79,12 +82,18 @@
notifier.handle(invocation);
// then
- verify(listener1).reportInvocation(new NotifiedMethodInvocationReport(invocation, (Object) computedException));
- verify(listener2).reportInvocation(new NotifiedMethodInvocationReport(invocation, (Object) computedException));
+ verify(listener1)
+ .reportInvocation(
+ new NotifiedMethodInvocationReport(invocation, (Object) computedException));
+ verify(listener2)
+ .reportInvocation(
+ new NotifiedMethodInvocationReport(invocation, (Object) computedException));
}
@Test(expected = ParseException.class)
- public void should_notify_all_listeners_when_called_delegate_handler_throws_exception_and_rethrow_it() throws Throwable {
+ public void
+ should_notify_all_listeners_when_called_delegate_handler_throws_exception_and_rethrow_it()
+ throws Throwable {
// given
ParseException parseException = new ParseException("", 0);
given(mockHandler.handle(invocation)).willThrow(parseException);
@@ -95,14 +104,20 @@
fail();
} finally {
// then
- verify(listener1).reportInvocation(new NotifiedMethodInvocationReport(invocation, parseException));
- verify(listener2).reportInvocation(new NotifiedMethodInvocationReport(invocation, parseException));
+ verify(listener1)
+ .reportInvocation(
+ new NotifiedMethodInvocationReport(invocation, parseException));
+ verify(listener2)
+ .reportInvocation(
+ new NotifiedMethodInvocationReport(invocation, parseException));
}
}
@Test
public void should_report_listener_exception() throws Throwable {
- willThrow(new NullPointerException()).given(customListener).reportInvocation(any(MethodInvocationReport.class));
+ willThrow(new NullPointerException())
+ .given(customListener)
+ .reportInvocation(any(MethodInvocationReport.class));
try {
notifier.handle(invocation);
@@ -117,7 +132,8 @@
}
@Test
- public void should_delegate_all_MockHandlerInterface_to_the_parameterized_MockHandler() throws Exception {
+ public void should_delegate_all_MockHandlerInterface_to_the_parameterized_MockHandler()
+ throws Exception {
notifier.getInvocationContainer();
notifier.getMockSettings();
diff --git a/src/test/java/org/mockito/internal/handler/MockHandlerFactoryTest.java b/src/test/java/org/mockito/internal/handler/MockHandlerFactoryTest.java
index 890a8cb..d82bc78 100644
--- a/src/test/java/org/mockito/internal/handler/MockHandlerFactoryTest.java
+++ b/src/test/java/org/mockito/internal/handler/MockHandlerFactoryTest.java
@@ -4,6 +4,10 @@
*/
package org.mockito.internal.handler;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.internal.handler.MockHandlerFactory.createMockHandler;
+
import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.internal.creation.MockSettingsImpl;
@@ -14,10 +18,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.internal.handler.MockHandlerFactory.createMockHandler;
-
/**
* by Szczepan Faber, created at: 5/22/12
*/
@@ -26,37 +26,39 @@
private final IMethods mock = Mockito.mock(IMethods.class);
@Test
- //see issue 331
+ // see issue 331
public void handle_result_must_not_be_null_for_primitives() throws Throwable {
- //given:
- MockCreationSettings<?> settings = (MockCreationSettings<?>) new MockSettingsImpl().defaultAnswer(new Returns(null));
- MockHandler<?> handler = createMockHandler(settings);
+ // given:
+ MockCreationSettings<?> settings =
+ (MockCreationSettings<?>) new MockSettingsImpl().defaultAnswer(new Returns(null));
+ MockHandler<?> handler = createMockHandler(settings);
mock.intReturningMethod();
Invocation invocation = super.getLastInvocation();
- //when:
+ // when:
Object result = handler.handle(invocation);
- //then null value is not a valid result for a primitive
+ // then null value is not a valid result for a primitive
assertNotNull(result);
assertEquals(0, result);
}
@Test
- //see issue 331
+ // see issue 331
public void valid_handle_result_is_permitted() throws Throwable {
- //given:
- MockCreationSettings<?> settings = (MockCreationSettings<?>) new MockSettingsImpl().defaultAnswer(new Returns(123));
- MockHandler<?> handler = createMockHandler(settings);
+ // given:
+ MockCreationSettings<?> settings =
+ (MockCreationSettings<?>) new MockSettingsImpl().defaultAnswer(new Returns(123));
+ MockHandler<?> handler = createMockHandler(settings);
mock.intReturningMethod();
Invocation invocation = super.getLastInvocation();
- //when:
+ // when:
Object result = handler.handle(invocation);
- //then
+ // then
assertEquals(123, result);
}
}
diff --git a/src/test/java/org/mockito/internal/handler/MockHandlerImplTest.java b/src/test/java/org/mockito/internal/handler/MockHandlerImplTest.java
index 31e1fe6..c0fed25 100644
--- a/src/test/java/org/mockito/internal/handler/MockHandlerImplTest.java
+++ b/src/test/java/org/mockito/internal/handler/MockHandlerImplTest.java
@@ -2,9 +2,18 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.handler;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+
+import java.util.Arrays;
+
import org.junit.Test;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;
@@ -23,20 +32,11 @@
import org.mockito.listeners.MethodInvocationReport;
import org.mockitoutil.TestBase;
-import java.util.Arrays;
-
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-
@SuppressWarnings({"unchecked", "serial"})
public class MockHandlerImplTest extends TestBase {
- private StubbedInvocationMatcher stubbedInvocationMatcher = mock(StubbedInvocationMatcher.class);
+ private StubbedInvocationMatcher stubbedInvocationMatcher =
+ mock(StubbedInvocationMatcher.class);
private Invocation invocation = mock(Invocation.class);
@Test
@@ -46,11 +46,13 @@
@SuppressWarnings("rawtypes")
MockHandlerImpl<?> handler = new MockHandlerImpl(new MockSettingsImpl());
mockingProgress().verificationStarted(VerificationModeFactory.atLeastOnce());
- handler.matchersBinder = new MatchersBinder() {
- public InvocationMatcher bindMatchers(ArgumentMatcherStorage argumentMatcherStorage, Invocation invocation) {
- throw new InvalidUseOfMatchersException();
- }
- };
+ handler.matchersBinder =
+ new MatchersBinder() {
+ public InvocationMatcher bindMatchers(
+ ArgumentMatcherStorage argumentMatcherStorage, Invocation invocation) {
+ throw new InvalidUseOfMatchersException();
+ }
+ };
try {
// when
@@ -64,12 +66,14 @@
assertNull(mockingProgress().pullVerificationMode());
}
-
@Test(expected = MockitoException.class)
- public void should_throw_mockito_exception_when_invocation_handler_throws_anything() throws Throwable {
+ public void should_throw_mockito_exception_when_invocation_handler_throws_anything()
+ throws Throwable {
// given
InvocationListener throwingListener = mock(InvocationListener.class);
- doThrow(new Throwable()).when(throwingListener).reportInvocation(any(MethodInvocationReport.class));
+ doThrow(new Throwable())
+ .when(throwingListener)
+ .reportInvocation(any(MethodInvocationReport.class));
MockHandlerImpl<?> handler = create_correctly_stubbed_handler(throwingListener);
// when
@@ -83,12 +87,16 @@
given(mockSettings.getDefaultAnswer()).willReturn(new Returns(AWrongType.WRONG_TYPE));
@SuppressWarnings("unused") // otherwise cast is not done
- String there_should_not_be_a_CCE_here = (String) handler.handle(
- new InvocationBuilder().method(Object.class.getDeclaredMethod("toString")).toInvocation()
- );
+ String there_should_not_be_a_CCE_here =
+ (String)
+ handler.handle(
+ new InvocationBuilder()
+ .method(Object.class.getDeclaredMethod("toString"))
+ .toInvocation());
}
- private MockHandlerImpl<?> create_correctly_stubbed_handler(InvocationListener throwingListener) {
+ private MockHandlerImpl<?> create_correctly_stubbed_handler(
+ InvocationListener throwingListener) {
MockHandlerImpl<?> handler = create_handler_with_listeners(throwingListener);
stub_ordinary_invocation_with_given_return_value(handler);
return handler;
@@ -98,18 +106,18 @@
stub_ordinary_invocation_with_invocation_matcher(handler, stubbedInvocationMatcher);
}
-
- private void stub_ordinary_invocation_with_invocation_matcher(MockHandlerImpl<?> handler, StubbedInvocationMatcher value) {
+ private void stub_ordinary_invocation_with_invocation_matcher(
+ MockHandlerImpl<?> handler, StubbedInvocationMatcher value) {
handler.invocationContainer = mock(InvocationContainerImpl.class);
given(handler.invocationContainer.findAnswerFor(any(Invocation.class))).willReturn(value);
}
-
private MockHandlerImpl<?> create_handler_with_listeners(InvocationListener... listener) {
@SuppressWarnings("rawtypes")
MockHandlerImpl<?> handler = new MockHandlerImpl(mock(MockSettingsImpl.class));
handler.matchersBinder = mock(MatchersBinder.class);
- given(handler.getMockSettings().getInvocationListeners()).willReturn(Arrays.asList(listener));
+ given(handler.getMockSettings().getInvocationListeners())
+ .willReturn(Arrays.asList(listener));
return handler;
}
diff --git a/src/test/java/org/mockito/internal/invocation/InvocationBuilder.java b/src/test/java/org/mockito/internal/invocation/InvocationBuilder.java
index b3106a6..281d41b 100644
--- a/src/test/java/org/mockito/internal/invocation/InvocationBuilder.java
+++ b/src/test/java/org/mockito/internal/invocation/InvocationBuilder.java
@@ -2,22 +2,23 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation;
-import org.mockito.Mockito;
-import org.mockito.internal.invocation.mockref.MockStrongReference;
-import org.mockito.internal.debugging.LocationImpl;
-import org.mockito.invocation.Invocation;
-import org.mockito.invocation.Location;
-import org.mockitousage.IMethods;
+import static java.util.Arrays.asList;
+
+import static org.mockito.internal.invocation.InterceptedInvocation.NO_OP;
import java.lang.reflect.Method;
import java.util.LinkedList;
import java.util.List;
-import static java.util.Arrays.asList;
-import static org.mockito.internal.invocation.InterceptedInvocation.NO_OP;
+import org.mockito.Mockito;
+import org.mockito.internal.debugging.LocationImpl;
+import org.mockito.internal.invocation.mockref.MockReference;
+import org.mockito.internal.invocation.mockref.MockStrongReference;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.Location;
+import org.mockitousage.IMethods;
/**
* Build an invocation.
@@ -27,7 +28,7 @@
private String methodName = "simpleMethod";
private int sequenceNumber = 0;
- private Object[] args = new Object[]{};
+ private Object[] args = new Object[] {};
private Object mock = Mockito.mock(IMethods.class);
private Method method;
private boolean verified;
@@ -55,24 +56,40 @@
}
try {
- method = IMethods.class.getMethod(methodName, argTypes.toArray(new Class[argTypes.size()]));
+ method =
+ IMethods.class.getMethod(
+ methodName, argTypes.toArray(new Class[argTypes.size()]));
} catch (Exception e) {
- throw new RuntimeException("builder only creates invocations of IMethods interface", e);
+ throw new RuntimeException(
+ "builder only creates invocations of IMethods interface", e);
}
}
- Invocation i = new InterceptedInvocation(new MockStrongReference<Object>(mock, false),
- new SerializableMethod(method),
- args,
- NO_OP,
- location == null ? new LocationImpl() : location,
- 1);
+ Invocation i =
+ createInvocation(
+ new MockStrongReference<Object>(mock, false),
+ new SerializableMethod(method),
+ args,
+ NO_OP,
+ location == null ? new LocationImpl() : location,
+ 1);
if (verified) {
i.markVerified();
}
return i;
}
+ protected Invocation createInvocation(
+ MockReference<Object> mockRef,
+ MockitoMethod mockitoMethod,
+ Object[] arguments,
+ RealMethod realMethod,
+ Location location,
+ int sequenceNumber) {
+ return new InterceptedInvocation(
+ mockRef, mockitoMethod, arguments, realMethod, location, sequenceNumber);
+ }
+
public InvocationBuilder method(String methodName) {
this.methodName = methodName;
return this;
@@ -89,7 +106,7 @@
}
public InvocationBuilder arg(Object o) {
- this.args = new Object[]{o};
+ this.args = new Object[] {o};
return this;
}
@@ -126,11 +143,16 @@
}
public InvocationBuilder location(final String location) {
- this.location = new Location() {
- public String toString() {
- return location;
- }
- };
+ this.location =
+ new Location() {
+ public String toString() {
+ return location;
+ }
+
+ public String getSourceFile() {
+ return "SomeClass";
+ }
+ };
return this;
}
}
diff --git a/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java b/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java
index 6d48b96..55b721e 100644
--- a/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java
+++ b/src/test/java/org/mockito/internal/invocation/InvocationMarkerTest.java
@@ -4,53 +4,55 @@
*/
package org.mockito.internal.invocation;
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicReference;
+
import org.junit.Test;
import org.mockito.internal.verification.InOrderContextImpl;
import org.mockito.invocation.Invocation;
import org.mockito.invocation.MatchableInvocation;
import org.mockitoutil.TestBase;
-import java.util.Arrays;
-import java.util.concurrent.atomic.AtomicReference;
-
-import static org.junit.Assert.*;
-
public class InvocationMarkerTest extends TestBase {
@Test
public void shouldMarkInvocationAsVerified() {
- //given
+ // given
Invocation i = new InvocationBuilder().toInvocation();
InvocationMatcher im = new InvocationBuilder().toInvocationMatcher();
assertFalse(i.isVerified());
- //when
+ // when
InvocationMarker.markVerified(Arrays.asList(i), im);
- //then
+ // then
assertTrue(i.isVerified());
}
@Test
public void shouldCaptureArguments() {
- //given
+ // given
Invocation i = new InvocationBuilder().toInvocation();
final AtomicReference<Invocation> box = new AtomicReference<Invocation>();
- MatchableInvocation c = new InvocationMatcher(i) {
- public void captureArgumentsFrom(Invocation i) {
- box.set(i);
- }};
+ MatchableInvocation c =
+ new InvocationMatcher(i) {
+ public void captureArgumentsFrom(Invocation i) {
+ box.set(i);
+ }
+ };
- //when
+ // when
InvocationMarker.markVerified(Arrays.asList(i), c);
- //then
+ // then
assertEquals(i, box.get());
}
@Test
public void shouldMarkInvocationsAsVerifiedInOrder() {
- //given
+ // given
InOrderContextImpl context = new InOrderContextImpl();
Invocation i = new InvocationBuilder().toInvocation();
@@ -58,10 +60,10 @@
assertFalse(context.isVerified(i));
assertFalse(i.isVerified());
- //when
+ // when
InvocationMarker.markVerifiedInOrder(Arrays.asList(i), im, context);
- //then
+ // then
assertTrue(context.isVerified(i));
assertTrue(i.isVerified());
}
diff --git a/src/test/java/org/mockito/internal/invocation/InvocationMatcherTest.java b/src/test/java/org/mockito/internal/invocation/InvocationMatcherTest.java
index 7ef9406..0b3d09d 100644
--- a/src/test/java/org/mockito/internal/invocation/InvocationMatcherTest.java
+++ b/src/test/java/org/mockito/internal/invocation/InvocationMatcherTest.java
@@ -2,14 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation;
import static java.util.Arrays.asList;
+
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.internal.matchers.Any.ANY;
import java.lang.reflect.Method;
@@ -17,6 +17,7 @@
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+
import org.assertj.core.api.Assertions;
import org.junit.Before;
import org.junit.Test;
@@ -54,8 +55,10 @@
@Test
public void should_not_equal_if_number_of_arguments_differ() throws Exception {
- InvocationMatcher withOneArg = new InvocationMatcher(new InvocationBuilder().args("test").toInvocation());
- InvocationMatcher withTwoArgs = new InvocationMatcher(new InvocationBuilder().args("test", 100).toInvocation());
+ InvocationMatcher withOneArg =
+ new InvocationMatcher(new InvocationBuilder().args("test").toInvocation());
+ InvocationMatcher withTwoArgs =
+ new InvocationMatcher(new InvocationBuilder().args("test", 100).toInvocation());
assertFalse(withOneArg.equals(null));
assertFalse(withOneArg.equals(withTwoArgs));
@@ -64,9 +67,11 @@
@Test
public void should_to_string_with_matchers() throws Exception {
ArgumentMatcher m = NotNull.NOT_NULL;
- InvocationMatcher notNull = new InvocationMatcher(new InvocationBuilder().toInvocation(), asList(m));
+ InvocationMatcher notNull =
+ new InvocationMatcher(new InvocationBuilder().toInvocation(), asList(m));
ArgumentMatcher mTwo = new Equals('x');
- InvocationMatcher equals = new InvocationMatcher(new InvocationBuilder().toInvocation(), asList(mTwo));
+ InvocationMatcher equals =
+ new InvocationMatcher(new InvocationBuilder().toInvocation(), asList(mTwo));
assertThat(notNull.toString()).contains("simpleMethod(notNull())");
assertThat(equals.toString()).contains("simpleMethod('x')");
@@ -89,19 +94,23 @@
@Test
public void should_not_be_similar_if_mocks_are_different() throws Exception {
- Invocation onDifferentMock = new InvocationBuilder().simpleMethod().mock("different mock").toInvocation();
+ Invocation onDifferentMock =
+ new InvocationBuilder().simpleMethod().mock("different mock").toInvocation();
assertFalse(simpleMethod.hasSimilarMethod(onDifferentMock));
}
@Test
- public void should_not_be_similar_if_is_overloaded_but_used_with_the_same_arg() throws Exception {
+ public void should_not_be_similar_if_is_overloaded_but_used_with_the_same_arg()
+ throws Exception {
Method method = IMethods.class.getMethod("simpleMethod", String.class);
Method overloadedMethod = IMethods.class.getMethod("simpleMethod", Object.class);
String sameArg = "test";
- InvocationMatcher invocation = new InvocationBuilder().method(method).arg(sameArg).toInvocationMatcher();
- Invocation overloadedInvocation = new InvocationBuilder().method(overloadedMethod).arg(sameArg).toInvocation();
+ InvocationMatcher invocation =
+ new InvocationBuilder().method(method).arg(sameArg).toInvocationMatcher();
+ Invocation overloadedInvocation =
+ new InvocationBuilder().method(overloadedMethod).arg(sameArg).toInvocation();
assertFalse(invocation.hasSimilarMethod(overloadedInvocation));
}
@@ -111,76 +120,84 @@
Method method = IMethods.class.getMethod("simpleMethod", String.class);
Method overloadedMethod = IMethods.class.getMethod("simpleMethod", Object.class);
- InvocationMatcher invocation = new InvocationBuilder().mock(mock).method(method).arg("foo").toInvocationMatcher();
- Invocation overloadedInvocation = new InvocationBuilder().mock(mock).method(overloadedMethod).arg("bar").toInvocation();
+ InvocationMatcher invocation =
+ new InvocationBuilder().mock(mock).method(method).arg("foo").toInvocationMatcher();
+ Invocation overloadedInvocation =
+ new InvocationBuilder()
+ .mock(mock)
+ .method(overloadedMethod)
+ .arg("bar")
+ .toInvocation();
assertTrue(invocation.hasSimilarMethod(overloadedInvocation));
}
@Test
public void should_capture_arguments_from_invocation() throws Exception {
- //given
+ // given
Invocation invocation = new InvocationBuilder().args("1", 100).toInvocation();
CapturingMatcher capturingMatcher = new CapturingMatcher();
- InvocationMatcher invocationMatcher = new InvocationMatcher(invocation, (List) asList(new Equals("1"), capturingMatcher));
+ InvocationMatcher invocationMatcher =
+ new InvocationMatcher(invocation, (List) asList(new Equals("1"), capturingMatcher));
- //when
+ // when
invocationMatcher.captureArgumentsFrom(invocation);
- //then
+ // then
assertEquals(1, capturingMatcher.getAllValues().size());
assertEquals(100, capturingMatcher.getLastValue());
}
@Test
public void should_match_varargs_using_any_varargs() throws Exception {
- //given
+ // given
mock.varargs("1", "2");
Invocation invocation = getLastInvocation();
InvocationMatcher invocationMatcher = new InvocationMatcher(invocation, (List) asList(ANY));
- //when
+ // when
boolean match = invocationMatcher.matches(invocation);
- //then
+ // then
assertTrue(match);
}
@Test
public void should_capture_varargs_as_vararg() throws Exception {
- //given
+ // given
mock.mixedVarargs(1, "a", "b");
Invocation invocation = getLastInvocation();
CapturingMatcher m = new CapturingMatcher();
- InvocationMatcher invocationMatcher = new InvocationMatcher(invocation, Arrays.<ArgumentMatcher>asList(new Equals(1), m));
+ InvocationMatcher invocationMatcher =
+ new InvocationMatcher(invocation, Arrays.<ArgumentMatcher>asList(new Equals(1), m));
- //when
+ // when
invocationMatcher.captureArgumentsFrom(invocation);
- //then
+ // then
Assertions.assertThat(m.getAllValues()).containsExactly("a", "b");
}
- @Test // like using several time the captor in the vararg
+ @Test // like using several time the captor in the vararg
public void should_capture_arguments_when_args_count_does_NOT_match() throws Exception {
- //given
+ // given
mock.varargs();
Invocation invocation = getLastInvocation();
- //when
- InvocationMatcher invocationMatcher = new InvocationMatcher(invocation,(List) asList(ANY));
+ // when
+ InvocationMatcher invocationMatcher = new InvocationMatcher(invocation, (List) asList(ANY));
- //then
+ // then
invocationMatcher.captureArgumentsFrom(invocation);
}
@Test
public void should_create_from_invocations() throws Exception {
- //given
+ // given
Invocation i = new InvocationBuilder().toInvocation();
- //when
+ // when
List<InvocationMatcher> out = InvocationMatcher.createFrom(asList(i));
- //then
+ // then
assertEquals(1, out.size());
assertEquals(i, out.get(0).getInvocation());
}
diff --git a/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java b/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java
index 7172998..fd02ac5 100644
--- a/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java
+++ b/src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java
@@ -2,9 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.invocation;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
import org.assertj.core.api.Assertions;
import org.junit.Before;
import org.junit.Test;
@@ -16,16 +24,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-
-
public class InvocationsFinderTest extends TestBase {
private LinkedList<Invocation> invocations = new LinkedList<Invocation>();
@@ -33,26 +31,36 @@
private Invocation simpleMethodInvocationTwo;
private Invocation differentMethodInvocation;
-
private final InOrderContext context = new InOrderContextImpl();
@Mock private IMethods mock;
@Before
public void setup() throws Exception {
- simpleMethodInvocation = new InvocationBuilder().mock(mock).simpleMethod().seq(1).toInvocation();
- simpleMethodInvocationTwo = new InvocationBuilder().mock(mock).simpleMethod().seq(2).toInvocation();
- differentMethodInvocation = new InvocationBuilder().mock(mock).differentMethod().seq(3).toInvocation();
- invocations.addAll(Arrays.asList(simpleMethodInvocation, simpleMethodInvocationTwo, differentMethodInvocation));
-
+ simpleMethodInvocation =
+ new InvocationBuilder().mock(mock).simpleMethod().seq(1).toInvocation();
+ simpleMethodInvocationTwo =
+ new InvocationBuilder().mock(mock).simpleMethod().seq(2).toInvocation();
+ differentMethodInvocation =
+ new InvocationBuilder().mock(mock).differentMethod().seq(3).toInvocation();
+ invocations.addAll(
+ Arrays.asList(
+ simpleMethodInvocation,
+ simpleMethodInvocationTwo,
+ differentMethodInvocation));
}
@Test
public void shouldFindActualInvocations() throws Exception {
- List<Invocation> actual = InvocationsFinder.findInvocations(invocations, new InvocationMatcher(simpleMethodInvocation));
- Assertions.assertThat(actual).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
+ List<Invocation> actual =
+ InvocationsFinder.findInvocations(
+ invocations, new InvocationMatcher(simpleMethodInvocation));
+ Assertions.assertThat(actual)
+ .containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
- actual = InvocationsFinder.findInvocations(invocations, new InvocationMatcher(differentMethodInvocation));
+ actual =
+ InvocationsFinder.findInvocations(
+ invocations, new InvocationMatcher(differentMethodInvocation));
Assertions.assertThat(actual).containsSequence(differentMethodInvocation);
}
@@ -71,60 +79,75 @@
@Test
public void shouldFindFirstUnverifiedInOrder() throws Exception {
- //given
+ // given
InOrderContextImpl context = new InOrderContextImpl();
- assertSame(simpleMethodInvocation, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
+ assertSame(
+ simpleMethodInvocation,
+ InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
- //when
+ // when
context.markVerified(simpleMethodInvocationTwo);
context.markVerified(simpleMethodInvocation);
- //then
- assertSame(differentMethodInvocation, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
+ // then
+ assertSame(
+ differentMethodInvocation,
+ InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
- //when
+ // when
context.markVerified(differentMethodInvocation);
- //then
+ // then
assertNull(InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
}
@Test
public void shouldFindFirstUnverifiedInOrderAndRespectSequenceNumber() throws Exception {
- //given
+ // given
InOrderContextImpl context = new InOrderContextImpl();
- assertSame(simpleMethodInvocation, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
+ assertSame(
+ simpleMethodInvocation,
+ InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
- //when
- //skipping verification of first invocation, then:
+ // when
+ // skipping verification of first invocation, then:
context.markVerified(simpleMethodInvocationTwo);
context.markVerified(differentMethodInvocation);
- //then
+ // then
assertSame(null, InvocationsFinder.findFirstUnverifiedInOrder(context, invocations));
}
@Test
public void shouldFindFirstUnverifiedInvocationOnMock() throws Exception {
- assertSame(simpleMethodInvocation, InvocationsFinder.findFirstUnverified(invocations, simpleMethodInvocation.getMock()));
+ assertSame(
+ simpleMethodInvocation,
+ InvocationsFinder.findFirstUnverified(
+ invocations, simpleMethodInvocation.getMock()));
assertNull(InvocationsFinder.findFirstUnverified(invocations, "different mock"));
}
@Test
public void shouldFindFirstSimilarInvocationByName() throws Exception {
- Invocation overloadedSimpleMethod = new InvocationBuilder().mock(mock).simpleMethod().arg("test").toInvocation();
+ Invocation overloadedSimpleMethod =
+ new InvocationBuilder().mock(mock).simpleMethod().arg("test").toInvocation();
- Invocation found = InvocationsFinder.findSimilarInvocation(invocations, new InvocationMatcher(overloadedSimpleMethod));
+ Invocation found =
+ InvocationsFinder.findSimilarInvocation(
+ invocations, new InvocationMatcher(overloadedSimpleMethod));
assertSame(found, simpleMethodInvocation);
}
@Test
public void shouldFindInvocationWithTheSameMethod() throws Exception {
- Invocation overloadedDifferentMethod = new InvocationBuilder().differentMethod().arg("test").toInvocation();
+ Invocation overloadedDifferentMethod =
+ new InvocationBuilder().differentMethod().arg("test").toInvocation();
invocations.add(overloadedDifferentMethod);
- Invocation found = InvocationsFinder.findSimilarInvocation(invocations, new InvocationMatcher(overloadedDifferentMethod));
+ Invocation found =
+ InvocationsFinder.findSimilarInvocation(
+ invocations, new InvocationMatcher(overloadedDifferentMethod));
assertSame(found, overloadedDifferentMethod);
}
@@ -138,22 +161,32 @@
@Test
public void shouldFindAllMatchingUnverifiedChunks() throws Exception {
- List<Invocation> allMatching = InvocationsFinder.findAllMatchingUnverifiedChunks(invocations, new InvocationMatcher(simpleMethodInvocation), context);
- Assertions.assertThat(allMatching).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
+ List<Invocation> allMatching =
+ InvocationsFinder.findAllMatchingUnverifiedChunks(
+ invocations, new InvocationMatcher(simpleMethodInvocation), context);
+ Assertions.assertThat(allMatching)
+ .containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
context.markVerified(simpleMethodInvocation);
- allMatching = InvocationsFinder.findAllMatchingUnverifiedChunks(invocations, new InvocationMatcher(simpleMethodInvocation), context);
+ allMatching =
+ InvocationsFinder.findAllMatchingUnverifiedChunks(
+ invocations, new InvocationMatcher(simpleMethodInvocation), context);
Assertions.assertThat(allMatching).containsSequence(simpleMethodInvocationTwo);
context.markVerified(simpleMethodInvocationTwo);
- allMatching = InvocationsFinder.findAllMatchingUnverifiedChunks(invocations, new InvocationMatcher(simpleMethodInvocation), context);
+ allMatching =
+ InvocationsFinder.findAllMatchingUnverifiedChunks(
+ invocations, new InvocationMatcher(simpleMethodInvocation), context);
assertTrue(allMatching.isEmpty());
}
@Test
public void shouldFindMatchingChunk() throws Exception {
- List<Invocation> chunk = InvocationsFinder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 2, context);
- Assertions.assertThat(chunk).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
+ List<Invocation> chunk =
+ InvocationsFinder.findMatchingChunk(
+ invocations, new InvocationMatcher(simpleMethodInvocation), 2, context);
+ Assertions.assertThat(chunk)
+ .containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo);
}
@Test
@@ -161,8 +194,14 @@
Invocation simpleMethodInvocationThree = new InvocationBuilder().mock(mock).toInvocation();
invocations.add(simpleMethodInvocationThree);
- List<Invocation> chunk = InvocationsFinder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 1, context);
- Assertions.assertThat(chunk).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo, simpleMethodInvocationThree);
+ List<Invocation> chunk =
+ InvocationsFinder.findMatchingChunk(
+ invocations, new InvocationMatcher(simpleMethodInvocation), 1, context);
+ Assertions.assertThat(chunk)
+ .containsSequence(
+ simpleMethodInvocation,
+ simpleMethodInvocationTwo,
+ simpleMethodInvocationThree);
}
@Test
@@ -170,8 +209,14 @@
Invocation simpleMethodInvocationThree = new InvocationBuilder().mock(mock).toInvocation();
invocations.add(simpleMethodInvocationThree);
- List<Invocation> chunk = InvocationsFinder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 1, context);
- Assertions.assertThat(chunk).containsSequence(simpleMethodInvocation, simpleMethodInvocationTwo, simpleMethodInvocationThree);
+ List<Invocation> chunk =
+ InvocationsFinder.findMatchingChunk(
+ invocations, new InvocationMatcher(simpleMethodInvocation), 1, context);
+ Assertions.assertThat(chunk)
+ .containsSequence(
+ simpleMethodInvocation,
+ simpleMethodInvocationTwo,
+ simpleMethodInvocationThree);
}
@Test
@@ -189,11 +234,17 @@
@Test
public void shouldFindAllStackTraces() {
List<Location> all = InvocationsFinder.getAllLocations(invocations);
- Assertions.assertThat(all).contains(simpleMethodInvocation.getLocation(), simpleMethodInvocationTwo.getLocation(), differentMethodInvocation.getLocation());
+ Assertions.assertThat(all)
+ .contains(
+ simpleMethodInvocation.getLocation(),
+ simpleMethodInvocationTwo.getLocation(),
+ differentMethodInvocation.getLocation());
}
@Test
public void shouldNotFindLocationsForEmptyInvocationsList() {
- Assertions.assertThat(InvocationsFinder.getAllLocations(Collections.<Invocation>emptyList())).isEmpty();
+ Assertions.assertThat(
+ InvocationsFinder.getAllLocations(Collections.<Invocation>emptyList()))
+ .isEmpty();
}
}
diff --git a/src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java b/src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java
index 46a75eb..b79a1fc 100644
--- a/src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java
+++ b/src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java
@@ -5,9 +5,10 @@
package org.mockito.internal.invocation;
import static java.util.Arrays.asList;
+
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.internal.invocation.MatcherApplicationStrategy.getMatcherApplicationStrategyFor;
import static org.mockito.internal.matchers.Any.ANY;
@@ -32,8 +33,7 @@
@SuppressWarnings("unchecked")
public class MatcherApplicationStrategyTest extends TestBase {
- @Mock
- IMethods mock;
+ @Mock IMethods mock;
private Invocation invocation;
private List matchers;
@@ -51,7 +51,9 @@
matchers = asList(new Equals("1"));
// when
- boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(RETURN_ALWAYS_FALSE);
+ boolean match =
+ getMatcherApplicationStrategyFor(invocation, matchers)
+ .forEachMatcherAndArgument(RETURN_ALWAYS_FALSE);
// then
assertFalse(match);
@@ -64,7 +66,9 @@
matchers = asList(new Equals("1"));
// when
- boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(RETURN_ALWAYS_TRUE);
+ boolean match =
+ getMatcherApplicationStrategyFor(invocation, matchers)
+ .forEachMatcherAndArgument(RETURN_ALWAYS_TRUE);
// then
assertTrue(match);
@@ -77,7 +81,9 @@
matchers = asList(new Equals("1"));
// when
- boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(RETURN_ALWAYS_TRUE);
+ boolean match =
+ getMatcherApplicationStrategyFor(invocation, matchers)
+ .forEachMatcherAndArgument(RETURN_ALWAYS_TRUE);
// then
assertFalse(match);
@@ -90,7 +96,9 @@
matchers = asList(new Equals("1"), new Equals("2"));
// when
- boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(RETURN_ALWAYS_TRUE);
+ boolean match =
+ getMatcherApplicationStrategyFor(invocation, matchers)
+ .forEachMatcherAndArgument(RETURN_ALWAYS_TRUE);
// then
assertFalse(match);
@@ -103,7 +111,9 @@
matchers = asList(new Equals("1"), Any.ANY, new InstanceOf(String.class));
// when
- boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
+ boolean match =
+ getMatcherApplicationStrategyFor(invocation, matchers)
+ .forEachMatcherAndArgument(recordAction);
// then
assertTrue(match);
@@ -116,7 +126,9 @@
matchers = asList(ANY);
// when
- boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
+ boolean match =
+ getMatcherApplicationStrategyFor(invocation, matchers)
+ .forEachMatcherAndArgument(recordAction);
// then
assertTrue(match);
@@ -129,7 +141,9 @@
matchers = asList(new Equals(1));
// when
- boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
+ boolean match =
+ getMatcherApplicationStrategyFor(invocation, matchers)
+ .forEachMatcherAndArgument(recordAction);
// then
assertFalse(match);
@@ -142,7 +156,9 @@
matchers = asList(new Equals(1), ANY);
// when
- boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
+ boolean match =
+ getMatcherApplicationStrategyFor(invocation, matchers)
+ .forEachMatcherAndArgument(recordAction);
// then
assertTrue(match);
@@ -155,7 +171,9 @@
matchers = asList(new Equals(1));
// when
- boolean match = getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
+ boolean match =
+ getMatcherApplicationStrategyFor(invocation, matchers)
+ .forEachMatcherAndArgument(recordAction);
// then
assertFalse(match);
@@ -170,11 +188,11 @@
matchers = asList(new Equals(null), ANY);
// when
- getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
+ getMatcherApplicationStrategyFor(invocation, matchers)
+ .forEachMatcherAndArgument(recordAction);
// then
recordAction.assertContainsExactly(new Equals(null), ANY, ANY);
-
}
@Test
@@ -184,7 +202,8 @@
matchers = asList(ANY);
// when
- getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
+ getMatcherApplicationStrategyFor(invocation, matchers)
+ .forEachMatcherAndArgument(recordAction);
// then
recordAction.assertContainsExactly(ANY, ANY);
@@ -198,7 +217,8 @@
matchers = asList(argumentMatcher);
// when
- getMatcherApplicationStrategyFor(invocation, matchers).forEachMatcherAndArgument(recordAction);
+ getMatcherApplicationStrategyFor(invocation, matchers)
+ .forEachMatcherAndArgument(recordAction);
// then
recordAction.assertContainsExactly(argumentMatcher, argumentMatcher);
@@ -208,6 +228,7 @@
public boolean matches(Object o) {
return true;
}
+
public void describeTo(Description description) {}
}
@@ -239,18 +260,19 @@
}
}
- private static final ArgumentMatcherAction RETURN_ALWAYS_TRUE = new ArgumentMatcherAction() {
- @Override
- public boolean apply(ArgumentMatcher<?> matcher, Object argument) {
- return true;
- }
- };
+ private static final ArgumentMatcherAction RETURN_ALWAYS_TRUE =
+ new ArgumentMatcherAction() {
+ @Override
+ public boolean apply(ArgumentMatcher<?> matcher, Object argument) {
+ return true;
+ }
+ };
- private static final ArgumentMatcherAction RETURN_ALWAYS_FALSE = new ArgumentMatcherAction() {
- @Override
- public boolean apply(ArgumentMatcher<?> matcher, Object argument) {
- return false;
- }
- };
-
+ private static final ArgumentMatcherAction RETURN_ALWAYS_FALSE =
+ new ArgumentMatcherAction() {
+ @Override
+ public boolean apply(ArgumentMatcher<?> matcher, Object argument) {
+ return false;
+ }
+ };
}
diff --git a/src/test/java/org/mockito/internal/invocation/SerializableMethodTest.java b/src/test/java/org/mockito/internal/invocation/SerializableMethodTest.java
index d320f25..bbf7eb9 100644
--- a/src/test/java/org/mockito/internal/invocation/SerializableMethodTest.java
+++ b/src/test/java/org/mockito/internal/invocation/SerializableMethodTest.java
@@ -4,16 +4,15 @@
*/
package org.mockito.internal.invocation;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
+import static org.junit.Assert.*;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
-import static org.junit.Assert.*;
-
+import org.junit.Before;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
public class SerializableMethodTest extends TestBase {
@@ -70,6 +69,6 @@
assertFalse(new SerializableMethod(testBaseToStringMethod).equals(method));
}
- //TODO: add tests for generated equals() method
+ // TODO: add tests for generated equals() method
}
diff --git a/src/test/java/org/mockito/internal/invocation/TypeSafeMatchingTest.java b/src/test/java/org/mockito/internal/invocation/TypeSafeMatchingTest.java
index 94b4a23..0a29cee 100644
--- a/src/test/java/org/mockito/internal/invocation/TypeSafeMatchingTest.java
+++ b/src/test/java/org/mockito/internal/invocation/TypeSafeMatchingTest.java
@@ -25,11 +25,9 @@
private static final Object NOT_A_COMPARABLE = new Object();
- @Rule
- public MockitoRule mockitoRule = MockitoJUnit.rule();
+ @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
- @Mock
- public IMethods mock;
+ @Mock public IMethods mock;
/**
* Should not throw an {@link NullPointerException}
@@ -40,7 +38,6 @@
public void compareNullArgument() {
boolean match = matchesTypeSafe().apply(new LessOrEqual<Integer>(5), null);
assertThat(match).isFalse();
-
}
/**
@@ -102,7 +99,6 @@
public boolean matches(Integer arg, Void v) {
throw new UnsupportedOperationException();
}
-
}
boolean match = matchesTypeSafe().apply(new TestMatcher(), 123);
@@ -111,8 +107,7 @@
@Test
public void matchesWithSubTypeExtendingGenericClass() {
- abstract class GenericMatcher<T> implements ArgumentMatcher<T> {
- }
+ abstract class GenericMatcher<T> implements ArgumentMatcher<T> {}
class TestMatcher extends GenericMatcher<Integer> {
@Override
public boolean matches(Integer argument) {
@@ -127,8 +122,7 @@
public void dontMatchesWithSubTypeExtendingGenericClass() {
final AtomicBoolean wasCalled = new AtomicBoolean();
- abstract class GenericMatcher<T> implements ArgumentMatcher<T> {
- }
+ abstract class GenericMatcher<T> implements ArgumentMatcher<T> {}
class TestMatcher extends GenericMatcher<Integer> {
@Override
public boolean matches(Integer argument) {
diff --git a/src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java b/src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java
index 1e3d8e9..5c31e5a 100644
--- a/src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java
+++ b/src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java
@@ -4,21 +4,20 @@
*/
package org.mockito.internal.invocation.mockref;
+import static org.junit.Assert.fail;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
-import org.mockito.internal.invocation.mockref.MockWeakReference;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-
public class MockWeakReferenceTest extends TestBase {
@Test
public void descriptive_exception_when_mock_was_collected() {
try {
- //when
+ // when
new MockWeakReference(null).get();
- //then
+ // then
fail();
} catch (Exception e) {
Assertions.assertThat(e).hasMessageContaining("The mock object was garbage collected");
diff --git a/src/test/java/org/mockito/internal/junit/ArgMismatchFinderTest.java b/src/test/java/org/mockito/internal/junit/ArgMismatchFinderTest.java
index 4c59809..2659412 100644
--- a/src/test/java/org/mockito/internal/junit/ArgMismatchFinderTest.java
+++ b/src/test/java/org/mockito/internal/junit/ArgMismatchFinderTest.java
@@ -4,15 +4,16 @@
*/
package org.mockito.internal.junit;
+import static java.util.Arrays.asList;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.when;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static java.util.Arrays.asList;
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.when;
-
public class ArgMismatchFinderTest extends TestBase {
ArgMismatchFinder finder = new ArgMismatchFinder();
@@ -21,109 +22,112 @@
@Test
public void no_interactions() throws Exception {
- //when
+ // when
StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
- //then
+ // then
assertEquals(0, mismatches.size());
}
@Test
public void no_mismatch_when_mock_different() throws Exception {
- //given
+ // given
when(mock1.simpleMethod(1)).thenReturn("1");
- mock2.simpleMethod(2); //arg mismatch on different mock
+ mock2.simpleMethod(2); // arg mismatch on different mock
- //when
+ // when
StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
- //then
+ // then
assertEquals(0, mismatches.size());
}
@Test
public void no_mismatch_when_method_different() throws Exception {
- //given
+ // given
when(mock1.simpleMethod(1)).thenReturn("1");
mock1.otherMethod();
- //when
+ // when
StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
- //then
+ // then
assertEquals(0, mismatches.size());
}
@Test
public void no_mismatch_when_stubbing_used() throws Exception {
- //given
+ // given
when(mock1.simpleMethod(1)).thenReturn("1");
mock1.simpleMethod(1); // stub used
mock1.simpleMethod(2); // no stubbing, but we don't want it to be reported, either
- //when
+ // when
StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
- //then
+ // then
assertEquals(0, mismatches.size());
}
@Test
public void stubbing_mismatch() throws Exception {
- //given
+ // given
when(mock1.simpleMethod(1)).thenReturn("1");
mock1.simpleMethod(2);
- //when
+ // when
StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
- //then
+ // then
assertEquals(1, mismatches.size());
}
@Test
public void single_mismatch_with_multiple_invocations() throws Exception {
- //given
+ // given
when(mock1.simpleMethod(1)).thenReturn("1");
mock1.simpleMethod(2);
mock1.simpleMethod(3);
- //when
+ // when
StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
- //then
+ // then
assertEquals(1, mismatches.size());
- assertEquals("{mock1.simpleMethod(1);=[mock1.simpleMethod(2);, mock1.simpleMethod(3);]}", mismatches.toString());
+ assertEquals(
+ "{mock1.simpleMethod(1);=[mock1.simpleMethod(2);, mock1.simpleMethod(3);]}",
+ mismatches.toString());
}
@Test
public void single_invocation_with_multiple_stubs() throws Exception {
- //given
+ // given
when(mock1.simpleMethod(1)).thenReturn("1");
when(mock1.simpleMethod(2)).thenReturn("2");
mock1.simpleMethod(3);
- //when
+ // when
StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
- //then
+ // then
assertEquals(2, mismatches.size());
- assertEquals("{mock1.simpleMethod(1);=[mock1.simpleMethod(3);], mock1.simpleMethod(2);=[mock1.simpleMethod(3);]}"
- , mismatches.toString());
+ assertEquals(
+ "{mock1.simpleMethod(1);=[mock1.simpleMethod(3);], mock1.simpleMethod(2);=[mock1.simpleMethod(3);]}",
+ mismatches.toString());
}
@Test
public void mismatch_reports_only_unstubbed_invocations() throws Exception {
- //given
- when(mock1.simpleMethod(1)).thenReturn("1"); //unused
- when(mock1.simpleMethod(2)).thenReturn("2"); //used
- mock1.simpleMethod(2); //stubbed
- mock1.simpleMethod(3); //unstubbed
+ // given
+ when(mock1.simpleMethod(1)).thenReturn("1"); // unused
+ when(mock1.simpleMethod(2)).thenReturn("2"); // used
+ mock1.simpleMethod(2); // stubbed
+ mock1.simpleMethod(3); // unstubbed
- //when
+ // when
StubbingArgMismatches mismatches = finder.getStubbingArgMismatches(asList(mock1, mock2));
- //then
+ // then
assertEquals("{mock1.simpleMethod(1);=[mock1.simpleMethod(3);]}", mismatches.toString());
}
}
diff --git a/src/test/java/org/mockito/internal/junit/ExceptionFactoryTest.java b/src/test/java/org/mockito/internal/junit/ExceptionFactoryTest.java
index a1e2564..69baf30 100644
--- a/src/test/java/org/mockito/internal/junit/ExceptionFactoryTest.java
+++ b/src/test/java/org/mockito/internal/junit/ExceptionFactoryTest.java
@@ -8,51 +8,121 @@
import static org.mockitoutil.ClassLoaders.excludingClassLoader;
import java.lang.reflect.Method;
+
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.exceptions.verification.ArgumentsAreDifferent;
public class ExceptionFactoryTest {
- private static ClassLoader classLoaderWithoutJUnit = excludingClassLoader().withCodeSourceUrlOf(ExceptionFactory.class).without("org.junit", "junit").build();
+ private static ClassLoader classLoaderWithoutJUnitOrOpenTest =
+ excludingClassLoader()
+ .withCodeSourceUrlOf(ExceptionFactory.class)
+ .without("org.junit", "junit", "org.opentest4j")
+ .build();
+ private static ClassLoader classLoaderWithoutOpenTest =
+ excludingClassLoader()
+ .withCodeSourceUrlOf(ExceptionFactory.class, org.junit.ComparisonFailure.class)
+ .without("org.opentest4j")
+ .build();
+ private static ClassLoader currentClassLoader = ExceptionFactoryTest.class.getClassLoader();
- /** loaded by the current current class loader */
- private static Class<?> junitArgumentsAreDifferent;
+ /** loaded by the current classloader */
+ private static Class<?> opentestComparisonFailure;
- /** loaded by the custom classloader {@value #classLoaderWithoutJUnit}, which excludes junit-classes */
+ private static Class<?> opentestArgumentsAreDifferent;
+
+ /** loaded by the classloader {@value #classLoaderWithoutOpenTest}, which excludes OpenTest4J classes */
+ private static Class<?> junit3ComparisonFailure;
+
+ private static Class<?> junit3ArgumentsAreDifferent;
+
+ /** loaded by the custom classloader {@value #classLoaderWithoutJUnitOrOpenTest}, which excludes JUnit and OpenTest4J classes */
private static Class<?> nonJunitArgumentsAreDifferent;
@BeforeClass
public static void init() throws ClassNotFoundException {
- nonJunitArgumentsAreDifferent = classLoaderWithoutJUnit.loadClass(ArgumentsAreDifferent.class.getName());
- junitArgumentsAreDifferent = org.mockito.exceptions.verification.junit.ArgumentsAreDifferent.class;
+ nonJunitArgumentsAreDifferent =
+ classLoaderWithoutJUnitOrOpenTest.loadClass(ArgumentsAreDifferent.class.getName());
+ junit3ComparisonFailure =
+ classLoaderWithoutOpenTest.loadClass(
+ junit.framework.ComparisonFailure.class.getName());
+ junit3ArgumentsAreDifferent =
+ classLoaderWithoutOpenTest.loadClass(
+ org.mockito.exceptions.verification.junit.ArgumentsAreDifferent.class
+ .getName());
+ opentestComparisonFailure = org.opentest4j.AssertionFailedError.class;
+ opentestArgumentsAreDifferent =
+ org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent.class;
}
@Test
- public void createArgumentsAreDifferentException_withoutJUnit() throws Exception {
- Class<?> exceptionFactory = classLoaderWithoutJUnit.loadClass(ExceptionFactory.class.getName());
-
- Method m = exceptionFactory.getDeclaredMethod("createArgumentsAreDifferentException", String.class, String.class, String.class);
- Object e = m.invoke(null, "message", "wanted", "actual");
+ public void createArgumentsAreDifferentException_withoutJUnitOrOpenTest() throws Exception {
+ AssertionError e = invokeFactoryThroughLoader(classLoaderWithoutJUnitOrOpenTest);
assertThat(e).isExactlyInstanceOf(nonJunitArgumentsAreDifferent);
}
@Test
- public void createArgumentsAreDifferentException_withJUnit() throws Exception {
- AssertionError e = ExceptionFactory.createArgumentsAreDifferentException("message", "wanted", "actual");
+ public void createArgumentsAreDifferentException_withJUnit3_butNotOpenTest() throws Exception {
+ AssertionError e = invokeFactoryThroughLoader(classLoaderWithoutOpenTest);
- assertThat(e).isExactlyInstanceOf(junitArgumentsAreDifferent);
+ assertThat(e)
+ .isExactlyInstanceOf(junit3ArgumentsAreDifferent)
+ .isInstanceOf(junit3ComparisonFailure);
}
@Test
- public void createArgumentsAreDifferentException_withJUnit2x() throws Exception {
+ public void createArgumentsAreDifferentException_withOpenTest() throws Exception {
+ AssertionError e = invokeFactoryThroughLoader(currentClassLoader);
+
+ assertThat(e)
+ .isExactlyInstanceOf(opentestArgumentsAreDifferent)
+ .isInstanceOf(opentestComparisonFailure);
+ }
+
+ @Test
+ public void createArgumentsAreDifferentException_withoutJUnitOrOpenTest_2x() throws Exception {
AssertionError e;
- e = ExceptionFactory.createArgumentsAreDifferentException("message", "wanted", "actual");
- assertThat(e).isExactlyInstanceOf(junitArgumentsAreDifferent);
+ e = invokeFactoryThroughLoader(classLoaderWithoutJUnitOrOpenTest);
+ assertThat(e).isExactlyInstanceOf(nonJunitArgumentsAreDifferent);
- e = ExceptionFactory.createArgumentsAreDifferentException("message", "wanted", "actual");
- assertThat(e).isExactlyInstanceOf(junitArgumentsAreDifferent);
+ e = invokeFactoryThroughLoader(classLoaderWithoutJUnitOrOpenTest);
+ assertThat(e).isExactlyInstanceOf(nonJunitArgumentsAreDifferent);
+ }
+
+ @Test
+ public void createArgumentsAreDifferentException_withJUnit3_2x() throws Exception {
+ AssertionError e;
+
+ e = invokeFactoryThroughLoader(classLoaderWithoutOpenTest);
+ assertThat(e).isExactlyInstanceOf(junit3ArgumentsAreDifferent);
+
+ e = invokeFactoryThroughLoader(classLoaderWithoutOpenTest);
+ assertThat(e).isExactlyInstanceOf(junit3ArgumentsAreDifferent);
+ }
+
+ @Test
+ public void createArgumentsAreDifferentException_withOpenTest_2x() throws Exception {
+ AssertionError e;
+
+ e = invokeFactoryThroughLoader(currentClassLoader);
+ assertThat(e).isExactlyInstanceOf(opentestArgumentsAreDifferent);
+
+ e = invokeFactoryThroughLoader(currentClassLoader);
+ assertThat(e).isExactlyInstanceOf(opentestArgumentsAreDifferent);
+ }
+
+ private static AssertionError invokeFactoryThroughLoader(ClassLoader loader) throws Exception {
+ Class<?> exceptionFactory = loader.loadClass(ExceptionFactory.class.getName());
+
+ Method m =
+ exceptionFactory.getDeclaredMethod(
+ "createArgumentsAreDifferentException",
+ String.class,
+ String.class,
+ String.class);
+ return (AssertionError) m.invoke(null, "message", "wanted", "actual");
}
}
diff --git a/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java b/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java
index 7d5968d..f971893 100644
--- a/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java
+++ b/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java
@@ -4,6 +4,10 @@
*/
package org.mockito.internal.junit;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.when;
+
import org.junit.Rule;
import org.junit.Test;
import org.mockito.Mock;
@@ -13,16 +17,13 @@
import org.mockitousage.IMethods;
import org.mockitoutil.SafeJUnitRule;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mockingDetails;
-import static org.mockito.Mockito.when;
-
public class JUnitRuleTest {
@Rule public SafeJUnitRule rule = new SafeJUnitRule(MockitoJUnit.rule());
@Mock IMethods mock;
- @Test public void injects_into_test_case() throws Throwable {
+ @Test
+ public void injects_into_test_case() throws Throwable {
assertTrue(mockingDetails(mock).isMock());
}
@@ -42,9 +43,9 @@
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
@Test
public void does_not_check_invalid_mockito_usage_on_failure() throws Throwable {
- //This intended behavior is questionable
- //However, it was like that since the beginning of JUnit rule support
- //Users never questioned this behavior. Hence, let's stick to it unless we have more data
+ // This intended behavior is questionable
+ // However, it was like that since the beginning of JUnit rule support
+ // Users never questioned this behavior. Hence, let's stick to it unless we have more data
rule.expectFailure(RuntimeException.class, "foo");
Mockito.when(mock.simpleMethod()); // <--- unfinished stubbing
diff --git a/src/test/java/org/mockito/internal/junit/StubbingArgMismatchesTest.java b/src/test/java/org/mockito/internal/junit/StubbingArgMismatchesTest.java
index c597659..5349364 100644
--- a/src/test/java/org/mockito/internal/junit/StubbingArgMismatchesTest.java
+++ b/src/test/java/org/mockito/internal/junit/StubbingArgMismatchesTest.java
@@ -4,15 +4,15 @@
*/
package org.mockito.internal.junit;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
import org.junit.Test;
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockito.internal.util.SimpleMockitoLogger;
import org.mockito.invocation.Invocation;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
public class StubbingArgMismatchesTest extends TestBase {
SimpleMockitoLogger logger = new SimpleMockitoLogger();
@@ -20,51 +20,67 @@
@Test
public void no_op_when_no_mismatches() throws Exception {
- //when
+ // when
mismatches.format("MyTest.myTestMethod", logger);
- //then
+ // then
assertTrue(logger.isEmpty());
}
@Test
public void logs_mismatch() throws Exception {
- //given
+ // given
mismatches.add(
new InvocationBuilder().args("a").location("-> at A.java").toInvocation(),
new InvocationBuilder().args("b").location("-> at B.java").toInvocation());
- //when
+ // when
mismatches.format("MyTest.myTestMethod", logger);
- //then
+ // then
assertEquals(
- "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n" +
- "[MockitoHint] 1. Unused... -> at B.java\n" +
- "[MockitoHint] ...args ok? -> at A.java\n", logger.getLoggedInfo());
+ "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n"
+ + "[MockitoHint] 1. Unused... -> at B.java\n"
+ + "[MockitoHint] ...args ok? -> at A.java\n",
+ logger.getLoggedInfo());
}
@Test
- public void multiple_matching_invocations_per_stub_plus_some_other_invocation() throws Exception {
- //given
- Invocation stubbing = new InvocationBuilder().args("a").location("-> at A.java").toInvocation();
- mismatches.add(new InvocationBuilder().args("x").location("-> at X.java").toInvocation(), stubbing);
- mismatches.add(new InvocationBuilder().args("y").location("-> at Y.java").toInvocation(), stubbing);
+ public void multiple_matching_invocations_per_stub_plus_some_other_invocation()
+ throws Exception {
+ // given
+ Invocation stubbing =
+ new InvocationBuilder().args("a").location("-> at A.java").toInvocation();
+ mismatches.add(
+ new InvocationBuilder().args("x").location("-> at X.java").toInvocation(),
+ stubbing);
+ mismatches.add(
+ new InvocationBuilder().args("y").location("-> at Y.java").toInvocation(),
+ stubbing);
mismatches.add(
- new InvocationBuilder().method("differentMethod").args("n").location("-> at N.java").toInvocation(),
- new InvocationBuilder().method("differentMethod").args("m").location("-> at M.java").toInvocation());
+ new InvocationBuilder()
+ .method("differentMethod")
+ .args("n")
+ .location("-> at N.java")
+ .toInvocation(),
+ new InvocationBuilder()
+ .method("differentMethod")
+ .args("m")
+ .location("-> at M.java")
+ .toInvocation());
- //when
+ // when
mismatches.format("MyTest.myTestMethod", logger);
- //then
+ // then
assertEquals(
- "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n" +
- "[MockitoHint] 1. Unused... -> at A.java\n" +
- "[MockitoHint] ...args ok? -> at X.java\n" +
- "[MockitoHint] ...args ok? -> at Y.java\n" +
- "[MockitoHint] 2. Unused... -> at M.java\n" +
- "[MockitoHint] ...args ok? -> at N.java\n", logger.getLoggedInfo());
+ "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n"
+ + "[MockitoHint] 1. Unused... -> at A.java\n"
+ + "[MockitoHint] ...args ok? -> at X.java\n"
+ + "[MockitoHint] ...args ok? -> at Y.java\n"
+ + "[MockitoHint] 2. Unused... -> at M.java\n"
+ + "[MockitoHint] ...args ok? -> at N.java\n",
+ logger.getLoggedInfo());
}
}
diff --git a/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java b/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java
index af1d3a1..9083d19 100644
--- a/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java
+++ b/src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java
@@ -4,6 +4,13 @@
*/
package org.mockito.internal.junit;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.internal.stubbing.answers.DoesNothing.doesNothing;
+
+import java.util.Arrays;
+import java.util.Collections;
+
import org.junit.Test;
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockito.internal.stubbing.StubbedInvocationMatcher;
@@ -11,49 +18,50 @@
import org.mockito.stubbing.Stubbing;
import org.mockitoutil.TestBase;
-import java.util.Arrays;
-import java.util.Collections;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.internal.stubbing.answers.DoesNothing.doesNothing;
-
public class UnusedStubbingsTest extends TestBase {
private SimpleMockitoLogger logger = new SimpleMockitoLogger();
@Test
public void no_unused_stubbings() throws Exception {
- //given
+ // given
UnusedStubbings stubbings = new UnusedStubbings(Collections.<Stubbing>emptyList());
- //when
+ // when
stubbings.format("MyTest.myTestMethod", logger);
- //then
+ // then
assertEquals("", logger.getLoggedInfo());
}
@Test
public void unused_stubbings() throws Exception {
- //given
- UnusedStubbings stubbings = new UnusedStubbings(Arrays.asList(
- new StubbedInvocationMatcher(doesNothing(), new InvocationBuilder().toInvocationMatcher(), null),
- new StubbedInvocationMatcher(doesNothing(), new InvocationBuilder().toInvocationMatcher(), null)
- ));
+ // given
+ UnusedStubbings stubbings =
+ new UnusedStubbings(
+ Arrays.asList(
+ new StubbedInvocationMatcher(
+ doesNothing(),
+ new InvocationBuilder().toInvocationMatcher(),
+ null),
+ new StubbedInvocationMatcher(
+ doesNothing(),
+ new InvocationBuilder().toInvocationMatcher(),
+ null)));
-
- //when
+ // when
stubbings.format("MyTest.myTestMethod", logger);
- //then
- assertThat(filterLineNo(logger.getLoggedInfo())).isIn(
- "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n" + //Java <9
- "[MockitoHint] 1. Unused -> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n" +
- "[MockitoHint] 2. Unused -> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n",
- "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n" + //Java 9
- "[MockitoHint] 1. Unused -> at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n" +
- "[MockitoHint] 2. Unused -> at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n"
- );
+ // then
+ assertThat(filterLineNo(logger.getLoggedInfo()))
+ .isIn(
+ "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n"
+ + // Java <9
+ "[MockitoHint] 1. Unused -> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n"
+ + "[MockitoHint] 2. Unused -> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n",
+ "[MockitoHint] MyTest.myTestMethod (see javadoc for MockitoHint):\n"
+ + // Java 9
+ "[MockitoHint] 1. Unused -> at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n"
+ + "[MockitoHint] 2. Unused -> at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n");
}
}
diff --git a/src/test/java/org/mockito/internal/junit/util/JUnitFailureHackerTest.java b/src/test/java/org/mockito/internal/junit/util/JUnitFailureHackerTest.java
index ff23b0b..3e3fb8d 100644
--- a/src/test/java/org/mockito/internal/junit/util/JUnitFailureHackerTest.java
+++ b/src/test/java/org/mockito/internal/junit/util/JUnitFailureHackerTest.java
@@ -4,6 +4,9 @@
*/
package org.mockito.internal.junit.util;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.junit.runner.Description;
@@ -11,36 +14,34 @@
import org.mockito.internal.exceptions.ExceptionIncludingMockitoWarnings;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.assertj.core.api.Assertions.assertThat;
-
public class JUnitFailureHackerTest extends TestBase {
JUnitFailureHacker hacker = new JUnitFailureHacker();
@Test
public void shouldReplaceException() throws Exception {
- //given
+ // given
RuntimeException actualExc = new RuntimeException("foo");
Failure failure = new Failure(Description.EMPTY, actualExc);
- //when
+ // when
hacker.appendWarnings(failure, "unused stubbing");
- //then
+ // then
assertEquals(ExceptionIncludingMockitoWarnings.class, failure.getException().getClass());
assertEquals(actualExc, failure.getException().getCause());
- Assertions.assertThat(actualExc.getStackTrace()).isEqualTo(failure.getException().getStackTrace());
+ Assertions.assertThat(actualExc.getStackTrace())
+ .isEqualTo(failure.getException().getStackTrace());
}
@Test
public void shouldAppendWarning() throws Exception {
Failure failure = new Failure(Description.EMPTY, new RuntimeException("foo"));
- //when
+ // when
hacker.appendWarnings(failure, "unused stubbing blah");
- //then
+ // then
assertThat(failure.getException()).hasMessageContaining("unused stubbing blah");
}
@@ -49,10 +50,10 @@
RuntimeException ex = new RuntimeException("foo");
Failure failure = new Failure(Description.EMPTY, ex);
- //when
+ // when
hacker.appendWarnings(failure, "");
- //then
+ // then
assertEquals(ex, failure.getException());
}
@@ -61,10 +62,10 @@
RuntimeException ex = new RuntimeException("foo");
Failure failure = new Failure(Description.EMPTY, ex);
- //when
+ // when
hacker.appendWarnings(failure, null);
- //then
+ // then
assertEquals(ex, failure.getException());
}
@@ -72,10 +73,10 @@
public void shouldPrintTheWarningSoICanSeeIt() throws Exception {
Failure failure = new Failure(Description.EMPTY, new RuntimeException("foo"));
- //when
+ // when
hacker.appendWarnings(failure, "unused stubbing blah");
- //then
+ // then
System.out.println(failure.getException());
}
}
diff --git a/src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java b/src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java
index ac963c4..6b2c77c 100644
--- a/src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java
+++ b/src/test/java/org/mockito/internal/listeners/StubbingLookupNotifierTest.java
@@ -4,17 +4,6 @@
*/
package org.mockito.internal.listeners;
-import org.assertj.core.util.Lists;
-import org.junit.Test;
-import org.mockito.ArgumentMatcher;
-import org.mockito.internal.creation.settings.CreationSettings;
-import org.mockito.invocation.Invocation;
-import org.mockito.stubbing.Stubbing;
-import org.mockitoutil.TestBase;
-
-import java.util.Collection;
-import java.util.List;
-
import static org.assertj.core.util.Lists.emptyList;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.doReturn;
@@ -22,6 +11,18 @@
import static org.mockito.Mockito.verify;
import static org.mockito.internal.listeners.StubbingLookupNotifier.notifyStubbedAnswerLookup;
+import java.util.Collection;
+import java.util.List;
+
+import org.assertj.core.util.Lists;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.invocation.Invocation;
+import org.mockito.listeners.StubbingLookupListener;
+import org.mockito.stubbing.Stubbing;
+import org.mockitoutil.TestBase;
+
public class StubbingLookupNotifierTest extends TestBase {
Invocation invocation = mock(Invocation.class);
@@ -60,10 +61,10 @@
@Override
public boolean matches(StubbingLookupNotifier.Event argument) {
- return invocation == argument.getInvocation() &&
- stubbingFound == argument.getStubbingFound() &&
- allStubbings == argument.getAllStubbings() &&
- creationSettings == argument.getMockSettings();
+ return invocation == argument.getInvocation()
+ && stubbingFound == argument.getStubbingFound()
+ && allStubbings == argument.getAllStubbings()
+ && creationSettings == argument.getMockSettings();
}
}
}
diff --git a/src/test/java/org/mockito/internal/listeners/VerificationStartedNotifierTest.java b/src/test/java/org/mockito/internal/listeners/VerificationStartedNotifierTest.java
index 59e99c6..419fa7c 100644
--- a/src/test/java/org/mockito/internal/listeners/VerificationStartedNotifierTest.java
+++ b/src/test/java/org/mockito/internal/listeners/VerificationStartedNotifierTest.java
@@ -4,109 +4,127 @@
*/
package org.mockito.internal.listeners;
-import org.junit.Test;
-import org.mockito.MockingDetails;
-import org.mockitoutil.TestBase;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
import static java.util.Collections.emptyList;
+
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.mockingDetails;
import static org.mockito.Mockito.withSettings;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Test;
+import org.mockito.MockingDetails;
+import org.mockitoutil.TestBase;
+
public class VerificationStartedNotifierTest extends TestBase {
MockingDetails mockingDetails = mockingDetails(mock(List.class));
@Test
public void does_not_do_anything_when_list_is_empty() throws Exception {
- //expect nothing to happen
+ // expect nothing to happen
VerificationStartedNotifier.notifyVerificationStarted((List) emptyList(), mockingDetails);
}
@Test
public void decent_exception_when_setting_non_mock() throws Exception {
- VerificationStartedNotifier.Event event = new VerificationStartedNotifier.Event(mockingDetails);
+ VerificationStartedNotifier.Event event =
+ new VerificationStartedNotifier.Event(mockingDetails);
try {
- //when
+ // when
event.setMock("not a mock");
fail();
} catch (Exception e) {
- //then
- assertEquals("VerificationStartedEvent.setMock() does not accept parameter which is not a Mockito mock.\n" +
- " Received parameter: \"not a mock\".\n" +
- " See the Javadoc.", e.getMessage());
+ // then
+ assertEquals(
+ "VerificationStartedEvent.setMock() does not accept parameter which is not a Mockito mock.\n"
+ + " Received parameter: \"not a mock\".\n"
+ + " See the Javadoc.",
+ e.getMessage());
}
}
@Test
public void shows_clean_exception_message_when_illegal_null_arg_is_used() throws Exception {
- VerificationStartedNotifier.Event event = new VerificationStartedNotifier.Event(mockingDetails);
+ VerificationStartedNotifier.Event event =
+ new VerificationStartedNotifier.Event(mockingDetails);
try {
- //when
+ // when
event.setMock(null);
fail();
} catch (Exception e) {
- //then
- assertEquals("VerificationStartedEvent.setMock() does not accept null parameter. See the Javadoc.", e.getMessage());
+ // then
+ assertEquals(
+ "VerificationStartedEvent.setMock() does not accept null parameter. See the Javadoc.",
+ e.getMessage());
}
}
@Test
public void decent_exception_when_setting_mock_of_wrong_type() throws Exception {
final Set differentTypeMock = mock(Set.class);
- VerificationStartedNotifier.Event event = new VerificationStartedNotifier.Event(mockingDetails);
+ VerificationStartedNotifier.Event event =
+ new VerificationStartedNotifier.Event(mockingDetails);
try {
- //when
+ // when
event.setMock(differentTypeMock);
fail();
} catch (Exception e) {
- //then
- assertEquals(filterHashCode("VerificationStartedEvent.setMock() does not accept parameter which is not the same type as the original mock.\n" +
- " Required type: java.util.List\n" +
- " Received parameter: Mock for Set, hashCode: xxx.\n" +
- " See the Javadoc."), filterHashCode(e.getMessage()));
+ // then
+ assertEquals(
+ filterHashCode(
+ "VerificationStartedEvent.setMock() does not accept parameter which is not the same type as the original mock.\n"
+ + " Required type: java.util.List\n"
+ + " Received parameter: Mock for Set, hashCode: xxx.\n"
+ + " See the Javadoc."),
+ filterHashCode(e.getMessage()));
}
}
@Test
- public void decent_exception_when_setting_mock_that_does_not_implement_all_desired_interfaces() throws Exception {
+ public void decent_exception_when_setting_mock_that_does_not_implement_all_desired_interfaces()
+ throws Exception {
final Set mock = mock(Set.class, withSettings().extraInterfaces(List.class));
final Set missingExtraInterface = mock(Set.class);
- VerificationStartedNotifier.Event event = new VerificationStartedNotifier.Event(mockingDetails(mock));
+ VerificationStartedNotifier.Event event =
+ new VerificationStartedNotifier.Event(mockingDetails(mock));
try {
- //when setting mock that does not have all necessary interfaces
+ // when setting mock that does not have all necessary interfaces
event.setMock(missingExtraInterface);
fail();
} catch (Exception e) {
- //then
- assertEquals(filterHashCode("VerificationStartedEvent.setMock() does not accept parameter which does not implement all extra interfaces of the original mock.\n" +
- " Required type: java.util.Set\n" +
- " Required extra interface: java.util.List\n" +
- " Received parameter: Mock for Set, hashCode: xxx.\n" +
- " See the Javadoc."), filterHashCode(e.getMessage()));
+ // then
+ assertEquals(
+ filterHashCode(
+ "VerificationStartedEvent.setMock() does not accept parameter which does not implement all extra interfaces of the original mock.\n"
+ + " Required type: java.util.Set\n"
+ + " Required extra interface: java.util.List\n"
+ + " Received parameter: Mock for Set, hashCode: xxx.\n"
+ + " See the Javadoc."),
+ filterHashCode(e.getMessage()));
}
}
@Test
public void accepts_replacement_mock_if_all_types_are_compatible() throws Exception {
final Set mock = mock(Set.class, withSettings().extraInterfaces(List.class, Map.class));
- final Set compatibleMock = mock(Set.class, withSettings().extraInterfaces(List.class, Map.class));
- VerificationStartedNotifier.Event event = new VerificationStartedNotifier.Event(mockingDetails(mock));
+ final Set compatibleMock =
+ mock(Set.class, withSettings().extraInterfaces(List.class, Map.class));
+ VerificationStartedNotifier.Event event =
+ new VerificationStartedNotifier.Event(mockingDetails(mock));
- //when
+ // when
event.setMock(compatibleMock);
- //then
+ // then
assertEquals(compatibleMock, event.getMock());
}
}
diff --git a/src/test/java/org/mockito/internal/matchers/CapturingMatcherTest.java b/src/test/java/org/mockito/internal/matchers/CapturingMatcherTest.java
index be2b369..a4c6b59 100644
--- a/src/test/java/org/mockito/internal/matchers/CapturingMatcherTest.java
+++ b/src/test/java/org/mockito/internal/matchers/CapturingMatcherTest.java
@@ -4,70 +4,71 @@
*/
package org.mockito.internal.matchers;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockitoutil.TestBase;
-
-import java.util.Iterator;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
+import java.util.Iterator;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockitoutil.TestBase;
+
public class CapturingMatcherTest extends TestBase {
@Test
public void should_capture_arguments() throws Exception {
- //given
+ // given
CapturingMatcher<String> m = new CapturingMatcher<String>();
- //when
+ // when
m.captureFrom("foo");
m.captureFrom("bar");
- //then
+ // then
assertThat(m.getAllValues()).containsSequence("foo", "bar");
}
@Test
public void should_know_last_captured_value() throws Exception {
- //given
+ // given
CapturingMatcher<String> m = new CapturingMatcher<String>();
- //when
+ // when
m.captureFrom("foo");
m.captureFrom("bar");
- //then
+ // then
assertEquals("bar", m.getLastValue());
}
@Test
public void should_scream_when_nothing_yet_captured() throws Exception {
- //given
+ // given
CapturingMatcher<String> m = new CapturingMatcher<String>();
try {
- //when
+ // when
m.getLastValue();
- //then
+ // then
fail();
- } catch (MockitoException e) {}
+ } catch (MockitoException e) {
+ }
}
@Test
public void should_not_fail_when_used_in_concurrent_tests() throws Exception {
- //given
+ // given
final CapturingMatcher<String> m = new CapturingMatcher<String>();
- //when
+ // when
m.captureFrom("concurrent access");
Iterator<String> iterator = m.getAllValues().iterator();
m.captureFrom("concurrent access");
- //then
+ // then
assertThat(iterator.hasNext()).isTrue();
- assertThat(iterator.next()).isEqualTo("concurrent access"); // Potential ConcurrentModificationException
+ assertThat(iterator.next())
+ .isEqualTo("concurrent access"); // Potential ConcurrentModificationException
}
-
}
diff --git a/src/test/java/org/mockito/internal/matchers/ComparableMatchersTest.java b/src/test/java/org/mockito/internal/matchers/ComparableMatchersTest.java
index ac8d8d1..583a848 100644
--- a/src/test/java/org/mockito/internal/matchers/ComparableMatchersTest.java
+++ b/src/test/java/org/mockito/internal/matchers/ComparableMatchersTest.java
@@ -2,17 +2,16 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
-import java.math.BigDecimal;
-
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import java.math.BigDecimal;
+
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
public class ComparableMatchersTest extends TestBase {
@Test
@@ -44,8 +43,12 @@
assertTrue(cmpEq.matches(new BigDecimal("5")));
}
- private void test(CompareTo<String> compareTo, boolean lower, boolean higher,
- boolean equals, String name) {
+ private void test(
+ CompareTo<String> compareTo,
+ boolean lower,
+ boolean higher,
+ boolean equals,
+ String name) {
assertEquals(lower, compareTo.matches("a"));
assertEquals(equals, compareTo.matches("b"));
diff --git a/src/test/java/org/mockito/internal/matchers/EqualityTest.java b/src/test/java/org/mockito/internal/matchers/EqualityTest.java
index 4c4ad4f..81f1f68 100644
--- a/src/test/java/org/mockito/internal/matchers/EqualityTest.java
+++ b/src/test/java/org/mockito/internal/matchers/EqualityTest.java
@@ -4,13 +4,13 @@
*/
package org.mockito.internal.matchers;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.internal.matchers.Equality.areEqual;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
public class EqualityTest extends TestBase {
@Test
@@ -23,14 +23,15 @@
assertTrue(areEqual(new Object[10], new Object[10]));
assertTrue(areEqual(new int[] {1}, new Integer[] {1}));
assertTrue(areEqual(new Object[] {"1"}, new String[] {"1"}));
- Object badequals=new BadEquals();
- assertTrue(areEqual(badequals,badequals));
+ Object badequals = new BadEquals();
+ assertTrue(areEqual(badequals, badequals));
assertFalse(areEqual(new Object[9], new Object[10]));
assertFalse(areEqual(new int[] {1, 2}, new int[] {1}));
assertFalse(areEqual(new int[] {1}, new double[] {1.0}));
}
+ @SuppressWarnings("EqualsHashCode")
private final class BadEquals {
@Override
public boolean equals(Object oth) {
diff --git a/src/test/java/org/mockito/internal/matchers/EqualsTest.java b/src/test/java/org/mockito/internal/matchers/EqualsTest.java
index 6a1f321..ba5c578 100644
--- a/src/test/java/org/mockito/internal/matchers/EqualsTest.java
+++ b/src/test/java/org/mockito/internal/matchers/EqualsTest.java
@@ -2,14 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.*;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
public class EqualsTest extends TestBase {
@@ -30,21 +28,21 @@
@Test
public void shouldDescribeWithExtraTypeInfo() throws Exception {
- String descStr = new Equals(100).toStringWithType();
+ 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();
+ 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();
+ String descStr = new Equals("x").toStringWithType(String.class.getSimpleName());
assertEquals("(String) \"x\"", descStr);
}
@@ -79,29 +77,29 @@
@Test
public void shouldMatchTypes() throws Exception {
- //when
+ // when
ContainsExtraTypeInfo equals = new Equals(10);
- //then
+ // then
assertTrue(equals.typeMatches(10));
assertFalse(equals.typeMatches(10L));
}
@Test
public void shouldMatchTypesSafelyWhenActualIsNull() throws Exception {
- //when
+ // when
ContainsExtraTypeInfo equals = new Equals(null);
- //then
+ // then
assertFalse(equals.typeMatches(10));
}
@Test
public void shouldMatchTypesSafelyWhenGivenIsNull() throws Exception {
- //when
+ // when
ContainsExtraTypeInfo equals = new Equals(10);
- //then
+ // then
assertFalse(equals.typeMatches(null));
}
}
diff --git a/src/test/java/org/mockito/internal/matchers/InstanceOfTest.java b/src/test/java/org/mockito/internal/matchers/InstanceOfTest.java
index 127fd57..8addef8 100644
--- a/src/test/java/org/mockito/internal/matchers/InstanceOfTest.java
+++ b/src/test/java/org/mockito/internal/matchers/InstanceOfTest.java
@@ -4,22 +4,21 @@
*/
package org.mockito.internal.matchers;
-import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
import java.util.ArrayList;
import java.util.List;
-import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
public class InstanceOfTest {
@Test
public void should_describe_the_matcher() {
- assertThat(new InstanceOf(Object.class).toString()).contains("isA")
- .contains("Object");
- assertThat(new InstanceOf(Object[].class).toString()).contains("isA")
- .contains("Object[]");
- assertThat(new InstanceOf(Object.class, "matches something").toString()).isEqualTo("matches something");
+ assertThat(new InstanceOf(Object.class).toString()).contains("isA").contains("Object");
+ assertThat(new InstanceOf(Object[].class).toString()).contains("isA").contains("Object[]");
+ assertThat(new InstanceOf(Object.class, "matches something").toString())
+ .isEqualTo("matches something");
}
@Test
diff --git a/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java b/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java
index b2d9215..74cfd9d 100644
--- a/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java
+++ b/src/test/java/org/mockito/internal/matchers/MatchersPrinterTest.java
@@ -4,15 +4,15 @@
*/
package org.mockito.internal.matchers;
-import org.junit.Test;
-import org.mockito.internal.matchers.text.MatchersPrinter;
-import org.mockito.internal.reporting.PrintSettings;
-import org.mockitoutil.TestBase;
+import static org.junit.Assert.assertEquals;
import java.util.Arrays;
import java.util.List;
-import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+import org.mockito.internal.matchers.text.MatchersPrinter;
+import org.mockito.internal.reporting.PrintSettings;
+import org.mockitoutil.TestBase;
@SuppressWarnings("unchecked")
public class MatchersPrinterTest extends TestBase {
@@ -21,45 +21,61 @@
@Test
public void shouldGetArgumentsLine() {
- String line = printer.getArgumentsLine((List) Arrays.asList(new Equals(1), new Equals(2)), new PrintSettings());
+ String line =
+ printer.getArgumentsLine(
+ (List) Arrays.asList(new Equals(1), new Equals(2)), new PrintSettings());
assertEquals("(1, 2);", line);
}
@Test
public void shouldGetArgumentsBlock() {
- String line = printer.getArgumentsBlock((List) Arrays.asList(new Equals(1), new Equals(2)), new PrintSettings());
+ String line =
+ printer.getArgumentsBlock(
+ (List) Arrays.asList(new Equals(1), new Equals(2)), new PrintSettings());
assertEquals("(\n 1,\n 2\n);", line);
}
@Test
public void shouldDescribeTypeInfoOnlyMarkedMatchers() {
- //when
- String line = printer.getArgumentsLine((List) Arrays.asList(new Equals(1L), new Equals(2)), PrintSettings.verboseMatchers(1));
- //then
+ // when
+ String line =
+ printer.getArgumentsLine(
+ (List) Arrays.asList(new Equals(1L), new Equals(2)),
+ PrintSettings.verboseMatchers(1));
+ // then
assertEquals("(1L, (Integer) 2);", line);
}
@Test
public void shouldDescribeStringMatcher() {
- //when
- String line = printer.getArgumentsLine((List) Arrays.asList(new Equals(1L), new Equals("x")), PrintSettings.verboseMatchers(1));
- //then
+ // when
+ String line =
+ printer.getArgumentsLine(
+ (List) Arrays.asList(new Equals(1L), new Equals("x")),
+ PrintSettings.verboseMatchers(1));
+ // then
assertEquals("(1L, (String) \"x\");", line);
}
@Test
public void shouldGetVerboseArgumentsInBlock() {
- //when
- String line = printer.getArgumentsBlock((List) Arrays.asList(new Equals(1L), new Equals(2)), PrintSettings.verboseMatchers(0, 1));
- //then
+ // when
+ String line =
+ printer.getArgumentsBlock(
+ (List) Arrays.asList(new Equals(1L), new Equals(2)),
+ PrintSettings.verboseMatchers(0, 1));
+ // then
assertEquals("(\n (Long) 1L,\n (Integer) 2\n);", line);
}
@Test
public void shouldGetVerboseArgumentsEvenIfSomeMatchersAreNotVerbose() {
- //when
- String line = printer.getArgumentsLine((List) Arrays.asList(new Equals(1L), NotNull.NOT_NULL), PrintSettings.verboseMatchers(0));
- //then
+ // when
+ String line =
+ printer.getArgumentsLine(
+ (List) Arrays.asList(new Equals(1L), NotNull.NOT_NULL),
+ PrintSettings.verboseMatchers(0));
+ // then
assertEquals("((Long) 1L, notNull());", line);
}
}
diff --git a/src/test/java/org/mockito/internal/matchers/MatchersToStringTest.java b/src/test/java/org/mockito/internal/matchers/MatchersToStringTest.java
index e0a1241..6d243a0 100644
--- a/src/test/java/org/mockito/internal/matchers/MatchersToStringTest.java
+++ b/src/test/java/org/mockito/internal/matchers/MatchersToStringTest.java
@@ -2,16 +2,16 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.matchers;
+import static org.junit.Assert.assertEquals;
+
import java.util.regex.Pattern;
+
import org.junit.Test;
import org.mockito.ArgumentMatcher;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-
public class MatchersToStringTest extends TestBase {
@Test
@@ -41,19 +41,19 @@
@Test
public void sameToStringWithObject() {
- Object o = new Object() {
- @Override
- public String toString() {
- return "X";
- }
- };
+ Object o =
+ new Object() {
+ @Override
+ public String toString() {
+ return "X";
+ }
+ };
assertEquals("same(X)", new Same(o).toString());
}
@Test
public void equalsToStringWithString() {
assertEquals("\"X\"", new Equals("X").toString());
-
}
@Test
@@ -63,20 +63,21 @@
@Test
public void equalsToStringWithObject() {
- Object o = new Object() {
- @Override
- public String toString() {
- return "X";
- }
- };
+ Object o =
+ new Object() {
+ @Override
+ public String toString() {
+ return "X";
+ }
+ };
assertEquals("X", new Equals(o).toString());
}
@Test
public void orToString() {
- ArgumentMatcher<?> m1=new Equals(1);
- ArgumentMatcher<?> m2=new Equals(2);
- assertEquals("or(1, 2)", new Or(m1,m2).toString());
+ ArgumentMatcher<?> m1 = new Equals(1);
+ ArgumentMatcher<?> m2 = new Equals(2);
+ assertEquals("or(1, 2)", new Or(m1, m2).toString());
}
@Test
@@ -86,9 +87,9 @@
@Test
public void andToString() {
- ArgumentMatcher<?> m1=new Equals(1);
- ArgumentMatcher<?> m2=new Equals(2);
- assertEquals("and(1, 2)", new And(m1,m2).toString());
+ ArgumentMatcher<?> m1 = new Equals(1);
+ ArgumentMatcher<?> m2 = new Equals(2);
+ assertEquals("and(1, 2)", new And(m1, m2).toString());
}
@Test
@@ -116,5 +117,4 @@
assertEquals("matches(\"\\\\s+\")", new Matches("\\s+").toString());
assertEquals("matches(\"\\\\s+\")", new Matches(Pattern.compile("\\s+")).toString());
}
-
}
diff --git a/src/test/java/org/mockito/internal/matchers/StringMatchersTest.java b/src/test/java/org/mockito/internal/matchers/StringMatchersTest.java
index a810b8a..f3bd2ae 100644
--- a/src/test/java/org/mockito/internal/matchers/StringMatchersTest.java
+++ b/src/test/java/org/mockito/internal/matchers/StringMatchersTest.java
@@ -4,74 +4,73 @@
*/
package org.mockito.internal.matchers;
-import org.junit.Test;
-
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+
/**
* Tests for the Matchers that operate over strings
*/
public class StringMatchersTest {
- @Test
- public void startsWithString() {
- assertTrue(new StartsWith("mockito").matches("mockito is here"));
- }
+ @Test
+ public void startsWithString() {
+ assertTrue(new StartsWith("mockito").matches("mockito is here"));
+ }
- @Test
- public void doesNotStartWithString() {
- assertFalse(new StartsWith("junit").matches("mockito is here"));
- }
+ @Test
+ public void doesNotStartWithString() {
+ assertFalse(new StartsWith("junit").matches("mockito is here"));
+ }
- @Test
- public void nullStartsWith() {
- assertFalse(new StartsWith("java").matches(null));
- }
+ @Test
+ public void nullStartsWith() {
+ assertFalse(new StartsWith("java").matches(null));
+ }
- @Test
- public void endsWithString() {
- assertTrue(new EndsWith("mockito").matches("here is mockito"));
- }
+ @Test
+ public void endsWithString() {
+ assertTrue(new EndsWith("mockito").matches("here is mockito"));
+ }
- @Test
- public void doesNotEndWithString() {
- assertFalse(new EndsWith("junit").matches("here is mockito"));
- }
+ @Test
+ public void doesNotEndWithString() {
+ assertFalse(new EndsWith("junit").matches("here is mockito"));
+ }
- @Test
- public void nullEndsWith() {
- assertFalse(new EndsWith("java").matches(null));
- }
+ @Test
+ public void nullEndsWith() {
+ assertFalse(new EndsWith("java").matches(null));
+ }
- @Test
- public void containsString() {
- assertTrue(new Contains("mockito").matches("****mockito****"));
- }
+ @Test
+ public void containsString() {
+ assertTrue(new Contains("mockito").matches("****mockito****"));
+ }
- @Test
- public void stringDoesNotContain() {
- assertFalse(new Contains("junit").matches("****mockito****"));
- }
+ @Test
+ public void stringDoesNotContain() {
+ assertFalse(new Contains("junit").matches("****mockito****"));
+ }
- @Test
- public void nullContainsNothing() {
- assertFalse(new Contains("mockito").matches(null));
- }
+ @Test
+ public void nullContainsNothing() {
+ assertFalse(new Contains("mockito").matches(null));
+ }
- @Test
- public void matchesRegex() {
- assertTrue(new Find("eleph.nt").matches("the elephant in the room"));
- assertTrue(new Find("eleph.nt").matches("the elephInt in the room"));
- }
+ @Test
+ public void matchesRegex() {
+ assertTrue(new Find("eleph.nt").matches("the elephant in the room"));
+ assertTrue(new Find("eleph.nt").matches("the elephInt in the room"));
+ }
- @Test
- public void doesNotMatchRegex() {
- assertFalse(new Find("eleph.nt").matches("the otter in the room"));
- }
+ @Test
+ public void doesNotMatchRegex() {
+ assertFalse(new Find("eleph.nt").matches("the otter in the room"));
+ }
- @Test
- public void nullDoesNotMatchRegex() {
- assertFalse(new Find("eleph.nt").matches(null));
- }
-
+ @Test
+ public void nullDoesNotMatchRegex() {
+ assertFalse(new Find("eleph.nt").matches(null));
+ }
}
diff --git a/src/test/java/org/mockito/internal/matchers/apachecommons/EqualsBuilderTest.java b/src/test/java/org/mockito/internal/matchers/apachecommons/EqualsBuilderTest.java
index 7baecfa..53f3410 100644
--- a/src/test/java/org/mockito/internal/matchers/apachecommons/EqualsBuilderTest.java
+++ b/src/test/java/org/mockito/internal/matchers/apachecommons/EqualsBuilderTest.java
@@ -2,18 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
-//Class comes from Apache Commons Lang, added some tiny changes
package org.mockito.internal.matchers.apachecommons;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
+import static org.junit.Assert.*;
import java.math.BigDecimal;
import java.util.Arrays;
-import static org.junit.Assert.*;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+// Class comes from Apache Commons Lang, added some tiny changes
/**
* @author <a href="mailto:sdowney@panix.com">Steve Downey</a>
* @author <a href="mailto:scolebourne@joda.org">Stephen Colebourne</a>
@@ -24,20 +23,24 @@
public class EqualsBuilderTest extends TestBase {
@Test
- public void testname() throws Exception {
-
- }
+ public void testname() throws Exception {}
static class TestObject {
private int a;
- public TestObject() {
- }
+
+ public TestObject() {}
+
public TestObject(int a) {
this.a = a;
}
+
public boolean equals(Object o) {
- if (o == null) { return false; }
- if (o == this) { return true; }
+ if (o == null) {
+ return false;
+ }
+ if (o == this) {
+ return true;
+ }
if (o.getClass() != getClass()) {
return false;
}
@@ -45,6 +48,7 @@
TestObject rhs = (TestObject) o;
return (a == rhs.a);
}
+
public int hashCode() {
return super.hashCode();
}
@@ -60,16 +64,23 @@
static class TestSubObject extends TestObject {
private int b;
+
public TestSubObject() {
super(0);
}
+
public TestSubObject(int a, int b) {
super(a);
this.b = b;
}
+
public boolean equals(Object o) {
- if (o == null) { return false; }
- if (o == this) { return true; }
+ if (o == null) {
+ return false;
+ }
+ if (o == this) {
+ return true;
+ }
if (o.getClass() != getClass()) {
return false;
}
@@ -77,6 +88,7 @@
TestSubObject rhs = (TestSubObject) o;
return super.equals(o) && (b == rhs.b);
}
+
public int hashCode() {
return 1;
}
@@ -99,6 +111,7 @@
@SuppressWarnings("unused")
static class TestTSubObject extends TestObject {
private transient int t;
+
public TestTSubObject(int a, int t) {
super(a);
this.t = t;
@@ -108,6 +121,7 @@
@SuppressWarnings("unused")
static class TestTTSubObject extends TestTSubObject {
private transient int tt;
+
public TestTTSubObject(int a, int t, int tt) {
super(a, t);
this.tt = tt;
@@ -117,6 +131,7 @@
@SuppressWarnings("unused")
static class TestTTLeafObject extends TestTTSubObject {
private int leafValue;
+
public TestTTLeafObject(int a, int t, int tt, int leafValue) {
super(a, t, tt);
this.leafValue = leafValue;
@@ -125,18 +140,22 @@
static class TestTSubObject2 extends TestObject {
private transient int t;
+
public TestTSubObject2(int a, int t) {
super(a);
}
+
public int getT() {
return t;
}
+
public void setT(int t) {
this.t = t;
}
}
- @Test public void testReflectionEquals() {
+ @Test
+ public void testReflectionEquals() {
TestObject o1 = new TestObject(4);
TestObject o2 = new TestObject(5);
assertTrue(EqualsBuilder.reflectionEquals(o1, o1));
@@ -151,18 +170,29 @@
assertTrue(EqualsBuilder.reflectionEquals((Object) null, (Object) null));
}
- @Test public void testReflectionHierarchyEquals() {
+ @Test
+ public void testReflectionHierarchyEquals() {
testReflectionHierarchyEquals(false);
testReflectionHierarchyEquals(true);
// Transients
- assertTrue(EqualsBuilder.reflectionEquals(new TestTTLeafObject(1, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 4), true));
- assertTrue(EqualsBuilder.reflectionEquals(new TestTTLeafObject(1, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 4), false));
- assertTrue(!EqualsBuilder.reflectionEquals(new TestTTLeafObject(1, 0, 0, 4), new TestTTLeafObject(1, 2, 3, 4), true));
- assertTrue(!EqualsBuilder.reflectionEquals(new TestTTLeafObject(1, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 0), true));
- assertTrue(!EqualsBuilder.reflectionEquals(new TestTTLeafObject(0, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 4), true));
+ assertTrue(
+ EqualsBuilder.reflectionEquals(
+ new TestTTLeafObject(1, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 4), true));
+ assertTrue(
+ EqualsBuilder.reflectionEquals(
+ new TestTTLeafObject(1, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 4), false));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestTTLeafObject(1, 0, 0, 4), new TestTTLeafObject(1, 2, 3, 4), true));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestTTLeafObject(1, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 0), true));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestTTLeafObject(0, 2, 3, 4), new TestTTLeafObject(1, 2, 3, 4), true));
}
- private void testReflectionHierarchyEquals(boolean testTransients) {
+ private void testReflectionHierarchyEquals(boolean testTransients) {
TestObject to1 = new TestObject(4);
TestObject to1Bis = new TestObject(4);
TestObject to1Ter = new TestObject(4);
@@ -176,43 +206,79 @@
TestSubObject tso1ter = new TestSubObject(1, 4);
TestSubObject tso2 = new TestSubObject(2, 5);
- testReflectionEqualsEquivalenceRelationship(to1, to1Bis, to1Ter, to2, new TestObject(), testTransients);
- testReflectionEqualsEquivalenceRelationship(tso1, tso1bis, tso1ter, tso2, new TestSubObject(), testTransients);
+ testReflectionEqualsEquivalenceRelationship(
+ to1, to1Bis, to1Ter, to2, new TestObject(), testTransients);
+ testReflectionEqualsEquivalenceRelationship(
+ tso1, tso1bis, tso1ter, tso2, new TestSubObject(), testTransients);
// More sanity checks:
// same values
assertTrue(EqualsBuilder.reflectionEquals(ttlo, ttlo, testTransients));
- assertTrue(EqualsBuilder.reflectionEquals(new TestSubObject(1, 10), new TestSubObject(1, 10), testTransients));
+ assertTrue(
+ EqualsBuilder.reflectionEquals(
+ new TestSubObject(1, 10), new TestSubObject(1, 10), testTransients));
// same super values, diff sub values
- assertTrue(!EqualsBuilder.reflectionEquals(new TestSubObject(1, 10), new TestSubObject(1, 11), testTransients));
- assertTrue(!EqualsBuilder.reflectionEquals(new TestSubObject(1, 11), new TestSubObject(1, 10), testTransients));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestSubObject(1, 10), new TestSubObject(1, 11), testTransients));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestSubObject(1, 11), new TestSubObject(1, 10), testTransients));
// diff super values, same sub values
- assertTrue(!EqualsBuilder.reflectionEquals(new TestSubObject(0, 10), new TestSubObject(1, 10), testTransients));
- assertTrue(!EqualsBuilder.reflectionEquals(new TestSubObject(1, 10), new TestSubObject(0, 10), testTransients));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestSubObject(0, 10), new TestSubObject(1, 10), testTransients));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestSubObject(1, 10), new TestSubObject(0, 10), testTransients));
// mix super and sub types: equals
assertTrue(EqualsBuilder.reflectionEquals(to1, teso, testTransients));
assertTrue(EqualsBuilder.reflectionEquals(teso, to1, testTransients));
- assertTrue(EqualsBuilder.reflectionEquals(to1, ttso, false)); // Force testTransients = false for this assert
- assertTrue(EqualsBuilder.reflectionEquals(ttso, to1, false)); // Force testTransients = false for this assert
+ assertTrue(
+ EqualsBuilder.reflectionEquals(
+ to1, ttso, false)); // Force testTransients = false for this assert
+ assertTrue(
+ EqualsBuilder.reflectionEquals(
+ ttso, to1, false)); // Force testTransients = false for this assert
- assertTrue(EqualsBuilder.reflectionEquals(to1, tttso, false)); // Force testTransients = false for this assert
- assertTrue(EqualsBuilder.reflectionEquals(tttso, to1, false)); // Force testTransients = false for this assert
+ assertTrue(
+ EqualsBuilder.reflectionEquals(
+ to1, tttso, false)); // Force testTransients = false for this assert
+ assertTrue(
+ EqualsBuilder.reflectionEquals(
+ tttso, to1, false)); // Force testTransients = false for this assert
- assertTrue(EqualsBuilder.reflectionEquals(ttso, tttso, false)); // Force testTransients = false for this assert
- assertTrue(EqualsBuilder.reflectionEquals(tttso, ttso, false)); // Force testTransients = false for this assert
+ assertTrue(
+ EqualsBuilder.reflectionEquals(
+ ttso, tttso, false)); // Force testTransients = false for this assert
+ assertTrue(
+ EqualsBuilder.reflectionEquals(
+ tttso, ttso, false)); // Force testTransients = false for this assert
// mix super and sub types: NOT equals
- assertTrue(!EqualsBuilder.reflectionEquals(new TestObject(0), new TestEmptySubObject(1), testTransients));
- assertTrue(!EqualsBuilder.reflectionEquals(new TestEmptySubObject(1), new TestObject(0), testTransients));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestObject(0), new TestEmptySubObject(1), testTransients));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestEmptySubObject(1), new TestObject(0), testTransients));
- assertTrue(!EqualsBuilder.reflectionEquals(new TestObject(0), new TestTSubObject(1, 1), testTransients));
- assertTrue(!EqualsBuilder.reflectionEquals(new TestTSubObject(1, 1), new TestObject(0), testTransients));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestObject(0), new TestTSubObject(1, 1), testTransients));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestTSubObject(1, 1), new TestObject(0), testTransients));
- assertTrue(!EqualsBuilder.reflectionEquals(new TestObject(1), new TestSubObject(0, 10), testTransients));
- assertTrue(!EqualsBuilder.reflectionEquals(new TestSubObject(0, 10), new TestObject(1), testTransients));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestObject(1), new TestSubObject(0, 10), testTransients));
+ assertTrue(
+ !EqualsBuilder.reflectionEquals(
+ new TestSubObject(0, 10), new TestObject(1), testTransients));
assertTrue(!EqualsBuilder.reflectionEquals(to1, ttlo));
assertTrue(!EqualsBuilder.reflectionEquals(tso1, this));
@@ -234,25 +300,27 @@
* @param oToChange a TestObject that will be changed
*/
private void testReflectionEqualsEquivalenceRelationship(
- TestObject to,
- TestObject toBis,
- TestObject toTer,
- TestObject to2,
- TestObject oToChange,
- boolean testTransients) {
+ TestObject to,
+ TestObject toBis,
+ TestObject toTer,
+ TestObject to2,
+ TestObject oToChange,
+ boolean testTransients) {
// reflection test
assertTrue(EqualsBuilder.reflectionEquals(to, to, testTransients));
assertTrue(EqualsBuilder.reflectionEquals(to2, to2, testTransients));
// symmetry test
- assertTrue(EqualsBuilder.reflectionEquals(to, toBis, testTransients) && EqualsBuilder.reflectionEquals(toBis, to, testTransients));
+ assertTrue(
+ EqualsBuilder.reflectionEquals(to, toBis, testTransients)
+ && EqualsBuilder.reflectionEquals(toBis, to, testTransients));
// transitive test
assertTrue(
- EqualsBuilder.reflectionEquals(to, toBis, testTransients)
- && EqualsBuilder.reflectionEquals(toBis, toTer, testTransients)
- && EqualsBuilder.reflectionEquals(to, toTer, testTransients));
+ EqualsBuilder.reflectionEquals(to, toBis, testTransients)
+ && EqualsBuilder.reflectionEquals(toBis, toTer, testTransients)
+ && EqualsBuilder.reflectionEquals(to, toTer, testTransients));
// consistency test
oToChange.setA(to.getA());
@@ -276,7 +344,8 @@
assertTrue(EqualsBuilder.reflectionEquals((Object) null, (Object) null, testTransients));
}
- @Test public void testSuper() {
+ @Test
+ public void testSuper() {
TestObject o1 = new TestObject(4);
TestObject o2 = new TestObject(5);
assertEquals(true, new EqualsBuilder().appendSuper(true).append(o1, o1).isEquals());
@@ -285,7 +354,8 @@
assertEquals(false, new EqualsBuilder().appendSuper(false).append(o1, o2).isEquals());
}
- @Test public void testObject() {
+ @Test
+ public void testObject() {
TestObject o1 = new TestObject(4);
TestObject o2 = new TestObject(5);
assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
@@ -300,70 +370,85 @@
assertTrue(new EqualsBuilder().append((Object) null, (Object) null).isEquals());
}
- @Test public void testLong() {
+ @Test
+ public void testLong() {
long o1 = 1L;
long o2 = 2L;
assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
}
- @Test public void testInt() {
+ @Test
+ public void testInt() {
int o1 = 1;
int o2 = 2;
assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
}
- @Test public void testShort() {
+ @Test
+ public void testShort() {
short o1 = 1;
short o2 = 2;
assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
}
- @Test public void testChar() {
+ @Test
+ public void testChar() {
char o1 = 1;
char o2 = 2;
assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
}
- @Test public void testByte() {
+ @Test
+ public void testByte() {
byte o1 = 1;
byte o2 = 2;
assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
}
- @Test public void testDouble() {
+ @Test
+ public void testDouble() {
double o1 = 1;
double o2 = 2;
assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
assertTrue(!new EqualsBuilder().append(o1, Double.NaN).isEquals());
assertTrue(new EqualsBuilder().append(Double.NaN, Double.NaN).isEquals());
- assertTrue(new EqualsBuilder().append(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY).isEquals());
+ assertTrue(
+ new EqualsBuilder()
+ .append(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY)
+ .isEquals());
}
- @Test public void testFloat() {
+ @Test
+ public void testFloat() {
float o1 = 1;
float o2 = 2;
assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
assertTrue(!new EqualsBuilder().append(o1, Float.NaN).isEquals());
assertTrue(new EqualsBuilder().append(Float.NaN, Float.NaN).isEquals());
- assertTrue(new EqualsBuilder().append(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY).isEquals());
+ assertTrue(
+ new EqualsBuilder()
+ .append(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY)
+ .isEquals());
}
// https://issues.apache.org/jira/browse/LANG-393
- @Test public void testBigDecimal() {
+ @Test
+ public void testBigDecimal() {
BigDecimal o1 = new BigDecimal("2.0");
BigDecimal o2 = new BigDecimal("2.00");
assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
assertTrue(new EqualsBuilder().append(o1, o2).isEquals());
}
- @Test public void testAccessors() {
+ @Test
+ public void testAccessors() {
EqualsBuilder equalsBuilder = new EqualsBuilder();
assertTrue(equalsBuilder.isEquals());
equalsBuilder.setEquals(true);
@@ -372,14 +457,16 @@
assertFalse(equalsBuilder.isEquals());
}
- @Test public void testBoolean() {
+ @Test
+ public void testBoolean() {
boolean o1 = true;
boolean o2 = false;
assertTrue(new EqualsBuilder().append(o1, o1).isEquals());
assertTrue(!new EqualsBuilder().append(o1, o2).isEquals());
}
- @Test public void testObjectArray() {
+ @Test
+ public void testObjectArray() {
TestObject[] obj1 = new TestObject[3];
obj1[0] = new TestObject(4);
obj1[1] = new TestObject(5);
@@ -407,7 +494,8 @@
assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testLongArray() {
+ @Test
+ public void testLongArray() {
long[] obj1 = new long[2];
obj1[0] = 5L;
obj1[1] = 6L;
@@ -425,7 +513,8 @@
assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testIntArray() {
+ @Test
+ public void testIntArray() {
int[] obj1 = new int[2];
obj1[0] = 5;
obj1[1] = 6;
@@ -443,7 +532,8 @@
assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testShortArray() {
+ @Test
+ public void testShortArray() {
short[] obj1 = new short[2];
obj1[0] = 5;
obj1[1] = 6;
@@ -461,7 +551,8 @@
assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testCharArray() {
+ @Test
+ public void testCharArray() {
char[] obj1 = new char[2];
obj1[0] = 5;
obj1[1] = 6;
@@ -479,7 +570,8 @@
assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testByteArray() {
+ @Test
+ public void testByteArray() {
byte[] obj1 = new byte[2];
obj1[0] = 5;
obj1[1] = 6;
@@ -497,7 +589,8 @@
assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testDoubleArray() {
+ @Test
+ public void testDoubleArray() {
double[] obj1 = new double[2];
obj1[0] = 5;
obj1[1] = 6;
@@ -515,7 +608,8 @@
assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testFloatArray() {
+ @Test
+ public void testFloatArray() {
float[] obj1 = new float[2];
obj1[0] = 5;
obj1[1] = 6;
@@ -533,7 +627,8 @@
assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testBooleanArray() {
+ @Test
+ public void testBooleanArray() {
boolean[] obj1 = new boolean[2];
obj1[0] = true;
obj1[1] = false;
@@ -551,7 +646,8 @@
assertTrue(new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testMultiLongArray() {
+ @Test
+ public void testMultiLongArray() {
long[][] array1 = new long[2][2];
long[][] array2 = new long[2][2];
for (int i = 0; i < array1.length; ++i) {
@@ -566,7 +662,8 @@
assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
}
- @Test public void testMultiIntArray() {
+ @Test
+ public void testMultiIntArray() {
int[][] array1 = new int[2][2];
int[][] array2 = new int[2][2];
for (int i = 0; i < array1.length; ++i) {
@@ -581,7 +678,8 @@
assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
}
- @Test public void testMultiShortArray() {
+ @Test
+ public void testMultiShortArray() {
short[][] array1 = new short[2][2];
short[][] array2 = new short[2][2];
for (short i = 0; i < array1.length; ++i) {
@@ -596,7 +694,8 @@
assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
}
- @Test public void testMultiCharArray() {
+ @Test
+ public void testMultiCharArray() {
char[][] array1 = new char[2][2];
char[][] array2 = new char[2][2];
for (char i = 0; i < array1.length; ++i) {
@@ -611,7 +710,8 @@
assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
}
- @Test public void testMultiByteArray() {
+ @Test
+ public void testMultiByteArray() {
byte[][] array1 = new byte[2][2];
byte[][] array2 = new byte[2][2];
for (byte i = 0; i < array1.length; ++i) {
@@ -625,7 +725,9 @@
array1[1][1] = 0;
assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
}
- @Test public void testMultiFloatArray() {
+
+ @Test
+ public void testMultiFloatArray() {
float[][] array1 = new float[2][2];
float[][] array2 = new float[2][2];
for (int i = 0; i < array1.length; ++i) {
@@ -640,7 +742,8 @@
assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
}
- @Test public void testMultiDoubleArray() {
+ @Test
+ public void testMultiDoubleArray() {
double[][] array1 = new double[2][2];
double[][] array2 = new double[2][2];
for (int i = 0; i < array1.length; ++i) {
@@ -655,7 +758,8 @@
assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
}
- @Test public void testMultiBooleanArray() {
+ @Test
+ public void testMultiBooleanArray() {
boolean[][] array1 = new boolean[2][2];
boolean[][] array2 = new boolean[2][2];
for (int i = 0; i < array1.length; ++i) {
@@ -670,14 +774,15 @@
assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
// compare 1 dim to 2.
- boolean[] array3 = new boolean[]{true, true};
+ boolean[] array3 = new boolean[] {true, true};
assertFalse(new EqualsBuilder().append(array1, array3).isEquals());
assertFalse(new EqualsBuilder().append(array3, array1).isEquals());
assertFalse(new EqualsBuilder().append(array2, array3).isEquals());
assertFalse(new EqualsBuilder().append(array3, array2).isEquals());
}
- @Test public void testRaggedArray() {
+ @Test
+ public void testRaggedArray() {
long[][] array1 = new long[2][];
long[][] array2 = new long[2][];
for (int i = 0; i < array1.length; ++i) {
@@ -694,7 +799,8 @@
assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
}
- @Test public void testMixedArray() {
+ @Test
+ public void testMixedArray() {
Object[] array1 = new Object[2];
Object[] array2 = new Object[2];
for (int i = 0; i < array1.length; ++i) {
@@ -711,7 +817,8 @@
assertTrue(!new EqualsBuilder().append(array1, array2).isEquals());
}
- @Test public void testObjectArrayHiddenByObject() {
+ @Test
+ public void testObjectArrayHiddenByObject() {
TestObject[] array1 = new TestObject[2];
array1[0] = new TestObject(4);
array1[1] = new TestObject(5);
@@ -728,7 +835,8 @@
assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testLongArrayHiddenByObject() {
+ @Test
+ public void testLongArrayHiddenByObject() {
long[] array1 = new long[2];
array1[0] = 5L;
array1[1] = 6L;
@@ -745,7 +853,8 @@
assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testIntArrayHiddenByObject() {
+ @Test
+ public void testIntArrayHiddenByObject() {
int[] array1 = new int[2];
array1[0] = 5;
array1[1] = 6;
@@ -762,7 +871,8 @@
assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testShortArrayHiddenByObject() {
+ @Test
+ public void testShortArrayHiddenByObject() {
short[] array1 = new short[2];
array1[0] = 5;
array1[1] = 6;
@@ -779,7 +889,8 @@
assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testCharArrayHiddenByObject() {
+ @Test
+ public void testCharArrayHiddenByObject() {
char[] array1 = new char[2];
array1[0] = 5;
array1[1] = 6;
@@ -796,7 +907,8 @@
assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testByteArrayHiddenByObject() {
+ @Test
+ public void testByteArrayHiddenByObject() {
byte[] array1 = new byte[2];
array1[0] = 5;
array1[1] = 6;
@@ -813,7 +925,8 @@
assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testDoubleArrayHiddenByObject() {
+ @Test
+ public void testDoubleArrayHiddenByObject() {
double[] array1 = new double[2];
array1[0] = 5;
array1[1] = 6;
@@ -830,7 +943,8 @@
assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testFloatArrayHiddenByObject() {
+ @Test
+ public void testFloatArrayHiddenByObject() {
float[] array1 = new float[2];
array1[0] = 5;
array1[1] = 6;
@@ -847,7 +961,8 @@
assertTrue(!new EqualsBuilder().append(obj1, obj2).isEquals());
}
- @Test public void testBooleanArrayHiddenByObject() {
+ @Test
+ public void testBooleanArrayHiddenByObject() {
boolean[] array1 = new boolean[2];
array1[0] = true;
array1[1] = false;
@@ -883,6 +998,7 @@
}
return false;
}
+
public int hashCode() {
return 1;
}
@@ -911,6 +1027,7 @@
}
return false;
}
+
public int hashCode() {
return 1;
}
@@ -925,9 +1042,10 @@
* of each other and do not share a parent aside from Object.
* See http://issues.apache.org/bugzilla/show_bug.cgi?id=33069
*/
- @Test public void testUnrelatedClasses() {
- Object[] x = new Object[]{new TestACanEqualB(1)};
- Object[] y = new Object[]{new TestBCanEqualA(1)};
+ @Test
+ public void testUnrelatedClasses() {
+ Object[] x = new Object[] {new TestACanEqualB(1)};
+ Object[] y = new Object[] {new TestBCanEqualA(1)};
// sanity checks:
assertTrue(Arrays.equals(x, x));
@@ -946,18 +1064,20 @@
}
/**
- * Test from http://issues.apache.org/bugzilla/show_bug.cgi?id=33067
+ * Test from https://issues.apache.org/jira/browse/LANG-42
*/
- @Test public void testNpeForNullElement() {
- Object[] x1 = new Object[] { new Integer(1), null, new Integer(3) };
- Object[] x2 = new Object[] { new Integer(1), new Integer(2), new Integer(3) };
+ @Test
+ public void testNpeForNullElement() {
+ Object[] x1 = new Object[] {new Integer(1), null, new Integer(3)};
+ Object[] x2 = new Object[] {new Integer(1), new Integer(2), new Integer(3)};
// causes an NPE in 2.0 according to:
- // http://issues.apache.org/bugzilla/show_bug.cgi?id=33067
+ // https://issues.apache.org/jira/browse/LANG-42
new EqualsBuilder().append(x1, x2);
}
- @Test public void testReflectionEqualsExcludeFields() throws Exception {
+ @Test
+ public void testReflectionEqualsExcludeFields() throws Exception {
TestObjectWithMultipleFields x1 = new TestObjectWithMultipleFields(1, 2, 3);
TestObjectWithMultipleFields x2 = new TestObjectWithMultipleFields(1, 3, 4);
@@ -978,7 +1098,9 @@
// still equal as long as both differing fields are among excluded
assertTrue(EqualsBuilder.reflectionEquals(x1, x2, new String[] {"one", "two", "three"}));
- assertTrue(EqualsBuilder.reflectionEquals(x1, x2, new String[] {"one", "two", "three", "xxx"}));
+ assertTrue(
+ EqualsBuilder.reflectionEquals(
+ x1, x2, new String[] {"one", "two", "three", "xxx"}));
}
@SuppressWarnings("unused")
diff --git a/src/test/java/org/mockito/internal/matchers/text/MatcherToStringTest.java b/src/test/java/org/mockito/internal/matchers/text/MatcherToStringTest.java
index 23eb71a..746ee69 100644
--- a/src/test/java/org/mockito/internal/matchers/text/MatcherToStringTest.java
+++ b/src/test/java/org/mockito/internal/matchers/text/MatcherToStringTest.java
@@ -4,30 +4,35 @@
*/
package org.mockito.internal.matchers.text;
+import static org.junit.Assert.assertEquals;
+
import org.junit.Test;
import org.mockito.ArgumentMatcher;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-
public class MatcherToStringTest extends TestBase {
static class MatcherWithoutDescription implements ArgumentMatcher<Object> {
+ @Override
public boolean matches(Object argument) {
return false;
}
}
static class MatcherWithDescription implements ArgumentMatcher<Object> {
+ @Override
public boolean matches(Object argument) {
return false;
}
+
+ @Override
public String toString() {
return "*my custom description*";
}
}
static class MatcherWithInheritedDescription extends MatcherWithDescription {
+ @Override
public boolean matches(Object argument) {
return false;
}
@@ -35,8 +40,44 @@
@Test
public void better_toString_for_matchers() {
- assertEquals("<Matcher without description>", MatcherToString.toString(new MatcherWithoutDescription()));
- assertEquals("*my custom description*", MatcherToString.toString(new MatcherWithDescription()));
- assertEquals("*my custom description*", MatcherToString.toString(new MatcherWithInheritedDescription()));
+ assertEquals(
+ "<Matcher without description>",
+ MatcherToString.toString(new MatcherWithoutDescription()));
+ assertEquals(
+ "*my custom description*", MatcherToString.toString(new MatcherWithDescription()));
+ assertEquals(
+ "*my custom description*",
+ MatcherToString.toString(new MatcherWithInheritedDescription()));
+ }
+
+ @Test
+ public void default_name_for_anonymous_matchers() {
+ ArgumentMatcher<Object> anonymousMatcher =
+ new ArgumentMatcher<Object>() {
+ @Override
+ public boolean matches(Object argument) {
+ return false;
+ }
+ };
+ assertEquals("<custom argument matcher>", MatcherToString.toString(anonymousMatcher));
+
+ ArgumentMatcher<Object> anonymousDescriptiveMatcher =
+ new MatcherWithDescription() {
+ @Override
+ public boolean matches(Object argument) {
+ return false;
+ }
+ };
+ assertEquals(
+ "*my custom description*", MatcherToString.toString(anonymousDescriptiveMatcher));
+ }
+
+ @Test
+ public void default_name_for_synthetic_matchers() {
+ ArgumentMatcher<Object> lambdaMatcher = argument -> true;
+ assertEquals("<custom argument matcher>", MatcherToString.toString(lambdaMatcher));
+
+ ArgumentMatcher<Object> methodRefMatcher = lambdaMatcher::matches;
+ assertEquals("<custom argument matcher>", MatcherToString.toString(methodRefMatcher));
}
}
diff --git a/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java b/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java
index 42559f5..1ece06c 100644
--- a/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java
+++ b/src/test/java/org/mockito/internal/matchers/text/ValuePrinterTest.java
@@ -4,14 +4,14 @@
*/
package org.mockito.internal.matchers.text;
-
-import java.util.LinkedHashMap;
-import org.junit.Test;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.internal.matchers.text.ValuePrinter.print;
+import java.util.LinkedHashMap;
+
+import org.junit.Test;
+
public class ValuePrinterTest {
@Test
@@ -23,19 +23,30 @@
assertThat(print(3L)).isEqualTo("3L");
assertThat(print(3.14d)).isEqualTo("3.14d");
assertThat(print(3.14f)).isEqualTo("3.14f");
- assertThat(print(new int[]{1, 2})).isEqualTo("[1, 2]");
- assertThat(print(new LinkedHashMap<String, Object>() {{
- put("foo", 2L);
- }})).isEqualTo("{\"foo\" = 2L}");
- assertThat(print(new LinkedHashMap<String, Object>() {{
- put("int passed as hex", 0x01);
- put("byte", (byte) 0x01);
- put("short", (short) 2);
- put("int", 3);
- put("long", 4L);
- put("float", 2.71f);
- put("double", 3.14d);
- }})).isEqualTo("{\"int passed as hex\" = 1, \"byte\" = (byte) 0x01, \"short\" = (short) 2, \"int\" = 3, \"long\" = 4L, \"float\" = 2.71f, \"double\" = 3.14d}");
+ assertThat(print(new int[] {1, 2})).isEqualTo("[1, 2]");
+ assertThat(
+ print(
+ new LinkedHashMap<String, Object>() {
+ {
+ put("foo", 2L);
+ }
+ }))
+ .isEqualTo("{\"foo\" = 2L}");
+ assertThat(
+ print(
+ new LinkedHashMap<String, Object>() {
+ {
+ put("int passed as hex", 0x01);
+ put("byte", (byte) 0x01);
+ put("short", (short) 2);
+ put("int", 3);
+ put("long", 4L);
+ put("float", 2.71f);
+ put("double", 3.14d);
+ }
+ }))
+ .isEqualTo(
+ "{\"int passed as hex\" = 1, \"byte\" = (byte) 0x01, \"short\" = (short) 2, \"int\" = 3, \"long\" = 4L, \"float\" = 2.71f, \"double\" = 3.14d}");
assertTrue(print(new UnsafeToString()).contains("UnsafeToString"));
assertThat(print(new ToString())).isEqualTo("ToString");
assertThat(print(new FormattedText("formatted"))).isEqualTo("formatted");
@@ -53,12 +64,11 @@
public String toString() {
return "ToString";
}
-
}
+
static class UnsafeToString {
public String toString() {
throw new RuntimeException("ka-boom!");
}
-
}
}
diff --git a/src/test/java/org/mockito/internal/progress/AtLeastTest.java b/src/test/java/org/mockito/internal/progress/AtLeastTest.java
index e8cc8f8..8e2762b 100644
--- a/src/test/java/org/mockito/internal/progress/AtLeastTest.java
+++ b/src/test/java/org/mockito/internal/progress/AtLeastTest.java
@@ -4,14 +4,14 @@
*/
package org.mockito.internal.progress;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
import org.junit.Test;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.verification.VerificationModeFactory;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-
public class AtLeastTest extends TestBase {
@Test
diff --git a/src/test/java/org/mockito/internal/progress/MockingProgressImplTest.java b/src/test/java/org/mockito/internal/progress/MockingProgressImplTest.java
index 7ef0334..4b812de 100644
--- a/src/test/java/org/mockito/internal/progress/MockingProgressImplTest.java
+++ b/src/test/java/org/mockito/internal/progress/MockingProgressImplTest.java
@@ -2,9 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.progress;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+
import org.assertj.core.api.Assertions;
import org.assertj.core.api.ThrowableAssert;
import org.junit.Before;
@@ -17,15 +25,6 @@
import org.mockito.verification.VerificationMode;
import org.mockitoutil.TestBase;
-import java.util.LinkedHashSet;
-import java.util.Set;
-
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
public class MockingProgressImplTest extends TestBase {
private MockingProgress mockingProgress;
@@ -54,15 +53,16 @@
try {
mockingProgress.verificationStarted(VerificationModeFactory.atLeastOnce());
fail();
- } catch (MockitoException e) {}
+ } catch (MockitoException e) {
+ }
}
@Test
public void shouldNotifyListenerSafely() throws Exception {
- //when
+ // when
mockingProgress.addListener(null);
- //then no exception is thrown:
+ // then no exception is thrown:
mockingProgress.mockingStarted(null, null);
}
@@ -73,36 +73,39 @@
final Set<MockitoListener> listeners = new LinkedHashSet<MockitoListener>();
- //when
+ // when
MockingProgressImpl.addListener(listener1, listeners);
- //then
- Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- public void call() {
- MockingProgressImpl.addListener(listener2, listeners);
- }
- }).isInstanceOf(RedundantListenerException.class);
+ // then
+ Assertions.assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ MockingProgressImpl.addListener(listener2, listeners);
+ }
+ })
+ .isInstanceOf(RedundantListenerException.class);
}
@Test
public void should_clean_up_listeners_automatically() {
MockitoListener someListener = mock(MockitoListener.class);
MyListener cleanListener = mock(MyListener.class);
- MyListener dirtyListener = when(mock(MyListener.class).isListenerDirty()).thenReturn(true).getMock();
+ MyListener dirtyListener =
+ when(mock(MyListener.class).isListenerDirty()).thenReturn(true).getMock();
Set<MockitoListener> listeners = new LinkedHashSet<MockitoListener>();
- //when
+ // when
MockingProgressImpl.addListener(someListener, listeners);
MockingProgressImpl.addListener(dirtyListener, listeners);
- //then
+ // then
Assertions.assertThat(listeners).containsExactlyInAnyOrder(someListener, dirtyListener);
- //when
+ // when
MockingProgressImpl.addListener(cleanListener, listeners);
- //then dirty listener was removed automatically
+ // then dirty listener was removed automatically
Assertions.assertThat(listeners).containsExactlyInAnyOrder(someListener, cleanListener);
}
diff --git a/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java b/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java
index 673ca10..26ba187 100644
--- a/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java
+++ b/src/test/java/org/mockito/internal/progress/ThreadSafeMockingProgressTest.java
@@ -4,18 +4,18 @@
*/
package org.mockito.internal.progress;
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.internal.verification.DummyVerificationMode;
-import org.mockitoutil.TestBase;
-
-import java.util.List;
-
import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.internal.verification.DummyVerificationMode;
+import org.mockitoutil.TestBase;
+
public class ThreadSafeMockingProgressTest extends TestBase {
@After
@@ -25,11 +25,11 @@
@Test
public void shouldShareState() throws Exception {
- //given
+ // given
MockingProgress p = mockingProgress();
p.verificationStarted(new DummyVerificationMode());
- //then
+ // then
p = mockingProgress();
assertNotNull(p.pullVerificationMode());
}
@@ -37,11 +37,11 @@
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
@Test
public void shouldKnowWhenVerificationHasStarted() throws Exception {
- //given
+ // given
verify(mock(List.class));
MockingProgress p = mockingProgress();
- //then
+ // then
assertNotNull(p.pullVerificationMode());
}
}
diff --git a/src/test/java/org/mockito/internal/progress/TimesTest.java b/src/test/java/org/mockito/internal/progress/TimesTest.java
index d0095bd..a981e48 100644
--- a/src/test/java/org/mockito/internal/progress/TimesTest.java
+++ b/src/test/java/org/mockito/internal/progress/TimesTest.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.progress;
import org.junit.Rule;
@@ -11,17 +10,15 @@
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.verification.VerificationModeFactory;
-
-public class TimesTest {
- @Rule
- public ExpectedException exception = ExpectedException.none();
+public class TimesTest {
+ @Rule public ExpectedException exception = ExpectedException.none();
@Test
public void shouldNotAllowNegativeNumberOfInvocations() throws Exception {
- exception.expect(MockitoException.class);
- exception.expectMessage("Negative value is not allowed here");
+ exception.expect(MockitoException.class);
+ exception.expectMessage("Negative value is not allowed here");
- VerificationModeFactory.times(-50);
+ VerificationModeFactory.times(-50);
}
}
diff --git a/src/test/java/org/mockito/internal/progress/VerificationModeBuilder.java b/src/test/java/org/mockito/internal/progress/VerificationModeBuilder.java
index a22fabd..07fedac 100644
--- a/src/test/java/org/mockito/internal/progress/VerificationModeBuilder.java
+++ b/src/test/java/org/mockito/internal/progress/VerificationModeBuilder.java
@@ -2,10 +2,8 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.progress;
-
import org.mockito.internal.verification.Times;
import org.mockito.internal.verification.VerificationModeFactory;
diff --git a/src/test/java/org/mockito/internal/reporting/PluralizerTest.java b/src/test/java/org/mockito/internal/reporting/PluralizerTest.java
index e559581..c1be438 100644
--- a/src/test/java/org/mockito/internal/reporting/PluralizerTest.java
+++ b/src/test/java/org/mockito/internal/reporting/PluralizerTest.java
@@ -4,11 +4,11 @@
*/
package org.mockito.internal.reporting;
+import static org.junit.Assert.assertEquals;
+
import org.junit.Test;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-
public class PluralizerTest extends TestBase {
@Test
diff --git a/src/test/java/org/mockito/internal/runners/DefaultInternalRunnerTest.java b/src/test/java/org/mockito/internal/runners/DefaultInternalRunnerTest.java
index cca74bc..c8912ec 100644
--- a/src/test/java/org/mockito/internal/runners/DefaultInternalRunnerTest.java
+++ b/src/test/java/org/mockito/internal/runners/DefaultInternalRunnerTest.java
@@ -4,55 +4,67 @@
*/
package org.mockito.internal.runners;
-import org.junit.Test;
-import org.junit.runner.Description;
-import org.junit.runner.notification.Failure;
-import org.junit.runner.notification.RunListener;
-import org.junit.runner.notification.RunNotifier;
-import org.mockito.Mock;
-import org.mockito.internal.junit.MockitoTestListener;
-import org.mockito.internal.junit.TestFinishedEvent;
-import org.mockito.internal.util.Supplier;
-
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.model.Statement;
+import org.mockito.Mock;
+import org.mockito.internal.junit.MockitoTestListener;
+import org.mockito.internal.junit.TestFinishedEvent;
+import org.mockito.internal.util.Supplier;
+
public class DefaultInternalRunnerTest {
private final RunListener runListener = mock(RunListener.class);
private final MockitoTestListener mockitoTestListener = mock(MockitoTestListener.class);
- private final Supplier<MockitoTestListener> supplier = new Supplier<MockitoTestListener>() {
- public MockitoTestListener get() {
- return mockitoTestListener;
- }
- };
+ private final Supplier<MockitoTestListener> supplier =
+ new Supplier<MockitoTestListener>() {
+ public MockitoTestListener get() {
+ return mockitoTestListener;
+ }
+ };
@Test
public void does_not_fail_when_tests_succeeds() throws Exception {
- new DefaultInternalRunner(SuccessTest.class, supplier)
- .run(newNotifier(runListener));
+ new DefaultInternalRunner(SuccessTest.class, supplier).run(newNotifier(runListener));
- verify(runListener, never()).testFailure(any(Failure.class));
- verify(runListener, times(1)).testFinished(any(Description.class));
- verify(mockitoTestListener, only()).testFinished(any(TestFinishedEvent.class));
+ verifyTestFinishedSuccessfully();
}
@Test
public void does_not_fail_second_test_when_first_test_fail() throws Exception {
new DefaultInternalRunner(TestFailOnInitialization.class, supplier)
- .run(newNotifier(runListener));
+ .run(newNotifier(runListener));
verify(runListener, times(1)).testFailure(any(Failure.class));
- verify(runListener, never()).testFinished(any(Description.class));
- verify(mockitoTestListener, never()).testFinished(any(TestFinishedEvent.class));
+ verify(runListener, times(1)).testFinished(any(Description.class));
+ verify(mockitoTestListener, only()).testFinished(any(TestFinishedEvent.class));
- reset(runListener);
+ reset(runListener, mockitoTestListener);
- new DefaultInternalRunner(SuccessTest.class, supplier)
- .run(newNotifier(runListener));
+ new DefaultInternalRunner(SuccessTest.class, supplier).run(newNotifier(runListener));
+ verifyTestFinishedSuccessfully();
+ }
+
+ @Test
+ public void does_not_fail_when_rule_invokes_statement_multiple_times() throws Exception {
+ new DefaultInternalRunner(TestWithRepeatingRule.class, supplier)
+ .run(newNotifier(runListener));
+
+ verifyTestFinishedSuccessfully();
+ }
+
+ private void verifyTestFinishedSuccessfully() throws Exception {
verify(runListener, never()).testFailure(any(Failure.class));
verify(runListener, times(1)).testFinished(any(Description.class));
verify(mockitoTestListener, only()).testFinished(any(TestFinishedEvent.class));
@@ -64,22 +76,35 @@
return notifier;
}
- public static final class SuccessTest {
+ public static class SuccessTest {
@Test
- public void test() {
+ public void this_test_is_NOT_supposed_to_fail() {
assertTrue(true);
}
}
public static final class TestFailOnInitialization {
- @Mock
- private System system;
+ @Mock private System system;
@Test
- public void test() {
+ public void this_test_is_supposed_to_fail() {
assertNotNull(system);
}
}
+
+ public static final class TestWithRepeatingRule extends SuccessTest {
+
+ @Rule
+ public TestRule rule =
+ (base, description) ->
+ new Statement() {
+ @Override
+ public void evaluate() throws Throwable {
+ base.evaluate();
+ base.evaluate();
+ }
+ };
+ }
}
diff --git a/src/test/java/org/mockito/internal/runners/util/RunnerProviderTest.java b/src/test/java/org/mockito/internal/runners/util/RunnerProviderTest.java
index 7693c57..da77bdc 100644
--- a/src/test/java/org/mockito/internal/runners/util/RunnerProviderTest.java
+++ b/src/test/java/org/mockito/internal/runners/util/RunnerProviderTest.java
@@ -4,22 +4,23 @@
*/
package org.mockito.internal.runners.util;
+import static org.junit.Assert.assertNotNull;
+
import org.junit.Test;
import org.mockito.internal.runners.DefaultInternalRunner;
import org.mockito.internal.runners.InternalRunner;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertNotNull;
-
public class RunnerProviderTest extends TestBase {
@Test
public void shouldCreateRunnerInstance() throws Throwable {
- //given
+ // given
RunnerProvider provider = new RunnerProvider();
- //when
- InternalRunner runner = provider.newInstance(DefaultInternalRunner.class.getName(), this.getClass(), null);
- //then
+ // when
+ InternalRunner runner =
+ provider.newInstance(DefaultInternalRunner.class.getName(), this.getClass(), null);
+ // then
assertNotNull(runner);
}
}
diff --git a/src/test/java/org/mockito/internal/runners/util/TestMethodsFinderTest.java b/src/test/java/org/mockito/internal/runners/util/TestMethodsFinderTest.java
index 57c34b5..18c5f6a 100644
--- a/src/test/java/org/mockito/internal/runners/util/TestMethodsFinderTest.java
+++ b/src/test/java/org/mockito/internal/runners/util/TestMethodsFinderTest.java
@@ -4,16 +4,17 @@
*/
package org.mockito.internal.runners.util;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
public class TestMethodsFinderTest extends TestBase {
public static class HasTests {
- @Test public void someTest() {}
+ @Test
+ public void someTest() {}
}
static class DoesNotHaveTests {
diff --git a/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java b/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java
index a65ae21..19f9f31 100644
--- a/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java
+++ b/src/test/java/org/mockito/internal/session/DefaultMockitoSessionBuilderTest.java
@@ -4,6 +4,15 @@
*/
package org.mockito.internal.session;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.when;
+import static org.mockito.quality.Strictness.WARN;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
import org.junit.After;
import org.junit.Test;
import org.mockito.Mock;
@@ -14,71 +23,86 @@
import org.mockito.session.MockitoSessionLogger;
import org.mockitoutil.ThrowableAssert;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.when;
-import static org.mockito.quality.Strictness.WARN;
-
public class DefaultMockitoSessionBuilderTest {
- @After public void after() {
+ @After
+ public void after() {
new StateMaster().clearMockitoListeners();
}
- @Test public void creates_sessions() {
- //no configuration is legal
+ @Test
+ public void creates_sessions() {
+ // no configuration is legal
new DefaultMockitoSessionBuilder().startMocking().finishMocking();
- //passing null to configuration is legal, default value will be used
+ // passing null to configuration is legal, default value will be used
new DefaultMockitoSessionBuilder().initMocks((Object) null).startMocking().finishMocking();
- new DefaultMockitoSessionBuilder().initMocks((Object[]) null).startMocking().finishMocking();
- new DefaultMockitoSessionBuilder().initMocks(null, null).strictness(null).startMocking().finishMocking();
+ new DefaultMockitoSessionBuilder()
+ .initMocks((Object[]) null)
+ .startMocking()
+ .finishMocking();
+ new DefaultMockitoSessionBuilder()
+ .initMocks(null, null)
+ .strictness(null)
+ .startMocking()
+ .finishMocking();
new DefaultMockitoSessionBuilder().strictness(null).startMocking().finishMocking();
- //happy path
+ // happy path
new DefaultMockitoSessionBuilder().initMocks(this).startMocking().finishMocking();
new DefaultMockitoSessionBuilder().initMocks(new Object()).startMocking().finishMocking();
- new DefaultMockitoSessionBuilder().strictness(Strictness.LENIENT).startMocking().finishMocking();
+ new DefaultMockitoSessionBuilder()
+ .strictness(Strictness.LENIENT)
+ .startMocking()
+ .finishMocking();
}
- @Test public void creates_sessions_for_multiple_test_class_instances_for_repeated_calls() {
+ @Test
+ public void creates_sessions_for_multiple_test_class_instances_for_repeated_calls() {
TestClass testClass = new TestClass();
TestClass.NestedTestClass nestedTestClass = testClass.new NestedTestClass();
- new DefaultMockitoSessionBuilder().initMocks(testClass).initMocks(nestedTestClass).startMocking().finishMocking();
+ new DefaultMockitoSessionBuilder()
+ .initMocks(testClass)
+ .initMocks(nestedTestClass)
+ .startMocking()
+ .finishMocking();
assertNotNull(testClass.set);
assertNotNull(nestedTestClass.list);
}
- @Test public void creates_sessions_for_multiple_test_class_instances_for_varargs_call() {
+ @Test
+ public void creates_sessions_for_multiple_test_class_instances_for_varargs_call() {
TestClass testClass = new TestClass();
TestClass.NestedTestClass nestedTestClass = testClass.new NestedTestClass();
- new DefaultMockitoSessionBuilder().initMocks(testClass, nestedTestClass).startMocking().finishMocking();
+ new DefaultMockitoSessionBuilder()
+ .initMocks(testClass, nestedTestClass)
+ .startMocking()
+ .finishMocking();
assertNotNull(testClass.set);
assertNotNull(nestedTestClass.list);
}
- @Test public void uses_logger_and_strictness() {
+ @Test
+ public void uses_logger_and_strictness() {
TestClass testClass = new TestClass();
final List<String> hints = new ArrayList<String>();
- MockitoSession session = new DefaultMockitoSessionBuilder()
- .initMocks(testClass)
- .strictness(WARN)
- .logger(new MockitoSessionLogger() {
- @Override
- public void log(String hint) {
- hints.add(hint);
- }
- })
- .startMocking();
+ MockitoSession session =
+ new DefaultMockitoSessionBuilder()
+ .initMocks(testClass)
+ .strictness(WARN)
+ .logger(
+ new MockitoSessionLogger() {
+ @Override
+ public void log(String hint) {
+ hints.add(hint);
+ }
+ })
+ .startMocking();
when(testClass.set.add(1)).thenReturn(true);
@@ -87,24 +111,30 @@
assertFalse(hints.isEmpty());
}
- @Test public void requires_finish_mocking() {
+ @Test
+ public void requires_finish_mocking() {
new DefaultMockitoSessionBuilder().startMocking();
- ThrowableAssert.assertThat(new Runnable() {
- public void run() {
- new DefaultMockitoSessionBuilder().startMocking();
- }
- }).throwsException(UnfinishedMockingSessionException.class);
+ ThrowableAssert.assertThat(
+ new Runnable() {
+ public void run() {
+ new DefaultMockitoSessionBuilder().startMocking();
+ }
+ })
+ .throwsException(UnfinishedMockingSessionException.class);
}
- @Test public void auto_cleans_dirty_listeners() {
+ @Test
+ public void auto_cleans_dirty_listeners() {
new DefaultMockitoSessionBuilder().startMocking();
- ThrowableAssert.assertThat(new Runnable() {
- public void run() {
- new DefaultMockitoSessionBuilder().startMocking();
- }
- }).throwsException(UnfinishedMockingSessionException.class);
+ ThrowableAssert.assertThat(
+ new Runnable() {
+ public void run() {
+ new DefaultMockitoSessionBuilder().startMocking();
+ }
+ })
+ .throwsException(UnfinishedMockingSessionException.class);
}
class TestClass {
diff --git a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java b/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
index 52e481d..fafff65 100644
--- a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplStubbingTest.java
@@ -2,9 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.stubbing;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.exceptions.base.MockitoException;
@@ -17,10 +20,6 @@
import org.mockito.invocation.Invocation;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
-
public class InvocationContainerImplStubbingTest extends TestBase {
private InvocationContainerImpl invocationContainerImpl;
@@ -33,11 +32,13 @@
state = mockingProgress();
invocationContainerImpl = new InvocationContainerImpl(new MockSettingsImpl());
- invocationContainerImpl.setInvocationForPotentialStubbing(new InvocationBuilder().toInvocationMatcher());
+ invocationContainerImpl.setInvocationForPotentialStubbing(
+ new InvocationBuilder().toInvocationMatcher());
invocationContainerImplStubOnly =
- new InvocationContainerImpl( new MockSettingsImpl().stubOnly());
- invocationContainerImplStubOnly.setInvocationForPotentialStubbing(new InvocationBuilder().toInvocationMatcher());
+ new InvocationContainerImpl(new MockSettingsImpl().stubOnly());
+ invocationContainerImplStubOnly.setInvocationForPotentialStubbing(
+ new InvocationBuilder().toInvocationMatcher());
simpleMethod = new InvocationBuilder().simpleMethod().toInvocation();
}
@@ -62,11 +63,13 @@
@Test
public void should_get_results_for_methods() throws Throwable {
- invocationContainerImpl.setInvocationForPotentialStubbing(new InvocationMatcher(simpleMethod));
+ invocationContainerImpl.setInvocationForPotentialStubbing(
+ new InvocationMatcher(simpleMethod));
invocationContainerImpl.addAnswer(new Returns("simpleMethod"), null);
Invocation differentMethod = new InvocationBuilder().differentMethod().toInvocation();
- invocationContainerImpl.setInvocationForPotentialStubbing(new InvocationMatcher(differentMethod));
+ invocationContainerImpl.setInvocationForPotentialStubbing(
+ new InvocationMatcher(differentMethod));
invocationContainerImpl.addAnswer(new ThrowsException(new MyException()), null);
assertEquals("simpleMethod", invocationContainerImpl.answerTo(simpleMethod));
@@ -74,16 +77,19 @@
try {
invocationContainerImpl.answerTo(differentMethod);
fail();
- } catch (MyException e) {}
+ } catch (MyException e) {
+ }
}
@Test
public void should_get_results_for_methods_stub_only() throws Throwable {
- invocationContainerImplStubOnly.setInvocationForPotentialStubbing(new InvocationMatcher(simpleMethod));
+ invocationContainerImplStubOnly.setInvocationForPotentialStubbing(
+ new InvocationMatcher(simpleMethod));
invocationContainerImplStubOnly.addAnswer(new Returns("simpleMethod"), null);
Invocation differentMethod = new InvocationBuilder().differentMethod().toInvocation();
- invocationContainerImplStubOnly.setInvocationForPotentialStubbing(new InvocationMatcher(differentMethod));
+ invocationContainerImplStubOnly.setInvocationForPotentialStubbing(
+ new InvocationMatcher(differentMethod));
invocationContainerImplStubOnly.addAnswer(new ThrowsException(new MyException()), null);
assertEquals("simpleMethod", invocationContainerImplStubOnly.answerTo(simpleMethod));
@@ -91,7 +97,8 @@
try {
invocationContainerImplStubOnly.answerTo(differentMethod);
fail();
- } catch (MyException e) {}
+ } catch (MyException e) {
+ }
}
@Test
@@ -99,7 +106,8 @@
try {
invocationContainerImpl.addAnswer(new ThrowsException(null), null);
fail();
- } catch (MockitoException e) {}
+ } catch (MockitoException e) {
+ }
}
@SuppressWarnings("serial")
diff --git a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java b/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java
index c63d6e9..aef75ee 100644
--- a/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/InvocationContainerImplTest.java
@@ -4,6 +4,13 @@
*/
package org.mockito.internal.stubbing;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.LinkedList;
+import java.util.concurrent.CountDownLatch;
+
import org.junit.Test;
import org.mockito.internal.creation.MockSettingsImpl;
import org.mockito.internal.invocation.InvocationBuilder;
@@ -13,21 +20,14 @@
import org.mockito.invocation.Invocation;
import org.mockito.mock.MockCreationSettings;
-import java.util.LinkedList;
-import java.util.concurrent.CountDownLatch;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
/**
* Author: Szczepan Faber
*/
public class InvocationContainerImplTest {
- InvocationContainerImpl container = new InvocationContainerImpl( new MockSettingsImpl());
+ InvocationContainerImpl container = new InvocationContainerImpl(new MockSettingsImpl());
InvocationContainerImpl containerStubOnly =
- new InvocationContainerImpl( (MockCreationSettings) new MockSettingsImpl().stubOnly());
+ new InvocationContainerImpl((MockCreationSettings) new MockSettingsImpl().stubOnly());
Invocation invocation = new InvocationBuilder().toInvocation();
LinkedList<Throwable> exceptions = new LinkedList<Throwable>();
@@ -41,40 +41,42 @@
doShouldBeThreadSafe(containerStubOnly);
}
- //works 50% of the time
+ // works 50% of the time
private void doShouldBeThreadSafe(final InvocationContainerImpl c) throws Throwable {
- //given
+ // given
Thread[] t = new Thread[200];
final CountDownLatch starter = new CountDownLatch(200);
- for (int i = 0; i < t.length; i++ ) {
- t[i] = new Thread() {
- public void run() {
- try {
- starter.await(); //NOPMD
- } catch (InterruptedException e) {
- throw new RuntimeException(e);
- }
- c.setInvocationForPotentialStubbing(new InvocationMatcher(invocation));
- c.addAnswer(new Returns("foo"), null);
- c.findAnswerFor(invocation);
- }
- };
- t[i].setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
- public void uncaughtException(Thread t, Throwable e) {
- exceptions.add(e);
- }
- });
+ for (int i = 0; i < t.length; i++) {
+ t[i] =
+ new Thread() {
+ public void run() {
+ try {
+ starter.await(); // NOPMD
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ c.setInvocationForPotentialStubbing(new InvocationMatcher(invocation));
+ c.addAnswer(new Returns("foo"), null);
+ c.findAnswerFor(invocation);
+ }
+ };
+ t[i].setUncaughtExceptionHandler(
+ new Thread.UncaughtExceptionHandler() {
+ public void uncaughtException(Thread t, Throwable e) {
+ exceptions.add(e);
+ }
+ });
t[i].start();
starter.countDown();
}
- //when
+ // when
for (Thread aT : t) {
aT.join();
}
- //then
+ // then
if (exceptions.size() != 0) {
throw exceptions.getFirst();
}
@@ -105,7 +107,8 @@
@Test
public void should_tell_if_has_invocation_for_potential_stubbing_stub_only() throws Exception {
- containerStubOnly.setInvocationForPotentialStubbing(new InvocationBuilder().toInvocationMatcher());
+ containerStubOnly.setInvocationForPotentialStubbing(
+ new InvocationBuilder().toInvocationMatcher());
assertTrue(containerStubOnly.hasInvocationForPotentialStubbing());
containerStubOnly.addAnswer(new ReturnsEmptyValues(), null);
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/AbstractThrowsExceptionTest.java b/src/test/java/org/mockito/internal/stubbing/answers/AbstractThrowsExceptionTest.java
new file mode 100644
index 0000000..c4fa7a1
--- /dev/null
+++ b/src/test/java/org/mockito/internal/stubbing/answers/AbstractThrowsExceptionTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.mock;
+import static org.mockito.internal.exceptions.Reporter.cannotStubWithNullThrowable;
+import static org.mockito.internal.exceptions.Reporter.checkedExceptionInvalid;
+
+import java.io.IOException;
+import java.nio.charset.CharacterCodingException;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.invocation.Invocation;
+
+public class AbstractThrowsExceptionTest {
+
+ @Test
+ public void should_raise_wanted_throwable() {
+ Throwable expected = new Exception();
+ AbstractThrowsException ate = instantiateFixture(expected);
+
+ Throwable throwable = Assertions.catchThrowable(() -> ate.answer(createMethodInvocation()));
+ assertNotNull("Should have raised an exception.", throwable);
+ assertSame(expected, throwable);
+ }
+
+ @Test
+ public void should_throw_mock_exception_without_stacktrace() {
+ AbstractThrowsException ate = instantiateFixture(mock(Exception.class));
+
+ Throwable throwable = Assertions.catchThrowable(() -> ate.answer(createMethodInvocation()));
+ assertNotNull("Should have raised an exception.", throwable);
+ assertThat(throwable.getStackTrace()).describedAs("no stack trace, it's mock").isNull();
+ }
+
+ @Test
+ public void should_fill_in_exception_stacktrace() {
+ AbstractThrowsException ate = instantiateFixture(new Exception());
+
+ Throwable throwable = Assertions.catchThrowable(() -> ate.answer(createMethodInvocation()));
+ assertNotNull("Should have raised an exception.", throwable);
+ assertThat(throwable.getStackTrace()[0].getClassName())
+ .isEqualTo(AbstractThrowsException.class.getName());
+ assertThat(throwable.getStackTrace()[0].getMethodName()).isEqualTo("answer");
+ }
+
+ @Test
+ public void should_invalidate_null_throwable() {
+ AbstractThrowsException ate = instantiateFixture(null);
+
+ Throwable throwable =
+ Assertions.catchThrowableOfType(
+ () -> ate.validateFor(createMethodInvocation()), MockitoException.class);
+ assertNotNull("Should have raised a MockitoException.", throwable);
+ assertEquals(cannotStubWithNullThrowable().getMessage(), throwable.getMessage());
+ }
+
+ @Test
+ public void should_throw_illegal_state_exception_if_null_answer() {
+ AbstractThrowsException ate = instantiateFixture(null);
+
+ Throwable throwable =
+ Assertions.catchThrowableOfType(
+ () -> ate.answer(createMethodInvocation()), IllegalStateException.class);
+ assertNotNull("Should have raised a IllegalStateException.", throwable);
+ assertEquals(
+ "throwable is null: you shall not call #answer if #validateFor fails!",
+ throwable.getMessage());
+ }
+
+ @Test
+ public void should_pass_proper_checked_exception() {
+ instantiateFixture(new CharacterCodingException()).validateFor(createMethodInvocation());
+ }
+
+ @Test
+ public void should_fail_invalid_checked_exception() {
+ AbstractThrowsException ate = instantiateFixture(new IOException());
+ Throwable comparison = ate.getThrowable();
+
+ Throwable throwable =
+ Assertions.catchThrowableOfType(
+ () -> ate.validateFor(createMethodInvocation()), MockitoException.class);
+ assertNotNull("Should have raised a MockitoException.", throwable);
+ assertEquals(checkedExceptionInvalid(comparison).getMessage(), throwable.getMessage());
+ }
+
+ @Test
+ public void should_pass_RuntimeException() {
+ instantiateFixture(new RuntimeException()).validateFor(createMethodInvocation());
+ }
+
+ @Test
+ public void should_pass_Error() {
+ instantiateFixture(new Error()).validateFor(createMethodInvocation());
+ }
+
+ /** Creates a fixture for AbstractThrowsException that returns the given Throwable. */
+ private static AbstractThrowsException instantiateFixture(Throwable throwable) {
+ return new AbstractThrowsException() {
+ @Override
+ protected Throwable getThrowable() {
+ return throwable;
+ }
+ };
+ }
+
+ /** Creates Invocation of a "canThrowException" method call. */
+ private static Invocation createMethodInvocation() {
+ return new InvocationBuilder().method("canThrowException").toInvocation();
+ }
+
+ @Test
+ public void fixture_should_return_expected_throwable() {
+ Throwable expected = new RuntimeException();
+ AbstractThrowsException ate = instantiateFixture(expected);
+
+ assertSame(expected, ate.getThrowable());
+ }
+}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/AnswersWithDelayTest.java b/src/test/java/org/mockito/internal/stubbing/answers/AnswersWithDelayTest.java
index 35c5265..9f90d17 100644
--- a/src/test/java/org/mockito/internal/stubbing/answers/AnswersWithDelayTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/answers/AnswersWithDelayTest.java
@@ -4,29 +4,38 @@
*/
package org.mockito.internal.stubbing.answers;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.within;
+
+import java.util.Date;
+
import org.junit.Test;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.invocation.InvocationBuilder;
-import java.util.Date;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.within;
-
public class AnswersWithDelayTest {
@Test
public void should_return_value() throws Throwable {
- assertThat(new AnswersWithDelay(1, new Returns("value")).answer(new InvocationBuilder().method("oneArg").arg("A").toInvocation())).isEqualTo("value");
+ assertThat(
+ new AnswersWithDelay(1, new Returns("value"))
+ .answer(
+ new InvocationBuilder()
+ .method("oneArg")
+ .arg("A")
+ .toInvocation()))
+ .isEqualTo("value");
}
@Test(expected = MockitoException.class)
public void should_fail_when_contained_answer_should_fail() throws Throwable {
- new AnswersWithDelay(1, new Returns("one")).validateFor(new InvocationBuilder().method("voidMethod").toInvocation());
+ new AnswersWithDelay(1, new Returns("one"))
+ .validateFor(new InvocationBuilder().method("voidMethod").toInvocation());
}
@Test
public void should_succeed_when_contained_answer_should_succeed() throws Throwable {
- new AnswersWithDelay(1, new Returns("one")).validateFor(new InvocationBuilder().simpleMethod().toInvocation());
+ new AnswersWithDelay(1, new Returns("one"))
+ .validateFor(new InvocationBuilder().simpleMethod().toInvocation());
}
@Test
@@ -43,4 +52,3 @@
assertThat(timePassed).isCloseTo(sleepyTime, within(15L));
}
}
-
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/CallsRealMethodsTest.java b/src/test/java/org/mockito/internal/stubbing/answers/CallsRealMethodsTest.java
index 63118e5..f8d904f 100644
--- a/src/test/java/org/mockito/internal/stubbing/answers/CallsRealMethodsTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/answers/CallsRealMethodsTest.java
@@ -1,14 +1,15 @@
/*
- * Copyright (c) 2017 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-
-/*
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
package org.mockito.internal.stubbing.answers;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.RETURNS_DEFAULTS;
+import static org.mockito.Mockito.mock;
+
+import java.util.ArrayList;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.exceptions.base.MockitoException;
@@ -16,40 +17,38 @@
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockito.invocation.Invocation;
-import java.util.ArrayList;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.RETURNS_DEFAULTS;
-import static org.mockito.Mockito.mock;
-
public class CallsRealMethodsTest {
@Test
public void should_delegate_to_returns_default_when_abstract_method() throws Throwable {
- Invocation abstractMethod = new InvocationBuilder().method("booleanReturningMethod").toInvocation();
- assertThat(new CallsRealMethods().answer(abstractMethod)).isEqualTo(RETURNS_DEFAULTS.answer(abstractMethod));
+ Invocation abstractMethod =
+ new InvocationBuilder().method("booleanReturningMethod").toInvocation();
+ assertThat(new CallsRealMethods().answer(abstractMethod))
+ .isEqualTo(RETURNS_DEFAULTS.answer(abstractMethod));
}
@Test
public void should_fail_when_calling_real_method_on_interface() throws Throwable {
- //given
- Invocation invocationOnInterface = new InvocationBuilder().method("simpleMethod").toInvocation();
+ // given
+ Invocation invocationOnInterface =
+ new InvocationBuilder().method("simpleMethod").toInvocation();
try {
- //when
+ // when
new CallsRealMethods().validateFor(invocationOnInterface);
- //then
+ // then
Assertions.fail("can not invoke interface");
- } catch (MockitoException expected) {}
+ } catch (MockitoException expected) {
+ }
}
@Test
public void should_be_OK_when_calling_real_method_on_concrete_class() throws Throwable {
- //given
+ // given
ArrayList<?> mock = mock(ArrayList.class);
mock.clear();
Invocation invocationOnClass = new MockitoCore().getLastInvocation();
- //when
+ // when
new CallsRealMethods().validateFor(invocationOnClass);
- //then no exception is thrown
+ // then no exception is thrown
}
}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidatorTest.java b/src/test/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidatorTest.java
index 9caed65..df78604 100644
--- a/src/test/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidatorTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/answers/DefaultAnswerValidatorTest.java
@@ -4,24 +4,24 @@
*/
package org.mockito.internal.stubbing.answers;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
import org.junit.Test;
import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
import org.mockito.internal.invocation.InvocationBuilder;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-
public class DefaultAnswerValidatorTest {
@Test
- public void should_fail_if_returned_value_of_answer_is_incompatible_with_return_type() throws Throwable {
+ public void should_fail_if_returned_value_of_answer_is_incompatible_with_return_type()
+ throws Throwable {
// given
- class AWrongType {
- }
+ class AWrongType {}
try {
// when
- DefaultAnswerValidator.validateReturnValueFor(new InvocationBuilder().method("toString").toInvocation(),
- new AWrongType());
+ DefaultAnswerValidator.validateReturnValueFor(
+ new InvocationBuilder().method("toString").toInvocation(), new AWrongType());
fail("expected validation to fail");
} catch (WrongTypeOfReturnValue e) {
// then
@@ -34,7 +34,7 @@
@Test
public void should_not_fail_if_returned_value_of_answer_is_null() throws Throwable {
- DefaultAnswerValidator.validateReturnValueFor(new InvocationBuilder().method("toString").toInvocation(),
- null);
+ DefaultAnswerValidator.validateReturnValueFor(
+ new InvocationBuilder().method("toString").toInvocation(), null);
}
}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/DoesNothingTest.java b/src/test/java/org/mockito/internal/stubbing/answers/DoesNothingTest.java
index f3c83ff..adb7974 100644
--- a/src/test/java/org/mockito/internal/stubbing/answers/DoesNothingTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/answers/DoesNothingTest.java
@@ -5,6 +5,7 @@
package org.mockito.internal.stubbing.answers;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
import static org.mockito.internal.stubbing.answers.DoesNothing.doesNothing;
import static org.mockitoutil.TestBase.getLastInvocation;
@@ -15,7 +16,7 @@
import org.mockito.invocation.Invocation;
import org.mockitousage.IMethods;
-public class DoesNothingTest {
+public class DoesNothingTest {
private IMethods mock;
private Invocation invocation_Void;
@@ -23,7 +24,7 @@
private Invocation invocation_String;
@Before
- public void init(){
+ public void init() {
mock = mock(IMethods.class);
mock.voidMethod();
@@ -44,12 +45,12 @@
}
@Test(expected = MockitoException.class)
- public void validateFor_nonVoidReturnType_shouldFail() {
+ public void validateFor_nonVoidReturnType_shouldFail() {
doesNothing().validateFor(invocation_String);
}
@Test
- public void validateFor_voidReturnType_shouldPass() {
+ public void validateFor_voidReturnType_shouldPass() {
doesNothing().validateFor(invocation_void);
}
@@ -58,5 +59,17 @@
doesNothing().validateFor(invocation_Void);
}
+ @Test
+ public void answer_returns_null_for_generic_parameter() {
+ SubclassWithGenericParameter mock = mock(SubclassWithGenericParameter.class);
+ doNothing().when(mock).methodReturningT();
+ }
+ static class SuperClassWithGenericParameter<T> {
+ T methodReturningT() {
+ return null;
+ }
+ }
+
+ static class SubclassWithGenericParameter extends SuperClassWithGenericParameter<Void> {}
}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoTest.java b/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoTest.java
index 13e61cc..3c9d969 100644
--- a/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoTest.java
@@ -4,77 +4,172 @@
*/
package org.mockito.internal.stubbing.answers;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockitoutil.TestBase.getLastInvocation;
+
import java.lang.reflect.Method;
import java.nio.charset.CharacterCodingException;
+
import org.junit.Test;
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockito.invocation.Invocation;
import org.mockitousage.IMethods;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockitoutil.TestBase.getLastInvocation;
-
public class InvocationInfoTest {
@Test
public void should_know_valid_throwables() throws Exception {
- //when
+ // when
Invocation invocation = new InvocationBuilder().method("canThrowException").toInvocation();
InvocationInfo info = new InvocationInfo(invocation);
- //then
+ // then
assertThat(info.isValidException(new Exception())).isFalse();
assertThat(info.isValidException(new CharacterCodingException())).isTrue();
}
@Test
public void should_know_valid_return_types() throws Exception {
- assertThat(new InvocationInfo(new InvocationBuilder().method("integerReturningMethod").toInvocation()).isValidReturnType(Integer.class)).isTrue();
- assertThat(new InvocationInfo(new InvocationBuilder().method("integerReturningMethod").toInvocation()).isValidReturnType(int.class)).isTrue();
- assertThat(new InvocationInfo(new InvocationBuilder().method("intReturningMethod").toInvocation()).isValidReturnType(Integer.class)).isTrue();
- assertThat(new InvocationInfo(new InvocationBuilder().method("intReturningMethod").toInvocation()).isValidReturnType(int.class)).isTrue();
- assertThat(new InvocationInfo(new InvocationBuilder().method("integerReturningMethod").toInvocation()).isValidReturnType(String.class)).isFalse();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method("integerReturningMethod")
+ .toInvocation())
+ .isValidReturnType(Integer.class))
+ .isTrue();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method("integerReturningMethod")
+ .toInvocation())
+ .isValidReturnType(int.class))
+ .isTrue();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method("intReturningMethod")
+ .toInvocation())
+ .isValidReturnType(Integer.class))
+ .isTrue();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method("intReturningMethod")
+ .toInvocation())
+ .isValidReturnType(int.class))
+ .isTrue();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method("integerReturningMethod")
+ .toInvocation())
+ .isValidReturnType(String.class))
+ .isFalse();
}
@Test
public void should_know_when_invocation_returns_primitive() {
- assertThat(new InvocationInfo(new InvocationBuilder().method("intReturningMethod").toInvocation()).returnsPrimitive()).isTrue();
- assertThat(new InvocationInfo(new InvocationBuilder().method("integerReturningMethod").toInvocation()).returnsPrimitive()).isFalse();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method("intReturningMethod")
+ .toInvocation())
+ .returnsPrimitive())
+ .isTrue();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method("integerReturningMethod")
+ .toInvocation())
+ .returnsPrimitive())
+ .isFalse();
}
@Test
public void should_know_when_invocation_returns_void() {
- assertThat(new InvocationInfo(new InvocationBuilder().method("voidMethod").toInvocation()).isVoid()).isTrue();
- assertThat(new InvocationInfo(new InvocationBuilder().method("integerReturningMethod").toInvocation()).isVoid()).isFalse();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder().method("voidMethod").toInvocation())
+ .isVoid())
+ .isTrue();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method("integerReturningMethod")
+ .toInvocation())
+ .isVoid())
+ .isFalse();
}
@Test
public void should_read_the_method_name() {
- assertThat(new InvocationInfo(new InvocationBuilder().method("voidMethod").toInvocation()).getMethodName()).isEqualTo("voidMethod");
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder().method("voidMethod").toInvocation())
+ .getMethodName())
+ .isEqualTo("voidMethod");
}
@Test
public void should_read_the_method_return_name() {
- assertThat(new InvocationInfo(new InvocationBuilder().method("voidMethod").toInvocation()).printMethodReturnType()).isEqualTo("void");
- assertThat(new InvocationInfo(new InvocationBuilder().method("integerReturningMethod").toInvocation()).printMethodReturnType()).isEqualTo("Integer");
- assertThat(new InvocationInfo(new InvocationBuilder().method("intReturningMethod").toInvocation()).printMethodReturnType()).isEqualTo("int");
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder().method("voidMethod").toInvocation())
+ .printMethodReturnType())
+ .isEqualTo("void");
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method("integerReturningMethod")
+ .toInvocation())
+ .printMethodReturnType())
+ .isEqualTo("Integer");
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method("intReturningMethod")
+ .toInvocation())
+ .printMethodReturnType())
+ .isEqualTo("int");
}
@Test
public void should_know_abstract_method() throws Exception { // To be extended with Java 8
- assertThat(new InvocationInfo(new InvocationBuilder().method(iAmAbstract()).toInvocation()).isAbstract()).isTrue();
- assertThat(new InvocationInfo(new InvocationBuilder().method(iAmNotAbstract()).toInvocation()).isAbstract()).isFalse();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method(iAmAbstract())
+ .toInvocation())
+ .isAbstract())
+ .isTrue();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method(iAmNotAbstract())
+ .toInvocation())
+ .isAbstract())
+ .isFalse();
}
@Test
public void should_know_method_is_declared_on_interface() throws Exception {
- assertThat(new InvocationInfo(new InvocationBuilder().method(iAmAbstract()).toInvocation()).isDeclaredOnInterface()).isFalse();
- assertThat(new InvocationInfo(new InvocationBuilder().method("voidMethod").toInvocation()).isDeclaredOnInterface()).isTrue();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder()
+ .method(iAmAbstract())
+ .toInvocation())
+ .isDeclaredOnInterface())
+ .isFalse();
+ assertThat(
+ new InvocationInfo(
+ new InvocationBuilder().method("voidMethod").toInvocation())
+ .isDeclaredOnInterface())
+ .isTrue();
}
@Test
- public void isVoid_invocationOnVoidMethod_returnTrue(){
+ public void isVoid_invocationOnVoidMethod_returnTrue() {
mock(IMethods.class).voidMethod();
InvocationInfo voidMethod = new InvocationInfo(getLastInvocation());
@@ -83,7 +178,7 @@
}
@Test
- public void isVoid_invocationOnVoidReturningMethod_returnTrue(){
+ public void isVoid_invocationOnVoidReturningMethod_returnTrue() {
mock(IMethods.class).voidReturningMethod();
InvocationInfo voidRetuningMethod = new InvocationInfo(getLastInvocation());
@@ -92,7 +187,7 @@
}
@Test
- public void isVoid_invocationNonVoidMethod_returnFalse(){
+ public void isVoid_invocationNonVoidMethod_returnFalse() {
mock(IMethods.class).simpleMethod();
InvocationInfo stringReturningMethod = new InvocationInfo(getLastInvocation());
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java b/src/test/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java
index 3a817cb..be8b315 100644
--- a/src/test/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java
@@ -4,6 +4,9 @@
*/
package org.mockito.internal.stubbing.answers;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.exceptions.base.MockitoException;
@@ -12,9 +15,6 @@
import org.mockito.invocation.Invocation;
import org.mockito.invocation.InvocationOnMock;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-
public class ReturnsArgumentAtTest {
@Test
public void should_be_able_to_return_the_first_parameter() throws Throwable {
@@ -22,8 +22,7 @@
}
@Test
- public void should_be_able_to_return_the_second_parameter()
- throws Throwable {
+ public void should_be_able_to_return_the_second_parameter() throws Throwable {
assertThat(new ReturnsArgumentAt(1).answer(invocationWith("A", "B", "C"))).isEqualTo("B");
}
@@ -43,100 +42,127 @@
@Test
public void should_identify_bad_parameter_type_for_invocation() throws Exception {
try {
- new ReturnsArgumentAt(1).validateFor(new InvocationBuilder().method("varargsReturningString")
- .argTypes(Object[].class)
- .args(new Object(), new Object(), new Object())
- .toInvocation());
+ new ReturnsArgumentAt(1)
+ .validateFor(
+ new InvocationBuilder()
+ .method("varargsReturningString")
+ .argTypes(Object[].class)
+ .args(new Object(), new Object(), new Object())
+ .toInvocation());
Assertions.fail("should scream");
- } catch (WrongTypeOfReturnValue ignored) { }
+ } catch (WrongTypeOfReturnValue ignored) {
+ }
try {
- new ReturnsArgumentAt(0).validateFor(new InvocationBuilder().method("oneArray")
- .argTypes(boolean[].class)
- .args(true, false, false)
- .toInvocation());
+ new ReturnsArgumentAt(0)
+ .validateFor(
+ new InvocationBuilder()
+ .method("oneArray")
+ .argTypes(boolean[].class)
+ .args(true, false, false)
+ .toInvocation());
Assertions.fail("should scream");
- } catch (WrongTypeOfReturnValue ignored) { }
+ } catch (WrongTypeOfReturnValue ignored) {
+ }
try {
- new ReturnsArgumentAt(0).validateFor(new InvocationBuilder().method("mixedVarargsReturningString")
- .argTypes(Object.class, String[].class)
- .args(new Object(), new String[]{"A", "B", "C"})
- .toInvocation());
+ new ReturnsArgumentAt(0)
+ .validateFor(
+ new InvocationBuilder()
+ .method("mixedVarargsReturningString")
+ .argTypes(Object.class, String[].class)
+ .args(new Object(), new String[] {"A", "B", "C"})
+ .toInvocation());
Assertions.fail("should scream");
- } catch (WrongTypeOfReturnValue ignored) { }
+ } catch (WrongTypeOfReturnValue ignored) {
+ }
}
@Test
- public void should_not_scream_when_mixed_vararg_parameter_is_compatible_with_invocation() throws Exception {
- new ReturnsArgumentAt(1).validateFor(new InvocationBuilder().method("mixedVarargsReturningString")
- .argTypes(Object.class, String[].class)
- .args(new Object(), new String[]{"A", "B", "C"})
- .toInvocation());
+ public void should_not_scream_when_mixed_vararg_parameter_is_compatible_with_invocation()
+ throws Exception {
+ new ReturnsArgumentAt(1)
+ .validateFor(
+ new InvocationBuilder()
+ .method("mixedVarargsReturningString")
+ .argTypes(Object.class, String[].class)
+ .args(new Object(), new String[] {"A", "B", "C"})
+ .toInvocation());
}
- @Test
+ @Test
public void should_handle_returning_vararg_as_array() throws Throwable {
- Invocation mixedVarargsReturningStringArray = new InvocationBuilder().method("mixedVarargsReturningStringArray")
- .argTypes(Object.class, String[].class)
- .args(new Object(), new String[]{"A", "B", "C"})
- .toInvocation();
+ Invocation mixedVarargsReturningStringArray =
+ new InvocationBuilder()
+ .method("mixedVarargsReturningStringArray")
+ .argTypes(Object.class, String[].class)
+ .args(new Object(), new String[] {"A", "B", "C"})
+ .toInvocation();
new ReturnsArgumentAt(1).validateFor(mixedVarargsReturningStringArray);
- assertThat(new ReturnsArgumentAt(1).answer(mixedVarargsReturningStringArray)).isEqualTo(new String[]{"A", "B", "C"});
+ assertThat(new ReturnsArgumentAt(1).answer(mixedVarargsReturningStringArray))
+ .isEqualTo(new String[] {"A", "B", "C"});
- Invocation mixedVarargsReturningObjectArray = new InvocationBuilder().method("mixedVarargsReturningStringArray")
- .argTypes(Object.class, String[].class)
- .args(new Object(), new String[]{"A", "B", "C"})
- .toInvocation();
+ Invocation mixedVarargsReturningObjectArray =
+ new InvocationBuilder()
+ .method("mixedVarargsReturningStringArray")
+ .argTypes(Object.class, String[].class)
+ .args(new Object(), new String[] {"A", "B", "C"})
+ .toInvocation();
new ReturnsArgumentAt(1).validateFor(mixedVarargsReturningObjectArray);
- assertThat(new ReturnsArgumentAt(1).answer(mixedVarargsReturningObjectArray)).isEqualTo(new String[]{"A", "B", "C"});
+ assertThat(new ReturnsArgumentAt(1).answer(mixedVarargsReturningObjectArray))
+ .isEqualTo(new String[] {"A", "B", "C"});
}
@Test
- public void should_raise_an_exception_if_index_is_not_in_allowed_range_at_creation_time() throws Throwable {
+ public void should_raise_an_exception_if_index_is_not_in_allowed_range_at_creation_time()
+ throws Throwable {
try {
new ReturnsArgumentAt(-30);
fail();
} catch (Exception e) {
- assertThat(e.getMessage()).containsIgnoringCase("argument index")
- .containsIgnoringCase("positive number")
- .contains("1")
- .containsIgnoringCase("last argument");
+ assertThat(e.getMessage())
+ .containsIgnoringCase("argument index")
+ .containsIgnoringCase("positive number")
+ .contains("1")
+ .containsIgnoringCase("last argument");
}
}
@Test
public void should_allow_possible_argument_types() throws Exception {
- new ReturnsArgumentAt(0).validateFor(
- new InvocationBuilder().method("intArgumentReturningInt")
- .argTypes(int.class)
- .arg(1000)
- .toInvocation()
- );
- new ReturnsArgumentAt(0).validateFor(
- new InvocationBuilder().method("toString")
- .argTypes(String.class)
- .arg("whatever")
- .toInvocation()
- );
- new ReturnsArgumentAt(2).validateFor(
- new InvocationBuilder().method("varargsObject")
- .argTypes(int.class, Object[].class)
- .args(1000, "Object", "Object")
- .toInvocation()
- );
- new ReturnsArgumentAt(1).validateFor(
- new InvocationBuilder().method("threeArgumentMethod")
- .argTypes(int.class, Object.class, String.class)
- .args(1000, "Object", "String")
- .toInvocation()
- );
+ new ReturnsArgumentAt(0)
+ .validateFor(
+ new InvocationBuilder()
+ .method("intArgumentReturningInt")
+ .argTypes(int.class)
+ .arg(1000)
+ .toInvocation());
+ new ReturnsArgumentAt(0)
+ .validateFor(
+ new InvocationBuilder()
+ .method("toString")
+ .argTypes(String.class)
+ .arg("whatever")
+ .toInvocation());
+ new ReturnsArgumentAt(2)
+ .validateFor(
+ new InvocationBuilder()
+ .method("varargsObject")
+ .argTypes(int.class, Object[].class)
+ .args(1000, "Object", "Object")
+ .toInvocation());
+ new ReturnsArgumentAt(1)
+ .validateFor(
+ new InvocationBuilder()
+ .method("threeArgumentMethod")
+ .argTypes(int.class, Object.class, String.class)
+ .args(1000, "Object", "String")
+ .toInvocation());
}
@Test
public void should_fail_if_index_is_not_in_range_for_one_arg_invocation() throws Throwable {
try {
- new ReturnsArgumentAt(30).validateFor(new InvocationBuilder().method("oneArg")
- .arg("A")
- .toInvocation());
+ new ReturnsArgumentAt(30)
+ .validateFor(new InvocationBuilder().method("oneArg").arg("A").toInvocation());
fail();
} catch (MockitoException e) {
assertThat(e.getMessage())
@@ -149,11 +175,11 @@
}
@Test
- public void should_fail_if_index_is_not_in_range_for_example_with_no_arg_invocation() throws Throwable {
+ public void should_fail_if_index_is_not_in_range_for_example_with_no_arg_invocation()
+ throws Throwable {
try {
- new ReturnsArgumentAt(ReturnsArgumentAt.LAST_ARGUMENT).validateFor(
- new InvocationBuilder().simpleMethod().toInvocation()
- );
+ new ReturnsArgumentAt(ReturnsArgumentAt.LAST_ARGUMENT)
+ .validateFor(new InvocationBuilder().simpleMethod().toInvocation());
fail();
} catch (MockitoException e) {
assertThat(e.getMessage())
@@ -165,14 +191,16 @@
}
@Test
- public void should_fail_if_argument_type_of_signature_is_incompatible_with_return_type() throws Throwable {
+ public void should_fail_if_argument_type_of_signature_is_incompatible_with_return_type()
+ throws Throwable {
try {
- new ReturnsArgumentAt(2).validateFor(
- new InvocationBuilder().method("varargsReturningString")
- .argTypes(Object[].class)
- .args("anyString", new Object(), "anyString")
- .toInvocation()
- );
+ new ReturnsArgumentAt(2)
+ .validateFor(
+ new InvocationBuilder()
+ .method("varargsReturningString")
+ .argTypes(Object[].class)
+ .args("anyString", new Object(), "anyString")
+ .toInvocation());
fail();
} catch (WrongTypeOfReturnValue e) {
assertThat(e.getMessage())
@@ -187,19 +215,20 @@
@Test
public void shouldNotFailWhenArgumentIsGenericAndCompatibleWithReturnType() throws Exception {
- new ReturnsArgumentAt(0 ).validateFor(
- new InvocationBuilder().method("genericToString")
- .argTypes(Object.class)
- .args("anyString")
- .toInvocation()
- );
+ new ReturnsArgumentAt(0)
+ .validateFor(
+ new InvocationBuilder()
+ .method("genericToString")
+ .argTypes(Object.class)
+ .args("anyString")
+ .toInvocation());
}
-
private static InvocationOnMock invocationWith(Object... parameters) {
- return new InvocationBuilder().method("varargsReturningString")
- .argTypes(Object[].class)
- .args(new Object[] { parameters }).toInvocation(); // one vararg param (sic!)
+ return new InvocationBuilder()
+ .method("varargsReturningString")
+ .argTypes(Object[].class)
+ .args(new Object[] {parameters})
+ .toInvocation(); // one vararg param (sic!)
}
-
}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/ReturnsTest.java b/src/test/java/org/mockito/internal/stubbing/answers/ReturnsTest.java
index b4d6b43..7c59806 100644
--- a/src/test/java/org/mockito/internal/stubbing/answers/ReturnsTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/answers/ReturnsTest.java
@@ -4,17 +4,25 @@
*/
package org.mockito.internal.stubbing.answers;
+import static java.lang.Boolean.TRUE;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
import org.junit.Test;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.invocation.InvocationBuilder;
-import static java.lang.Boolean.TRUE;
-import static org.assertj.core.api.Assertions.assertThat;
-
public class ReturnsTest {
@Test
public void should_return_value() throws Throwable {
- assertThat(new Returns("value").answer(new InvocationBuilder().method("oneArg").arg("A").toInvocation())).isEqualTo("value");
+ assertThat(
+ new Returns("value")
+ .answer(
+ new InvocationBuilder()
+ .method("oneArg")
+ .arg("A")
+ .toInvocation()))
+ .isEqualTo("value");
}
@Test(expected = MockitoException.class)
@@ -25,27 +33,52 @@
@Test
public void should_allow_correct_type_of_return_value() throws Throwable {
new Returns("one").validateFor(new InvocationBuilder().simpleMethod().toInvocation());
- new Returns(false).validateFor(new InvocationBuilder().method("booleanReturningMethod").toInvocation());
- new Returns(TRUE).validateFor(new InvocationBuilder().method("booleanObjectReturningMethod").toInvocation());
- new Returns(1).validateFor(new InvocationBuilder().method("integerReturningMethod").toInvocation());
- new Returns(1L).validateFor(new InvocationBuilder().method("longReturningMethod").toInvocation());
- new Returns(1L).validateFor(new InvocationBuilder().method("longObjectReturningMethod").toInvocation());
- new Returns(null).validateFor(new InvocationBuilder().method("objectReturningMethodNoArgs").toInvocation());
- new Returns(1).validateFor(new InvocationBuilder().method("objectReturningMethodNoArgs").toInvocation());
+ new Returns(false)
+ .validateFor(
+ new InvocationBuilder().method("booleanReturningMethod").toInvocation());
+ new Returns(TRUE)
+ .validateFor(
+ new InvocationBuilder()
+ .method("booleanObjectReturningMethod")
+ .toInvocation());
+ new Returns(1)
+ .validateFor(
+ new InvocationBuilder().method("integerReturningMethod").toInvocation());
+ new Returns(1L)
+ .validateFor(new InvocationBuilder().method("longReturningMethod").toInvocation());
+ new Returns(1L)
+ .validateFor(
+ new InvocationBuilder().method("longObjectReturningMethod").toInvocation());
+ new Returns(null)
+ .validateFor(
+ new InvocationBuilder()
+ .method("objectReturningMethodNoArgs")
+ .toInvocation());
+ new Returns(1)
+ .validateFor(
+ new InvocationBuilder()
+ .method("objectReturningMethodNoArgs")
+ .toInvocation());
}
@Test(expected = MockitoException.class)
public void should_fail_on_return_type_mismatch() throws Throwable {
- new Returns("String").validateFor(new InvocationBuilder().method("booleanReturningMethod").toInvocation());
+ new Returns("String")
+ .validateFor(
+ new InvocationBuilder().method("booleanReturningMethod").toInvocation());
}
@Test(expected = MockitoException.class)
public void should_fail_on_wrong_primitive() throws Throwable {
- new Returns(1).validateFor(new InvocationBuilder().method("doubleReturningMethod").toInvocation());
+ new Returns(1)
+ .validateFor(
+ new InvocationBuilder().method("doubleReturningMethod").toInvocation());
}
@Test(expected = MockitoException.class)
public void should_fail_on_null_with_primitive() throws Throwable {
- new Returns(null).validateFor(new InvocationBuilder().method("booleanReturningMethod").toInvocation());
+ new Returns(null)
+ .validateFor(
+ new InvocationBuilder().method("booleanReturningMethod").toInvocation());
}
}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionForClassTypeTest.java b/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionForClassTypeTest.java
new file mode 100644
index 0000000..ae1b880
--- /dev/null
+++ b/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionForClassTypeTest.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.stubbing.answers;
+
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+
+import org.junit.Test;
+
+public class ThrowsExceptionForClassTypeTest {
+ @Test
+ public void should_return_throwable_of_expected_class() {
+ ThrowsExceptionForClassType throwsExceptionForClassType =
+ new ThrowsExceptionForClassType(Exception.class);
+
+ assertSame(Exception.class, throwsExceptionForClassType.getThrowable().getClass());
+ }
+
+ @Test
+ public void should_return_different_throwables() {
+ ThrowsExceptionForClassType throwsExceptionForClassType =
+ new ThrowsExceptionForClassType(Exception.class);
+
+ Throwable first = throwsExceptionForClassType.getThrowable();
+ Throwable second = throwsExceptionForClassType.getThrowable();
+ assertNotSame(first, second);
+ }
+}
diff --git a/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java b/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java
index 2e71102..9b8e799 100644
--- a/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java
@@ -4,27 +4,31 @@
*/
package org.mockito.internal.stubbing.answers;
+import static junit.framework.TestCase.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.mock;
+
import java.io.IOException;
import java.nio.charset.CharacterCodingException;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockito.invocation.Invocation;
-import static junit.framework.TestCase.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-
-
public class ThrowsExceptionTest {
@Test
public void should_raise_wanted_throwable() throws Throwable {
try {
- new ThrowsException(new IllegalStateException("my dear throwable")).answer(createMethodInvocation());
+ new ThrowsException(new IllegalStateException("my dear throwable"))
+ .answer(createMethodInvocation());
Assertions.fail("should have raised wanted exception");
} catch (Throwable throwable) {
- assertThat(throwable).isInstanceOf(IllegalStateException.class).hasMessage("my dear throwable");
+ assertThat(throwable)
+ .isInstanceOf(IllegalStateException.class)
+ .hasMessage("my dear throwable");
}
}
@@ -43,8 +47,10 @@
// given
Exception throwableToRaise = new Exception();
throwableToRaise.fillInStackTrace();
- assertThat(throwableToRaise.getStackTrace()[0].getClassName()).isEqualTo(this.getClass().getName());
- assertThat(throwableToRaise.getStackTrace()[0].getMethodName()).isEqualTo("should_fill_in_exception_stacktrace");
+ assertThat(throwableToRaise.getStackTrace()[0].getClassName())
+ .isEqualTo(this.getClass().getName());
+ assertThat(throwableToRaise.getStackTrace()[0].getMethodName())
+ .isEqualTo("should_fill_in_exception_stacktrace");
try {
// when
@@ -53,7 +59,8 @@
} catch (Throwable throwable) {
// then
throwable.printStackTrace();
- assertThat(throwableToRaise.getStackTrace()[0].getClassName()).isEqualTo(ThrowsException.class.getName());
+ assertThat(throwableToRaise.getStackTrace()[0].getClassName())
+ .isEqualTo(AbstractThrowsException.class.getName());
assertThat(throwableToRaise.getStackTrace()[0].getMethodName()).isEqualTo("answer");
}
}
@@ -64,7 +71,8 @@
Invocation invocation = createMethodInvocation();
new ThrowsException(null).validateFor(invocation);
Assertions.fail("should have raised a MockitoException");
- } catch (MockitoException expected) {}
+ } catch (MockitoException expected) {
+ }
}
@Test
@@ -93,10 +101,25 @@
new ThrowsException(new RuntimeException()).validateFor(createMethodInvocation());
}
+ @Test
+ public void should_return_expected_throwable() {
+ Throwable expected = new Exception();
+ ThrowsException throwsException = new ThrowsException(expected);
+
+ assertSame(expected, throwsException.getThrowable());
+ }
+
+ @Test
+ public void should_return_same_throwable() {
+ ThrowsException throwsException = new ThrowsException(new Exception());
+
+ Throwable first = throwsException.getThrowable();
+ Throwable second = throwsException.getThrowable();
+ assertSame(first, second);
+ }
+
/** Creates Invocation of a "canThrowException" method call. */
private static Invocation createMethodInvocation() {
- return new InvocationBuilder()
- .method("canThrowException")
- .toInvocation();
+ return new InvocationBuilder().method("canThrowException").toInvocation();
}
}
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocationsTest.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocationsTest.java
index 6da2a10..a2a28ef 100644
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocationsTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ForwardsInvocationsTest.java
@@ -4,11 +4,11 @@
*/
package org.mockito.internal.stubbing.defaultanswers;
+import static org.junit.Assert.assertEquals;
+
import org.junit.Test;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-
public class ForwardsInvocationsTest extends TestBase {
interface Foo {
@@ -25,12 +25,17 @@
@Test
public void should_call_method_with_varargs() throws Throwable {
ForwardsInvocations forwardsInvocations = new ForwardsInvocations(new FooImpl());
- assertEquals(4, forwardsInvocations.answer(invocationOf(Foo.class, "bar", "b", new Object[] {12, "3", 4.5})));
+ assertEquals(
+ 4,
+ forwardsInvocations.answer(
+ invocationOf(Foo.class, "bar", "b", new Object[] {12, "3", 4.5})));
}
@Test
public void should_call_method_with_empty_varargs() throws Throwable {
ForwardsInvocations forwardsInvocations = new ForwardsInvocations(new FooImpl());
- assertEquals(1, forwardsInvocations.answer(invocationOf(Foo.class, "bar", "b", new Object[] {})));
+ assertEquals(
+ 1,
+ forwardsInvocations.answer(invocationOf(Foo.class, "bar", "b", new Object[] {})));
}
}
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/HasPrimitiveMethods.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/HasPrimitiveMethods.java
index 9aaea02..77f3b64 100755
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/HasPrimitiveMethods.java
+++ b/src/test/java/org/mockito/internal/stubbing/defaultanswers/HasPrimitiveMethods.java
@@ -7,11 +7,18 @@
@SuppressWarnings("unused")
interface HasPrimitiveMethods {
boolean booleanMethod();
+
char charMethod();
+
byte byteMethod();
+
short shortMethod();
+
int intMethod();
+
long longMethod();
+
float floatMethod();
+
double doubleMethod();
}
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java
index 68fbaf5..c80c746 100644
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java
@@ -2,19 +2,18 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.stubbing.defaultanswers;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.mock;
+
+import java.util.*;
+
import org.junit.Assume;
import org.junit.Test;
import org.mockito.invocation.Invocation;
import org.mockitoutil.TestBase;
-import java.util.*;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.mock;
-
public class ReturnsEmptyValuesTest extends TestBase {
private final ReturnsEmptyValues values = new ReturnsEmptyValues();
@@ -67,25 +66,25 @@
d.compareTo(new Date());
Invocation compareTo = this.getLastInvocation();
- //when
+ // when
Object result = values.answer(compareTo);
- //then
+ // then
assertTrue(result != (Object) 0);
}
@SuppressWarnings("SelfComparison")
@Test
public void should_return_zero_if_mock_is_compared_to_itself() {
- //given
+ // given
Date d = mock(Date.class);
d.compareTo(d);
Invocation compareTo = this.getLastInvocation();
- //when
+ // when
Object result = values.answer(compareTo);
- //then
+ // then
assertEquals(0, result);
}
@@ -96,7 +95,8 @@
@Test
public void should_return_empty_OptionalDouble() throws Exception {
- verify_empty_Optional_is_returned("java.util.stream.DoubleStream", "java.util.OptionalDouble");
+ verify_empty_Optional_is_returned(
+ "java.util.stream.DoubleStream", "java.util.OptionalDouble");
}
@Test
@@ -109,10 +109,11 @@
verify_empty_Optional_is_returned("java.util.stream.LongStream", "java.util.OptionalLong");
}
- private void verify_empty_Optional_is_returned(String streamFqcn, String optionalFqcn) throws Exception {
+ private void verify_empty_Optional_is_returned(String streamFqcn, String optionalFqcn)
+ throws Exception {
Class<?> streamType = getClassOrSkipTest(streamFqcn);
- //given
+ // given
Object stream = mock(streamType);
Object optional = streamType.getMethod("findAny").invoke(stream);
assertNotNull(optional);
@@ -120,10 +121,10 @@
Invocation findAny = this.getLastInvocation();
- //when
+ // when
Object result = values.answer(findAny);
- //then
+ // then
assertEquals(optional, result);
}
@@ -159,6 +160,22 @@
assertEquals("count of empty " + streamFqcn, 0L, count);
}
+ @Test
+ public void should_return_empty_duration() throws Exception {
+ // given
+ final String fqcn = "java.time.Duration";
+ final Class<?> durationClass = getClassOrSkipTest(fqcn);
+
+ // when
+ final Object duration = values.returnValueFor(durationClass);
+ final int nano = (Integer) durationClass.getMethod("getNano").invoke(duration);
+ final long seconds = (Long) durationClass.getMethod("getSeconds").invoke(duration);
+
+ // then
+ assertEquals("nano of empty " + fqcn, 0, nano);
+ assertEquals("seconds of empty " + fqcn, 0L, seconds);
+ }
+
/**
* Tries to load the given class. If the class is not found, the complete test is skipped.
*/
@@ -170,5 +187,4 @@
return null;
}
}
-
}
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java
index d91df8c..fb239c0 100644
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsGenericDeepStubsTest.java
@@ -4,16 +4,20 @@
*/
package org.mockito.internal.stubbing.defaultanswers;
-import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import java.io.Closeable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.concurrent.Callable;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
-import static org.mockito.Mockito.mock;
+import org.junit.Test;
+import org.mockitousage.examples.use.Article;
@SuppressWarnings("unused")
public class ReturnsGenericDeepStubsTest {
@@ -23,21 +27,29 @@
interface GenericsNest<K extends Comparable<K> & Cloneable> extends Map<K, Set<Number>> {
Set<Number> remove(Object key); // override with fixed ParameterizedType
+
List<? super Number> returningWildcard();
+
Map<String, K> returningNonMockableNestedGeneric();
+
K returningK();
+
<O extends K> List<O> paramTypeWithTypeParams();
+
<S extends Appendable, T extends S> T twoTypeParams(S s);
+
<O extends K> O typeVarWithTypeParams();
+
Number returnsNormalType();
}
@Test
- public void generic_deep_mock_frenzy__look_at_these_chained_calls() throws Exception {
+ public void generic_deep_mock_frenzy__look_at_these_chained_calls() {
GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
Set<? extends Map.Entry<? extends Cloneable, Set<Number>>> entries = mock.entrySet();
- Iterator<? extends Map.Entry<? extends Cloneable,Set<Number>>> entriesIterator = mock.entrySet().iterator();
+ Iterator<? extends Map.Entry<? extends Cloneable, Set<Number>>> entriesIterator =
+ mock.entrySet().iterator();
Map.Entry<? extends Cloneable, Set<Number>> nextEntry = mock.entrySet().iterator().next();
Cloneable cloneableKey = mock.entrySet().iterator().next().getKey();
@@ -49,17 +61,21 @@
}
@Test
- public void can_create_mock_from_multiple_type_variable_bounds_when_return_type_of_parameterized_method_is_a_parameterizedtype_that_is_referencing_a_typevar_on_class() throws Exception {
+ public void
+ can_create_mock_from_multiple_type_variable_bounds_when_return_type_of_parameterized_method_is_a_parameterizedType_that_is_referencing_a_typeVar_on_class() {
GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
- Cloneable cloneable_bound_that_is_declared_on_typevar_K_in_the_class_which_is_referenced_by_typevar_O_declared_on_the_method =
- mock.paramTypeWithTypeParams().get(0);
- Comparable<?> comparable_bound_that_is_declared_on_typevar_K_in_the_class_which_is_referenced_by_typevar_O_declared_on_the_method =
- mock.paramTypeWithTypeParams().get(0);
+ Cloneable
+ cloneable_bound_that_is_declared_on_typevar_K_in_the_class_which_is_referenced_by_typevar_O_declared_on_the_method =
+ mock.paramTypeWithTypeParams().get(0);
+ Comparable<?>
+ comparable_bound_that_is_declared_on_typevar_K_in_the_class_which_is_referenced_by_typevar_O_declared_on_the_method =
+ mock.paramTypeWithTypeParams().get(0);
}
@Test
- public void can_create_mock_from_multiple_type_variable_bounds_when_method_return_type_is_referencing_a_typevar_on_class() throws Exception {
+ public void
+ can_create_mock_from_multiple_type_variable_bounds_when_method_return_type_is_referencing_a_typeVar_on_class() {
GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
Cloneable cloneable_bound_of_typevar_K = mock.returningK();
@@ -67,24 +83,28 @@
}
@Test
- public void can_create_mock_from_multiple_type_variable_bounds_when_return_type_of_parameterized_method_is_a_typevar_that_is_referencing_a_typevar_on_class() throws Exception {
+ public void
+ can_create_mock_from_multiple_type_variable_bounds_when_return_type_of_parameterized_method_is_a_typeVar_that_is_referencing_a_typeVar_on_class() {
GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
- Cloneable cloneable_bound_of_typevar_K_referenced_by_typevar_O = (Cloneable) mock.typeVarWithTypeParams();
- Comparable<?> comparable_bound_of_typevar_K_referenced_by_typevar_O = (Comparable<?>) mock.typeVarWithTypeParams();
+ Cloneable cloneable_bound_of_typevar_K_referenced_by_typevar_O =
+ (Cloneable) mock.typeVarWithTypeParams();
+ Comparable<?> comparable_bound_of_typevar_K_referenced_by_typevar_O =
+ (Comparable<?>) mock.typeVarWithTypeParams();
}
@Test
- public void can_create_mock_from_return_types_declared_with_a_bounded_wildcard() throws Exception {
+ public void can_create_mock_from_return_types_declared_with_a_bounded_wildcard() {
GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
List<? super Integer> objects = mock.returningWildcard();
- Number type_that_is_the_upper_bound_of_the_wildcard = (Number) mock.returningWildcard().get(45);
+ Number type_that_is_the_upper_bound_of_the_wildcard =
+ (Number) mock.returningWildcard().get(45);
type_that_is_the_upper_bound_of_the_wildcard.floatValue();
}
@Test
- public void can_still_work_with_raw_type_in_the_return_type() throws Exception {
+ public void can_still_work_with_raw_type_in_the_return_type() {
GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
Number the_raw_type_that_should_be_returned = mock.returnsNormalType();
@@ -92,22 +112,97 @@
}
@Test
- public void will_return_default_value_on_non_mockable_nested_generic() throws Exception {
+ public void will_return_default_value_on_non_mockable_nested_generic() {
GenericsNest<?> genericsNest = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
ListOfInteger listOfInteger = mock(ListOfInteger.class, RETURNS_DEEP_STUBS);
- AnotherListOfInteger anotherListOfInteger = mock(AnotherListOfInteger.class, RETURNS_DEEP_STUBS);
+ AnotherListOfInteger anotherListOfInteger =
+ mock(AnotherListOfInteger.class, RETURNS_DEEP_STUBS);
- assertThat(genericsNest.returningNonMockableNestedGeneric().keySet().iterator().next()).isNull();
+ assertThat(genericsNest.returningNonMockableNestedGeneric().keySet().iterator().next())
+ .isNull();
assertThat(listOfInteger.get(25)).isEqualTo(0);
assertThat(anotherListOfInteger.get(25)).isEqualTo(0);
}
@Test(expected = ClassCastException.class)
- public void as_expected_fail_with_a_CCE_on_callsite_when_erasure_takes_place_for_example___StringBuilder_is_subject_to_erasure() throws Exception {
+ public void
+ as_expected_fail_with_a_CCE_on_call_site_when_erasure_takes_place_for_example___StringBuilder_is_subject_to_erasure() {
GenericsNest<?> mock = mock(GenericsNest.class, RETURNS_DEEP_STUBS);
// following assignment needed to create a ClassCastException on the call site (i.e. : here)
StringBuilder stringBuilder_assignment_that_should_throw_a_CCE =
mock.twoTypeParams(new StringBuilder()).append(2).append(3);
}
+
+ class WithGenerics<T> {
+ T execute() {
+ throw new IllegalArgumentException();
+ }
+ }
+
+ class SubClass<S> extends WithGenerics<S> {}
+
+ class UserOfSubClass {
+ SubClass<String> generate() {
+ return null;
+ }
+ }
+
+ @Test
+ public void can_handle_deep_stubs_with_generics_at_end_of_deep_invocation() {
+ UserOfSubClass mock = mock(UserOfSubClass.class, RETURNS_DEEP_STUBS);
+
+ when(mock.generate().execute()).thenReturn("sub");
+
+ assertThat(mock.generate().execute()).isEqualTo("sub");
+ }
+
+ public interface TopInterface<T> {
+ T generic();
+ }
+
+ public interface MiddleInterface<T> extends TopInterface<T> {}
+
+ public class OwningClassWithDeclaredUpperBounds<
+ T extends Iterable<Article> & Callable<Article> & Closeable> {
+ public abstract class AbstractInner implements MiddleInterface<T> {}
+ }
+
+ @Test
+ public void
+ cannot_handle_deep_stubs_with_generics_declared_upper_bounds_at_end_of_deep_invocation()
+ throws Exception {
+ OwningClassWithDeclaredUpperBounds.AbstractInner mock =
+ mock(OwningClassWithDeclaredUpperBounds.AbstractInner.class, RETURNS_DEEP_STUBS);
+
+ // It seems that while the syntax used on OwningClassWithDeclaredUpperBounds.AbstractInner
+ // appear to be legal, the javac compiler does not follow through
+ // hence we need casting, this may also explain why GenericMetadataSupport has trouble to
+ // extract matching data as well.
+
+ assertThat(mock.generic())
+ .describedAs("mock should implement first bound : 'Iterable'")
+ .isInstanceOf(Iterable.class);
+ assertThat(((Iterable<Article>) mock.generic()).iterator())
+ .describedAs("Iterable returns Iterator")
+ .isInstanceOf(Iterator.class);
+ assertThat(((Iterable<Article>) mock.generic()).iterator().next())
+ .describedAs(
+ "Cannot yet extract Type argument 'Article' so return null instead of a mock "
+ + "of type Object (which would raise CCE on the call-site)")
+ .isNull();
+
+ assertThat(mock.generic())
+ .describedAs("mock should implement second interface bound : 'Callable'")
+ .isInstanceOf(Callable.class);
+ assertThat(((Callable<Article>) mock.generic()).call())
+ .describedAs(
+ "Cannot yet extract Type argument 'Article' so return null instead of a mock "
+ + "of type Object (which would raise CCE on the call-site)")
+ .isNull();
+
+ assertThat(mock.generic())
+ .describedAs("mock should implement third interface bound : 'Closeable'")
+ .isInstanceOf(Closeable.class);
+ }
}
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocksTest.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocksTest.java
index 7de160c..3691412 100755
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocksTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMocksTest.java
@@ -4,51 +4,75 @@
*/
package org.mockito.internal.stubbing.defaultanswers;
-import org.junit.Test;
-import org.mockito.internal.configuration.plugins.Plugins;
-import org.mockito.internal.util.MockUtil;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.*;
import static org.junit.Assume.assumeFalse;
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.internal.stubbing.defaultanswers.ReturnsGenericDeepStubsTest.WithGenerics;
+import org.mockito.internal.util.MockUtil;
+import org.mockitoutil.TestBase;
public class ReturnsMocksTest extends TestBase {
private ReturnsMocks values = new ReturnsMocks();
- interface FooInterface {
+ interface AllInterface {
+ FooInterface getInterface();
+
+ BarClass getNormalClass();
+
+ Baz getFinalClass();
+
+ WithGenerics<String> withGenerics();
}
- class BarClass {
- }
+ interface FooInterface {}
- final class Baz {
- }
+ class BarClass {}
+
+ final class Baz {}
@Test
- public void should_return_mock_value_for_interface() throws Exception {
- Object interfaceMock = values.returnValueFor(FooInterface.class);
+ public void should_return_mock_value_for_interface() throws Throwable {
+ Object interfaceMock = values.answer(invocationOf(AllInterface.class, "getInterface"));
assertTrue(MockUtil.isMock(interfaceMock));
}
@Test
- public void should_return_mock_value_for_class() throws Exception {
- Object classMock = values.returnValueFor(BarClass.class);
+ public void should_return_mock_value_for_class() throws Throwable {
+ Object classMock = values.answer(invocationOf(AllInterface.class, "getNormalClass"));
assertTrue(MockUtil.isMock(classMock));
}
+ @SuppressWarnings("unchecked")
@Test
- public void should_return_null_for_final_class_if_unsupported() throws Exception {
+ public void should_return_mock_value_for_generic_class() throws Throwable {
+ WithGenerics<String> classMock =
+ (WithGenerics<String>)
+ values.answer(invocationOf(AllInterface.class, "withGenerics"));
+ assertTrue(MockUtil.isMock(classMock));
+ when(classMock.execute()).thenReturn("return");
+ assertEquals("return", classMock.execute());
+ }
+
+ @Test
+ public void should_return_null_for_final_class_if_unsupported() throws Throwable {
assumeFalse(Plugins.getMockMaker().isTypeMockable(Baz.class).mockable());
- assertNull(values.returnValueFor(Baz.class));
+ assertNull(values.answer(invocationOf(AllInterface.class, "getFinalClass")));
}
@Test
public void should_return_the_usual_default_values_for_primitives() throws Throwable {
ReturnsMocks answer = new ReturnsMocks();
- assertEquals(false, answer.answer(invocationOf(HasPrimitiveMethods.class, "booleanMethod")));
- assertEquals((char) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "charMethod")));
- assertEquals((byte) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "byteMethod")));
- assertEquals((short) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "shortMethod")));
+ assertEquals(
+ false, answer.answer(invocationOf(HasPrimitiveMethods.class, "booleanMethod")));
+ assertEquals(
+ (char) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "charMethod")));
+ assertEquals(
+ (byte) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "byteMethod")));
+ assertEquals(
+ (short) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "shortMethod")));
assertEquals(0, answer.answer(invocationOf(HasPrimitiveMethods.class, "intMethod")));
assertEquals(0L, answer.answer(invocationOf(HasPrimitiveMethods.class, "longMethod")));
assertEquals(0f, answer.answer(invocationOf(HasPrimitiveMethods.class, "floatMethod")));
@@ -58,12 +82,14 @@
@SuppressWarnings("unused")
interface StringMethods {
String stringMethod();
+
String[] stringArrayMethod();
}
@Test
public void should_return_empty_array() throws Throwable {
- String[] ret = (String[]) values.answer(invocationOf(StringMethods.class, "stringArrayMethod"));
+ String[] ret =
+ (String[]) values.answer(invocationOf(StringMethods.class, "stringArrayMethod"));
assertTrue(ret.getClass().isArray());
assertTrue(ret.length == 0);
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValuesTest.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValuesTest.java
index 4eac8cb..15ba0cd 100644
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValuesTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValuesTest.java
@@ -4,12 +4,12 @@
*/
package org.mockito.internal.stubbing.defaultanswers;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
public class ReturnsMoreEmptyValuesTest extends TestBase {
private ReturnsMoreEmptyValues rv = new ReturnsMoreEmptyValues();
diff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNullsTest.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNullsTest.java
index 228c56a..870f0ce 100644
--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNullsTest.java
+++ b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsSmartNullsTest.java
@@ -5,38 +5,58 @@
package org.mockito.internal.stubbing.defaultanswers;
import static org.assertj.core.api.Assertions.assertThat;
-
-import org.junit.Test;
-import org.mockito.exceptions.verification.SmartNullPointerException;
-import org.mockito.stubbing.Answer;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Test;
+import org.mockito.exceptions.verification.SmartNullPointerException;
+import org.mockito.internal.debugging.LocationImpl;
+import org.mockito.internal.invocation.InterceptedInvocation;
+import org.mockito.internal.invocation.SerializableMethod;
+import org.mockito.internal.invocation.mockref.MockStrongReference;
+import org.mockito.stubbing.Answer;
+import org.mockitoutil.TestBase;
public class ReturnsSmartNullsTest extends TestBase {
@Test
public void should_return_the_usual_default_values_for_primitives() throws Throwable {
Answer<Object> answer = new ReturnsSmartNulls();
- assertEquals(false , answer.answer(invocationOf(HasPrimitiveMethods.class, "booleanMethod")));
- assertEquals((char) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "charMethod")));
- assertEquals((byte) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "byteMethod")));
- assertEquals((short) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "shortMethod")));
- assertEquals(0, answer.answer(invocationOf(HasPrimitiveMethods.class, "intMethod")));
- assertEquals(0L, answer.answer(invocationOf(HasPrimitiveMethods.class, "longMethod")));
- assertEquals(0f, answer.answer(invocationOf(HasPrimitiveMethods.class, "floatMethod")));
- assertEquals(0d, answer.answer(invocationOf(HasPrimitiveMethods.class, "doubleMethod")));
+ assertEquals(
+ false, answer.answer(invocationOf(HasPrimitiveMethods.class, "booleanMethod")));
+ assertEquals(
+ (char) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "charMethod")));
+ assertEquals(
+ (byte) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "byteMethod")));
+ assertEquals(
+ (short) 0, answer.answer(invocationOf(HasPrimitiveMethods.class, "shortMethod")));
+ assertEquals(0, answer.answer(invocationOf(HasPrimitiveMethods.class, "intMethod")));
+ assertEquals(0L, answer.answer(invocationOf(HasPrimitiveMethods.class, "longMethod")));
+ assertEquals(0f, answer.answer(invocationOf(HasPrimitiveMethods.class, "floatMethod")));
+ assertEquals(0d, answer.answer(invocationOf(HasPrimitiveMethods.class, "doubleMethod")));
}
@SuppressWarnings("unused")
interface Foo {
Foo get();
+
Foo withArgs(String oneArg, String otherArg);
}
@Test
- public void should_return_an_object_that_fails_on_any_method_invocation_for_non_primitives() throws Throwable {
+ public void should_return_an_object_that_fails_on_any_method_invocation_for_non_primitives()
+ throws Throwable {
Answer<Object> answer = new ReturnsSmartNulls();
Foo smartNull = (Foo) answer.answer(invocationOf(Foo.class, "get"));
@@ -44,7 +64,8 @@
try {
smartNull.get();
fail();
- } catch (SmartNullPointerException expected) {}
+ } catch (SmartNullPointerException expected) {
+ }
}
@Test
@@ -53,9 +74,7 @@
Foo smartNull = (Foo) answer.answer(invocationOf(Foo.class, "get"));
- assertThat(smartNull.toString())
- .contains("SmartNull returned by")
- .contains("foo.get()");
+ assertThat(smartNull.toString()).contains("SmartNull returned by").contains("foo.get()");
}
@Test
@@ -65,13 +84,14 @@
Foo smartNull = (Foo) answer.answer(invocationOf(Foo.class, "withArgs", "oompa", "lumpa"));
assertThat(smartNull.toString())
- .contains("foo.withArgs")
- .contains("oompa")
- .contains("lumpa");
+ .contains("foo.withArgs")
+ .contains("oompa")
+ .contains("lumpa");
}
@Test
- public void should_print_the_parameters_on_SmartNullPointerException_message() throws Throwable {
+ public void should_print_the_parameters_on_SmartNullPointerException_message()
+ throws Throwable {
Answer<Object> answer = new ReturnsSmartNulls();
Foo smartNull = (Foo) answer.answer(invocationOf(Foo.class, "withArgs", "oompa", "lumpa"));
@@ -80,9 +100,281 @@
smartNull.get();
fail();
} catch (SmartNullPointerException e) {
- assertThat(e)
- .hasMessageContaining("oompa")
- .hasMessageContaining("lumpa");
+ assertThat(e).hasMessageContaining("oompa").hasMessageContaining("lumpa");
}
}
+
+ interface GenericFoo<T> {
+ T get();
+ }
+
+ interface GenericFooBar extends GenericFoo<Foo> {
+ <I> I method();
+
+ <I> I methodWithArgs(int firstArg, I secondArg);
+
+ <I> I methodWithVarArgs(int firstArg, I... secondArg);
+ }
+
+ @Test
+ public void should_return_an_object_that_has_been_defined_with_class_generic()
+ throws Throwable {
+ Answer<Object> answer = new ReturnsSmartNulls();
+
+ Foo smartNull = (Foo) answer.answer(invocationOf(GenericFooBar.class, "get"));
+
+ assertThat(smartNull.toString())
+ .contains("SmartNull returned by")
+ .contains("genericFooBar.get()");
+ }
+
+ @Test
+ public void should_return_an_object_that_has_been_defined_with_method_generic()
+ throws Throwable {
+
+ Answer<Object> answer = new ReturnsSmartNulls();
+
+ String smartNull = (String) answer.answer(invocationOf(GenericFooBar.class, "method"));
+
+ assertThat(smartNull).isNull();
+ }
+
+ private static <T> InterceptedInvocation invocationMethodWithArgs(final T obj)
+ throws NoSuchMethodException {
+ return new InterceptedInvocation(
+ new MockStrongReference<Object>(mock(GenericFooBar.class), false),
+ new SerializableMethod(
+ GenericFooBar.class.getMethod("methodWithArgs", int.class, Object.class)),
+ new Object[] {1, obj},
+ InterceptedInvocation.NO_OP,
+ new LocationImpl(),
+ 1);
+ }
+
+ @Test
+ public void
+ should_return_a_String_that_has_been_defined_with_method_generic_and_provided_in_argument()
+ throws Throwable {
+
+ Answer<Object> answer = new ReturnsSmartNulls();
+
+ Object smartNull = answer.answer(invocationMethodWithArgs("secondArg"));
+
+ assertThat(smartNull).isNotNull().isInstanceOf(String.class).asString().isEmpty();
+ }
+
+ @Test
+ public void
+ should_return_a_empty_list_that_has_been_defined_with_method_generic_and_provided_in_argument()
+ throws Throwable {
+
+ final List<String> list = Collections.singletonList("String");
+ Answer<Object> answer = new ReturnsSmartNulls();
+
+ Object smartNull = answer.answer(invocationMethodWithArgs(list));
+
+ assertThat(smartNull).isNotNull().isInstanceOf(List.class);
+ assertThat((List) smartNull).isEmpty();
+ }
+
+ @Test
+ public void
+ should_return_a_empty_map_that_has_been_defined_with_method_generic_and_provided_in_argument()
+ throws Throwable {
+
+ final Map<String, String> map = new HashMap<String, String>();
+ map.put("key-1", "value-1");
+ map.put("key-2", "value-2");
+ Answer<Object> answer = new ReturnsSmartNulls();
+
+ Object smartNull = answer.answer(invocationMethodWithArgs(map));
+
+ assertThat(smartNull).isNotNull().isInstanceOf(Map.class);
+ assertThat((Map) smartNull).isEmpty();
+ }
+
+ @Test
+ public void
+ should_return_a_empty_set_that_has_been_defined_with_method_generic_and_provided_in_argument()
+ throws Throwable {
+
+ Answer<Object> answer = new ReturnsSmartNulls();
+
+ Object smartNull =
+ answer.answer(
+ invocationMethodWithArgs(
+ new HashSet<String>(Arrays.asList("set-1", "set-2"))));
+
+ assertThat(smartNull).isNotNull().isInstanceOf(Set.class);
+ assertThat((Set) smartNull).isEmpty();
+ }
+
+ @Test
+ public void
+ should_return_a_new_mock_that_has_been_defined_with_method_generic_and_provided_in_argument()
+ throws Throwable {
+
+ Answer<Object> answer = new ReturnsSmartNulls();
+ final Foo mock = mock(Foo.class);
+
+ Object smartNull = answer.answer(invocationMethodWithArgs(mock));
+
+ assertThat(smartNull).isNotNull().isNotSameAs(mock);
+ assertThat(smartNull.toString())
+ .contains("SmartNull returned by")
+ .contains("genericFooBar.methodWithArgs(");
+ }
+
+ @Test
+ public void
+ should_return_an_Object_that_has_been_defined_with_method_generic_and_provided_in_argument()
+ throws Throwable {
+
+ Answer<Object> answer = new ReturnsSmartNulls();
+
+ Object smartNull = answer.answer(invocationMethodWithArgs(new Object() {}));
+
+ assertThat(smartNull.toString())
+ .contains("SmartNull returned by")
+ .contains("genericFooBar.methodWithArgs(");
+ }
+
+ @Test
+ public void should_throw_a_error_on_invocation_of_returned_mock() throws Throwable {
+
+ final Answer<Object> answer = new ReturnsSmartNulls();
+ final Foo mock = mock(Foo.class);
+
+ final Throwable throwable =
+ Assertions.catchThrowable(
+ new ThrowableAssert.ThrowingCallable() {
+ @Override
+ public void call() throws Throwable {
+ ((Foo) answer.answer(invocationMethodWithArgs(mock))).get();
+ }
+ });
+
+ Assertions.assertThat(throwable)
+ .isInstanceOf(SmartNullPointerException.class)
+ .hasMessageContaining("genericFooBar.methodWithArgs(")
+ .hasMessageContaining("1")
+ .hasMessageContaining(mock.toString());
+ }
+
+ private static <T> InterceptedInvocation invocationMethodWithVarArgs(final T[] obj)
+ throws NoSuchMethodException {
+ return new InterceptedInvocation(
+ new MockStrongReference<Object>(mock(GenericFooBar.class), false),
+ new SerializableMethod(
+ GenericFooBar.class.getMethod(
+ "methodWithVarArgs", int.class, Object[].class)),
+ new Object[] {1, obj},
+ InterceptedInvocation.NO_OP,
+ new LocationImpl(),
+ 1);
+ }
+
+ @Test
+ public void
+ should_return_a_String_that_has_been_defined_with_method_generic_and_provided_in_var_args()
+ throws Throwable {
+
+ Answer<Object> answer = new ReturnsSmartNulls();
+
+ Object smartNull =
+ answer.answer(invocationMethodWithVarArgs(new String[] {"varArg-1", "varArg-2"}));
+
+ assertThat(smartNull).isNotNull().isInstanceOf(String.class).asString().isEmpty();
+ }
+
+ @Test
+ public void
+ should_return_a_empty_list_that_has_been_defined_with_method_generic_and_provided_in_var_args()
+ throws Throwable {
+
+ final List<String> arg1 = Collections.singletonList("String");
+ final List<String> arg2 = Arrays.asList("str-1", "str-2");
+ Answer<Object> answer = new ReturnsSmartNulls();
+
+ Object smartNull = answer.answer(invocationMethodWithVarArgs(new List[] {arg1, arg2}));
+
+ assertThat(smartNull).isNotNull().isInstanceOf(List.class);
+ assertThat((List) smartNull).isEmpty();
+ }
+
+ @Test
+ public void
+ should_return_a_empty_map_that_has_been_defined_with_method_generic_and_provided_in_var_args()
+ throws Throwable {
+
+ final Map<String, String> map1 =
+ new HashMap<String, String>() {
+ {
+ put("key-1", "value-1");
+ put("key-2", "value-2");
+ }
+ };
+ final Map<String, String> map2 =
+ new HashMap<String, String>() {
+ {
+ put("key-3", "value-1");
+ put("key-4", "value-2");
+ }
+ };
+ Answer<Object> answer = new ReturnsSmartNulls();
+
+ Object smartNull = answer.answer(invocationMethodWithVarArgs(new Map[] {map1, map2}));
+
+ assertThat(smartNull).isNotNull().isInstanceOf(Map.class);
+ assertThat((Map) smartNull).isEmpty();
+ }
+
+ @Test
+ public void
+ should_return_a_empty_set_that_has_been_defined_with_method_generic_and_provided_in_var_args()
+ throws Throwable {
+
+ final HashSet<String> set1 = new HashSet<String>(Arrays.asList("set-1", "set-2"));
+ final HashSet<String> set2 = new HashSet<String>(Arrays.asList("set-1", "set-2"));
+ Answer<Object> answer = new ReturnsSmartNulls();
+
+ Object smartNull = answer.answer(invocationMethodWithVarArgs(new HashSet[] {set1, set2}));
+
+ assertThat(smartNull).isNotNull().isInstanceOf(Set.class);
+ assertThat((Set) smartNull).isEmpty();
+ }
+
+ @Test
+ public void
+ should_return_a_new_mock_that_has_been_defined_with_method_generic_and_provided_in_var_args()
+ throws Throwable {
+
+ Answer<Object> answer = new ReturnsSmartNulls();
+ final Foo mock1 = mock(Foo.class);
+ final Foo mock2 = mock(Foo.class);
+
+ Object smartNull = answer.answer(invocationMethodWithVarArgs(new Foo[] {mock1, mock2}));
+
+ assertThat(smartNull).isNotNull().isNotSameAs(mock1).isNotSameAs(mock2);
+ assertThat(smartNull.toString())
+ .contains("SmartNull returned by")
+ .contains("genericFooBar.methodWithVarArgs(");
+ }
+
+ @Test
+ public void
+ should_return_an_Object_that_has_been_defined_with_method_generic_and_provided_in_var_args()
+ throws Throwable {
+
+ Answer<Object> answer = new ReturnsSmartNulls();
+
+ Object smartNull =
+ answer.answer(
+ invocationMethodWithVarArgs(
+ new Object[] {new Object() {}, new Object() {}}));
+
+ assertThat(smartNull.toString())
+ .contains("SmartNull returned by")
+ .contains("genericFooBar.methodWithVarArgs(");
+ }
}
diff --git a/src/test/java/org/mockito/internal/util/ChecksTest.java b/src/test/java/org/mockito/internal/util/ChecksTest.java
index d2c75b5..21d067d 100644
--- a/src/test/java/org/mockito/internal/util/ChecksTest.java
+++ b/src/test/java/org/mockito/internal/util/ChecksTest.java
@@ -2,7 +2,6 @@
* Copyright (c) 2017 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.util;
import static org.junit.Assert.assertEquals;
@@ -12,8 +11,7 @@
import org.junit.rules.ExpectedException;
public class ChecksTest {
- @Rule
- public ExpectedException expectedException = ExpectedException.none();
+ @Rule public ExpectedException expectedException = ExpectedException.none();
@Test
public void checkNotNull_not_null() throws Exception {
diff --git a/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java b/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java
index ae2ef25..b199054 100644
--- a/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java
+++ b/src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java
@@ -4,6 +4,20 @@
*/
package org.mockito.internal.util;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+import java.util.Collection;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
@@ -14,20 +28,6 @@
import org.mockito.stubbing.Stubbing;
import org.mockitousage.IMethods;
-import java.util.Collection;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockingDetails;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.withSettings;
-
@SuppressWarnings("unchecked")
public class DefaultMockingDetailsTest {
@@ -36,27 +36,33 @@
@Mock private IMethods mock;
@Spy private Gork gork;
- @Before public void before() {
- MockitoAnnotations.initMocks(this);
+ @Before
+ public void before() {
+ MockitoAnnotations.openMocks(this);
}
@Test
public void should_provide_original_mock() throws Exception {
- //expect
+ // expect
assertEquals(mockingDetails(foo).getMock(), foo);
assertEquals(mockingDetails(null).getMock(), null);
}
@Test
- public void should_know_spy(){
+ public void should_know_spy() {
assertTrue(mockingDetails(gork).isMock());
- assertTrue(mockingDetails(spy( new Gork())).isMock());
+ assertTrue(mockingDetails(spy(new Gork())).isMock());
assertTrue(mockingDetails(spy(Gork.class)).isMock());
- assertTrue(mockingDetails(mock(Gork.class, withSettings().defaultAnswer(Mockito.CALLS_REAL_METHODS))).isMock());
+ assertTrue(
+ mockingDetails(
+ mock(
+ Gork.class,
+ withSettings().defaultAnswer(Mockito.CALLS_REAL_METHODS)))
+ .isMock());
}
@Test
- public void should_know_mock(){
+ public void should_know_mock() {
assertTrue(mockingDetails(foo).isMock());
assertTrue(mockingDetails(mock(Foo.class)).isMock());
assertFalse(mockingDetails(foo).isSpy());
@@ -79,29 +85,31 @@
@Test
public void provides_invocations() {
- //when
+ // when
mock.simpleMethod(10);
mock.otherMethod();
- //then
+ // then
assertEquals(0, mockingDetails(foo).getInvocations().size());
- assertEquals("[mock.simpleMethod(10);, mock.otherMethod();]", mockingDetails(mock).getInvocations().toString());
+ assertEquals(
+ "[mock.simpleMethod(10);, mock.otherMethod();]",
+ mockingDetails(mock).getInvocations().toString());
}
@Test
public void manipulating_invocations_is_safe() {
mock.simpleMethod();
- //when we manipulate the invocations
+ // when we manipulate the invocations
mockingDetails(mock).getInvocations().clear();
- //then we didn't actually changed the invocations
+ // then we didn't actually changed the invocations
assertEquals(1, mockingDetails(mock).getInvocations().size());
}
@Test
public void provides_mock_creation_settings() {
- //smoke test some creation settings
+ // smoke test some creation settings
assertEquals(Foo.class, mockingDetails(foo).getMockCreationSettings().getTypeToMock());
assertEquals(Bar.class, mockingDetails(bar).getMockCreationSettings().getTypeToMock());
assertEquals(0, mockingDetails(mock).getMockCreationSettings().getExtraInterfaces().size());
@@ -115,36 +123,42 @@
@Test
public void fails_when_getting_invocations_when_null() {
try {
- //when
+ // when
mockingDetails(null).getInvocations();
- //then
+ // then
fail();
} catch (NotAMockException e) {
- assertEquals("Argument passed to Mockito.mockingDetails() should be a mock, but is null!", e.getMessage());
+ assertEquals(
+ "Argument passed to Mockito.mockingDetails() should be a mock, but is null!",
+ e.getMessage());
}
}
@Test
public void fails_when_getting_invocations_when_not_mock() {
try {
- //when
+ // when
mockingDetails(new Object()).getInvocations();
- //then
+ // then
fail();
} catch (NotAMockException e) {
- assertEquals("Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!", e.getMessage());
+ assertEquals(
+ "Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!",
+ e.getMessage());
}
}
@Test
public void fails_when_getting_stubbings_from_non_mock() {
try {
- //when
+ // when
mockingDetails(new Object()).getStubbings();
- //then
+ // then
fail();
} catch (NotAMockException e) {
- assertEquals("Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!", e.getMessage());
+ assertEquals(
+ "Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!",
+ e.getMessage());
}
}
@@ -158,35 +172,37 @@
when(mock.simpleMethod(1)).thenReturn("1");
when(mock.otherMethod()).thenReturn("2");
- //when
+ // when
Collection<Stubbing> stubbings = mockingDetails(mock).getStubbings();
- //then
+ // then
assertEquals(2, stubbings.size());
- assertEquals("[mock.simpleMethod(1); stubbed with: [Returns: 1], mock.otherMethod(); stubbed with: [Returns: 2]]", stubbings.toString());
+ assertEquals(
+ "[mock.simpleMethod(1); stubbed with: [Returns: 1], mock.otherMethod(); stubbed with: [Returns: 2]]",
+ stubbings.toString());
}
@Test
public void manipulating_stubbings_explicitly_is_safe() {
when(mock.simpleMethod(1)).thenReturn("1");
- //when somebody manipulates stubbings directly
+ // when somebody manipulates stubbings directly
mockingDetails(mock).getStubbings().clear();
- //then it does not affect stubbings of the mock
+ // then it does not affect stubbings of the mock
assertEquals(1, mockingDetails(mock).getStubbings().size());
}
@Test
public void prints_invocations() throws Exception {
- //given
+ // given
given(mock.simpleMethod("different arg")).willReturn("foo");
mock.simpleMethod("arg");
- //when
+ // when
String log = Mockito.mockingDetails(mock).printInvocations();
- //then
+ // then
assertThat(log).containsIgnoringCase("unused");
assertThat(log).containsIgnoringCase("mock.simpleMethod(\"arg\")");
assertThat(log).containsIgnoringCase("mock.simpleMethod(\"different arg\")");
@@ -195,16 +211,20 @@
@Test
public void fails_when_printin_invocations_from_non_mock() {
try {
- //when
+ // when
mockingDetails(new Object()).printInvocations();
- //then
+ // then
fail();
} catch (NotAMockException e) {
- assertEquals("Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!", e.getMessage());
+ assertEquals(
+ "Argument passed to Mockito.mockingDetails() should be a mock, but is an instance of class java.lang.Object!",
+ e.getMessage());
}
}
- public class Foo { }
- public interface Bar { }
- public static class Gork { }
+ public class Foo {}
+
+ public interface Bar {}
+
+ public static class Gork {}
}
diff --git a/src/test/java/org/mockito/internal/util/MockCreationValidatorTest.java b/src/test/java/org/mockito/internal/util/MockCreationValidatorTest.java
index 1a9b109..ccb1347 100644
--- a/src/test/java/org/mockito/internal/util/MockCreationValidatorTest.java
+++ b/src/test/java/org/mockito/internal/util/MockCreationValidatorTest.java
@@ -4,17 +4,18 @@
*/
package org.mockito.internal.util;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockitousage.IMethods;
+import static java.util.Arrays.asList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
-import static java.util.Arrays.asList;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockitousage.IMethods;
@SuppressWarnings("unchecked")
public class MockCreationValidatorTest {
@@ -22,38 +23,39 @@
MockCreationValidator validator = new MockCreationValidator();
@Test
- public void should_not_allow_extra_interface_that_is_the_same_as_the_mocked_type() throws Exception {
+ public void should_not_allow_extra_interface_that_is_the_same_as_the_mocked_type()
+ throws Exception {
try {
- //when
+ // when
validator.validateExtraInterfaces(IMethods.class, (Collection) asList(IMethods.class));
fail();
} catch (MockitoException e) {
- //then
+ // then
assertThat(e.getMessage()).contains("You mocked following type: IMethods");
}
}
@Test(expected = MockitoException.class)
public void should_not_allow_inconsistent_types() throws Exception {
- //when
+ // when
validator.validateMockedType(List.class, new ArrayList());
- //then
+ // then
}
@Test
public void should_allow_only_consistent_types() throws Exception {
- //when
+ // when
validator.validateMockedType(ArrayList.class, new ArrayList());
- //then no exception is thrown
+ // then no exception is thrown
}
@Test
public void should_validation_be_safe_when_nulls_passed() throws Exception {
- //when
+ // when
validator.validateMockedType(null, new ArrayList());
- //or
+ // or
validator.validateMockedType(ArrayList.class, null);
- //then no exception is thrown
+ // then no exception is thrown
}
@Test
diff --git a/src/test/java/org/mockito/internal/util/MockNameImplTest.java b/src/test/java/org/mockito/internal/util/MockNameImplTest.java
index 071594b..583bd7a 100644
--- a/src/test/java/org/mockito/internal/util/MockNameImplTest.java
+++ b/src/test/java/org/mockito/internal/util/MockNameImplTest.java
@@ -4,39 +4,66 @@
*/
package org.mockito.internal.util;
+import static org.junit.Assert.assertEquals;
+
import org.junit.Test;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-
public class MockNameImplTest extends TestBase {
@Test
public void shouldProvideTheNameForClass() throws Exception {
- //when
- String name = new MockNameImpl(null, SomeClass.class).toString();
- //then
+ // when
+ String name = new MockNameImpl(null, SomeClass.class, false).toString();
+ // then
assertEquals("someClass", name);
}
@Test
+ public void shouldProvideTheNameForClassOnStaticMock() throws Exception {
+ // when
+ String name = new MockNameImpl(null, SomeClass.class, true).toString();
+ // then
+ assertEquals("SomeClass.class", name);
+ }
+
+ @Test
public void shouldProvideTheNameForAnonymousClass() throws Exception {
- //given
+ // given
SomeInterface anonymousInstance = new SomeInterface() {};
- //when
- String name = new MockNameImpl(null, anonymousInstance.getClass()).toString();
- //then
+ // when
+ String name = new MockNameImpl(null, anonymousInstance.getClass(), false).toString();
+ // then
assertEquals("someInterface", name);
}
@Test
+ public void shouldProvideTheNameForAnonymousClassOnStatic() throws Exception {
+ // given
+ SomeInterface anonymousInstance = new SomeInterface() {};
+ // when
+ String name = new MockNameImpl(null, anonymousInstance.getClass(), true).toString();
+ // then
+ assertEquals("SomeInterface$.class", name);
+ }
+
+ @Test
public void shouldProvideTheGivenName() throws Exception {
- //when
- String name = new MockNameImpl("The Hulk", SomeClass.class).toString();
- //then
+ // when
+ String name = new MockNameImpl("The Hulk", SomeClass.class, false).toString();
+ // then
+ assertEquals("The Hulk", name);
+ }
+
+ @Test
+ public void shouldProvideTheGivenNameOnStatic() throws Exception {
+ // when
+ String name = new MockNameImpl("The Hulk", SomeClass.class, true).toString();
+ // then
assertEquals("The Hulk", name);
}
private class SomeClass {}
+
private class SomeInterface {}
}
diff --git a/src/test/java/org/mockito/internal/util/MockSettingsTest.java b/src/test/java/org/mockito/internal/util/MockSettingsTest.java
index 01df499..ab39828 100644
--- a/src/test/java/org/mockito/internal/util/MockSettingsTest.java
+++ b/src/test/java/org/mockito/internal/util/MockSettingsTest.java
@@ -4,36 +4,35 @@
*/
package org.mockito.internal.util;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+
import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.internal.creation.settings.CreationSettings;
import org.mockito.mock.MockCreationSettings;
import org.mockitoutil.TestBase;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
public class MockSettingsTest extends TestBase {
@Test
public void public_api_for_creating_settings() throws Exception {
- //when
- MockCreationSettings<List> settings = Mockito.withSettings()
- .name("dummy")
- .build(List.class);
+ // when
+ MockCreationSettings<List> settings =
+ Mockito.withSettings().name("dummy").build(List.class);
- //then
+ // then
assertEquals(List.class, settings.getTypeToMock());
assertEquals("dummy", settings.getMockName().toString());
}
+
@Test
public void test_without_annotations() throws Exception {
- MockCreationSettings<List> settings = Mockito.withSettings()
- .withoutAnnotations()
- .build(List.class);
+ MockCreationSettings<List> settings =
+ Mockito.withSettings().withoutAnnotations().build(List.class);
- CreationSettings copy = new CreationSettings((CreationSettings)settings);
+ CreationSettings copy = new CreationSettings((CreationSettings) settings);
assertEquals(List.class, settings.getTypeToMock());
assertEquals(List.class, copy.getTypeToMock());
diff --git a/src/test/java/org/mockito/internal/util/MockUtilTest.java b/src/test/java/org/mockito/internal/util/MockUtilTest.java
index dee6413..2e649ee 100644
--- a/src/test/java/org/mockito/internal/util/MockUtilTest.java
+++ b/src/test/java/org/mockito/internal/util/MockUtilTest.java
@@ -2,9 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.util;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.withSettings;
+
+import java.util.ArrayList;
+import java.util.List;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.Mockito;
@@ -13,12 +18,6 @@
import org.mockito.internal.configuration.plugins.Plugins;
import org.mockitoutil.TestBase;
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.withSettings;
-
@SuppressWarnings("unchecked")
public class MockUtilTest extends TestBase {
@@ -28,12 +27,12 @@
assertNotNull(MockUtil.getMockHandler(mock));
}
- @Test (expected=NotAMockException.class)
+ @Test(expected = NotAMockException.class)
public void should_scream_when_not_a_mock_passed() {
MockUtil.getMockHandler("");
}
- @Test (expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void should_scream_when_null_passed() {
MockUtil.getMockHandler(null);
}
@@ -58,7 +57,11 @@
assertTrue(MockUtil.isSpy(Mockito.spy(new ArrayList())));
assertTrue(MockUtil.isSpy(Mockito.spy(ArrayList.class)));
- assertTrue(MockUtil.isSpy(Mockito.mock(ArrayList.class, withSettings().defaultAnswer(Mockito.CALLS_REAL_METHODS))));
+ assertTrue(
+ MockUtil.isSpy(
+ Mockito.mock(
+ ArrayList.class,
+ withSettings().defaultAnswer(Mockito.CALLS_REAL_METHODS))));
}
@Test
@@ -78,7 +81,9 @@
}
final class FinalClass {}
+
class SomeClass {}
+
interface SomeInterface {}
@Test
diff --git a/src/test/java/org/mockito/internal/util/ObjectMethodsGuruTest.java b/src/test/java/org/mockito/internal/util/ObjectMethodsGuruTest.java
index 1a93c3b..3f9c594 100644
--- a/src/test/java/org/mockito/internal/util/ObjectMethodsGuruTest.java
+++ b/src/test/java/org/mockito/internal/util/ObjectMethodsGuruTest.java
@@ -4,45 +4,60 @@
*/
package org.mockito.internal.util;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Date;
+
import org.junit.Test;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.util.Date;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
public class ObjectMethodsGuruTest extends TestBase {
-
private interface HasCompareToButDoesNotImplementComparable {
int compareTo(HasCompareToButDoesNotImplementComparable other);
}
private interface HasCompare extends Comparable<HasCompare> {
int foo(HasCompare other);
+
int compareTo(HasCompare other, String redHerring);
+
int compareTo(String redHerring);
+
int compareTo(HasCompare redHerring);
}
@Test
public void shouldKnowToStringMethod() throws Exception {
- assertFalse(ObjectMethodsGuru.isToStringMethod(Object.class.getMethod("equals", Object.class)));
- assertFalse(ObjectMethodsGuru.isToStringMethod(IMethods.class.getMethod("toString", String.class)));
+ assertFalse(
+ ObjectMethodsGuru.isToStringMethod(Object.class.getMethod("equals", Object.class)));
+ assertFalse(
+ ObjectMethodsGuru.isToStringMethod(
+ IMethods.class.getMethod("toString", String.class)));
assertTrue(ObjectMethodsGuru.isToStringMethod(IMethods.class.getMethod("toString")));
}
-
@Test
public void shouldKnowCompareToMethod() throws Exception {
assertFalse(ObjectMethodsGuru.isCompareToMethod(Date.class.getMethod("toString")));
- assertFalse(ObjectMethodsGuru.isCompareToMethod(HasCompare.class.getMethod("foo", HasCompare.class)));
- assertFalse(ObjectMethodsGuru.isCompareToMethod(HasCompare.class.getMethod("compareTo", HasCompare.class, String.class)));
- assertFalse(ObjectMethodsGuru.isCompareToMethod(HasCompare.class.getMethod("compareTo", String.class)));
- assertFalse(ObjectMethodsGuru.isCompareToMethod(HasCompareToButDoesNotImplementComparable.class.getDeclaredMethod("compareTo", HasCompareToButDoesNotImplementComparable.class)));
+ assertFalse(
+ ObjectMethodsGuru.isCompareToMethod(
+ HasCompare.class.getMethod("foo", HasCompare.class)));
+ assertFalse(
+ ObjectMethodsGuru.isCompareToMethod(
+ HasCompare.class.getMethod("compareTo", HasCompare.class, String.class)));
+ assertFalse(
+ ObjectMethodsGuru.isCompareToMethod(
+ HasCompare.class.getMethod("compareTo", String.class)));
+ assertFalse(
+ ObjectMethodsGuru.isCompareToMethod(
+ HasCompareToButDoesNotImplementComparable.class.getDeclaredMethod(
+ "compareTo", HasCompareToButDoesNotImplementComparable.class)));
- assertTrue(ObjectMethodsGuru.isCompareToMethod(HasCompare.class.getMethod("compareTo", HasCompare.class)));
+ assertTrue(
+ ObjectMethodsGuru.isCompareToMethod(
+ HasCompare.class.getMethod("compareTo", HasCompare.class)));
}
}
diff --git a/src/test/java/org/mockito/internal/util/PlatformTest.java b/src/test/java/org/mockito/internal/util/PlatformTest.java
index bf07977..b72c71d 100644
--- a/src/test/java/org/mockito/internal/util/PlatformTest.java
+++ b/src/test/java/org/mockito/internal/util/PlatformTest.java
@@ -4,11 +4,12 @@
*/
package org.mockito.internal.util;
+import static org.assertj.core.api.Assertions.assertThat;
+
import java.util.HashMap;
import java.util.Map;
-import org.junit.Test;
-import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
// Possible description on a IBM J9 VM (see #801)
//
@@ -41,17 +42,25 @@
@Test
public void should_warn_for_jvm() throws Exception {
- assertThat(Platform.warnForVM("Java HotSpot(TM) 64-Bit Server VM",
- "HotSpot", "hotspot warning",
- "IBM", "ibm warning"))
+ assertThat(
+ Platform.warnForVM(
+ "Java HotSpot(TM) 64-Bit Server VM",
+ "HotSpot",
+ "hotspot warning",
+ "IBM",
+ "ibm warning"))
.isEqualTo("hotspot warning");
- assertThat(Platform.warnForVM("IBM J9 VM",
- "HotSpot", "hotspot warning",
- "IBM", "ibm warning"))
+ assertThat(
+ Platform.warnForVM(
+ "IBM J9 VM", "HotSpot", "hotspot warning", "IBM", "ibm warning"))
.isEqualTo("ibm warning");
- assertThat(Platform.warnForVM("whatever",
- null, "should not be returned",
- null, "should not be returned"))
+ assertThat(
+ Platform.warnForVM(
+ "whatever",
+ null,
+ "should not be returned",
+ null,
+ "should not be returned"))
.isEqualTo("");
}
@@ -59,36 +68,42 @@
public void should_parse_open_jdk_string_and_report_wether_below_or_nut_update_45() {
// Given
// Sources :
- // - http://www.oracle.com/technetwork/java/javase/versioning-naming-139433.html
- // - http://www.oracle.com/technetwork/java/javase/jdk7-naming-418744.html
- // - http://www.oracle.com/technetwork/java/javase/jdk8-naming-2157130.html
- // - http://stackoverflow.com/questions/35844985/how-do-we-get-sr-and-fp-of-ibm-jre-using-java
- // - http://www.ibm.com/support/knowledgecenter/SSYKE2_6.0.0/com.ibm.java.doc.user.win32.60/user/java_version_check.html
- Map<String, Boolean> versions = new HashMap<String, Boolean>() {{
- put("1.8.0_92-b14", false);
- put("1.8.0-b24", true);
- put("1.8.0_5", true);
- put("1.8.0b5_u44", true);
- put("1.8.0b5_u92", false);
- put("1.7.0_4", false);
- put("1.4.0_03-b04", false);
- put("1.4.0_03-ea-b01", false);
- put("pxi3270_27sr4-20160303_03 (SR4)", false);
- put("pwi3260sr11-20120412_01 (SR11)", false);
- put("pwa6480sr1fp10-20150711_01 (SR1 FP10)", false);
- put("null", false);
- }};
+ // - https://www.oracle.com/java/technologies/javase/versioning-naming.html
+ // - https://www.oracle.com/java/technologies/javase/jdk7-naming.html
+ // - https://www.oracle.com/java/technologies/javase/jdk8-naming.html
+ // -
+ // https://stackoverflow.com/questions/35844985/how-do-we-get-sr-and-fp-of-ibm-jre-using-java
+ // -
+ // https://www.ibm.com/support/knowledgecenter/SSYKE2_8.0.0/com.ibm.java.80.doc/user/build_number.html
+ Map<String, Boolean> versions =
+ new HashMap<String, Boolean>() {
+ {
+ put("1.8.0_92-b14", false);
+ put("1.8.0-b24", true);
+ put("1.8.0_5", true);
+ put("1.8.0b5_u44", true);
+ put("1.8.0b5_u92", false);
+ put("1.7.0_4", false);
+ put("1.4.0_03-b04", false);
+ put("1.4.0_03-ea-b01", false);
+ put("pxi3270_27sr4-20160303_03 (SR4)", false);
+ put("pwi3260sr11-20120412_01 (SR11)", false);
+ put("pwa6480sr1fp10-20150711_01 (SR1 FP10)", false);
+ put("null", false);
+ }
+ };
assertPlatformParsesCorrectlyVariousVersionScheme(versions);
}
@Test
public void should_parse_open_jdk9_string() {
- // The tested method targets Java 8 but should be able to parse other Java version numbers including Java 9
+ // The tested method targets Java 8 but should be able to parse other Java version numbers
+ // including Java 9
// Given
// Sources :
- // - http://openjdk.java.net/jeps/223 (Java 9)
+ // - https://openjdk.java.net/jeps/223 (Java 9)
//
// System Property Existing Proposed
// ------------------------------- ------------ --------
@@ -119,21 +134,24 @@
// java.specification.version 1.9 9
// java.vm.specification.version 1.9 9
//
- Map<String, Boolean> versions = new HashMap<String, Boolean>() {{
- put("9-ea+73", false);
- put("9+100", false);
- put("9.1.2+62", false);
- put("9.0.1+20", false);
- }};
+ Map<String, Boolean> versions =
+ new HashMap<String, Boolean>() {
+ {
+ put("9-ea+73", false);
+ put("9+100", false);
+ put("9.1.2+62", false);
+ put("9.0.1+20", false);
+ }
+ };
assertPlatformParsesCorrectlyVariousVersionScheme(versions);
}
-
private void assertPlatformParsesCorrectlyVariousVersionScheme(Map<String, Boolean> versions) {
for (Map.Entry<String, Boolean> version : versions.entrySet()) {
- assertThat(Platform.isJava8BelowUpdate45(version.getKey())).describedAs(version.getKey())
- .isEqualTo(version.getValue());
+ assertThat(Platform.isJava8BelowUpdate45(version.getKey()))
+ .describedAs(version.getKey())
+ .isEqualTo(version.getValue());
}
}
}
diff --git a/src/test/java/org/mockito/internal/util/PrimitivesTest.java b/src/test/java/org/mockito/internal/util/PrimitivesTest.java
index 34dd362..214a7ec 100644
--- a/src/test/java/org/mockito/internal/util/PrimitivesTest.java
+++ b/src/test/java/org/mockito/internal/util/PrimitivesTest.java
@@ -4,12 +4,11 @@
*/
package org.mockito.internal.util;
-import org.junit.Test;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import org.junit.Test;
public class PrimitivesTest {
@Test
diff --git a/src/test/java/org/mockito/internal/util/SimpleMockitoLogger.java b/src/test/java/org/mockito/internal/util/SimpleMockitoLogger.java
index 129547f..2c735fb 100644
--- a/src/test/java/org/mockito/internal/util/SimpleMockitoLogger.java
+++ b/src/test/java/org/mockito/internal/util/SimpleMockitoLogger.java
@@ -4,6 +4,8 @@
*/
package org.mockito.internal.util;
+import org.mockito.plugins.MockitoLogger;
+
public class SimpleMockitoLogger implements MockitoLogger {
private StringBuilder loggedInfo = new StringBuilder();
@@ -27,7 +29,8 @@
public void assertEmpty() {
if (loggedInfo.length() != 0) {
- throw new AssertionError("Expected the logger to be empty but it has:\n" + loggedInfo.toString());
+ throw new AssertionError(
+ "Expected the logger to be empty but it has:\n" + loggedInfo.toString());
}
}
}
diff --git a/src/test/java/org/mockito/internal/util/SimpleMockitoLoggerTest.java b/src/test/java/org/mockito/internal/util/SimpleMockitoLoggerTest.java
index 123502a..a12d4da 100644
--- a/src/test/java/org/mockito/internal/util/SimpleMockitoLoggerTest.java
+++ b/src/test/java/org/mockito/internal/util/SimpleMockitoLoggerTest.java
@@ -4,20 +4,20 @@
*/
package org.mockito.internal.util;
+import static org.junit.Assert.assertEquals;
+
import org.junit.Test;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-
public class SimpleMockitoLoggerTest extends TestBase {
@Test
public void shouldLog() throws Exception {
- //given
+ // given
SimpleMockitoLogger logger = new SimpleMockitoLogger();
- //when
+ // when
logger.log("foo");
- //then
+ // then
assertEquals("foo", logger.getLoggedInfo());
}
}
diff --git a/src/test/java/org/mockito/internal/util/StringUtilTest.java b/src/test/java/org/mockito/internal/util/StringUtilTest.java
index 1858fe0..526d399 100644
--- a/src/test/java/org/mockito/internal/util/StringUtilTest.java
+++ b/src/test/java/org/mockito/internal/util/StringUtilTest.java
@@ -2,25 +2,29 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.util;
-import org.junit.Test;
-
import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
-import static org.junit.Assert.assertEquals;
-import static org.assertj.core.api.Assertions.assertThat;
-public class StringUtilTest {
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class StringUtilTest {
@Test
- public void decamelizes_matcher() throws Exception {
- assertEquals("<Sentence with strong language>", StringUtil.decamelizeMatcher("SentenceWithStrongLanguage"));
- assertEquals("<W e i r d o 1>", StringUtil.decamelizeMatcher("WEIRDO1"));
- assertEquals("<_>", StringUtil.decamelizeMatcher("_"));
- assertEquals("<Has exactly 3 elements>", StringUtil.decamelizeMatcher("HasExactly3Elements"));
- assertEquals("<custom argument matcher>", StringUtil.decamelizeMatcher(""));
+ public void decamelizes_matcher_name() throws Exception {
+ assertEquals(
+ "<Sentence with strong language>",
+ StringUtil.decamelizeMatcherName("SentenceWithStrongLanguage"));
+ assertEquals("<W e i r d o 1>", StringUtil.decamelizeMatcherName("WEIRDO1"));
+ assertEquals("<_>", StringUtil.decamelizeMatcherName("_"));
+ assertEquals(
+ "<Has exactly 3 elements>",
+ StringUtil.decamelizeMatcherName("HasExactly3Elements"));
+ assertEquals("<custom argument matcher>", StringUtil.decamelizeMatcherName(""));
}
@Test
@@ -36,11 +40,11 @@
@Test
public void joins_two_lines() throws Exception {
- assertThat(StringUtil.join("line1","line2")).hasLineCount(3);
+ assertThat(StringUtil.join("line1", "line2")).hasLineCount(3);
}
@Test
- public void join_has_preceeding_linebreak() throws Exception {
+ public void join_has_preceding_linebreak() throws Exception {
assertThat(StringUtil.join("line1")).isEqualTo("\nline1");
}
@@ -51,8 +55,7 @@
@Test
public void joins_with_line_prefix() throws Exception {
- assertEquals("Hey!\n" +
- " - a\n" +
- " - b", StringUtil.join("Hey!\n", " - ", asList("a", "b")));
+ assertEquals(
+ "Hey!\n" + " - a\n" + " - b", StringUtil.join("Hey!\n", " - ", asList("a", "b")));
}
}
diff --git a/src/test/java/org/mockito/internal/util/TimerTest.java b/src/test/java/org/mockito/internal/util/TimerTest.java
index 8a4a173..f12efd8 100644
--- a/src/test/java/org/mockito/internal/util/TimerTest.java
+++ b/src/test/java/org/mockito/internal/util/TimerTest.java
@@ -12,32 +12,31 @@
import org.mockitoutil.TestBase;
public class TimerTest extends TestBase {
- @Rule
- public ExpectedException expectedException = ExpectedException.none();
+ @Rule public ExpectedException expectedException = ExpectedException.none();
@Test
public void should_return_true_if_task_is_in_acceptable_time_bounds() {
- //given
+ // given
long duration = 10000L;
Timer timer = new Timer(duration);
- //when
+ // when
timer.start();
- //then
+ // then
Assertions.assertThat(timer.isCounting()).isTrue();
}
@Test
public void should_return_false_when_time_run_out() throws Exception {
- //given
+ // given
Timer timer = new Timer(0);
timer.start();
- //when
+ // when
oneMillisecondPasses();
- //then
+ // then
Assertions.assertThat(timer.isCounting()).isFalse();
}
diff --git a/src/test/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java b/src/test/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java
index 031a654..9e03b1d 100644
--- a/src/test/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java
+++ b/src/test/java/org/mockito/internal/util/collections/HashCodeAndEqualsSafeSetTest.java
@@ -21,10 +21,8 @@
public class HashCodeAndEqualsSafeSetTest {
- @Rule
- public MockitoRule r = MockitoJUnit.rule();
- @Mock
- private UnmockableHashCodeAndEquals mock1;
+ @Rule public MockitoRule r = MockitoJUnit.rule();
+ @Mock private UnmockableHashCodeAndEquals mock1;
@Test
public void can_add_mock_that_have_failing_hashCode_method() throws Exception {
@@ -57,12 +55,9 @@
assertThat(mocks.isEmpty()).isTrue();
}
-
@Test
public void can_add_a_collection() throws Exception {
- HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(
- mock1,
- mock(Observer.class));
+ HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(mock1, mock(Observer.class));
HashCodeAndEqualsSafeSet workingSet = new HashCodeAndEqualsSafeSet();
@@ -73,9 +68,7 @@
@Test
public void can_retain_a_collection() throws Exception {
- HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(
- mock1,
- mock(Observer.class));
+ HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(mock1, mock(Observer.class));
HashCodeAndEqualsSafeSet workingSet = new HashCodeAndEqualsSafeSet();
@@ -88,9 +81,7 @@
@Test
public void can_remove_a_collection() throws Exception {
- HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(
- mock1,
- mock(Observer.class));
+ HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(mock1, mock(Observer.class));
HashCodeAndEqualsSafeSet workingSet = new HashCodeAndEqualsSafeSet();
@@ -103,9 +94,7 @@
@Test
public void can_iterate() throws Exception {
- HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(
- mock1,
- mock(Observer.class));
+ HashCodeAndEqualsSafeSet mocks = HashCodeAndEqualsSafeSet.of(mock1, mock(Observer.class));
LinkedList<Object> accumulator = new LinkedList<Object>();
for (Object mock : mocks) {
@@ -123,9 +112,9 @@
assertThat(mocks.toArray(new UnmockableHashCodeAndEquals[0])[0]).isSameAs(mock1);
}
- @Test(expected=CloneNotSupportedException.class)
- public void cloneIsNotSupported() throws CloneNotSupportedException{
- HashCodeAndEqualsSafeSet.of().clone();
+ @Test(expected = CloneNotSupportedException.class)
+ public void cloneIsNotSupported() throws CloneNotSupportedException {
+ Object ignored = HashCodeAndEqualsSafeSet.of().clone();
}
@Test
@@ -137,26 +126,26 @@
}
@Test
- public void isEqualToItself(){
+ public void isEqualToItself() {
HashCodeAndEqualsSafeSet set = HashCodeAndEqualsSafeSet.of(mock1);
assertThat(set).isEqualTo(set);
}
@Test
- public void isNotEqualToAnOtherTypeOfSetWithSameContent(){
+ public void isNotEqualToAnOtherTypeOfSetWithSameContent() {
HashCodeAndEqualsSafeSet set = HashCodeAndEqualsSafeSet.of();
assertThat(set).isNotEqualTo(new HashSet<Object>());
}
@Test
- public void isNotEqualWhenContentIsDifferent(){
+ public void isNotEqualWhenContentIsDifferent() {
HashCodeAndEqualsSafeSet set = HashCodeAndEqualsSafeSet.of(mock1);
assertThat(set).isNotEqualTo(HashCodeAndEqualsSafeSet.of());
}
@Test
- public void hashCodeIsEqualIfContentIsEqual(){
+ public void hashCodeIsEqualIfContentIsEqual() {
HashCodeAndEqualsSafeSet set = HashCodeAndEqualsSafeSet.of(mock1);
assertThat(set.hashCode()).isEqualTo(HashCodeAndEqualsSafeSet.of(mock1).hashCode());
}
@@ -178,11 +167,13 @@
}
private static class UnmockableHashCodeAndEquals {
- @Override public final int hashCode() {
+ @Override
+ public final int hashCode() {
throw new NullPointerException("I'm failing on hashCode and I don't care");
}
- @Override public final boolean equals(Object obj) {
+ @Override
+ public final boolean equals(Object obj) {
throw new NullPointerException("I'm failing on equals and I don't care");
}
}
diff --git a/src/test/java/org/mockito/internal/util/collections/IdentitySetTest.java b/src/test/java/org/mockito/internal/util/collections/IdentitySetTest.java
index da62926..1a44ba6 100644
--- a/src/test/java/org/mockito/internal/util/collections/IdentitySetTest.java
+++ b/src/test/java/org/mockito/internal/util/collections/IdentitySetTest.java
@@ -4,10 +4,9 @@
*/
package org.mockito.internal.util.collections;
-import org.junit.Test;
-
import static org.junit.Assert.*;
+import org.junit.Test;
public class IdentitySetTest {
@@ -15,15 +14,16 @@
@Test
public void shouldWork() throws Exception {
- //when
+ // when
Object o = new Object();
set.add(o);
- //then
+ // then
assertTrue(set.contains(o));
assertFalse(set.contains(new Object()));
}
+ @SuppressWarnings("EqualsHashCode")
class Fake {
@Override
public boolean equals(Object obj) {
@@ -33,16 +33,15 @@
@Test
public void shouldWorkEvenIfEqualsTheSame() throws Exception {
- //given
+ // given
assertEquals(new Fake(), new Fake());
Fake fake = new Fake();
- //when
+ // when
set.add(fake);
- //then
+ // then
assertTrue(set.contains(fake));
assertFalse(set.contains(new Fake()));
}
-
}
diff --git a/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java b/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java
index 71c8bb1..6f47fe2 100644
--- a/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java
+++ b/src/test/java/org/mockito/internal/util/collections/ListUtilTest.java
@@ -2,30 +2,33 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.util.collections;
+import static java.util.Arrays.asList;
+
+import static org.junit.Assert.assertTrue;
+
+import java.util.LinkedList;
+import java.util.List;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.internal.util.collections.ListUtil.Filter;
import org.mockitoutil.TestBase;
-import java.util.LinkedList;
-import java.util.List;
-
-import static java.util.Arrays.asList;
-import static org.junit.Assert.assertTrue;
-
public class ListUtilTest extends TestBase {
@Test
public void shouldFilterList() throws Exception {
List<String> list = asList("one", "x", "two", "x", "three");
- List<String> filtered = ListUtil.filter(list, new Filter<String>() {
- public boolean isOut(String object) {
- return object == "x";
- }
- });
+ List<String> filtered =
+ ListUtil.filter(
+ list,
+ new Filter<String>() {
+ public boolean isOut(String object) {
+ return object == "x";
+ }
+ });
Assertions.assertThat(filtered).containsSequence("one", "two", "three");
}
diff --git a/src/test/java/org/mockito/internal/util/io/IOUtilTest.java b/src/test/java/org/mockito/internal/util/io/IOUtilTest.java
index 0aa16a1..24099f6 100644
--- a/src/test/java/org/mockito/internal/util/io/IOUtilTest.java
+++ b/src/test/java/org/mockito/internal/util/io/IOUtilTest.java
@@ -4,16 +4,17 @@
*/
package org.mockito.internal.util.io;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import static java.util.Arrays.asList;
+
+import static org.junit.Assert.assertEquals;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
-import static java.util.Arrays.asList;
-import static org.junit.Assert.assertEquals;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
public class IOUtilTest {
diff --git a/src/test/java/org/mockito/internal/util/reflection/AccessibilityChangerTest.java b/src/test/java/org/mockito/internal/util/reflection/AccessibilityChangerTest.java
deleted file mode 100644
index 88bf1cf..0000000
--- a/src/test/java/org/mockito/internal/util/reflection/AccessibilityChangerTest.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-
-package org.mockito.internal.util.reflection;
-
-import org.junit.Test;
-
-import java.lang.reflect.Field;
-import java.util.Observable;
-
-import static org.mockitoutil.VmArgAssumptions.assumeVmArgPresent;
-
-public class AccessibilityChangerTest {
-
- @SuppressWarnings("unused")
- private Observable whatever;
-
- @Test
- public void should_enable_and_safely_disable() throws Exception {
- AccessibilityChanger changer = new AccessibilityChanger();
- changer.enableAccess(field("whatever"));
- changer.safelyDisableAccess(field("whatever"));
- }
-
- @Test(expected = java.lang.AssertionError.class)
- public void safelyDisableAccess_should_fail_when_enableAccess_not_called() throws Exception {
- assumeVmArgPresent("-ea");
- new AccessibilityChanger().safelyDisableAccess(field("whatever"));
- }
-
-
- private Field field(String fieldName) throws NoSuchFieldException {
- return this.getClass().getDeclaredField(fieldName);
- }
-
-}
diff --git a/src/test/java/org/mockito/internal/util/reflection/BeanPropertySetterTest.java b/src/test/java/org/mockito/internal/util/reflection/BeanPropertySetterTest.java
index a0b6119..66d25c2 100644
--- a/src/test/java/org/mockito/internal/util/reflection/BeanPropertySetterTest.java
+++ b/src/test/java/org/mockito/internal/util/reflection/BeanPropertySetterTest.java
@@ -4,16 +4,15 @@
*/
package org.mockito.internal.util.reflection;
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
+import static org.junit.Assert.*;
import java.io.File;
import java.io.FileOutputStream;
import java.lang.reflect.Field;
import java.util.UUID;
-import static org.junit.Assert.*;
-
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
public class BeanPropertySetterTest {
@@ -34,7 +33,8 @@
}
@Test
- public void use_the_setter_on_the_target_when_field_name_begins_by_at_least_2_caps() throws Exception {
+ public void use_the_setter_on_the_target_when_field_name_begins_by_at_least_2_caps()
+ throws Exception {
// given
BeanWithWeirdFields someBean = new BeanWithWeirdFields();
Field theField = someBean.getClass().getDeclaredField("UUID");
@@ -50,7 +50,8 @@
}
@Test
- public void should_not_fail_if_bean_class_declares_only_the_setter_for_the_property() throws Exception {
+ public void should_not_fail_if_bean_class_declares_only_the_setter_for_the_property()
+ throws Exception {
// given
SomeBeanWithJustASetter someBean = new SomeBeanWithJustASetter();
Field theField = someBean.getClass().getDeclaredField("theField");
@@ -65,7 +66,8 @@
}
@Test
- public void should_fail_if_matching_setter_cannot_be_found_and_if_report_failure_is_true() throws Exception {
+ public void should_fail_if_matching_setter_cannot_be_found_and_if_report_failure_is_true()
+ throws Exception {
// given
SomeBeanWithNoSetterMatchingFieldType bean = new SomeBeanWithNoSetterMatchingFieldType();
Field theField = bean.getClass().getDeclaredField("theField");
@@ -96,7 +98,8 @@
}
@Test
- public void return_false_if_no_setter_was_found_and_if_reportNoSetterFound_is_false() throws Exception {
+ public void return_false_if_no_setter_was_found_and_if_reportNoSetterFound_is_false()
+ throws Exception {
// given
SomeBeanWithNoSetterMatchingFieldType bean = new SomeBeanWithNoSetterMatchingFieldType();
Field theField = bean.getClass().getDeclaredField("theField");
@@ -132,6 +135,7 @@
this.theField = theField;
}
}
+
static class SomeBeanWithJustAGetter {
private File theField;
@@ -158,5 +162,4 @@
this.UUID = UUID;
}
}
-
}
diff --git a/src/test/java/org/mockito/internal/util/reflection/DummyClassForTests.java b/src/test/java/org/mockito/internal/util/reflection/DummyClassForTests.java
index 17d71ad..51cb5f9 100644
--- a/src/test/java/org/mockito/internal/util/reflection/DummyClassForTests.java
+++ b/src/test/java/org/mockito/internal/util/reflection/DummyClassForTests.java
@@ -4,6 +4,4 @@
*/
package org.mockito.internal.util.reflection;
-public class DummyClassForTests extends DummyParentClassForTests {
-
-}
+public class DummyClassForTests extends DummyParentClassForTests {}
diff --git a/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java b/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java
index 6967c02..a701dc9 100644
--- a/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java
+++ b/src/test/java/org/mockito/internal/util/reflection/DummyParentClassForTests.java
@@ -6,6 +6,6 @@
public class DummyParentClassForTests {
- @SuppressWarnings("unused")//I know, I know. We're doing nasty reflection hacks here...
+ @SuppressWarnings("unused") // I know, I know. We're doing nasty reflection hacks here...
private String somePrivateField;
}
diff --git a/src/test/java/org/mockito/internal/util/reflection/FieldInitializerTest.java b/src/test/java/org/mockito/internal/util/reflection/FieldInitializerTest.java
index 5d19011..aecdcb4 100644
--- a/src/test/java/org/mockito/internal/util/reflection/FieldInitializerTest.java
+++ b/src/test/java/org/mockito/internal/util/reflection/FieldInitializerTest.java
@@ -4,20 +4,18 @@
*/
package org.mockito.internal.util.reflection;
-import org.junit.Test;
-import org.mockito.InjectMocks;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.reflection.FieldInitializer.ConstructorArgumentResolver;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.util.reflection.FieldInitializer.ConstructorArgumentResolver;
public class FieldInitializerTest {
@@ -31,13 +29,14 @@
private Interface interfaceType;
private InnerClassType innerClassType;
private AbstractStaticClass instantiatedAbstractType = new ConcreteStaticClass();
- private Interface instantiatedInterfaceType = new ConcreteStaticClass();
+ private Interface instantiatedInterfaceType = new ConcreteStaticClass();
private InnerClassType instantiatedInnerClassType = new InnerClassType();
@Test
public void should_keep_same_instance_if_field_initialized() throws Exception {
final StaticClass backupInstance = alreadyInstantiated;
- FieldInitializer fieldInitializer = new FieldInitializer(this, field("alreadyInstantiated"));
+ FieldInitializer fieldInitializer =
+ new FieldInitializer(this, field("alreadyInstantiated"));
FieldInitializationReport report = fieldInitializer.initialize();
assertSame(backupInstance, report.fieldInstance());
@@ -67,7 +66,8 @@
@Test
public void should_instantiate_field_with_private_default_constructor() throws Exception {
- FieldInitializer fieldInitializer = new FieldInitializer(this, field("privateDefaultConstructor"));
+ FieldInitializer fieldInitializer =
+ new FieldInitializer(this, field("privateDefaultConstructor"));
FieldInitializationReport report = fieldInitializer.initialize();
assertNotNull(report.fieldInstance());
@@ -77,13 +77,16 @@
@Test(expected = MockitoException.class)
public void should_fail_to_instantiate_field_if_no_default_constructor() throws Exception {
- FieldInitializer fieldInitializer = new FieldInitializer(this, field("noDefaultConstructor"));
+ FieldInitializer fieldInitializer =
+ new FieldInitializer(this, field("noDefaultConstructor"));
fieldInitializer.initialize();
}
@Test
- public void should_fail_to_instantiate_field_if_default_constructor_throws_exception() throws Exception {
- FieldInitializer fieldInitializer = new FieldInitializer(this, field("throwingExDefaultConstructor"));
+ public void should_fail_to_instantiate_field_if_default_constructor_throws_exception()
+ throws Exception {
+ FieldInitializer fieldInitializer =
+ new FieldInitializer(this, field("throwingExDefaultConstructor"));
try {
fieldInitializer.initialize();
fail();
@@ -117,7 +120,7 @@
@Test(expected = MockitoException.class)
public void should_fail_for_local_type_field() throws Exception {
// when
- class LocalType { }
+ class LocalType {}
class TheTestWithLocalType {
@InjectMocks LocalType field;
@@ -126,13 +129,14 @@
TheTestWithLocalType testWithLocalType = new TheTestWithLocalType();
// when
- new FieldInitializer(testWithLocalType, testWithLocalType.getClass().getDeclaredField("field"));
+ new FieldInitializer(
+ testWithLocalType, testWithLocalType.getClass().getDeclaredField("field"));
}
@Test
public void should_not_fail_if_local_type_field_is_instantiated() throws Exception {
// when
- class LocalType { }
+ class LocalType {}
class TheTestWithLocalType {
@InjectMocks LocalType field = new LocalType();
@@ -141,7 +145,8 @@
TheTestWithLocalType testWithLocalType = new TheTestWithLocalType();
// when
- new FieldInitializer(testWithLocalType, testWithLocalType.getClass().getDeclaredField("field"));
+ new FieldInitializer(
+ testWithLocalType, testWithLocalType.getClass().getDeclaredField("field"));
}
@Test(expected = MockitoException.class)
@@ -156,8 +161,12 @@
@Test
public void can_instantiate_class_with_parameterized_constructor() throws Exception {
- ConstructorArgumentResolver resolver = given(mock(ConstructorArgumentResolver.class).resolveTypeInstances(any(Class.class)))
- .willReturn(new Object[]{null}).getMock();
+ ConstructorArgumentResolver resolver =
+ given(
+ mock(ConstructorArgumentResolver.class)
+ .resolveTypeInstances(any(Class.class)))
+ .willReturn(new Object[] {null})
+ .getMock();
new FieldInitializer(this, field("noDefaultConstructor"), resolver).initialize();
@@ -168,19 +177,18 @@
return this.getClass().getDeclaredField(fieldName);
}
- static class StaticClass {
- }
+ static class StaticClass {}
static class StaticClassWithDefaultConstructor {
- StaticClassWithDefaultConstructor() { }
+ StaticClassWithDefaultConstructor() {}
}
static class StaticClassWithPrivateDefaultConstructor {
- private StaticClassWithPrivateDefaultConstructor() { }
+ private StaticClassWithPrivateDefaultConstructor() {}
}
static class StaticClassWithoutDefaultConstructor {
- private StaticClassWithoutDefaultConstructor(String param) { }
+ private StaticClassWithoutDefaultConstructor(String param) {}
}
static class StaticClassThrowingExceptionDefaultConstructor {
@@ -189,19 +197,15 @@
}
}
- static abstract class AbstractStaticClass {
+ abstract static class AbstractStaticClass {
public AbstractStaticClass() {}
}
- interface Interface {
+ interface Interface {}
- }
-
- static class ConcreteStaticClass extends AbstractStaticClass implements Interface {
- }
+ static class ConcreteStaticClass extends AbstractStaticClass implements Interface {}
class InnerClassType {
- InnerClassType() { }
+ InnerClassType() {}
}
-
}
diff --git a/src/test/java/org/mockito/internal/util/reflection/FieldReaderTest.java b/src/test/java/org/mockito/internal/util/reflection/FieldReaderTest.java
index a7fa76e..2e9aeb8 100644
--- a/src/test/java/org/mockito/internal/util/reflection/FieldReaderTest.java
+++ b/src/test/java/org/mockito/internal/util/reflection/FieldReaderTest.java
@@ -4,12 +4,12 @@
*/
package org.mockito.internal.util.reflection;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
@SuppressWarnings("unused")
public class FieldReaderTest extends TestBase {
@@ -20,17 +20,17 @@
@Test
public void shouldKnowWhenNull() throws Exception {
- //when
+ // when
FieldReader reader = new FieldReader(new Foo(), Foo.class.getDeclaredField("isNull"));
- //then
+ // then
assertTrue(reader.isNull());
}
@Test
public void shouldKnowWhenNotNull() throws Exception {
- //when
+ // when
FieldReader reader = new FieldReader(new Foo(), Foo.class.getDeclaredField("notNull"));
- //then
+ // then
assertFalse(reader.isNull());
}
}
diff --git a/src/test/java/org/mockito/internal/util/reflection/FieldsTest.java b/src/test/java/org/mockito/internal/util/reflection/FieldsTest.java
index d86fb30..270cfae 100644
--- a/src/test/java/org/mockito/internal/util/reflection/FieldsTest.java
+++ b/src/test/java/org/mockito/internal/util/reflection/FieldsTest.java
@@ -4,69 +4,80 @@
*/
package org.mockito.internal.util.reflection;
-import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.internal.util.reflection.Fields.syntheticField;
import java.lang.reflect.Field;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.internal.util.reflection.Fields.syntheticField;
+import org.junit.Test;
public class FieldsTest {
@Test
public void fields_should_return_all_declared_fields_in_hierarchy() throws Exception {
- assertThat(Fields.allDeclaredFieldsOf(new HierarchyOfClasses()).filter(syntheticField()).names())
+ assertThat(
+ Fields.allDeclaredFieldsOf(new HierarchyOfClasses())
+ .filter(syntheticField())
+ .names())
.containsOnly("a", "b", "static_a", "static_b");
}
@Test
public void fields_should_return_declared_fields() throws Exception {
- assertThat(Fields.declaredFieldsOf(new HierarchyOfClasses()).filter(syntheticField()).names())
+ assertThat(
+ Fields.declaredFieldsOf(new HierarchyOfClasses())
+ .filter(syntheticField())
+ .names())
.containsOnly("b", "static_b");
}
@Test
public void can_filter_not_null_fields() throws Exception {
- assertThat(Fields.declaredFieldsOf(new NullOrNotNullFields()).notNull().filter(syntheticField()).names())
+ assertThat(
+ Fields.declaredFieldsOf(new NullOrNotNullFields())
+ .notNull()
+ .filter(syntheticField())
+ .names())
.containsOnly("c");
}
@Test
public void can_get_values_of_instance_fields() throws Exception {
- assertThat(Fields.declaredFieldsOf(new ValuedFields()).filter(syntheticField()).assignedValues())
+ assertThat(
+ Fields.declaredFieldsOf(new ValuedFields())
+ .filter(syntheticField())
+ .assignedValues())
.containsOnly("a", "b");
}
-
@Test
public void can_get_list_of_InstanceField() throws Exception {
ValuedFields instance = new ValuedFields();
assertThat(Fields.declaredFieldsOf(instance).filter(syntheticField()).instanceFields())
- .containsOnly(new InstanceField(field("a", instance), instance),
- new InstanceField(field("b", instance), instance)
- );
+ .containsOnly(
+ new InstanceField(field("a", instance), instance),
+ new InstanceField(field("b", instance), instance));
}
private Field field(String name, Object instance) throws NoSuchFieldException {
return instance.getClass().getDeclaredField(name);
}
-
interface AnInterface {
int someStaticInInterface = 0;
-
}
+
public static class ParentClass implements AnInterface {
static int static_a;
int a;
-
}
+
public static class HierarchyOfClasses extends ParentClass {
static int static_b;
int b = 1;
-
}
+
public static class NullOrNotNullFields {
static Object static_b;
Object b;
diff --git a/src/test/java/org/mockito/internal/util/reflection/GenericArrayReturnTypeTest.java b/src/test/java/org/mockito/internal/util/reflection/GenericArrayReturnTypeTest.java
index 452536a..d5a7459 100644
--- a/src/test/java/org/mockito/internal/util/reflection/GenericArrayReturnTypeTest.java
+++ b/src/test/java/org/mockito/internal/util/reflection/GenericArrayReturnTypeTest.java
@@ -4,19 +4,19 @@
*/
package org.mockito.internal.util.reflection;
-import org.junit.Test;
-import org.mockito.Answers;
+import static org.mockito.Mockito.mock;
import java.util.Set;
-import static org.mockito.Mockito.mock;
+import org.junit.Test;
+import org.mockito.Answers;
public class GenericArrayReturnTypeTest {
@Test
public void toArrayTypedDoesNotWork() throws Exception {
Container container = mock(Container.class, Answers.RETURNS_DEEP_STUBS);
- container.getInnerContainer().getTheProblem().toArray(new String[]{});
+ container.getInnerContainer().getTheProblem().toArray(new String[] {});
}
class Container {
@@ -36,5 +36,4 @@
return theProblem;
}
}
-
}
diff --git a/src/test/java/org/mockito/internal/util/reflection/GenericMasterTest.java b/src/test/java/org/mockito/internal/util/reflection/GenericMasterTest.java
index 4125e09..2e77d58 100644
--- a/src/test/java/org/mockito/internal/util/reflection/GenericMasterTest.java
+++ b/src/test/java/org/mockito/internal/util/reflection/GenericMasterTest.java
@@ -4,13 +4,13 @@
*/
package org.mockito.internal.util.reflection;
-import org.junit.Test;
+import static org.junit.Assert.assertEquals;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.*;
-import static org.junit.Assert.assertEquals;
+import org.junit.Test;
public class GenericMasterTest {
@@ -24,16 +24,27 @@
List<Set<Collection<String>>> multiNested;
public interface ListSet extends List<Set<?>> {}
+
public interface MapNumberString extends Map<Number, String> {}
+
public class HashMapNumberString<K extends Number> extends HashMap<K, String> {}
- public List<Number> numberList() { return null; }
- public Comparable<Number> numberComparable() { return null; }
+ public List<Number> numberList() {
+ return null;
+ }
+
+ public Comparable<Number> numberComparable() {
+ return null;
+ }
+
@SuppressWarnings("rawtypes")
- public List rawList() { return null; }
- public List<? extends Type> typeList() { return null; }
+ public List rawList() {
+ return null;
+ }
-
+ public List<? extends Type> typeList() {
+ return null;
+ }
@Test
public void should_find_generic_class() throws Exception {
@@ -56,5 +67,4 @@
private Field field(String fieldName) throws SecurityException, NoSuchFieldException {
return this.getClass().getDeclaredField(fieldName);
}
-
}
diff --git a/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java b/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java
index 323efbf..6c6333c 100644
--- a/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java
+++ b/src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java
@@ -4,59 +4,96 @@
*/
package org.mockito.internal.util.reflection;
-import org.junit.Test;
-
-import java.io.Serializable;
-import java.lang.reflect.Method;
-import java.lang.reflect.Type;
-import java.lang.reflect.TypeVariable;
-import java.util.*;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
import static org.mockito.internal.util.reflection.GenericMetadataSupport.inferFrom;
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Test;
+
public class GenericMetadataSupportTest {
interface GenericsSelfReference<T extends GenericsSelfReference<T>> {
T self();
}
+
interface UpperBoundedTypeWithClass<E extends Number & Comparable<E>> {
E get();
}
+
interface UpperBoundedTypeWithInterfaces<E extends Comparable<E> & Cloneable> {
E get();
}
+
interface ListOfNumbers extends List<Number> {}
+
interface AnotherListOfNumbers extends ListOfNumbers {}
abstract class ListOfNumbersImpl implements ListOfNumbers {}
+
abstract class AnotherListOfNumbersImpl extends ListOfNumbersImpl {}
interface ListOfAnyNumbers<N extends Number & Cloneable> extends List<N> {}
interface GenericsNest<K extends Comparable<K> & Cloneable> extends Map<K, Set<Number>> {
Set<Number> remove(Object key); // override with fixed ParameterizedType
+
List<? super Integer> returning_wildcard_with_class_lower_bound();
+
List<? super K> returning_wildcard_with_typeVar_lower_bound();
+
List<? extends K> returning_wildcard_with_typeVar_upper_bound();
+
K returningK();
+
<O extends K> List<O> paramType_with_type_params();
+
<S, T extends S> T two_type_params();
+
<O extends K> O typeVar_with_type_params();
}
- static class StringList extends ArrayList<String> { }
+ static class StringList extends ArrayList<String> {}
+
+ public interface TopInterface<T> {
+ T generic();
+ }
+
+ public interface MiddleInterface<T> extends TopInterface<T> {}
+
+ public class OwningClassWithDeclaredUpperBounds<
+ T extends List<String> & Comparable<String> & Cloneable> {
+ public abstract class AbstractInner implements MiddleInterface<T> {}
+ }
+
+ public class OwningClassWithNoDeclaredUpperBounds<T> {
+ public abstract class AbstractInner implements MiddleInterface<T> {}
+ }
@Test
public void typeVariable_of_self_type() {
- GenericMetadataSupport genericMetadata = inferFrom(GenericsSelfReference.class).resolveGenericReturnType(firstNamedMethod("self", GenericsSelfReference.class));
+ GenericMetadataSupport genericMetadata =
+ inferFrom(GenericsSelfReference.class)
+ .resolveGenericReturnType(
+ firstNamedMethod("self", GenericsSelfReference.class));
assertThat(genericMetadata.rawType()).isEqualTo(GenericsSelfReference.class);
}
@Test
- public void can_get_raw_type_from_Class() throws Exception {
+ public void can_get_raw_type_from_Class() {
assertThat(inferFrom(ListOfAnyNumbers.class).rawType()).isEqualTo(ListOfAnyNumbers.class);
assertThat(inferFrom(ListOfNumbers.class).rawType()).isEqualTo(ListOfNumbers.class);
assertThat(inferFrom(GenericsNest.class).rawType()).isEqualTo(GenericsNest.class);
@@ -64,19 +101,32 @@
}
@Test
- public void can_get_raw_type_from_ParameterizedType() throws Exception {
- assertThat(inferFrom(ListOfAnyNumbers.class.getGenericInterfaces()[0]).rawType()).isEqualTo(List.class);
- assertThat(inferFrom(ListOfNumbers.class.getGenericInterfaces()[0]).rawType()).isEqualTo(List.class);
- assertThat(inferFrom(GenericsNest.class.getGenericInterfaces()[0]).rawType()).isEqualTo(Map.class);
- assertThat(inferFrom(StringList.class.getGenericSuperclass()).rawType()).isEqualTo(ArrayList.class);
+ public void can_get_raw_type_from_ParameterizedType() {
+ assertThat(inferFrom(ListOfAnyNumbers.class.getGenericInterfaces()[0]).rawType())
+ .isEqualTo(List.class);
+ assertThat(inferFrom(ListOfNumbers.class.getGenericInterfaces()[0]).rawType())
+ .isEqualTo(List.class);
+ assertThat(inferFrom(GenericsNest.class.getGenericInterfaces()[0]).rawType())
+ .isEqualTo(Map.class);
+ assertThat(inferFrom(StringList.class.getGenericSuperclass()).rawType())
+ .isEqualTo(ArrayList.class);
}
@Test
- public void can_get_type_variables_from_Class() throws Exception {
- assertThat(inferFrom(GenericsNest.class).actualTypeArguments().keySet()).hasSize(1).extracting("name").contains("K");
+ public void can_get_type_variables_from_Class() {
+ assertThat(inferFrom(GenericsNest.class).actualTypeArguments().keySet())
+ .hasSize(1)
+ .extracting("name")
+ .contains("K");
assertThat(inferFrom(ListOfNumbers.class).actualTypeArguments().keySet()).isEmpty();
- assertThat(inferFrom(ListOfAnyNumbers.class).actualTypeArguments().keySet()).hasSize(1).extracting("name").contains("N");
- assertThat(inferFrom(Map.class).actualTypeArguments().keySet()).hasSize(2).extracting("name").contains("K", "V");
+ assertThat(inferFrom(ListOfAnyNumbers.class).actualTypeArguments().keySet())
+ .hasSize(1)
+ .extracting("name")
+ .contains("N");
+ assertThat(inferFrom(Map.class).actualTypeArguments().keySet())
+ .hasSize(2)
+ .extracting("name")
+ .contains("K", "V");
assertThat(inferFrom(Serializable.class).actualTypeArguments().keySet()).isEmpty();
assertThat(inferFrom(StringList.class).actualTypeArguments().keySet()).isEmpty();
}
@@ -84,122 +134,306 @@
@Test
public void can_resolve_type_variables_from_ancestors() throws Exception {
Method listGet = List.class.getMethod("get", int.class);
- assertThat(inferFrom(AnotherListOfNumbers.class).resolveGenericReturnType(listGet).rawType()).isEqualTo(Number.class);
- assertThat(inferFrom(AnotherListOfNumbersImpl.class).resolveGenericReturnType(listGet).rawType()).isEqualTo(Number.class);
+ assertThat(
+ inferFrom(AnotherListOfNumbers.class)
+ .resolveGenericReturnType(listGet)
+ .rawType())
+ .isEqualTo(Number.class);
+ assertThat(
+ inferFrom(AnotherListOfNumbersImpl.class)
+ .resolveGenericReturnType(listGet)
+ .rawType())
+ .isEqualTo(Number.class);
}
@Test
- public void can_get_type_variables_from_ParameterizedType() throws Exception {
- assertThat(inferFrom(GenericsNest.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(2).extracting("name").contains("K", "V");
- assertThat(inferFrom(ListOfAnyNumbers.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(1).extracting("name").contains("E");
- assertThat(inferFrom(Integer.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).hasSize(1).extracting("name").contains("T");
- assertThat(inferFrom(StringBuilder.class.getGenericInterfaces()[0]).actualTypeArguments().keySet()).isEmpty();
+ public void can_get_type_variables_from_ParameterizedType() {
+ assertThat(
+ inferFrom(GenericsNest.class.getGenericInterfaces()[0])
+ .actualTypeArguments()
+ .keySet())
+ .hasSize(2)
+ .extracting("name")
+ .contains("K", "V");
+ assertThat(
+ inferFrom(ListOfAnyNumbers.class.getGenericInterfaces()[0])
+ .actualTypeArguments()
+ .keySet())
+ .hasSize(1)
+ .extracting("name")
+ .contains("E");
+ assertThat(
+ inferFrom(Integer.class.getGenericInterfaces()[0])
+ .actualTypeArguments()
+ .keySet())
+ .hasSize(1)
+ .extracting("name")
+ .contains("T");
+ assertThat(
+ inferFrom(StringBuilder.class.getGenericInterfaces()[0])
+ .actualTypeArguments()
+ .keySet())
+ .isEmpty();
assertThat(inferFrom(StringList.class).actualTypeArguments().keySet()).isEmpty();
}
@Test
- public void typeVariable_return_type_of____iterator____resolved_to_Iterator_and_type_argument_to_String() throws Exception {
- GenericMetadataSupport genericMetadata = inferFrom(StringList.class).resolveGenericReturnType(firstNamedMethod("iterator", StringList.class));
+ public void
+ typeVariable_return_type_of____iterator____resolved_to_Iterator_and_type_argument_to_String() {
+ GenericMetadataSupport genericMetadata =
+ inferFrom(StringList.class)
+ .resolveGenericReturnType(firstNamedMethod("iterator", StringList.class));
assertThat(genericMetadata.rawType()).isEqualTo(Iterator.class);
assertThat(genericMetadata.actualTypeArguments().values()).contains(String.class);
}
@Test
- public void typeVariable_return_type_of____get____resolved_to_Set_and_type_argument_to_Number() throws Exception {
- GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("get", GenericsNest.class));
+ public void
+ typeVariable_return_type_of____get____resolved_to_Set_and_type_argument_to_Number() {
+ GenericMetadataSupport genericMetadata =
+ inferFrom(GenericsNest.class)
+ .resolveGenericReturnType(firstNamedMethod("get", GenericsNest.class));
assertThat(genericMetadata.rawType()).isEqualTo(Set.class);
assertThat(genericMetadata.actualTypeArguments().values()).contains(Number.class);
}
@Test
- public void bounded_typeVariable_return_type_of____returningK____resolved_to_Comparable_and_with_BoundedType() throws Exception {
- GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("returningK", GenericsNest.class));
+ public void
+ bounded_typeVariable_return_type_of____returningK____resolved_to_Comparable_and_with_BoundedType() {
+ GenericMetadataSupport genericMetadata =
+ inferFrom(GenericsNest.class)
+ .resolveGenericReturnType(
+ firstNamedMethod("returningK", GenericsNest.class));
assertThat(genericMetadata.rawType()).isEqualTo(Comparable.class);
- GenericMetadataSupport extraInterface_0 = inferFrom(genericMetadata.extraInterfaces().get(0));
+ GenericMetadataSupport extraInterface_0 =
+ inferFrom(genericMetadata.extraInterfaces().get(0));
assertThat(extraInterface_0.rawType()).isEqualTo(Cloneable.class);
}
@Test
- public void fixed_ParamType_return_type_of____remove____resolved_to_Set_and_type_argument_to_Number() throws Exception {
- GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("remove", GenericsNest.class));
+ public void
+ fixed_ParamType_return_type_of____remove____resolved_to_Set_and_type_argument_to_Number() {
+ GenericMetadataSupport genericMetadata =
+ inferFrom(GenericsNest.class)
+ .resolveGenericReturnType(firstNamedMethod("remove", GenericsNest.class));
assertThat(genericMetadata.rawType()).isEqualTo(Set.class);
assertThat(genericMetadata.actualTypeArguments().values()).contains(Number.class);
}
@Test
- public void paramType_return_type_of____values____resolved_to_Collection_and_type_argument_to_Parameterized_Set() throws Exception {
- GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("values", GenericsNest.class));
+ public void
+ paramType_return_type_of____values____resolved_to_Collection_and_type_argument_to_Parameterized_Set() {
+ GenericMetadataSupport genericMetadata =
+ inferFrom(GenericsNest.class)
+ .resolveGenericReturnType(firstNamedMethod("values", GenericsNest.class));
assertThat(genericMetadata.rawType()).isEqualTo(Collection.class);
- GenericMetadataSupport fromTypeVariableE = inferFrom(typeVariableValue(genericMetadata.actualTypeArguments(), "E"));
+ GenericMetadataSupport fromTypeVariableE =
+ inferFrom(typeVariableValue(genericMetadata.actualTypeArguments(), "E"));
assertThat(fromTypeVariableE.rawType()).isEqualTo(Set.class);
assertThat(fromTypeVariableE.actualTypeArguments().values()).contains(Number.class);
}
@Test
- public void paramType_with_type_parameters_return_type_of____paramType_with_type_params____resolved_to_Collection_and_type_argument_to_Parameterized_Set() throws Exception {
- GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("paramType_with_type_params", GenericsNest.class));
+ public void
+ paramType_with_type_parameters_return_type_of____paramType_with_type_params____resolved_to_Collection_and_type_argument_to_Parameterized_Set() {
+ GenericMetadataSupport genericMetadata =
+ inferFrom(GenericsNest.class)
+ .resolveGenericReturnType(
+ firstNamedMethod("paramType_with_type_params", GenericsNest.class));
assertThat(genericMetadata.rawType()).isEqualTo(List.class);
- Type firstBoundOfE = ((GenericMetadataSupport.TypeVarBoundedType) typeVariableValue(genericMetadata.actualTypeArguments(), "E")).firstBound();
+ Type firstBoundOfE =
+ ((GenericMetadataSupport.TypeVarBoundedType)
+ typeVariableValue(genericMetadata.actualTypeArguments(), "E"))
+ .firstBound();
assertThat(inferFrom(firstBoundOfE).rawType()).isEqualTo(Comparable.class);
}
@Test
- public void typeVariable_with_type_parameters_return_type_of____typeVar_with_type_params____resolved_K_hence_to_Comparable_and_with_BoundedType() throws Exception {
- GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("typeVar_with_type_params", GenericsNest.class));
+ public void
+ typeVariable_with_type_parameters_return_type_of____typeVar_with_type_params____resolved_K_hence_to_Comparable_and_with_BoundedType() {
+ GenericMetadataSupport genericMetadata =
+ inferFrom(GenericsNest.class)
+ .resolveGenericReturnType(
+ firstNamedMethod("typeVar_with_type_params", GenericsNest.class));
assertThat(genericMetadata.rawType()).isEqualTo(Comparable.class);
- GenericMetadataSupport extraInterface_0 = inferFrom(genericMetadata.extraInterfaces().get(0));
+ GenericMetadataSupport extraInterface_0 =
+ inferFrom(genericMetadata.extraInterfaces().get(0));
assertThat(extraInterface_0.rawType()).isEqualTo(Cloneable.class);
}
@Test
- public void class_return_type_of____append____resolved_to_StringBuilder_and_type_arguments() throws Exception {
- GenericMetadataSupport genericMetadata = inferFrom(StringBuilder.class).resolveGenericReturnType(firstNamedMethod("append", StringBuilder.class));
+ public void class_return_type_of____append____resolved_to_StringBuilder_and_type_arguments() {
+ GenericMetadataSupport genericMetadata =
+ inferFrom(StringBuilder.class)
+ .resolveGenericReturnType(firstNamedMethod("append", StringBuilder.class));
assertThat(genericMetadata.rawType()).isEqualTo(StringBuilder.class);
assertThat(genericMetadata.actualTypeArguments()).isEmpty();
}
-
-
@Test
- public void paramType_with_wildcard_return_type_of____returning_wildcard_with_class_lower_bound____resolved_to_List_and_type_argument_to_Integer() throws Exception {
- GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("returning_wildcard_with_class_lower_bound", GenericsNest.class));
+ public void
+ paramType_with_wildcard_return_type_of____returning_wildcard_with_class_lower_bound____resolved_to_List_and_type_argument_to_Integer() {
+ GenericMetadataSupport genericMetadata =
+ inferFrom(GenericsNest.class)
+ .resolveGenericReturnType(
+ firstNamedMethod(
+ "returning_wildcard_with_class_lower_bound",
+ GenericsNest.class));
assertThat(genericMetadata.rawType()).isEqualTo(List.class);
- GenericMetadataSupport.BoundedType boundedType = (GenericMetadataSupport.BoundedType) typeVariableValue(genericMetadata.actualTypeArguments(), "E");
+ GenericMetadataSupport.BoundedType boundedType =
+ (GenericMetadataSupport.BoundedType)
+ typeVariableValue(genericMetadata.actualTypeArguments(), "E");
assertThat(boundedType.firstBound()).isEqualTo(Integer.class);
assertThat(boundedType.interfaceBounds()).isEmpty();
}
@Test
- public void paramType_with_wildcard_return_type_of____returning_wildcard_with_typeVar_lower_bound____resolved_to_List_and_type_argument_to_Integer() throws Exception {
- GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("returning_wildcard_with_typeVar_lower_bound", GenericsNest.class));
+ public void
+ paramType_with_wildcard_return_type_of____returning_wildcard_with_typeVar_lower_bound____resolved_to_List_and_type_argument_to_Integer() {
+ GenericMetadataSupport genericMetadata =
+ inferFrom(GenericsNest.class)
+ .resolveGenericReturnType(
+ firstNamedMethod(
+ "returning_wildcard_with_typeVar_lower_bound",
+ GenericsNest.class));
assertThat(genericMetadata.rawType()).isEqualTo(List.class);
- GenericMetadataSupport.BoundedType boundedType = (GenericMetadataSupport.BoundedType) typeVariableValue(genericMetadata.actualTypeArguments(), "E");
-
- assertThat(inferFrom(boundedType.firstBound()).rawType()).isEqualTo(Comparable.class);
- assertThat(boundedType.interfaceBounds()).contains(Cloneable.class); }
-
- @Test
- public void paramType_with_wildcard_return_type_of____returning_wildcard_with_typeVar_upper_bound____resolved_to_List_and_type_argument_to_Integer() throws Exception {
- GenericMetadataSupport genericMetadata = inferFrom(GenericsNest.class).resolveGenericReturnType(firstNamedMethod("returning_wildcard_with_typeVar_upper_bound", GenericsNest.class));
-
- assertThat(genericMetadata.rawType()).isEqualTo(List.class);
- GenericMetadataSupport.BoundedType boundedType = (GenericMetadataSupport.BoundedType) typeVariableValue(genericMetadata.actualTypeArguments(), "E");
+ GenericMetadataSupport.BoundedType boundedType =
+ (GenericMetadataSupport.BoundedType)
+ typeVariableValue(genericMetadata.actualTypeArguments(), "E");
assertThat(inferFrom(boundedType.firstBound()).rawType()).isEqualTo(Comparable.class);
assertThat(boundedType.interfaceBounds()).contains(Cloneable.class);
}
- private Type typeVariableValue(Map<TypeVariable<?>, Type> typeVariables, String typeVariableName) {
+ @Test
+ public void
+ paramType_with_wildcard_return_type_of____returning_wildcard_with_typeVar_upper_bound____resolved_to_List_and_type_argument_to_Integer() {
+ GenericMetadataSupport genericMetadata =
+ inferFrom(GenericsNest.class)
+ .resolveGenericReturnType(
+ firstNamedMethod(
+ "returning_wildcard_with_typeVar_upper_bound",
+ GenericsNest.class));
+
+ assertThat(genericMetadata.rawType()).isEqualTo(List.class);
+ GenericMetadataSupport.BoundedType boundedType =
+ (GenericMetadataSupport.BoundedType)
+ typeVariableValue(genericMetadata.actualTypeArguments(), "E");
+
+ assertThat(inferFrom(boundedType.firstBound()).rawType()).isEqualTo(Comparable.class);
+ assertThat(boundedType.interfaceBounds()).contains(Cloneable.class);
+ }
+
+ @Test
+ public void can_extract_raw_type_from_bounds_on_terminal_typeVariable() {
+ assertThat(
+ inferFrom(OwningClassWithDeclaredUpperBounds.AbstractInner.class)
+ .resolveGenericReturnType(
+ firstNamedMethod(
+ "generic",
+ OwningClassWithDeclaredUpperBounds.AbstractInner
+ .class))
+ .rawType())
+ .isEqualTo(List.class);
+ assertThat(
+ inferFrom(OwningClassWithNoDeclaredUpperBounds.AbstractInner.class)
+ .resolveGenericReturnType(
+ firstNamedMethod(
+ "generic",
+ OwningClassWithNoDeclaredUpperBounds.AbstractInner
+ .class))
+ .rawType())
+ .isEqualTo(Object.class);
+ }
+
+ @Test
+ public void can_extract_interface_type_from_bounds_on_terminal_typeVariable() {
+
+ assertThat(
+ inferFrom(OwningClassWithDeclaredUpperBounds.AbstractInner.class)
+ .resolveGenericReturnType(
+ firstNamedMethod(
+ "generic",
+ OwningClassWithDeclaredUpperBounds.AbstractInner
+ .class))
+ .rawExtraInterfaces())
+ .containsExactly(Comparable.class, Cloneable.class);
+ assertThat(
+ inferFrom(OwningClassWithDeclaredUpperBounds.AbstractInner.class)
+ .resolveGenericReturnType(
+ firstNamedMethod(
+ "generic",
+ OwningClassWithDeclaredUpperBounds.AbstractInner
+ .class))
+ .extraInterfaces())
+ .containsExactly(
+ parameterizedTypeOf(Comparable.class, null, String.class), Cloneable.class);
+
+ assertThat(
+ inferFrom(OwningClassWithNoDeclaredUpperBounds.AbstractInner.class)
+ .resolveGenericReturnType(
+ firstNamedMethod(
+ "generic",
+ OwningClassWithNoDeclaredUpperBounds.AbstractInner
+ .class))
+ .extraInterfaces())
+ .isEmpty();
+ }
+
+ private ParameterizedType parameterizedTypeOf(
+ final Class<?> rawType, final Class<?> ownerType, final Type... actualTypeArguments) {
+ return new ParameterizedType() {
+ @Override
+ public Type[] getActualTypeArguments() {
+ return actualTypeArguments;
+ }
+
+ @Override
+ public Type getRawType() {
+ return rawType;
+ }
+
+ @Override
+ public Type getOwnerType() {
+ return ownerType;
+ }
+
+ @SuppressWarnings("EqualsHashCode")
+ public boolean equals(Object other) {
+ if (other instanceof ParameterizedType) {
+ ParameterizedType otherParamType = (ParameterizedType) other;
+ if (this == otherParamType) {
+ return true;
+ } else {
+ return equals(ownerType, otherParamType.getOwnerType())
+ && equals(rawType, otherParamType.getRawType())
+ && Arrays.equals(
+ actualTypeArguments,
+ otherParamType.getActualTypeArguments());
+ }
+ } else {
+ return false;
+ }
+ }
+
+ private boolean equals(Object a, Object b) {
+ return (a == b) || (a != null && a.equals(b));
+ }
+ };
+ }
+
+ private Type typeVariableValue(
+ Map<TypeVariable<?>, Type> typeVariables, String typeVariableName) {
for (Map.Entry<TypeVariable<?>, Type> typeVariableTypeEntry : typeVariables.entrySet()) {
if (typeVariableTypeEntry.getKey().getName().equals(typeVariableName)) {
return typeVariableTypeEntry.getValue();
@@ -212,11 +446,18 @@
private Method firstNamedMethod(String methodName, Class<?> clazz) {
for (Method method : clazz.getMethods()) {
- boolean protect_against_different_jdk_ordering_avoiding_bridge_methods = !method.isBridge();
- if (method.getName().contains(methodName) && protect_against_different_jdk_ordering_avoiding_bridge_methods) {
+ boolean protect_against_different_jdk_ordering_avoiding_bridge_methods =
+ !method.isBridge();
+ if (method.getName().contains(methodName)
+ && protect_against_different_jdk_ordering_avoiding_bridge_methods) {
return method;
}
}
- throw new IllegalStateException("The method : '" + methodName + "' do not exist in '" + clazz.getSimpleName() + "'");
+ throw new IllegalStateException(
+ "The method : '"
+ + methodName
+ + "' do not exist in '"
+ + clazz.getSimpleName()
+ + "'");
}
}
diff --git a/src/test/java/org/mockito/internal/util/reflection/GenericTypeExtractorTest.java b/src/test/java/org/mockito/internal/util/reflection/GenericTypeExtractorTest.java
index c4e941c..94abf86 100644
--- a/src/test/java/org/mockito/internal/util/reflection/GenericTypeExtractorTest.java
+++ b/src/test/java/org/mockito/internal/util/reflection/GenericTypeExtractorTest.java
@@ -4,59 +4,87 @@
*/
package org.mockito.internal.util.reflection;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.internal.util.reflection.GenericTypeExtractor.genericTypeOf;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.internal.util.reflection.GenericTypeExtractor.genericTypeOf;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
public class GenericTypeExtractorTest extends TestBase {
class Base<T> {}
+
static class StaticBase<T> {}
+
interface IBase<T> {}
+
interface StaticIBase<T> {}
class IntImpl extends Base<Integer> {}
+
static class StaticIntImpl extends StaticBase<Integer> {}
+
class NestedImpl extends Base<Base<String>> {}
+
class NonGeneric extends Base {}
- class IIntImpl implements IBase<Integer>{}
- class INestedImpl implements IBase<IBase<String>>{}
+ class IIntImpl implements IBase<Integer> {}
+
+ class INestedImpl implements IBase<IBase<String>> {}
+
class INonGeneric implements IBase {}
+
class Mixed extends Base<Integer> implements IBase<String> {}
class Deeper extends IntImpl implements Serializable {}
+
class EvenDeeper extends Deeper implements Cloneable {}
+
interface Iface extends IBase<Integer> {}
+
interface IDeeper extends Serializable, Iface, Cloneable {}
interface Crazy extends Serializable, IDeeper, Cloneable {}
+
class Crazier extends EvenDeeper implements Crazy {}
- @Test public void finds_generic_type() {
+ class SecondGeneric implements Serializable, IBase<Integer> {}
+
+ @Test
+ public void finds_generic_type() {
assertEquals(Integer.class, genericTypeOf(IntImpl.class, Base.class, IBase.class));
- assertEquals(Integer.class, genericTypeOf(StaticIntImpl.class, StaticBase.class, IBase.class));
+ assertEquals(
+ Integer.class, genericTypeOf(StaticIntImpl.class, StaticBase.class, IBase.class));
assertEquals(Object.class, genericTypeOf(NestedImpl.class, Base.class, IBase.class));
assertEquals(Object.class, genericTypeOf(NonGeneric.class, Base.class, IBase.class));
assertEquals(Object.class, genericTypeOf(String.class, Base.class, IBase.class));
assertEquals(Object.class, genericTypeOf(String.class, List.class, Map.class));
- assertEquals(String.class, genericTypeOf(new Base<String>() {}.getClass(), Base.class, IBase.class));
- assertEquals(String.class, genericTypeOf(new IBase<String>() {}.getClass(), Base.class, IBase.class));
- assertEquals(String.class, genericTypeOf(new StaticBase<String>() {}.getClass(), StaticBase.class, IBase.class));
- assertEquals(String.class, genericTypeOf(new StaticIBase<String>() {}.getClass(), Base.class, StaticIBase.class));
+ assertEquals(
+ String.class,
+ genericTypeOf(new Base<String>() {}.getClass(), Base.class, IBase.class));
+ assertEquals(
+ String.class,
+ genericTypeOf(new IBase<String>() {}.getClass(), Base.class, IBase.class));
+ assertEquals(
+ String.class,
+ genericTypeOf(
+ new StaticBase<String>() {}.getClass(), StaticBase.class, IBase.class));
+ assertEquals(
+ String.class,
+ genericTypeOf(
+ new StaticIBase<String>() {}.getClass(), Base.class, StaticIBase.class));
assertEquals(Integer.class, genericTypeOf(Mixed.class, Base.class, IBase.class));
assertEquals(Integer.class, genericTypeOf(IIntImpl.class, Base.class, IBase.class));
assertEquals(Object.class, genericTypeOf(INestedImpl.class, Base.class, IBase.class));
- assertEquals(Object.class, genericTypeOf(INonGeneric.class, IBase.class, INonGeneric.class));
+ assertEquals(
+ Object.class, genericTypeOf(INonGeneric.class, IBase.class, INonGeneric.class));
assertEquals(Integer.class, genericTypeOf(Deeper.class, Base.class, IBase.class));
assertEquals(Integer.class, genericTypeOf(EvenDeeper.class, Base.class, IBase.class));
@@ -64,5 +92,7 @@
assertEquals(Integer.class, genericTypeOf(IDeeper.class, Base.class, IBase.class));
assertEquals(Integer.class, genericTypeOf(Crazy.class, Base.class, IBase.class));
assertEquals(Integer.class, genericTypeOf(Crazier.class, Base.class, IBase.class));
+
+ assertEquals(Integer.class, genericTypeOf(SecondGeneric.class, Base.class, IBase.class));
}
}
diff --git a/src/test/java/org/mockito/internal/util/reflection/LenientCopyToolTest.java b/src/test/java/org/mockito/internal/util/reflection/LenientCopyToolTest.java
index 6a52161..e70d8aa 100644
--- a/src/test/java/org/mockito/internal/util/reflection/LenientCopyToolTest.java
+++ b/src/test/java/org/mockito/internal/util/reflection/LenientCopyToolTest.java
@@ -4,16 +4,16 @@
*/
package org.mockito.internal.util.reflection;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.*;
import java.lang.reflect.Field;
import java.util.LinkedList;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import org.junit.Test;
+import org.mockito.plugins.MemberAccessor;
+import org.mockitoutil.TestBase;
@SuppressWarnings("unchecked")
public class LenientCopyToolTest extends TestBase {
@@ -29,6 +29,7 @@
@SuppressWarnings("unused")
// required because static fields needs to be excluded from copying
private static int staticField = -100;
+
private int privateField = -100;
private transient int privateTransientField = -100;
String defaultField = "-100";
@@ -41,8 +42,7 @@
}
}
- public static class SomeOtherObject {
- }
+ public static class SomeOtherObject {}
private SomeObject from = new SomeObject(100);
private SomeObject to = mock(SomeObject.class);
@@ -113,49 +113,37 @@
@Test
public void shouldCopyValuesOfInheritedFields() throws Exception {
- //given
+ // given
((InheritMe) from).privateInherited = "foo";
((InheritMe) from).protectedInherited = "bar";
- assertThat(((InheritMe) to).privateInherited).isNotEqualTo(((InheritMe) from).privateInherited);
+ assertThat(((InheritMe) to).privateInherited)
+ .isNotEqualTo(((InheritMe) from).privateInherited);
- //when
+ // when
tool.copyToMock(from, to);
- //then
+ // then
assertEquals(((InheritMe) from).privateInherited, ((InheritMe) to).privateInherited);
}
@Test
- public void shouldEnableAndThenDisableAccessibility() throws Exception {
- //given
- Field privateField = SomeObject.class.getDeclaredField("privateField");
- assertFalse(privateField.isAccessible());
-
- //when
- tool.copyToMock(from, to);
-
- //then
- privateField = SomeObject.class.getDeclaredField("privateField");
- assertFalse(privateField.isAccessible());
- }
-
- @Test
public void shouldContinueEvenIfThereAreProblemsCopyingSingleFieldValue() throws Exception {
- //given
- tool.fieldCopier = mock(FieldCopier.class);
+ // given
+ tool.accessor = mock(MemberAccessor.class);
- doNothing().
- doThrow(new IllegalAccessException()).
- doNothing().
- when(tool.fieldCopier).
- copyValue(anyObject(), anyObject(), any(Field.class));
+ doNothing()
+ .doThrow(new IllegalStateException())
+ .doNothing()
+ .when(tool.accessor)
+ .set(any(Field.class), anyObject(), anyObject());
- //when
+ // when
tool.copyToMock(from, to);
- //then
- verify(tool.fieldCopier, atLeast(3)).copyValue(any(), any(), any(Field.class));
+ // then
+ verify(tool.accessor, atLeast(3)).get(any(Field.class), any());
+ verify(tool.accessor, atLeast(3)).set(any(Field.class), any(), any());
}
@Test
@@ -180,6 +168,5 @@
assertEquals(from.privateTransientField, to.privateTransientField);
assertEquals(from.protectedField, to.protectedField);
assertEquals(from.protectedInherited, to.protectedInherited);
-
}
}
diff --git a/src/test/java/org/mockito/internal/util/reflection/MemberAccessorTest.java b/src/test/java/org/mockito/internal/util/reflection/MemberAccessorTest.java
new file mode 100644
index 0000000..ee39031
--- /dev/null
+++ b/src/test/java/org/mockito/internal/util/reflection/MemberAccessorTest.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.util.reflection;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.mockito.plugins.MemberAccessor;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@RunWith(Parameterized.class)
+public class MemberAccessorTest {
+
+ @Parameterized.Parameters
+ public static Collection<Object[]> data() {
+ List<Object[]> data = new ArrayList<>();
+ data.add(new Object[] {new ReflectionMemberAccessor()});
+ data.add(new Object[] {new ModuleMemberAccessor()});
+ return data;
+ }
+
+ private final MemberAccessor accessor;
+
+ public MemberAccessorTest(MemberAccessor accessor) {
+ this.accessor = accessor;
+ }
+
+ @Test
+ public void test_read_field() throws Exception {
+ assertThat(accessor.get(Sample.class.getDeclaredField("field"), new Sample("foo")))
+ .isEqualTo("foo");
+ }
+
+ @Test
+ public void test_read_static_field() throws Exception {
+ Sample.staticField = "foo";
+ assertThat(accessor.get(Sample.class.getDeclaredField("staticField"), null))
+ .isEqualTo("foo");
+ }
+
+ @Test
+ public void test_write_field() throws Exception {
+ Sample sample = new Sample("foo");
+ accessor.set(Sample.class.getDeclaredField("field"), sample, "bar");
+ assertThat(sample.field).isEqualTo("bar");
+ }
+
+ @Test
+ public void test_write_static_field() throws Exception {
+ Sample.staticField = "foo";
+ accessor.set(Sample.class.getDeclaredField("staticField"), null, "bar");
+ assertThat(Sample.staticField).isEqualTo("bar");
+ }
+
+ @Test
+ public void test_invoke() throws Exception {
+ assertThat(
+ accessor.invoke(
+ Sample.class.getDeclaredMethod("test", String.class),
+ new Sample(null),
+ "foo"))
+ .isEqualTo("foo");
+ }
+
+ @Test
+ public void test_invoke_invocation_exception() {
+ assertThatThrownBy(
+ () ->
+ accessor.invoke(
+ Sample.class.getDeclaredMethod("test", String.class),
+ new Sample(null),
+ "exception"))
+ .isInstanceOf(InvocationTargetException.class);
+ }
+
+ @Test
+ public void test_invoke_illegal_arguments() {
+ assertThatThrownBy(
+ () ->
+ accessor.invoke(
+ Sample.class.getDeclaredMethod("test", String.class),
+ new Sample(null),
+ 42))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
+
+ @Test
+ public void test_new_instance() throws Exception {
+ assertThat(accessor.newInstance(Sample.class.getDeclaredConstructor(String.class), "foo"))
+ .isInstanceOf(Sample.class);
+ }
+
+ @Test
+ public void test_new_instance_illegal_arguments() {
+ assertThatThrownBy(
+ () ->
+ accessor.newInstance(
+ Sample.class.getDeclaredConstructor(String.class), 42))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
+
+ @Test
+ public void test_new_instance_invocation_exception() {
+ assertThatThrownBy(
+ () ->
+ accessor.newInstance(
+ Sample.class.getDeclaredConstructor(String.class),
+ "exception"))
+ .isInstanceOf(InvocationTargetException.class);
+ }
+
+ @Test
+ public void test_new_instance_instantiation_exception() {
+ assertThatThrownBy(
+ () -> accessor.newInstance(AbstractSample.class.getDeclaredConstructor()))
+ .isInstanceOf(InstantiationException.class);
+ }
+
+ @Test
+ public void test_set_final_field() throws Exception {
+ Sample sample = new Sample("foo");
+ accessor.set(Sample.class.getDeclaredField("finalField"), sample, "foo");
+ assertThat(sample.finalField).isEqualTo("foo");
+ }
+
+ private static class Sample {
+
+ private String field;
+
+ private final String finalField = null;
+
+ private static String staticField = "foo";
+
+ public Sample(String field) {
+ if ("exception".equals(field)) {
+ throw new RuntimeException();
+ }
+ this.field = field;
+ }
+
+ private String test(String value) {
+ if ("exception".equals(value)) {
+ throw new RuntimeException();
+ }
+ return value;
+ }
+ }
+
+ private abstract static class AbstractSample {}
+}
diff --git a/src/test/java/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java b/src/test/java/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java
index 6f3677a..cb75496 100644
--- a/src/test/java/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java
+++ b/src/test/java/org/mockito/internal/util/reflection/ParameterizedConstructorInstantiatorTest.java
@@ -2,32 +2,29 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.util.reflection;
-
-import org.junit.After;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Matchers;
-import org.mockito.Mock;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.internal.util.reflection.FieldInitializer.ConstructorArgumentResolver;
-import org.mockito.internal.util.reflection.FieldInitializer.ParameterizedConstructorInstantiator;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.io.IOException;
-import java.lang.reflect.Field;
-import java.util.Map;
-import java.util.Observer;
-import java.util.Set;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.fail;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.util.Map;
+import java.util.Observer;
+import java.util.Set;
+
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mock;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.util.reflection.FieldInitializer.ConstructorArgumentResolver;
+import org.mockito.internal.util.reflection.FieldInitializer.ParameterizedConstructorInstantiator;
+import org.mockito.junit.MockitoJUnitRunner;
@SuppressWarnings("unchecked")
@RunWith(MockitoJUnitRunner.class)
@@ -57,12 +54,18 @@
}
@Test
- public void should_fail_if_no_parameterized_constructor_found___excluding_inner_and_others_kind_of_types() throws Exception {
+ public void
+ should_fail_if_no_parameterized_constructor_found___excluding_inner_and_others_kind_of_types()
+ throws Exception {
try {
- new ParameterizedConstructorInstantiator(this, field("withNoArgConstructor"), resolver).instantiate();
+ new ParameterizedConstructorInstantiator(this, field("withNoArgConstructor"), resolver)
+ .instantiate();
fail();
} catch (MockitoException me) {
- assertThat(me.getMessage()).contains("no parameterized constructor").contains("withNoArgConstructor").contains("NoArgConstructor");
+ assertThat(me.getMessage())
+ .contains("no parameterized constructor")
+ .contains("withNoArgConstructor")
+ .contains("NoArgConstructor");
}
}
@@ -70,9 +73,11 @@
public void should_instantiate_type_if_resolver_provide_matching_types() throws Exception {
Observer observer = mock(Observer.class);
Map map = mock(Map.class);
- given(resolver.resolveTypeInstances(Matchers.<Class<?>[]>anyVararg())).willReturn(new Object[]{ observer, map });
+ given(resolver.resolveTypeInstances(ArgumentMatchers.<Class<?>[]>anyVararg()))
+ .willReturn(new Object[] {observer, map});
- new ParameterizedConstructorInstantiator(this, field("withMultipleConstructor"), resolver).instantiate();
+ new ParameterizedConstructorInstantiator(this, field("withMultipleConstructor"), resolver)
+ .instantiate();
assertNotNull(withMultipleConstructor);
assertNotNull(withMultipleConstructor.observer);
@@ -80,13 +85,17 @@
}
@Test
- public void should_fail_if_an_argument_instance_type_do_not_match_wanted_type() throws Exception {
+ public void should_fail_if_an_argument_instance_type_do_not_match_wanted_type()
+ throws Exception {
Observer observer = mock(Observer.class);
Set<?> wrongArg = mock(Set.class);
- given(resolver.resolveTypeInstances(Matchers.<Class<?>[]>anyVararg())).willReturn(new Object[]{ observer, wrongArg });
+ given(resolver.resolveTypeInstances(ArgumentMatchers.<Class<?>[]>any()))
+ .willReturn(new Object[] {observer, wrongArg});
try {
- new ParameterizedConstructorInstantiator(this, field("withMultipleConstructor"), resolver).instantiate();
+ new ParameterizedConstructorInstantiator(
+ this, field("withMultipleConstructor"), resolver)
+ .instantiate();
fail();
} catch (MockitoException e) {
assertThat(e.getMessage()).contains("argResolver").contains("incorrect types");
@@ -95,10 +104,13 @@
@Test
public void should_report_failure_if_constructor_throws_exception() throws Exception {
- given(resolver.resolveTypeInstances(Matchers.<Class<?>[]>anyVararg())).willReturn(new Object[]{ null });
+ given(resolver.resolveTypeInstances(ArgumentMatchers.<Class<?>[]>anyVararg()))
+ .willReturn(new Object[] {null});
try {
- new ParameterizedConstructorInstantiator(this, field("withThrowingConstructor"), resolver).instantiate();
+ new ParameterizedConstructorInstantiator(
+ this, field("withThrowingConstructor"), resolver)
+ .instantiate();
fail();
} catch (MockitoException e) {
assertThat(e.getMessage()).contains("constructor").contains("raised an exception");
@@ -107,10 +119,12 @@
@Test
public void should_instantiate_type_with_vararg_constructor() throws Exception {
- Observer[] vararg = new Observer[] { };
- given(resolver.resolveTypeInstances(Matchers.<Class<?>[]>anyVararg())).willReturn(new Object[]{ "", vararg});
+ Observer[] vararg = new Observer[] {};
+ given(resolver.resolveTypeInstances(ArgumentMatchers.<Class<?>[]>anyVararg()))
+ .willReturn(new Object[] {"", vararg});
- new ParameterizedConstructorInstantiator(this, field("withVarargConstructor"), resolver).instantiate();
+ new ParameterizedConstructorInstantiator(this, field("withVarargConstructor"), resolver)
+ .instantiate();
assertNotNull(withVarargConstructor);
}
@@ -122,22 +136,27 @@
}
private static class NoArgConstructor {
- NoArgConstructor() { }
+ NoArgConstructor() {}
}
private static class OneConstructor {
- public OneConstructor(Observer observer) { }
+ public OneConstructor(Observer observer) {}
}
private static class ThrowingConstructor {
- public ThrowingConstructor(Observer observer) throws IOException { throw new IOException(); }
+ public ThrowingConstructor(Observer observer) throws IOException {
+ throw new IOException();
+ }
}
private static class MultipleConstructor extends OneConstructor {
Observer observer;
Map map;
- public MultipleConstructor(Observer observer) { this(observer, null); }
+ public MultipleConstructor(Observer observer) {
+ this(observer, null);
+ }
+
public MultipleConstructor(Observer observer, Map map) {
super(observer);
this.observer = observer;
@@ -146,6 +165,6 @@
}
private static class VarargConstructor {
- VarargConstructor(String whatever, Observer... observers) { }
+ VarargConstructor(String whatever, Observer... observers) {}
}
}
diff --git a/src/test/java/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java b/src/test/java/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java
index e610cdf..ea50b4e 100644
--- a/src/test/java/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java
+++ b/src/test/java/org/mockito/internal/util/reflection/SuperTypesLastSorterTest.java
@@ -4,13 +4,13 @@
*/
package org.mockito.internal.util.reflection;
-import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.internal.util.reflection.SuperTypesLastSorter.sortSuperTypesLast;
import java.lang.reflect.Field;
import java.util.*;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.internal.util.reflection.SuperTypesLastSorter.sortSuperTypesLast;
+import org.junit.Test;
@SuppressWarnings("unused")
public class SuperTypesLastSorterTest {
@@ -18,21 +18,22 @@
* A Comparator that behaves like the old one, so the existing tests
* continue to work.
*/
- private static Comparator<Field> cmp = new Comparator<Field>() {
- public int compare(Field o1, Field o2) {
- if (o1.equals(o2)) {
- return 0;
- }
+ private static Comparator<Field> cmp =
+ new Comparator<Field>() {
+ public int compare(Field o1, Field o2) {
+ if (o1.equals(o2)) {
+ return 0;
+ }
- List<Field> l = sortSuperTypesLast(Arrays.asList(o1, o2));
+ List<Field> l = sortSuperTypesLast(Arrays.asList(o1, o2));
- if (l.get(0) == o1) {
- return -1;
- } else {
- return 1;
- }
- }
- };
+ if (l.get(0) == o1) {
+ return -1;
+ } else {
+ return 1;
+ }
+ }
+ };
private Object objectA;
private Object objectB;
@@ -49,7 +50,6 @@
private Iterable<?> yIterable;
private Integer zInteger;
-
@Test
public void when_same_type_the_order_is_based_on_field_name() throws Exception {
assertThat(cmp.compare(field("objectA"), field("objectB"))).isEqualTo(-1);
@@ -65,50 +65,45 @@
@Test
public void using_Collections_dot_sort() throws Exception {
- List<Field> unsortedFields = Arrays.asList(
- field("objectB"),
- field("integerB"),
- field("numberA"),
- field("numberB"),
- field("objectA"),
- field("integerA")
- );
+ List<Field> unsortedFields =
+ Arrays.asList(
+ field("objectB"),
+ field("integerB"),
+ field("numberA"),
+ field("numberB"),
+ field("objectA"),
+ field("integerA"));
- List<Field> sortedFields = sortSuperTypesLast(unsortedFields);
+ List<Field> sortedFields = sortSuperTypesLast(unsortedFields);
- assertThat(sortedFields).containsSequence(
- field("integerA"),
- field("integerB"),
- field("numberA"),
- field("numberB"),
- field("objectA"),
- field("objectB")
- );
+ assertThat(sortedFields)
+ .containsSequence(
+ field("integerA"),
+ field("integerB"),
+ field("numberA"),
+ field("numberB"),
+ field("objectA"),
+ field("objectB"));
}
-
@Test
public void issue_352_order_was_different_between_JDK6_and_JDK7() throws Exception {
- List<Field> unsortedFields = Arrays.asList(
- field("objectB"),
- field("objectA")
- );
+ List<Field> unsortedFields = Arrays.asList(field("objectB"), field("objectA"));
Collections.sort(unsortedFields, cmp);
- assertThat(unsortedFields).containsSequence(
- field("objectA"),
- field("objectB")
- );
+ assertThat(unsortedFields).containsSequence(field("objectA"), field("objectB"));
}
@Test
- public void fields_sort_consistently_when_interfaces_are_included() throws NoSuchFieldException {
+ public void fields_sort_consistently_when_interfaces_are_included()
+ throws NoSuchFieldException {
assertSortConsistently(field("iterableA"), field("numberA"), field("integerA"));
}
@Test
- public void fields_sort_consistently_when_names_and_type_indicate_different_order() throws NoSuchFieldException {
+ public void fields_sort_consistently_when_names_and_type_indicate_different_order()
+ throws NoSuchFieldException {
assertSortConsistently(field("xNumber"), field("yIterable"), field("zInteger"));
}
@@ -118,12 +113,12 @@
*/
private static void assertSortConsistently(Field a, Field b, Field c) {
Field[][] initialOrderings = {
- {a, b, c},
- {a, c, b},
- {b, a, c},
- {b, c, a},
- {c, a, b},
- {c, b, a}
+ {a, b, c},
+ {a, c, b},
+ {b, a, c},
+ {b, c, a},
+ {c, a, b},
+ {c, b, a}
};
Set<List<Field>> results = new HashSet<List<Field>>();
diff --git a/src/test/java/org/mockito/internal/verification/DefaultRegisteredInvocationsTest.java b/src/test/java/org/mockito/internal/verification/DefaultRegisteredInvocationsTest.java
index b5738d5..a870245 100644
--- a/src/test/java/org/mockito/internal/verification/DefaultRegisteredInvocationsTest.java
+++ b/src/test/java/org/mockito/internal/verification/DefaultRegisteredInvocationsTest.java
@@ -2,18 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockito.invocation.Invocation;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
public class DefaultRegisteredInvocationsTest extends TestBase {
private DefaultRegisteredInvocations invocations;
diff --git a/src/test/java/org/mockito/internal/verification/DescriptionTest.java b/src/test/java/org/mockito/internal/verification/DescriptionTest.java
index 3c0fa78..abf81cb 100644
--- a/src/test/java/org/mockito/internal/verification/DescriptionTest.java
+++ b/src/test/java/org/mockito/internal/verification/DescriptionTest.java
@@ -4,6 +4,12 @@
*/
package org.mockito.internal.verification;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.verify;
+import static org.mockito.MockitoAnnotations.openMocks;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
@@ -11,23 +17,15 @@
import org.mockito.internal.verification.api.VerificationData;
import org.mockito.verification.VerificationMode;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.verify;
-import static org.mockito.MockitoAnnotations.initMocks;
-
public class DescriptionTest {
- @Mock
- private VerificationMode mockVerificationMode;
+ @Mock private VerificationMode mockVerificationMode;
- @Mock
- private VerificationData mockVerificationData;
+ @Mock private VerificationData mockVerificationData;
@Before
public void setUp() {
- initMocks(this);
+ openMocks(this);
}
/**
@@ -53,4 +51,28 @@
assertEquals(expectedResult, e.getMessage());
}
}
+
+ /**
+ * Test of verify method, of class Description. This test validates that the custom message is prepended to the
+ * error message when verification fails and throws a Throwable which is not a MockitoAssertionError.
+ */
+ @Test
+ public void verification_failure_throwing_AssertionError_should_prepend_expected_message() {
+ String failureMessage = "message should be prepended to the original message";
+ String exceptionMessage = "original error message";
+ String expectedResult = failureMessage + "\n" + exceptionMessage;
+ AssertionError error = new AssertionError(exceptionMessage);
+ doThrow(error).when(mockVerificationMode).verify(mockVerificationData);
+
+ Description instance = new Description(mockVerificationMode, failureMessage);
+
+ try {
+ instance.verify(mockVerificationData);
+ verify(mockVerificationMode).verify(mockVerificationData);
+ fail("Should not have made it this far");
+
+ } catch (MockitoAssertionError e) {
+ assertEquals(expectedResult, e.getMessage());
+ }
+ }
}
diff --git a/src/test/java/org/mockito/internal/verification/DummyVerificationMode.java b/src/test/java/org/mockito/internal/verification/DummyVerificationMode.java
index db86511..92b3b64 100644
--- a/src/test/java/org/mockito/internal/verification/DummyVerificationMode.java
+++ b/src/test/java/org/mockito/internal/verification/DummyVerificationMode.java
@@ -8,8 +8,7 @@
import org.mockito.verification.VerificationMode;
public class DummyVerificationMode implements VerificationMode {
- public void verify(VerificationData data) {
- }
+ public void verify(VerificationData data) {}
public VerificationMode description(String description) {
return new DummyVerificationMode();
diff --git a/src/test/java/org/mockito/internal/verification/NoInteractionsTest.java b/src/test/java/org/mockito/internal/verification/NoInteractionsTest.java
new file mode 100644
index 0000000..7c628cd
--- /dev/null
+++ b/src/test/java/org/mockito/internal/verification/NoInteractionsTest.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification;
+
+import static junit.framework.TestCase.fail;
+import static org.mockito.Mockito.mock;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.internal.stubbing.InvocationContainerImpl;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+public class NoInteractionsTest extends TestBase {
+
+ @Test
+ public void noInteractionsExceptionMessageShouldDescribeMock() {
+ // given
+ NoInteractions n = new NoInteractions();
+ IMethods mock = mock(IMethods.class, "a mock");
+ InvocationMatcher i = new InvocationBuilder().mock(mock).toInvocationMatcher();
+
+ InvocationContainerImpl invocations = new InvocationContainerImpl(new MockSettingsImpl());
+ invocations.setInvocationForPotentialStubbing(i);
+
+ try {
+ // when
+ n.verify(new VerificationDataImpl(invocations, null));
+ // then
+ fail();
+ } catch (NoInteractionsWanted e) {
+ Assertions.assertThat(e.toString()).contains(mock.toString());
+ }
+ }
+}
diff --git a/src/test/java/org/mockito/internal/verification/NoMoreInteractionsTest.java b/src/test/java/org/mockito/internal/verification/NoMoreInteractionsTest.java
index 19455de..e75898f 100644
--- a/src/test/java/org/mockito/internal/verification/NoMoreInteractionsTest.java
+++ b/src/test/java/org/mockito/internal/verification/NoMoreInteractionsTest.java
@@ -4,6 +4,11 @@
*/
package org.mockito.internal.verification;
+import static java.util.Arrays.asList;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.mock;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.exceptions.verification.NoInteractionsWanted;
@@ -17,85 +22,82 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static java.util.Arrays.asList;
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.mock;
-
public class NoMoreInteractionsTest extends TestBase {
InOrderContextImpl context = new InOrderContextImpl();
@Test
public void shouldVerifyInOrder() {
- //given
+ // given
NoMoreInteractions n = new NoMoreInteractions();
Invocation i = new InvocationBuilder().toInvocation();
assertFalse(context.isVerified(i));
try {
- //when
+ // when
n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i), null));
- //then
+ // then
fail();
- } catch(VerificationInOrderFailure e) {}
+ } catch (VerificationInOrderFailure e) {
+ }
}
@Test
public void shouldVerifyInOrderAndPass() {
- //given
+ // given
NoMoreInteractions n = new NoMoreInteractions();
Invocation i = new InvocationBuilder().toInvocation();
context.markVerified(i);
assertTrue(context.isVerified(i));
- //when
+ // when
n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i), null));
- //then no exception is thrown
+ // then no exception is thrown
}
@Test
public void shouldVerifyInOrderMultipleInvoctions() {
- //given
+ // given
NoMoreInteractions n = new NoMoreInteractions();
Invocation i = new InvocationBuilder().seq(1).toInvocation();
Invocation i2 = new InvocationBuilder().seq(2).toInvocation();
- //when
+ // when
context.markVerified(i2);
- //then no exception is thrown
+ // then no exception is thrown
n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i, i2), null));
}
@Test
public void shouldVerifyInOrderMultipleInvoctionsAndThrow() {
- //given
+ // given
NoMoreInteractions n = new NoMoreInteractions();
Invocation i = new InvocationBuilder().seq(1).toInvocation();
Invocation i2 = new InvocationBuilder().seq(2).toInvocation();
try {
- //when
+ // when
n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i, i2), null));
fail();
- } catch (VerificationInOrderFailure e) {}
+ } catch (VerificationInOrderFailure e) {
+ }
}
@Test
public void noMoreInteractionsExceptionMessageShouldDescribeMock() {
- //given
+ // given
NoMoreInteractions n = new NoMoreInteractions();
IMethods mock = mock(IMethods.class, "a mock");
InvocationMatcher i = new InvocationBuilder().mock(mock).toInvocationMatcher();
- InvocationContainerImpl invocations =
- new InvocationContainerImpl( new MockSettingsImpl());
+ InvocationContainerImpl invocations = new InvocationContainerImpl(new MockSettingsImpl());
invocations.setInvocationForPotentialStubbing(i);
try {
- //when
+ // when
n.verify(new VerificationDataImpl(invocations, null));
- //then
+ // then
fail();
} catch (NoInteractionsWanted e) {
Assertions.assertThat(e.toString()).contains(mock.toString());
@@ -104,15 +106,15 @@
@Test
public void noMoreInteractionsInOrderExceptionMessageShouldDescribeMock() {
- //given
+ // given
NoMoreInteractions n = new NoMoreInteractions();
IMethods mock = mock(IMethods.class, "a mock");
Invocation i = new InvocationBuilder().mock(mock).toInvocation();
try {
- //when
+ // when
n.verifyInOrder(new VerificationDataInOrderImpl(context, asList(i), null));
- //then
+ // then
fail();
} catch (VerificationInOrderFailure e) {
Assertions.assertThat(e.toString()).contains(mock.toString());
diff --git a/src/test/java/org/mockito/internal/verification/OnlyTest.java b/src/test/java/org/mockito/internal/verification/OnlyTest.java
index 13df278..c269e3b 100644
--- a/src/test/java/org/mockito/internal/verification/OnlyTest.java
+++ b/src/test/java/org/mockito/internal/verification/OnlyTest.java
@@ -4,18 +4,18 @@
*/
package org.mockito.internal.verification;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoAssertionError;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.internal.invocation.InvocationMatcher;
-import org.mockito.invocation.MatchableInvocation;
-import org.mockito.internal.verification.api.VerificationData;
-import org.mockito.invocation.Invocation;
+import static org.junit.Assert.*;
import java.util.Arrays;
import java.util.List;
-import static org.junit.Assert.*;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoAssertionError;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.internal.verification.api.VerificationData;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.MatchableInvocation;
public class OnlyTest {
@@ -46,30 +46,33 @@
@Test
public void shouldMarkAsVerified() {
- //given
+ // given
Invocation invocation = new InvocationBuilder().toInvocation();
assertFalse(invocation.isVerified());
- //when
+ // when
only.verify(new VerificationDataStub(new InvocationMatcher(invocation), invocation));
- //then
+ // then
assertTrue(invocation.isVerified());
}
@Test
public void shouldNotMarkAsVerifiedWhenAssertionFailed() {
- //given
+ // given
Invocation invocation = new InvocationBuilder().toInvocation();
assertFalse(invocation.isVerified());
- //when
+ // when
try {
- only.verify(new VerificationDataStub(new InvocationBuilder().toInvocationMatcher(), invocation));
+ only.verify(
+ new VerificationDataStub(
+ new InvocationBuilder().toInvocationMatcher(), invocation));
fail();
- } catch (MockitoAssertionError e) {}
+ } catch (MockitoAssertionError e) {
+ }
- //then
+ // then
assertFalse(invocation.isVerified());
}
}
diff --git a/src/test/java/org/mockito/internal/verification/SmartPrinterTest.java b/src/test/java/org/mockito/internal/verification/SmartPrinterTest.java
index 4918991..645cb29 100644
--- a/src/test/java/org/mockito/internal/verification/SmartPrinterTest.java
+++ b/src/test/java/org/mockito/internal/verification/SmartPrinterTest.java
@@ -22,7 +22,10 @@
@Before
public void setup() throws Exception {
- mock.varargs("first very long argument", "second very long argument", "another very long argument");
+ mock.varargs(
+ "first very long argument",
+ "second very long argument",
+ "another very long argument");
multi = new InvocationMatcher(getLastInvocation());
mock.varargs("short arg");
@@ -31,41 +34,49 @@
@Test
public void shouldPrintBothInMultilinesWhenFirstIsMulti() {
- //when
+ // when
SmartPrinter printer = new SmartPrinter(multi, shortie.getInvocation());
- //then
+ // then
assertThat(printer.getWanted()).contains("\n");
- assertThat(printer.getActual()).contains("\n");
+ for (String actual : printer.getActuals()) {
+ assertThat(actual).contains("\n");
+ }
}
@Test
public void shouldPrintBothInMultilinesWhenSecondIsMulti() {
- //when
+ // when
SmartPrinter printer = new SmartPrinter(shortie, multi.getInvocation());
- //then
+ // then
assertThat(printer.getWanted()).contains("\n");
- assertThat(printer.getActual()).contains("\n");
+ for (String actual : printer.getActuals()) {
+ assertThat(actual).contains("\n");
+ }
}
@Test
public void shouldPrintBothInMultilinesWhenBothAreMulti() {
- //when
+ // when
SmartPrinter printer = new SmartPrinter(multi, multi.getInvocation());
- //then
+ // then
assertThat(printer.getWanted()).contains("\n");
- assertThat(printer.getActual()).contains("\n");
+ for (String actual : printer.getActuals()) {
+ assertThat(actual).contains("\n");
+ }
}
@Test
public void shouldPrintBothInSingleLineWhenBothAreShort() {
- //when
+ // when
SmartPrinter printer = new SmartPrinter(shortie, shortie.getInvocation());
- //then
+ // then
assertThat(printer.getWanted()).doesNotContain("\n");
- assertThat(printer.getActual()).doesNotContain("\n");
+ for (String actual : printer.getActuals()) {
+ assertThat(actual).doesNotContain("\n");
+ }
}
}
diff --git a/src/test/java/org/mockito/internal/verification/VerificationDataImplTest.java b/src/test/java/org/mockito/internal/verification/VerificationDataImplTest.java
index 9d4ee1f..2364102 100644
--- a/src/test/java/org/mockito/internal/verification/VerificationDataImplTest.java
+++ b/src/test/java/org/mockito/internal/verification/VerificationDataImplTest.java
@@ -4,22 +4,24 @@
*/
package org.mockito.internal.verification;
+import static org.junit.Assert.fail;
+
import org.junit.Test;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockito.internal.invocation.InvocationMatcher;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-
public class VerificationDataImplTest extends TestBase {
@Test
public void shouldToStringBeNotVerifiable() throws Exception {
- InvocationMatcher toString = new InvocationBuilder().method("toString").toInvocationMatcher();
+ InvocationMatcher toString =
+ new InvocationBuilder().method("toString").toInvocationMatcher();
try {
new VerificationDataImpl(null, toString);
fail();
- } catch (MockitoException e) {}
+ } catch (MockitoException e) {
+ }
}
}
diff --git a/src/test/java/org/mockito/internal/verification/VerificationOverTimeImplTest.java b/src/test/java/org/mockito/internal/verification/VerificationOverTimeImplTest.java
index e846216..4200462 100644
--- a/src/test/java/org/mockito/internal/verification/VerificationOverTimeImplTest.java
+++ b/src/test/java/org/mockito/internal/verification/VerificationOverTimeImplTest.java
@@ -4,31 +4,29 @@
*/
package org.mockito.internal.verification;
+import static org.hamcrest.CoreMatchers.is;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.verify;
+import static org.mockito.MockitoAnnotations.openMocks;
+
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.mockito.Mock;
import org.mockito.exceptions.base.MockitoAssertionError;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
import org.mockito.verification.VerificationMode;
-import static org.hamcrest.CoreMatchers.is;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.verify;
-import static org.mockito.MockitoAnnotations.initMocks;
-
public class VerificationOverTimeImplTest {
- @Mock
- private VerificationMode delegate;
+ @Mock private VerificationMode delegate;
private VerificationOverTimeImpl impl;
- @Rule
- public ExpectedException exception = ExpectedException.none();
+ @Rule public ExpectedException exception = ExpectedException.none();
@Before
public void setUp() {
- initMocks(this);
+ openMocks(this);
impl = new VerificationOverTimeImpl(10, 1000, delegate, true);
}
diff --git a/src/test/java/org/mockito/internal/verification/VerificationWithDescriptionTest.java b/src/test/java/org/mockito/internal/verification/VerificationWithDescriptionTest.java
index 0d206aa..36c7aac 100644
--- a/src/test/java/org/mockito/internal/verification/VerificationWithDescriptionTest.java
+++ b/src/test/java/org/mockito/internal/verification/VerificationWithDescriptionTest.java
@@ -4,27 +4,26 @@
*/
package org.mockito.internal.verification;
+import static org.assertj.core.api.Assertions.fail;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.description;
+import static org.mockito.Mockito.verify;
+
+import java.util.List;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.exceptions.base.MockitoAssertionError;
-import java.util.List;
-
-import static org.junit.Assert.assertTrue;
-import static org.assertj.core.api.Assertions.fail;
-import static org.mockito.Mockito.description;
-import static org.mockito.Mockito.verify;
-
public class VerificationWithDescriptionTest {
- @Mock
- private List<?> mock;
+ @Mock private List<?> mock;
@Before
public void setUp() {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
}
@Test
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 33bfbde..5f55faf 100644
--- a/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java
+++ b/src/test/java/org/mockito/internal/verification/argumentmatching/ArgumentMatchingToolTest.java
@@ -4,19 +4,20 @@
*/
package org.mockito.internal.verification.argumentmatching;
+import static java.util.Collections.singletonList;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.List;
+
import org.junit.Test;
import org.mockito.ArgumentMatcher;
import org.mockito.internal.matchers.ContainsExtraTypeInfo;
import org.mockito.internal.matchers.Equals;
import org.mockitoutil.TestBase;
-import java.util.Arrays;
-import java.util.List;
-
-import static java.util.Collections.singletonList;
-import static org.junit.Assert.assertEquals;
-
-@SuppressWarnings({ "unchecked", "serial" })
+@SuppressWarnings({"unchecked", "serial"})
public class ArgumentMatchingToolTest extends TestBase {
@Test
@@ -25,7 +26,9 @@
List<ArgumentMatcher> matchers = (List) Arrays.asList(new Equals(1));
// when
- Integer[] suspicious = ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(matchers, new Object[] { 10, 20 });
+ Integer[] suspicious =
+ ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(
+ matchers, new Object[] {10, 20});
// then
assertEquals(0, suspicious.length);
@@ -37,7 +40,9 @@
List<ArgumentMatcher> matchers = (List) Arrays.asList(new Equals(10), new Equals(20));
// when
- Integer[] suspicious = ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(matchers, new Object[] { 10, 20 });
+ Integer[] suspicious =
+ ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(
+ matchers, new Object[] {10, 20});
// then
assertEquals(0, suspicious.length);
@@ -51,7 +56,9 @@
// when
List<ArgumentMatcher> matchers = (List) Arrays.asList(new Equals(10), matcherInt20);
- Integer[] suspicious = ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(matchers, new Object[] { 10, longPretendingAnInt });
+ Integer[] suspicious =
+ ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(
+ matchers, new Object[] {10, longPretendingAnInt});
// then
assertEquals(1, suspicious.length);
@@ -61,15 +68,18 @@
@Test
public void shouldNotFindSuspiciousMatchersWhenTypesAreTheSame() {
// given
- Equals matcherWithBadDescription = new Equals(20) {
- public String toString() {
- return "10";
- }
- };
+ Equals matcherWithBadDescription =
+ new Equals(20) {
+ public String toString() {
+ return "10";
+ }
+ };
Integer argument = 10;
// when
- Integer[] suspicious = ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes((List) Arrays.asList(matcherWithBadDescription), new Object[] { argument });
+ Integer[] suspicious =
+ ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(
+ (List) Arrays.asList(matcherWithBadDescription), new Object[] {argument});
// then
assertEquals(0, suspicious.length);
@@ -78,7 +88,9 @@
@Test
public void shouldWorkFineWhenGivenArgIsNull() {
// when
- Integer[] suspicious = ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes((List) Arrays.asList(new Equals(20)), new Object[] { null });
+ Integer[] suspicious =
+ ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(
+ (List) Arrays.asList(new Equals(20)), new Object[] {null});
// then
assertEquals(0, suspicious.length);
@@ -87,8 +99,10 @@
@Test
@SuppressWarnings("rawtypes")
public void shouldUseMatchersSafely() {
- // This matcher is evil cause typeMatches(Object) returns true for every passed type but matches(T)
- // method accepts only Strings. When a Integer is passed (thru the matches(Object) bridge method ) a
+ // This matcher is evil cause typeMatches(Object) returns true for every passed type but
+ // matches(T)
+ // method accepts only Strings. When a Integer is passed (thru the matches(Object) bridge
+ // method ) a
// ClassCastException will be thrown.
class StringMatcher implements ArgumentMatcher<String>, ContainsExtraTypeInfo {
@Override
@@ -97,7 +111,7 @@
}
@Override
- public String toStringWithType() {
+ public String toStringWithType(String className) {
return "";
}
@@ -105,16 +119,22 @@
public boolean typeMatches(Object target) {
return true;
}
+
+ @Override
+ public Object getWanted() {
+ return "";
+ }
}
// given
List<ArgumentMatcher> matchers = (List) singletonList(new StringMatcher());
// when
- Integer[] suspicious = ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(matchers, new Object[] { 10 });
+ Integer[] suspicious =
+ ArgumentMatchingTool.getSuspiciouslyNotMatchingArgsIndexes(
+ matchers, new Object[] {10});
// then
assertEquals(0, suspicious.length);
}
-
}
diff --git a/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java
index c4a54c4..3f47758 100644
--- a/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java
+++ b/src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java
@@ -4,10 +4,15 @@
*/
package org.mockito.internal.verification.checkers;
+import static java.util.Arrays.asList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.internal.verification.checkers.AtLeastXNumberOfInvocationsChecker.checkAtLeastNumberOfInvocations;
+
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
-import org.mockito.exceptions.verification.TooLittleActualInvocations;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
import org.mockito.exceptions.verification.VerificationInOrderFailure;
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockito.internal.invocation.InvocationMatcher;
@@ -15,33 +20,29 @@
import org.mockito.internal.verification.api.InOrderContext;
import org.mockito.invocation.Invocation;
-import static java.util.Arrays.asList;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.internal.verification.checkers.AtLeastXNumberOfInvocationsChecker.checkAtLeastNumberOfInvocations;
+public class AtLeastXNumberOfInvocationsCheckerTest {
-public class AtLeastXNumberOfInvocationsCheckerTest {
-
- @Rule
- public ExpectedException exception = ExpectedException.none();
+ @Rule public ExpectedException exception = ExpectedException.none();
@Test
public void shouldMarkActualInvocationsAsVerifiedInOrder() {
InOrderContext context = new InOrderContextImpl();
- //given
+ // given
Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation();
Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation();
- //when
- checkAtLeastNumberOfInvocations(asList(invocation, invocationTwo), new InvocationMatcher(invocation), 1, context);
+ // when
+ checkAtLeastNumberOfInvocations(
+ asList(invocation, invocationTwo), new InvocationMatcher(invocation), 1, context);
- //then
+ // then
assertThat(invocation.isVerified()).isTrue();
}
@Test
- public void shouldReportTooLittleInvocationsInOrder() {
+ public void shouldReportTooFewInvocationsInOrder() {
InOrderContext context = new InOrderContextImpl();
- //given
+ // given
Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation();
Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation();
@@ -50,37 +51,38 @@
exception.expectMessage("Wanted *at least* 2 times");
exception.expectMessage("But was 1 time");
- //when
- checkAtLeastNumberOfInvocations(asList(invocation, invocationTwo), new InvocationMatcher(invocation), 2, context);
-
-
+ // when
+ checkAtLeastNumberOfInvocations(
+ asList(invocation, invocationTwo), new InvocationMatcher(invocation), 2, context);
}
@Test
public void shouldMarkActualInvocationsAsVerified() {
- //given
+ // given
Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation();
Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation();
- //when
- checkAtLeastNumberOfInvocations(asList(invocation, invocationTwo), new InvocationMatcher(invocation), 1);
+ // when
+ checkAtLeastNumberOfInvocations(
+ asList(invocation, invocationTwo), new InvocationMatcher(invocation), 1);
- //then
+ // then
assertThat(invocation.isVerified()).isTrue();
}
@Test
- public void shouldReportTooLittleInvocations() {
- //given
+ public void shouldReportTooFewInvocations() {
+ // given
Invocation invocation = new InvocationBuilder().simpleMethod().toInvocation();
Invocation invocationTwo = new InvocationBuilder().differentMethod().toInvocation();
- exception.expect(TooLittleActualInvocations.class);
+ exception.expect(TooFewActualInvocations.class);
exception.expectMessage("iMethods.simpleMethod()");
exception.expectMessage("Wanted *at least* 2 times");
exception.expectMessage("But was 1 time");
- //when
- checkAtLeastNumberOfInvocations(asList(invocation, invocationTwo), new InvocationMatcher(invocation), 2);
+ // when
+ checkAtLeastNumberOfInvocations(
+ asList(invocation, invocationTwo), new InvocationMatcher(invocation), 2);
}
}
diff --git a/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java
index 4ce557e..99c6a7a 100644
--- a/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java
+++ b/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java
@@ -2,81 +2,134 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification.checkers;
import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import java.util.ArrayList;
import java.util.List;
+
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
+import org.mockito.ArgumentMatcher;
import org.mockito.Mock;
import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
-import org.mockito.internal.invocation.InvocationBuilder;
-import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockito.internal.invocation.*;
+import org.mockito.internal.invocation.mockref.MockReference;
import org.mockito.invocation.Invocation;
+import org.mockito.invocation.Location;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
public class MissingInvocationCheckerTest extends TestBase {
- private InvocationMatcher wanted;
- private List<Invocation> invocations;
+ private InvocationMatcher wanted;
+ private List<Invocation> invocations;
- @Mock
- private IMethods mock;
+ @Mock private IMethods mock;
- @Rule
- public ExpectedException exception = ExpectedException.none();
+ @Rule public ExpectedException exception = ExpectedException.none();
- @Test
- public void shouldPassBecauseActualInvocationFound() {
- wanted = buildSimpleMethod().toInvocationMatcher();
- invocations = asList(buildSimpleMethod().toInvocation());
+ @Test
+ public void shouldPassBecauseActualInvocationFound() {
+ wanted = buildSimpleMethod().toInvocationMatcher();
+ invocations = asList(buildSimpleMethod().toInvocation());
- MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
- }
+ MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
+ }
- @Test
- public void shouldReportWantedButNotInvoked() {
- wanted = buildSimpleMethod().toInvocationMatcher();
- invocations = asList(buildDifferentMethod().toInvocation());
+ @Test
+ public void shouldReportWantedButNotInvoked() {
+ wanted = buildSimpleMethod().toInvocationMatcher();
+ invocations = asList(buildDifferentMethod().toInvocation());
- exception.expect(WantedButNotInvoked.class);
- exception.expectMessage("Wanted but not invoked:");
- exception.expectMessage("mock.simpleMethod()");
- exception.expectMessage("However, there was exactly 1 interaction with this mock:");
- exception.expectMessage("mock.differentMethod();");
+ exception.expect(WantedButNotInvoked.class);
+ exception.expectMessage("Wanted but not invoked:");
+ exception.expectMessage("mock.simpleMethod()");
+ exception.expectMessage("However, there was exactly 1 interaction with this mock:");
+ exception.expectMessage("mock.differentMethod();");
- MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
- }
+ MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
+ }
- @Test
- public void shouldReportWantedInvocationDiffersFromActual() {
- wanted = buildIntArgMethod().arg(2222).toInvocationMatcher();
- invocations = asList(buildIntArgMethod().arg(1111).toInvocation());
+ @Test
+ public void shouldReportWantedInvocationDiffersFromActual() {
+ wanted = buildIntArgMethod(new InvocationBuilder()).arg(2222).toInvocationMatcher();
+ invocations = asList(buildIntArgMethod(new InvocationBuilder()).arg(1111).toInvocation());
- exception.expect(ArgumentsAreDifferent.class);
+ exception.expect(ArgumentsAreDifferent.class);
- exception.expectMessage("Argument(s) are different! Wanted:");
- exception.expectMessage("mock.intArgumentMethod(2222);");
- exception.expectMessage("Actual invocation has different arguments:");
- exception.expectMessage("mock.intArgumentMethod(1111);");
+ exception.expectMessage("Argument(s) are different! Wanted:");
+ exception.expectMessage("mock.intArgumentMethod(2222);");
+ exception.expectMessage("Actual invocations have different arguments:");
+ exception.expectMessage("mock.intArgumentMethod(1111);");
- MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
- }
+ MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
+ }
- private InvocationBuilder buildIntArgMethod() {
- return new InvocationBuilder().mock(mock).method("intArgumentMethod").argTypes(int.class);
- }
+ @Test
+ public void shouldReportUsingInvocationDescription() {
+ wanted = buildIntArgMethod(new CustomInvocationBuilder()).arg(2222).toInvocationMatcher();
+ invocations =
+ singletonList(
+ buildIntArgMethod(new CustomInvocationBuilder()).arg(1111).toInvocation());
- private InvocationBuilder buildSimpleMethod() {
- return new InvocationBuilder().mock(mock).simpleMethod();
- }
+ exception.expect(ArgumentsAreDifferent.class);
- private InvocationBuilder buildDifferentMethod() {
- return new InvocationBuilder().mock(mock).differentMethod();
- }
+ exception.expectMessage("Argument(s) are different! Wanted:");
+ exception.expectMessage("mock.intArgumentMethod(MyCoolPrint(2222));");
+ exception.expectMessage("Actual invocations have different arguments:");
+ exception.expectMessage("mock.intArgumentMethod(MyCoolPrint(1111));");
+
+ MissingInvocationChecker.checkMissingInvocation(invocations, wanted);
+ }
+
+ private InvocationBuilder buildIntArgMethod(InvocationBuilder invocationBuilder) {
+ return invocationBuilder.mock(mock).method("intArgumentMethod").argTypes(int.class);
+ }
+
+ private InvocationBuilder buildSimpleMethod() {
+ return new InvocationBuilder().mock(mock).simpleMethod();
+ }
+
+ private InvocationBuilder buildDifferentMethod() {
+ return new InvocationBuilder().mock(mock).differentMethod();
+ }
+
+ static class CustomInvocationBuilder extends InvocationBuilder {
+ @Override
+ protected Invocation createInvocation(
+ MockReference<Object> mockRef,
+ MockitoMethod mockitoMethod,
+ final Object[] arguments,
+ RealMethod realMethod,
+ Location location,
+ int sequenceNumber) {
+ return new InterceptedInvocation(
+ mockRef, mockitoMethod, arguments, realMethod, location, sequenceNumber) {
+ @Override
+ public List<ArgumentMatcher> getArgumentsAsMatchers() {
+ List<ArgumentMatcher> matchers = new ArrayList<ArgumentMatcher>();
+ for (final Object argument : getRawArguments()) {
+ matchers.add(
+ new ArgumentMatcher() {
+ @Override
+ public boolean matches(Object a) {
+ return a == argument;
+ }
+
+ @Override
+ public String toString() {
+ return "MyCoolPrint(" + argument + ")";
+ }
+ });
+ }
+ return matchers;
+ }
+ };
+ }
+ }
}
diff --git a/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationInOrderCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationInOrderCheckerTest.java
index 7f37b12..7ce7907 100644
--- a/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationInOrderCheckerTest.java
+++ b/src/test/java/org/mockito/internal/verification/checkers/MissingInvocationInOrderCheckerTest.java
@@ -2,9 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification.checkers;
+import static java.util.Arrays.asList;
+
+import static org.mockito.internal.verification.checkers.MissingInvocationChecker.checkMissingInvocation;
+
+import java.util.List;
+
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
@@ -12,7 +17,7 @@
import org.mockito.Mock;
import org.mockito.exceptions.verification.VerificationInOrderFailure;
import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockito.internal.invocation.InvocationMatcher;
import org.mockito.internal.verification.InOrderContextImpl;
@@ -22,35 +27,26 @@
import org.mockito.junit.MockitoRule;
import org.mockitousage.IMethods;
-import java.util.List;
+public class MissingInvocationInOrderCheckerTest {
-import static java.util.Arrays.asList;
-import static org.mockito.internal.verification.checkers.MissingInvocationChecker.checkMissingInvocation;
+ private InvocationMatcher wanted;
+ private List<Invocation> invocations;
-public class MissingInvocationInOrderCheckerTest {
+ @Mock private IMethods mock;
- private InvocationMatcher wanted;
- private List<Invocation> invocations;
+ @Rule public ExpectedException exception = ExpectedException.none();
- @Mock
- private IMethods mock;
-
- @Rule
- public ExpectedException exception = ExpectedException.none();
-
- @Rule
- public MockitoRule mockitoRule = MockitoJUnit.rule();
+ @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
private InOrderContext context = new InOrderContextImpl();
@Before
- public void setup() {
- }
+ public void setup() {}
@Test
public void shouldPassWhenMatchingInteractionFound() throws Exception {
- invocations = asList(buildSimpleMethod().toInvocation());
+ invocations = asList(buildSimpleMethod().toInvocation());
wanted = buildSimpleMethod().toInvocationMatcher();
checkMissingInvocation(invocations, wanted, context);
@@ -58,64 +54,61 @@
@Test
public void shouldReportWantedButNotInvoked() throws Exception {
- invocations = asList(buildDifferentMethod().toInvocation());
+ invocations = asList(buildDifferentMethod().toInvocation());
wanted = buildSimpleMethod().toInvocationMatcher();
exception.expect(WantedButNotInvoked.class);
- exception.expectMessage("Wanted but not invoked:");
- exception.expectMessage("mock.simpleMethod()");
+ exception.expectMessage("Wanted but not invoked:");
+ exception.expectMessage("mock.simpleMethod()");
checkMissingInvocation(invocations, wanted, context);
}
@Test
public void shouldReportArgumentsAreDifferent() throws Exception {
- invocations = asList(buildIntArgMethod().arg(1111).toInvocation());
+ invocations = asList(buildIntArgMethod().arg(1111).toInvocation());
wanted = buildIntArgMethod().arg(2222).toInvocationMatcher();
exception.expect(ArgumentsAreDifferent.class);
- exception.expectMessage("Argument(s) are different! Wanted:");
- exception.expectMessage("mock.intArgumentMethod(2222);");
- exception.expectMessage("Actual invocation has different arguments:");
- exception.expectMessage("mock.intArgumentMethod(1111);");
+ exception.expectMessage("Argument(s) are different! Wanted:");
+ exception.expectMessage("mock.intArgumentMethod(2222);");
+ exception.expectMessage("Actual invocations have different arguments:");
+ exception.expectMessage("mock.intArgumentMethod(1111);");
- checkMissingInvocation(invocations, wanted, context);
-
- }
+ checkMissingInvocation(invocations, wanted, context);
+ }
@Test
public void shouldReportWantedDiffersFromActual() throws Exception {
- Invocation invocation1 = buildIntArgMethod().arg(1111).toInvocation();
- Invocation invocation2 = buildIntArgMethod().arg(2222).toInvocation();
+ Invocation invocation1 = buildIntArgMethod().arg(1111).toInvocation();
+ Invocation invocation2 = buildIntArgMethod().arg(2222).toInvocation();
- context.markVerified(invocation2);
- invocations = asList(invocation1,invocation2);
+ context.markVerified(invocation2);
+ invocations = asList(invocation1, invocation2);
wanted = buildIntArgMethod().arg(2222).toInvocationMatcher();
exception.expect(VerificationInOrderFailure.class);
- exception.expectMessage("Verification in order failure");
- exception.expectMessage("Wanted but not invoked:");
- exception.expectMessage("mock.intArgumentMethod(2222);");
- exception.expectMessage("Wanted anywhere AFTER following interaction:");
- exception.expectMessage("mock.intArgumentMethod(2222);");
+ exception.expectMessage("Verification in order failure");
+ exception.expectMessage("Wanted but not invoked:");
+ exception.expectMessage("mock.intArgumentMethod(2222);");
+ exception.expectMessage("Wanted anywhere AFTER following interaction:");
+ exception.expectMessage("mock.intArgumentMethod(2222);");
checkMissingInvocation(invocations, wanted, context);
}
private InvocationBuilder buildIntArgMethod() {
- return new InvocationBuilder().mock(mock).method("intArgumentMethod").argTypes(int.class);
- }
+ return new InvocationBuilder().mock(mock).method("intArgumentMethod").argTypes(int.class);
+ }
- private InvocationBuilder buildSimpleMethod() {
- return new InvocationBuilder().mock(mock).simpleMethod();
- }
+ private InvocationBuilder buildSimpleMethod() {
+ return new InvocationBuilder().mock(mock).simpleMethod();
+ }
- private InvocationBuilder buildDifferentMethod() {
- return new InvocationBuilder().mock(mock).differentMethod();
- }
-
-
+ private InvocationBuilder buildDifferentMethod() {
+ return new InvocationBuilder().mock(mock).differentMethod();
+ }
}
diff --git a/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java
index 61b2f2e..d1878fc 100644
--- a/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java
+++ b/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java
@@ -2,10 +2,16 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification.checkers;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Collections;
import java.util.List;
+
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.hamcrest.TypeSafeMatcher;
@@ -16,7 +22,7 @@
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.exceptions.verification.NeverWantedButInvoked;
-import org.mockito.exceptions.verification.TooLittleActualInvocations;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
import org.mockito.exceptions.verification.TooManyActualInvocations;
import org.mockito.internal.invocation.InvocationBuilder;
import org.mockito.internal.invocation.InvocationMatcher;
@@ -24,10 +30,6 @@
import org.mockito.junit.MockitoJUnitRunner;
import org.mockitousage.IMethods;
-import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
-import static org.assertj.core.api.Assertions.assertThat;
-
@RunWith(MockitoJUnitRunner.class)
public class NumberOfInvocationsCheckerTest {
@@ -35,21 +37,19 @@
private List<Invocation> invocations;
- @Mock
- private IMethods mock;
+ @Mock private IMethods mock;
- @Rule
- public ExpectedException exception = ExpectedException.none();
+ @Rule public ExpectedException exception = ExpectedException.none();
- @Rule
- public TestName testName = new TestName();
+ @Rule public TestName testName = new TestName();
@Test
- public void shouldReportTooLittleActual() throws Exception {
+ public void shouldReportTooFewActual() throws Exception {
wanted = buildSimpleMethod().toInvocationMatcher();
- invocations = asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
+ invocations =
+ asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
- exception.expect(TooLittleActualInvocations.class);
+ exception.expect(TooFewActualInvocations.class);
exception.expectMessage("mock.simpleMethod()");
exception.expectMessage("Wanted 100 times");
exception.expectMessage("But was 2 times");
@@ -60,9 +60,10 @@
@Test
public void shouldReportAllInvocationsStackTrace() throws Exception {
wanted = buildSimpleMethod().toInvocationMatcher();
- invocations = asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
+ invocations =
+ asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
- exception.expect(TooLittleActualInvocations.class);
+ exception.expect(TooFewActualInvocations.class);
exception.expectMessage("mock.simpleMethod()");
exception.expectMessage("Wanted 100 times");
exception.expectMessage("But was 2 times");
@@ -76,7 +77,7 @@
invocations = emptyList();
wanted = buildSimpleMethod().toInvocationMatcher();
- exception.expect(TooLittleActualInvocations.class);
+ exception.expect(TooFewActualInvocations.class);
exception.expectMessage("mock.simpleMethod()");
exception.expectMessage("Wanted 100 times");
exception.expectMessage("But was 0 times");
@@ -116,35 +117,60 @@
}
@Test
- public void shouldReportNeverWantedButInvoked() throws Exception {
- Invocation first = buildSimpleMethod().toInvocation();
+ public void shouldReportNeverWantedButInvokedWithArgs() throws Exception {
+ Invocation invocation = buildSimpleMethodWithArgs("arg1").toInvocation();
- invocations = asList(first);
- wanted = buildSimpleMethod().toInvocationMatcher();
+ invocations = Collections.singletonList(invocation);
+ wanted = buildSimpleMethodWithArgs("arg1").toInvocationMatcher();
exception.expect(NeverWantedButInvoked.class);
exception.expectMessage("Never wanted here");
exception.expectMessage("But invoked here");
- exception.expectMessage("" + first.getLocation());
+ exception.expectMessage("" + invocation.getLocation() + " with arguments: [arg1]");
NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 0);
}
- @Test
- public void shouldMarkInvocationsAsVerified() throws Exception {
- Invocation invocation = buildSimpleMethod().toInvocation();
- assertThat(invocation.isVerified()).isFalse();
+ @Test
+ public void shouldReportNeverWantedButInvokedWithArgs_multipleInvocations() throws Exception {
+ Invocation first = buildSimpleMethodWithArgs("arg1").toInvocation();
+ Invocation second = buildSimpleMethodWithArgs("arg1").toInvocation();
- invocations = asList(invocation);
- wanted = buildSimpleMethod().toInvocationMatcher();
- NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 1);
- assertThat(invocation.isVerified()).isTrue();
- }
+ invocations = asList(first, second);
+ wanted = buildSimpleMethodWithArgs("arg1").toInvocationMatcher();
+
+ exception.expect(NeverWantedButInvoked.class);
+ exception.expectMessage("Never wanted here");
+ exception.expectMessage("But invoked here");
+ exception.expectMessage("" + first.getLocation() + " with arguments: [arg1]");
+ exception.expectMessage("" + second.getLocation() + " with arguments: [arg1]");
+
+ NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 0);
+ }
+
+ @Test
+ public void shouldMarkInvocationsAsVerified() throws Exception {
+ Invocation invocation = buildSimpleMethod().toInvocation();
+ assertThat(invocation.isVerified()).isFalse();
+
+ invocations = asList(invocation);
+ wanted = buildSimpleMethod().toInvocationMatcher();
+ NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 1);
+ assertThat(invocation.isVerified()).isTrue();
+ }
private InvocationBuilder buildSimpleMethod() {
return new InvocationBuilder().mock(mock).simpleMethod();
}
+ private InvocationBuilder buildSimpleMethodWithArgs(String arg) {
+ return new InvocationBuilder().mock(mock).simpleMethod().args(arg);
+ }
+
+ private InvocationBuilder buildDifferentMethodWithArgs(String arg) {
+ return new InvocationBuilder().mock(mock).differentMethod().args(arg);
+ }
+
private static BaseMatcher<String> containsTimes(String value, int amount) {
return new StringContainsNumberMatcher(value, amount);
}
@@ -176,6 +202,5 @@
public void describeTo(Description description) {
description.appendText("containing '" + expected + "' exactly " + amount + " times");
}
-
}
}
diff --git a/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java b/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java
index bc031ac..aae3b81 100644
--- a/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java
+++ b/src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java
@@ -2,9 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockito.internal.verification.checkers;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+
import java.util.List;
import org.hamcrest.BaseMatcher;
@@ -22,11 +27,6 @@
import org.mockito.invocation.Invocation;
import org.mockitousage.IMethods;
-import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-
public class NumberOfInvocationsInOrderCheckerTest {
private InvocationMatcher wanted;
@@ -35,14 +35,12 @@
private IMethods mock;
- @Rule
- public ExpectedException exception = ExpectedException.none();
+ @Rule public ExpectedException exception = ExpectedException.none();
@Before
public void setup() {
context = new InOrderContextImpl();
mock = mock(IMethods.class, "mock");
-
}
@Test
@@ -61,7 +59,7 @@
}
@Test
- public void shouldReportTooLittleInvocations() throws Exception {
+ public void shouldReportTooFewInvocations() throws Exception {
Invocation first = buildSimpleMethod().toInvocation();
Invocation second = buildSimpleMethod().toInvocation();
@@ -89,9 +87,10 @@
}
@Test
- public void shouldReportTooLittleActual() throws Exception {
+ public void shouldReportTooFewActual() throws Exception {
wanted = buildSimpleMethod().toInvocationMatcher();
- invocations = asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
+ invocations =
+ asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
exception.expect(VerificationInOrderFailure.class);
exception.expectMessage("mock.simpleMethod()");
@@ -104,7 +103,8 @@
@Test
public void shouldReportWithAllInvocationsStackTrace() throws Exception {
wanted = buildSimpleMethod().toInvocationMatcher();
- invocations = asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
+ invocations =
+ asList(buildSimpleMethod().toInvocation(), buildSimpleMethod().toInvocation());
exception.expect(VerificationInOrderFailure.class);
exception.expectMessage("mock.simpleMethod()");
@@ -113,7 +113,6 @@
exception.expectMessage(containsTimes("-> at", 3));
NumberOfInvocationsChecker.checkNumberOfInvocations(invocations, wanted, 100, context);
-
}
@Test
@@ -218,7 +217,6 @@
public void describeTo(Description description) {
description.appendText("containing '" + expected + "' exactly " + amount + " times");
}
-
}
private InvocationBuilder buildSimpleMethod() {
diff --git a/src/test/java/org/mockito/junit/TestableJUnitRunner.java b/src/test/java/org/mockito/junit/TestableJUnitRunner.java
index 149e2bf..a8b04f0 100644
--- a/src/test/java/org/mockito/junit/TestableJUnitRunner.java
+++ b/src/test/java/org/mockito/junit/TestableJUnitRunner.java
@@ -4,6 +4,8 @@
*/
package org.mockito.junit;
+import java.lang.reflect.InvocationTargetException;
+
import org.junit.runners.model.InitializationError;
import org.mockito.internal.junit.MismatchReportingTestListener;
import org.mockito.internal.junit.MockitoTestListener;
@@ -12,22 +14,29 @@
import org.mockito.internal.util.SimpleMockitoLogger;
import org.mockito.internal.util.Supplier;
-import java.lang.reflect.InvocationTargetException;
-
public class TestableJUnitRunner extends MockitoJUnitRunner {
- private final static ThreadLocal<SimpleMockitoLogger> LOGGER = new ThreadLocal<SimpleMockitoLogger>() {
- protected SimpleMockitoLogger initialValue() {
- return new SimpleMockitoLogger();
- }
- };
+ private static final ThreadLocal<SimpleMockitoLogger> LOGGER =
+ new ThreadLocal<SimpleMockitoLogger>() {
+ protected SimpleMockitoLogger initialValue() {
+ return new SimpleMockitoLogger();
+ }
+ };
- public TestableJUnitRunner(Class<?> klass) throws InvocationTargetException, InitializationError {
- super(new StrictRunner(new RunnerFactory().create(klass, new Supplier<MockitoTestListener>() {
- public MockitoTestListener get() {
- return new MismatchReportingTestListener(LOGGER.get());
- }
- }), klass));
+ public TestableJUnitRunner(Class<?> klass)
+ throws InvocationTargetException, InitializationError {
+ super(
+ new StrictRunner(
+ new RunnerFactory()
+ .create(
+ klass,
+ new Supplier<MockitoTestListener>() {
+ public MockitoTestListener get() {
+ return new MismatchReportingTestListener(
+ LOGGER.get());
+ }
+ }),
+ klass));
}
public static SimpleMockitoLogger refreshedLogger() {
diff --git a/src/test/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunnerTest.java b/src/test/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunnerTest.java
index e72fa09..a9b487c 100644
--- a/src/test/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunnerTest.java
+++ b/src/test/java/org/mockito/runners/ConsoleSpammingMockitoJUnitRunnerTest.java
@@ -4,6 +4,8 @@
*/
package org.mockito.runners;
+import static org.junit.Assert.assertEquals;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.Description;
@@ -15,8 +17,6 @@
import org.mockito.internal.util.ConsoleMockitoLogger;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-
public class ConsoleSpammingMockitoJUnitRunnerTest extends TestBase {
private ConsoleSpammingMockitoJUnitRunner runner;
@@ -31,22 +31,25 @@
notifier = new RunNotifier();
}
- //TODO add sensible tests
+ // TODO add sensible tests
@Test
public void shouldDelegateToGetDescription() throws Exception {
- //given
+ // given
final Description expectedDescription = Description.createSuiteDescription(this.getClass());
- runner = new ConsoleSpammingMockitoJUnitRunner(loggerStub, new InternalRunnerStub() {
- public Description getDescription() {
- return expectedDescription;
- }
- });
+ runner =
+ new ConsoleSpammingMockitoJUnitRunner(
+ loggerStub,
+ new InternalRunnerStub() {
+ public Description getDescription() {
+ return expectedDescription;
+ }
+ });
- //when
+ // when
Description description = runner.getDescription();
- //then
+ // then
assertEquals(expectedDescription, description);
}
@@ -70,11 +73,8 @@
return null;
}
- public void run(RunNotifier notifier) {
- }
+ public void run(RunNotifier notifier) {}
- public void filter(Filter filter) throws NoTestsRemainException {
- }
-
+ public void filter(Filter filter) throws NoTestsRemainException {}
}
}
diff --git a/src/test/java/org/mockito/verification/NegativeDurationTest.java b/src/test/java/org/mockito/verification/NegativeDurationTest.java
index ddfe31a..7953008 100644
--- a/src/test/java/org/mockito/verification/NegativeDurationTest.java
+++ b/src/test/java/org/mockito/verification/NegativeDurationTest.java
@@ -11,8 +11,7 @@
import org.mockito.exceptions.misusing.FriendlyReminderException;
public class NegativeDurationTest {
- @Rule
- public ExpectedException expectedException = ExpectedException.none();
+ @Rule public ExpectedException expectedException = ExpectedException.none();
@Test
public void should_throw_exception_when_duration_is_negative_for_timeout_method() {
diff --git a/src/test/java/org/mockito/verification/TimeoutTest.java b/src/test/java/org/mockito/verification/TimeoutTest.java
index 241b39b..b4c1ada 100644
--- a/src/test/java/org/mockito/verification/TimeoutTest.java
+++ b/src/test/java/org/mockito/verification/TimeoutTest.java
@@ -4,6 +4,9 @@
*/
package org.mockito.verification;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockito.InOrder;
import org.mockito.Mock;
@@ -12,17 +15,11 @@
import org.mockito.internal.verification.VerificationDataImpl;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
public class TimeoutTest extends TestBase {
- @Mock
- VerificationMode mode;
- @Mock
- VerificationDataImpl data;
- @Mock
- Timer timer;
+ @Mock VerificationMode mode;
+ @Mock VerificationDataImpl data;
+ @Mock Timer timer;
private final MockitoAssertionError error = new MockitoAssertionError("");
@@ -45,15 +42,13 @@
Timeout t = new Timeout(1, mode, timer);
when(timer.isCounting()).thenReturn(true, true, true, false);
- doThrow(error).
- doThrow(error).
- doThrow(error).
- when(mode).verify(data);
+ doThrow(error).doThrow(error).doThrow(error).when(mode).verify(data);
try {
t.verify(data);
fail();
- } catch (MockitoAssertionError e) {}
+ } catch (MockitoAssertionError e) {
+ }
verify(timer, times(4)).isCounting();
}
@@ -63,10 +58,7 @@
Timeout t = new Timeout(1, mode, timer);
when(timer.isCounting()).thenReturn(true, true, true, false);
- doThrow(error).
- doThrow(error).
- doNothing().
- when(mode).verify(data);
+ doThrow(error).doThrow(error).doNothing().when(mode).verify(data);
t.verify(data);
verify(timer, times(3)).isCounting();
@@ -82,9 +74,9 @@
try {
t.verify(data);
fail();
- } catch (MockitoAssertionError e) {}
+ } catch (MockitoAssertionError e) {
+ }
verify(mode, times(5)).verify(data);
}
-
}
diff --git a/src/test/java/org/mockitointegration/NoByteCodeDependenciesTest.java b/src/test/java/org/mockitointegration/NoByteCodeDependenciesTest.java
new file mode 100644
index 0000000..2363fe6
--- /dev/null
+++ b/src/test/java/org/mockitointegration/NoByteCodeDependenciesTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2019 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitointegration;
+
+import static org.mockitoutil.ClassLoaders.coverageTool;
+
+import java.util.Set;
+
+import org.hamcrest.Matcher;
+import org.junit.*;
+import org.mockito.Mockito;
+import org.mockitoutil.ClassLoaders;
+
+public class NoByteCodeDependenciesTest {
+
+ private ClassLoader contextClassLoader;
+
+ @Test
+ public void pure_mockito_should_not_depend_bytecode_libraries() throws Exception {
+
+ ClassLoader classLoader_without_bytecode_libraries =
+ ClassLoaders.excludingClassLoader()
+ .withCodeSourceUrlOf(Mockito.class, Matcher.class)
+ .withCodeSourceUrlOf(coverageTool())
+ .without("net.bytebuddy", "org.objenesis")
+ .build();
+
+ Set<String> pureMockitoAPIClasses =
+ ClassLoaders.in(classLoader_without_bytecode_libraries)
+ .omit("bytebuddy", "runners", "junit", "JUnit", "opentest4j")
+ .listOwnedClasses();
+ pureMockitoAPIClasses.remove(
+ "org.mockito.internal.creation.instance.DefaultInstantiatorProvider");
+ pureMockitoAPIClasses.remove(
+ "org.mockito.internal.creation.instance.ObjenesisInstantiator");
+
+ // Remove classes that trigger plugin-loading, since bytebuddy plugins are the default.
+ pureMockitoAPIClasses.remove("org.mockito.internal.debugging.LocationImpl");
+ pureMockitoAPIClasses.remove("org.mockito.internal.exceptions.stacktrace.StackTraceFilter");
+ pureMockitoAPIClasses.remove("org.mockito.internal.util.MockUtil");
+
+ // Remove instrumentation-based member accessor which is optional.
+ pureMockitoAPIClasses.remove(
+ "org.mockito.internal.util.reflection.InstrumentationMemberAccessor");
+
+ for (String pureMockitoAPIClass : pureMockitoAPIClasses) {
+ checkDependency(classLoader_without_bytecode_libraries, pureMockitoAPIClass);
+ }
+ }
+
+ private void checkDependency(ClassLoader classLoader, String pureMockitoAPIClass)
+ throws ClassNotFoundException {
+ try {
+ Class.forName(pureMockitoAPIClass, true, classLoader);
+ } catch (Throwable e) {
+ e.printStackTrace();
+ throw new AssertionError(
+ String.format(
+ "'%s' has some dependency to Byte Buddy or Objenesis",
+ pureMockitoAPIClass));
+ }
+ }
+}
diff --git a/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java b/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java
index 90569a8..7b156f0 100644
--- a/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java
+++ b/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java
@@ -4,6 +4,10 @@
*/
package org.mockitointegration;
+import static org.mockitoutil.ClassLoaders.coverageTool;
+
+import java.util.Set;
+
import net.bytebuddy.ByteBuddy;
import net.bytebuddy.agent.ByteBuddyAgent;
import org.hamcrest.Matcher;
@@ -14,45 +18,51 @@
import org.mockitoutil.ClassLoaders;
import org.objenesis.Objenesis;
-import java.util.Set;
-
-import static org.mockitoutil.ClassLoaders.coverageTool;
-
public class NoJUnitDependenciesTest {
@Test
public void pure_mockito_should_not_depend_JUnit___ByteBuddy() throws Exception {
- Assume.assumeTrue("ByteBuddyMockMaker".equals(Plugins.getMockMaker().getClass().getSimpleName()));
+ Assume.assumeTrue(
+ "ByteBuddyMockMaker".equals(Plugins.getMockMaker().getClass().getSimpleName()));
- ClassLoader classLoader_without_JUnit = ClassLoaders.excludingClassLoader()
- .withCodeSourceUrlOf(
- Mockito.class,
- Matcher.class,
- ByteBuddy.class,
- ByteBuddyAgent.class,
- Objenesis.class
- )
- .withCodeSourceUrlOf(coverageTool())
- .without("junit", "org.junit")
- .build();
+ ClassLoader classLoader_without_JUnit =
+ ClassLoaders.excludingClassLoader()
+ .withCodeSourceUrlOf(
+ Mockito.class,
+ Matcher.class,
+ ByteBuddy.class,
+ ByteBuddyAgent.class,
+ Objenesis.class)
+ .withCodeSourceUrlOf(coverageTool())
+ .without("junit", "org.junit", "org.opentest4j")
+ .build();
- Set<String> pureMockitoAPIClasses = ClassLoaders.in(classLoader_without_JUnit).omit("runners", "junit", "JUnit").listOwnedClasses();
+ Set<String> pureMockitoAPIClasses =
+ ClassLoaders.in(classLoader_without_JUnit)
+ .omit("runners", "junit", "JUnit", "opentest4j")
+ .listOwnedClasses();
- // The later class is required to be initialized before any inline mock maker classes can be loaded.
- checkDependency(classLoader_without_JUnit, "org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker");
- pureMockitoAPIClasses.remove("org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker");
+ // The later class is required to be initialized before any inline mock maker classes can be
+ // loaded.
+ checkDependency(
+ classLoader_without_JUnit,
+ "org.mockito.internal.creation.bytebuddy.InlineDelegateByteBuddyMockMaker");
+ pureMockitoAPIClasses.remove(
+ "org.mockito.internal.creation.bytebuddy.InlineDelegateByteBuddyMockMaker");
for (String pureMockitoAPIClass : pureMockitoAPIClasses) {
checkDependency(classLoader_without_JUnit, pureMockitoAPIClass);
}
}
- private void checkDependency(ClassLoader classLoader_without_JUnit, String pureMockitoAPIClass) throws ClassNotFoundException {
+ private void checkDependency(ClassLoader classLoader_without_JUnit, String pureMockitoAPIClass)
+ throws ClassNotFoundException {
try {
Class.forName(pureMockitoAPIClass, true, classLoader_without_JUnit);
} catch (Throwable e) {
e.printStackTrace();
- throw new AssertionError(String.format("'%s' has some dependency to JUnit", pureMockitoAPIClass));
+ throw new AssertionError(
+ String.format("'%s' has some dependency to JUnit", pureMockitoAPIClass));
}
}
}
diff --git a/src/test/java/org/mockitousage/CompilationWarningsTest.java b/src/test/java/org/mockitousage/CompilationWarningsTest.java
index 408d5f6..faf019f 100644
--- a/src/test/java/org/mockitousage/CompilationWarningsTest.java
+++ b/src/test/java/org/mockitousage/CompilationWarningsTest.java
@@ -4,101 +4,187 @@
*/
package org.mockitousage;
+import static org.mockito.BDDMockito.*;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
-import static org.mockito.BDDMockito.*;
-
-
public class CompilationWarningsTest {
@Before
- public void pay_attention_to_compilation_warnings_and_JDK_version() {
- }
+ public void pay_attention_to_compilation_warnings_and_JDK_version() {}
@Test
public void no_warnings_for_most_common_api() throws Exception {
doReturn(null).when(mock(IMethods.class)).objectReturningMethodNoArgs();
doReturn("a", 12).when(mock(IMethods.class)).objectReturningMethodNoArgs();
doReturn(1000).when(mock(IMethods.class)).objectReturningMethodNoArgs();
- doThrow(new NullPointerException()).when(mock(IMethods.class)).objectReturningMethodNoArgs();
- doThrow(new NullPointerException(), new IllegalArgumentException()).when(mock(IMethods.class)).objectReturningMethodNoArgs();
- doThrow(NullPointerException.class).when(mock(IMethods.class)).objectReturningMethodNoArgs();
+ doThrow(new NullPointerException())
+ .when(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ doThrow(new NullPointerException(), new IllegalArgumentException())
+ .when(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ doThrow(NullPointerException.class)
+ .when(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
doAnswer(ignore()).doReturn(null).when(mock(IMethods.class)).objectReturningMethodNoArgs();
- doAnswer(ignore()).doReturn("a", 12).when(mock(IMethods.class)).objectReturningMethodNoArgs();
+ doAnswer(ignore())
+ .doReturn("a", 12)
+ .when(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
doAnswer(ignore()).doReturn(1000).when(mock(IMethods.class)).objectReturningMethodNoArgs();
- doAnswer(ignore()).doThrow(new NullPointerException()).when(mock(IMethods.class)).objectReturningMethodNoArgs();
- doAnswer(ignore()).doThrow(new NullPointerException(), new IllegalArgumentException()).when(mock(IMethods.class)).objectReturningMethodNoArgs();
- doAnswer(ignore()).doThrow(NullPointerException.class).when(mock(IMethods.class)).objectReturningMethodNoArgs();
+ doAnswer(ignore())
+ .doThrow(new NullPointerException())
+ .when(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ doAnswer(ignore())
+ .doThrow(new NullPointerException(), new IllegalArgumentException())
+ .when(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ doAnswer(ignore())
+ .doThrow(NullPointerException.class)
+ .when(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
when(mock(IMethods.class).objectReturningMethodNoArgs()).thenReturn(null);
when(mock(IMethods.class).objectReturningMethodNoArgs()).thenReturn("a", 12L);
when(mock(IMethods.class).objectReturningMethodNoArgs()).thenReturn(1000);
- when(mock(IMethods.class).objectReturningMethodNoArgs()).thenThrow(new NullPointerException());
- when(mock(IMethods.class).objectReturningMethodNoArgs()).thenThrow(new NullPointerException(), new IllegalArgumentException());
- when(mock(IMethods.class).objectReturningMethodNoArgs()).thenThrow(NullPointerException.class);
+ when(mock(IMethods.class).objectReturningMethodNoArgs())
+ .thenThrow(new NullPointerException());
+ when(mock(IMethods.class).objectReturningMethodNoArgs())
+ .thenThrow(new NullPointerException(), new IllegalArgumentException());
+ when(mock(IMethods.class).objectReturningMethodNoArgs())
+ .thenThrow(NullPointerException.class);
when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenReturn(null);
- when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenReturn("a", 12L);
+ when(mock(IMethods.class).objectReturningMethodNoArgs())
+ .then(ignore())
+ .thenReturn("a", 12L);
when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenReturn(1000);
- when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenThrow(new NullPointerException());
- when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenThrow(new NullPointerException(), new IllegalArgumentException());
- when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenThrow(NullPointerException.class);
+ when(mock(IMethods.class).objectReturningMethodNoArgs())
+ .then(ignore())
+ .thenThrow(new NullPointerException());
+ when(mock(IMethods.class).objectReturningMethodNoArgs())
+ .then(ignore())
+ .thenThrow(new NullPointerException(), new IllegalArgumentException());
+ when(mock(IMethods.class).objectReturningMethodNoArgs())
+ .then(ignore())
+ .thenThrow(NullPointerException.class);
willReturn(null).given(mock(IMethods.class)).objectReturningMethodNoArgs();
willReturn("a", 12).given(mock(IMethods.class)).objectReturningMethodNoArgs();
willReturn(1000).given(mock(IMethods.class)).objectReturningMethodNoArgs();
- willThrow(new NullPointerException()).given(mock(IMethods.class)).objectReturningMethodNoArgs();
- willThrow(new NullPointerException(), new IllegalArgumentException()).given(mock(IMethods.class)).objectReturningMethodNoArgs();
- willThrow(NullPointerException.class).given(mock(IMethods.class)).objectReturningMethodNoArgs();
+ willThrow(new NullPointerException())
+ .given(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ willThrow(new NullPointerException(), new IllegalArgumentException())
+ .given(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ willThrow(NullPointerException.class)
+ .given(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
- willAnswer(ignore()).willReturn(null).given(mock(IMethods.class)).objectReturningMethodNoArgs();
- willAnswer(ignore()).willReturn("a", 12).given(mock(IMethods.class)).objectReturningMethodNoArgs();
- willAnswer(ignore()).willReturn(1000).given(mock(IMethods.class)).objectReturningMethodNoArgs();
- willAnswer(ignore()).willThrow(new NullPointerException()).given(mock(IMethods.class)).objectReturningMethodNoArgs();
- willAnswer(ignore()).willThrow(new NullPointerException(), new IllegalArgumentException()).given(mock(IMethods.class)).objectReturningMethodNoArgs();
- willAnswer(ignore()).willThrow(NullPointerException.class).given(mock(IMethods.class)).objectReturningMethodNoArgs();
+ willAnswer(ignore())
+ .willReturn(null)
+ .given(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ willAnswer(ignore())
+ .willReturn("a", 12)
+ .given(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ willAnswer(ignore())
+ .willReturn(1000)
+ .given(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ willAnswer(ignore())
+ .willThrow(new NullPointerException())
+ .given(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ willAnswer(ignore())
+ .willThrow(new NullPointerException(), new IllegalArgumentException())
+ .given(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ willAnswer(ignore())
+ .willThrow(NullPointerException.class)
+ .given(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
given(mock(IMethods.class).objectReturningMethodNoArgs()).willReturn(null);
given(mock(IMethods.class).objectReturningMethodNoArgs()).willReturn("a", 12L);
given(mock(IMethods.class).objectReturningMethodNoArgs()).willReturn(1000);
- given(mock(IMethods.class).objectReturningMethodNoArgs()).willThrow(new NullPointerException());
- given(mock(IMethods.class).objectReturningMethodNoArgs()).willThrow(new NullPointerException(), new IllegalArgumentException());
- given(mock(IMethods.class).objectReturningMethodNoArgs()).willThrow(NullPointerException.class);
+ given(mock(IMethods.class).objectReturningMethodNoArgs())
+ .willThrow(new NullPointerException());
+ given(mock(IMethods.class).objectReturningMethodNoArgs())
+ .willThrow(new NullPointerException(), new IllegalArgumentException());
+ given(mock(IMethods.class).objectReturningMethodNoArgs())
+ .willThrow(NullPointerException.class);
given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willReturn(null);
- given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willReturn("a", 12L);
+ given(mock(IMethods.class).objectReturningMethodNoArgs())
+ .will(ignore())
+ .willReturn("a", 12L);
given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willReturn(1000);
- given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willThrow(new NullPointerException());
- given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willThrow(new NullPointerException(), new IllegalArgumentException());
- given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willThrow(NullPointerException.class);
+ given(mock(IMethods.class).objectReturningMethodNoArgs())
+ .will(ignore())
+ .willThrow(new NullPointerException());
+ given(mock(IMethods.class).objectReturningMethodNoArgs())
+ .will(ignore())
+ .willThrow(new NullPointerException(), new IllegalArgumentException());
+ given(mock(IMethods.class).objectReturningMethodNoArgs())
+ .will(ignore())
+ .willThrow(NullPointerException.class);
}
@Test
@SuppressWarnings("unchecked")
- public void heap_pollution_JDK7plus_warning_avoided_BUT_now_unchecked_generic_array_creation_warnings_ON_JDK5plus_environment() throws Exception {
- doThrow(NullPointerException.class, IllegalArgumentException.class).when(mock(IMethods.class)).objectReturningMethodNoArgs();
- when(mock(IMethods.class).objectReturningMethodNoArgs()).thenThrow(NullPointerException.class, IllegalArgumentException.class);
- doAnswer(ignore()).doThrow(NullPointerException.class, IllegalArgumentException.class).when(mock(IMethods.class)).objectReturningMethodNoArgs();
+ public void
+ heap_pollution_JDK7plus_warning_avoided_BUT_now_unchecked_generic_array_creation_warnings_ON_JDK5plus_environment()
+ throws Exception {
+ doThrow(NullPointerException.class, IllegalArgumentException.class)
+ .when(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ when(mock(IMethods.class).objectReturningMethodNoArgs())
+ .thenThrow(NullPointerException.class, IllegalArgumentException.class);
+ doAnswer(ignore())
+ .doThrow(NullPointerException.class, IllegalArgumentException.class)
+ .when(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
- willThrow(NullPointerException.class, IllegalArgumentException.class).given(mock(IMethods.class)).objectReturningMethodNoArgs();
- given(mock(IMethods.class).objectReturningMethodNoArgs()).willThrow(NullPointerException.class, IllegalArgumentException.class);
- willAnswer(ignore()).willThrow(NullPointerException.class, IllegalArgumentException.class).given(mock(IMethods.class)).objectReturningMethodNoArgs();
+ willThrow(NullPointerException.class, IllegalArgumentException.class)
+ .given(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ given(mock(IMethods.class).objectReturningMethodNoArgs())
+ .willThrow(NullPointerException.class, IllegalArgumentException.class);
+ willAnswer(ignore())
+ .willThrow(NullPointerException.class, IllegalArgumentException.class)
+ .given(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
}
@Test
public void unchecked_confusing_null_argument_warnings() throws Exception {
doReturn(null, (Object[]) null).when(mock(IMethods.class)).objectReturningMethodNoArgs();
- doAnswer(ignore()).doReturn(null, (Object[]) null).when(mock(IMethods.class)).objectReturningMethodNoArgs();
+ doAnswer(ignore())
+ .doReturn(null, (Object[]) null)
+ .when(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
when(mock(IMethods.class).objectReturningMethodNoArgs()).thenReturn(null, (Object[]) null);
- when(mock(IMethods.class).objectReturningMethodNoArgs()).then(ignore()).thenReturn(null, (Object[]) null);
+ when(mock(IMethods.class).objectReturningMethodNoArgs())
+ .then(ignore())
+ .thenReturn(null, (Object[]) null);
willReturn(null, (Object[]) null).given(mock(IMethods.class)).objectReturningMethodNoArgs();
given(mock(IMethods.class).objectReturningMethodNoArgs()).willReturn(null, (Object[]) null);
- willAnswer(ignore()).willReturn(null, (Object[]) null).given(mock(IMethods.class)).objectReturningMethodNoArgs();
- given(mock(IMethods.class).objectReturningMethodNoArgs()).will(ignore()).willReturn(null, (Object[]) null);
+ willAnswer(ignore())
+ .willReturn(null, (Object[]) null)
+ .given(mock(IMethods.class))
+ .objectReturningMethodNoArgs();
+ given(mock(IMethods.class).objectReturningMethodNoArgs())
+ .will(ignore())
+ .willReturn(null, (Object[]) null);
}
private static Answer<?> ignore() {
diff --git a/src/test/java/org/mockitousage/IMethods.java b/src/test/java/org/mockitousage/IMethods.java
index 7ec3750..1289742 100644
--- a/src/test/java/org/mockitousage/IMethods.java
+++ b/src/test/java/org/mockitousage/IMethods.java
@@ -42,7 +42,7 @@
Double doubleObjectReturningMethod();
- Object objectReturningMethod(Object ... objects);
+ Object objectReturningMethod(Object... objects);
Object objectReturningMethodNoArgs();
@@ -124,6 +124,9 @@
String simpleMethod(String one, Integer two, Integer three, Integer four, Integer five);
+ String simpleMethod(
+ String one, Integer two, Integer three, Integer four, Integer five, Integer six);
+
String simpleMethod(String one, String[] two);
Object threeArgumentMethod(int valueOne, Object valueTwo, String valueThree);
@@ -164,21 +167,21 @@
void varargsbyte(byte... bytes);
- int varargs(Object ... object);
+ int varargs(Object... object);
- String varargsReturningString(Object ... object);
+ String varargsReturningString(Object... object);
- int varargs(String ... string);
+ int varargs(String... string);
- void mixedVarargs(Object i, String ... string);
+ void mixedVarargs(Object i, String... string);
- String mixedVarargsReturningString(Object i, String ... string);
+ String mixedVarargsReturningString(Object i, String... string);
- String[] mixedVarargsReturningStringArray(Object i, String ... string);
+ String[] mixedVarargsReturningStringArray(Object i, String... string);
- Object[] mixedVarargsReturningObjectArray(Object i, String ... string);
+ Object[] mixedVarargsReturningObjectArray(Object i, String... string);
- List<String> listReturningMethod(Object ... objects);
+ List<String> listReturningMethod(Object... objects);
LinkedList<String> linkedListReturningMethod();
@@ -235,4 +238,52 @@
String forObject(Object object);
<T> 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 9417cbe..bb69656 100644
--- a/src/test/java/org/mockitousage/MethodsImpl.java
+++ b/src/test/java/org/mockitousage/MethodsImpl.java
@@ -237,6 +237,11 @@
return null;
}
+ public String simpleMethod(
+ String one, Integer two, Integer three, Integer four, Integer five, Integer six) {
+ return null;
+ }
+
public String simpleMethod(String one, String[] two) {
return null;
}
@@ -249,17 +254,14 @@
return null;
}
- public String fourArgumentMethod(int valueOne, String valueTwo, String valueThree, boolean[] array) {
+ public String fourArgumentMethod(
+ int valueOne, String valueTwo, String valueThree, boolean[] array) {
return null;
}
- public void twoArgumentMethod(int one, int two) {
+ public void twoArgumentMethod(int one, int two) {}
- }
-
- public void arrayMethod(String[] strings) {
-
- }
+ public void arrayMethod(String[] strings) {}
public String oneArray(boolean[] array) {
return null;
@@ -305,9 +307,7 @@
return null;
}
- public void varargsString(int i, String... string) {
-
- }
+ public void varargsString(int i, String... string) {}
public Object varargsObject(int i, Object... object) {
return null;
@@ -325,8 +325,7 @@
return -1;
}
- public void mixedVarargs(Object i, String... string) {
- }
+ public void mixedVarargs(Object i, String... string) {}
public String mixedVarargsReturningString(Object i, String... string) {
return null;
@@ -340,8 +339,7 @@
return null;
}
- public void varargsbyte(byte... bytes) {
- }
+ public void varargsbyte(byte... bytes) {}
public List<String> listReturningMethod(Object... objects) {
return null;
@@ -355,9 +353,7 @@
return null;
}
- public void voidMethod() {
-
- }
+ public void voidMethod() {}
public String forList(List<String> list) {
return null;
@@ -411,13 +407,9 @@
return null;
}
- public void longArg(long longArg) {
+ public void longArg(long longArg) {}
- }
-
- public void intArgumentMethod(int i) {
-
- }
+ public void intArgumentMethod(int i) {}
public int intArgumentReturningInt(int i) {
return 0;
@@ -456,4 +448,24 @@
public <T> 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/PlaygroundTest.java b/src/test/java/org/mockitousage/PlaygroundTest.java
index d3f5777..33c2036 100644
--- a/src/test/java/org/mockitousage/PlaygroundTest.java
+++ b/src/test/java/org/mockitousage/PlaygroundTest.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage;
import org.junit.Test;
@@ -22,12 +21,12 @@
}
class Boo {
- final public Object withLong(long y) {
- return "";
+ public final Object withLong(long y) {
+ return "";
}
public Object foo() {
- return "";
+ return "";
}
}
@@ -35,70 +34,68 @@
@Mock IMethods mockTwo;
@Test
- public void spyInAction() {
-
- }
+ public void spyInAction() {}
@Test
public void partialMockInAction() {
-// mock = mock(Foo.class, withSettings()
-// .defaultBehavior(CALLS_REAL_METHODS);
+ // mock = mock(Foo.class, withSettings()
+ // .defaultBehavior(CALLS_REAL_METHODS);
-// mock = mock(Foo.class, withSettings()
-// .defaultMockAnswer(CALLS_REAL_METHODS);
+ // mock = mock(Foo.class, withSettings()
+ // .defaultMockAnswer(CALLS_REAL_METHODS);
-// mock = mock(Foo.class, withSettings()
-// .defaultAnswer(CALLS_REAL_METHODS);
+ // mock = mock(Foo.class, withSettings()
+ // .defaultAnswer(CALLS_REAL_METHODS);
-// mock = mock(Foo.class, CALLS_REAL_METHODS);
+ // mock = mock(Foo.class, CALLS_REAL_METHODS);
-// mock = mock(Foo.class, withSettings()
-// .defaultBehavior(CALLS_REAL_METHODS)
-// .createUsingDefaultConstructor();
-//
-// mock = mock(Foo.class, withSettings()
-// .defaultBehavior(CALLS_REAL_METHODS)
-// .createPassingArguments("some arg", 1);
-//
-// spy = spy(Foo.class, "some arg", 1);
-//
-// .withName("foo")
-// .withDefaultBehavior(RETURNS_SMART_NULLS)
-// .withInterfaces(Bar.class);
-//
-// mock = mock(Foo.class)
-// .name("foo")
-// .defaultBehavior(RETURNS_SMART_NULLS)
-// .interfaces(Bar.class);
-//
-// mock = mock(Foo.class)
-// .named("foo")
-// .byDefault(RETURNS_SMART_NULLS)
-// .alsoImplements(Bar.class, Bar2.class);
-//
-// mock = mock(Foo.class)
-// hasName("foo");
+ // mock = mock(Foo.class, withSettings()
+ // .defaultBehavior(CALLS_REAL_METHODS)
+ // .createUsingDefaultConstructor();
+ //
+ // mock = mock(Foo.class, withSettings()
+ // .defaultBehavior(CALLS_REAL_METHODS)
+ // .createPassingArguments("some arg", 1);
+ //
+ // spy = spy(Foo.class, "some arg", 1);
+ //
+ // .withName("foo")
+ // .withDefaultBehavior(RETURNS_SMART_NULLS)
+ // .withInterfaces(Bar.class);
+ //
+ // mock = mock(Foo.class)
+ // .name("foo")
+ // .defaultBehavior(RETURNS_SMART_NULLS)
+ // .interfaces(Bar.class);
+ //
+ // mock = mock(Foo.class)
+ // .named("foo")
+ // .byDefault(RETURNS_SMART_NULLS)
+ // .alsoImplements(Bar.class, Bar2.class);
+ //
+ // mock = mock(Foo.class)
+ // hasName("foo");
-// when(mock.getStuff()).thenReturn("aha!");
-// when(mock.doSomeThing()).thenCallRealMethod();
-//
+ // when(mock.getStuff()).thenReturn("aha!");
+ // when(mock.doSomeThing()).thenCallRealMethod();
+ //
-// mock.doSomeThing();
+ // mock.doSomeThing();
}
-// interface Colored {
-//
-// }
-//
-// interface Bar {
-// <T extends Foo & Colored> T getColoredPoint();
-// }
-//
-// @Test
-// public void testname() throws Exception {
-// when(mock.get()).then(returnArgument());
-//
-// Bar mock = mock(Bar.class);
-// when(mock.getColoredPoint()).thenReturn(new Foo());
-// }
+ // interface Colored {
+ //
+ // }
+ //
+ // interface Bar {
+ // <T extends Foo & Colored> T getColoredPoint();
+ // }
+ //
+ // @Test
+ // public void testname() throws Exception {
+ // when(mock.get()).then(returnArgument());
+ //
+ // Bar mock = mock(Bar.class);
+ // when(mock.getColoredPoint()).thenReturn(new Foo());
+ // }
}
diff --git a/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java b/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java
index c740c7a..e3289f3 100644
--- a/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java
+++ b/src/test/java/org/mockitousage/PlaygroundWithDemoOfUnclonedParametersProblemTest.java
@@ -2,9 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.willAnswer;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+
+import java.util.Date;
+import java.util.GregorianCalendar;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
@@ -12,15 +20,6 @@
import org.mockito.stubbing.Answer;
import org.mockitoutil.TestBase;
-import java.util.Date;
-import java.util.GregorianCalendar;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.BDDMockito.willAnswer;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.verify;
-
public class PlaygroundWithDemoOfUnclonedParametersProblemTest extends TestBase {
ImportManager importManager;
@@ -36,46 +35,52 @@
@Test
public void shouldIncludeInitialLog() {
- //given
+ // given
int importType = 0;
Date currentDate = new GregorianCalendar(2009, 10, 12).getTime();
ImportLogBean initialLog = new ImportLogBean(currentDate, importType);
initialLog.setStatus(1);
- given(importLogDao.anyImportRunningOrRunnedToday(importType, currentDate)).willReturn(false);
- willAnswer(byCheckingLogEquals(initialLog)).given(importLogDao).include(any(ImportLogBean.class));
+ given(importLogDao.anyImportRunningOrRunnedToday(importType, currentDate))
+ .willReturn(false);
+ willAnswer(byCheckingLogEquals(initialLog))
+ .given(importLogDao)
+ .include(any(ImportLogBean.class));
- //when
+ // when
importManager.startImportProcess(importType, currentDate);
- //then
+ // then
verify(importLogDao).include(any(ImportLogBean.class));
}
@Test
public void shouldAlterFinalLog() {
- //given
+ // given
int importType = 0;
Date currentDate = new GregorianCalendar(2009, 10, 12).getTime();
ImportLogBean finalLog = new ImportLogBean(currentDate, importType);
finalLog.setStatus(9);
- given(importLogDao.anyImportRunningOrRunnedToday(importType, currentDate)).willReturn(false);
- willAnswer(byCheckingLogEquals(finalLog)).given(importLogDao).alter(any(ImportLogBean.class));
+ given(importLogDao.anyImportRunningOrRunnedToday(importType, currentDate))
+ .willReturn(false);
+ willAnswer(byCheckingLogEquals(finalLog))
+ .given(importLogDao)
+ .alter(any(ImportLogBean.class));
- //when
+ // when
importManager.startImportProcess(importType, currentDate);
- //then
+ // then
verify(importLogDao).alter(any(ImportLogBean.class));
}
private Answer<Object> byCheckingLogEquals(final ImportLogBean status) {
return new Answer<Object>() {
public Object answer(InvocationOnMock invocation) throws Throwable {
- ImportLogBean bean = invocation.getArgument(0);
+ ImportLogBean bean = invocation.getArgument(0);
assertEquals(status, bean);
return null;
}
@@ -98,7 +103,8 @@
importLogBean = createResume(importType, date);
if (isOkToImport(importType, date)) {
// get the right handler
- //importLogBean = ImportHandlerFactory.singleton().getImportHandler(importType).processImport(importLogBean);
+ // importLogBean =
+ // ImportHandlerFactory.singleton().getImportHandler(importType).processImport(importLogBean);
// 2 = ok
importLogBean.setStatus(2);
} else {
@@ -107,11 +113,9 @@
}
} catch (Exception e) {
// 9 = failed - exception
- if (importLogBean != null)
- importLogBean.setStatus(9);
+ if (importLogBean != null) importLogBean.setStatus(9);
} finally {
- if (importLogBean != null)
- finalizeResume(importLogBean);
+ if (importLogBean != null) finalizeResume(importLogBean);
}
}
@@ -120,8 +124,7 @@
}
private ImportLogBean createResume(int importType, Date date) {
- ImportLogBean importLogBean = new ImportLogBean(date,
- importType);
+ ImportLogBean importLogBean = new ImportLogBean(date, importType);
// 1 = running
importLogBean.setStatus(1);
importLogDao.include(importLogBean);
@@ -141,8 +144,7 @@
void alter(ImportLogBean importLogBean);
}
- private class IImportHandler {
- }
+ private class IImportHandler {}
private class ImportLogBean {
private Date currentDate;
@@ -167,7 +169,9 @@
if (importType != that.importType) return false;
if (status != that.status) return false;
- if (currentDate != null ? !currentDate.equals(that.currentDate) : that.currentDate != null) return false;
+ if (currentDate != null
+ ? !currentDate.equals(that.currentDate)
+ : that.currentDate != null) return false;
return true;
}
diff --git a/src/test/java/org/mockitousage/annotation/AnnotationsTest.java b/src/test/java/org/mockitousage/annotation/AnnotationsTest.java
index 3daf8b1..1a33f93 100644
--- a/src/test/java/org/mockitousage/annotation/AnnotationsTest.java
+++ b/src/test/java/org/mockitousage/annotation/AnnotationsTest.java
@@ -2,9 +2,18 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.annotation;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.verify;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.Answers;
@@ -15,16 +24,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.verify;
-
public class AnnotationsTest extends TestBase {
@Retention(RetentionPolicy.RUNTIME)
@@ -39,7 +38,7 @@
@Before
public void setup() {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
}
@Test
@@ -56,10 +55,11 @@
@Test
public void shouldScreamWhenInitializingMocksForNullClass() throws Exception {
try {
- MockitoAnnotations.initMocks(null);
+ MockitoAnnotations.openMocks(null);
fail();
} catch (MockitoException e) {
- assertEquals("testClass cannot be null. For info how to use @Mock annotations see examples in javadoc for MockitoAnnotations class",
+ assertEquals(
+ "testClass cannot be null. For info how to use @Mock annotations see examples in javadoc for MockitoAnnotations class",
e.getMessage());
}
}
@@ -67,18 +67,26 @@
@Test
public void shouldLookForAnnotatedMocksInSuperClasses() throws Exception {
Sub sub = new Sub();
- MockitoAnnotations.initMocks(sub);
+ MockitoAnnotations.openMocks(sub);
assertNotNull(sub.getMock());
assertNotNull(sub.getBaseMock());
assertNotNull(sub.getSuperBaseMock());
}
- @Mock(answer = Answers.RETURNS_MOCKS, name = "i have a name") IMethods namedAndReturningMocks;
- @Mock(answer = Answers.RETURNS_DEFAULTS) IMethods returningDefaults;
- @Mock(extraInterfaces = {List.class}) IMethods hasExtraInterfaces;
+ @Mock(answer = Answers.RETURNS_MOCKS, name = "i have a name")
+ IMethods namedAndReturningMocks;
+
+ @Mock(answer = Answers.RETURNS_DEFAULTS)
+ IMethods returningDefaults;
+
+ @Mock(extraInterfaces = {List.class})
+ IMethods hasExtraInterfaces;
+
@Mock() IMethods noExtraConfig;
- @Mock(stubOnly=true) IMethods stubOnly;
+
+ @Mock(stubOnly = true)
+ IMethods stubOnly;
@Test
public void shouldInitMocksWithGivenSettings() throws Exception {
diff --git a/src/test/java/org/mockitousage/annotation/CaptorAnnotationBasicTest.java b/src/test/java/org/mockitousage/annotation/CaptorAnnotationBasicTest.java
index 3876f86..6f8dc66 100644
--- a/src/test/java/org/mockitousage/annotation/CaptorAnnotationBasicTest.java
+++ b/src/test/java/org/mockitousage/annotation/CaptorAnnotationBasicTest.java
@@ -2,9 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.annotation;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.verify;
+
+import java.util.LinkedList;
+import java.util.List;
+
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
@@ -12,13 +18,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.util.LinkedList;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
-import static org.mockito.Mockito.verify;
-
@SuppressWarnings("unchecked")
public class CaptorAnnotationBasicTest extends TestBase {
@@ -52,10 +51,10 @@
@Test
public void shouldUseCaptorInOrdinaryWay() {
- //when
+ // when
createPerson("Wes", "Williams");
- //then
+ // then
ArgumentCaptor<Person> captor = ArgumentCaptor.forClass(Person.class);
verify(peopleRepository).save(captor.capture());
assertEquals("Wes", captor.getValue().getName());
@@ -66,24 +65,25 @@
@Test
public void shouldUseAnnotatedCaptor() {
- //when
+ // when
createPerson("Wes", "Williams");
- //then
+ // then
verify(peopleRepository).save(captor.capture());
assertEquals("Wes", captor.getValue().getName());
assertEquals("Williams", captor.getValue().getSurname());
}
@SuppressWarnings("rawtypes")
- @Captor ArgumentCaptor genericLessCaptor;
+ @Captor
+ ArgumentCaptor genericLessCaptor;
@Test
public void shouldUseGenericlessAnnotatedCaptor() {
- //when
+ // when
createPerson("Wes", "Williams");
- //then
+ // then
verify(peopleRepository).save((Person) genericLessCaptor.capture());
assertEquals("Wes", ((Person) genericLessCaptor.getValue()).getName());
assertEquals("Williams", ((Person) genericLessCaptor.getValue()).getSurname());
@@ -94,14 +94,14 @@
@Test
public void shouldCaptureGenericList() {
- //given
+ // given
List<String> list = new LinkedList<String>();
mock.listArgMethod(list);
- //when
+ // when
verify(mock).listArgMethod(genericListCaptor.capture());
- //then
+ // then
assertSame(list, genericListCaptor.getValue());
}
}
diff --git a/src/test/java/org/mockitousage/annotation/CaptorAnnotationTest.java b/src/test/java/org/mockitousage/annotation/CaptorAnnotationTest.java
index baca220..f015f1b 100644
--- a/src/test/java/org/mockitousage/annotation/CaptorAnnotationTest.java
+++ b/src/test/java/org/mockitousage/annotation/CaptorAnnotationTest.java
@@ -2,14 +2,10 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.annotation;
-import org.junit.Test;
-import org.mockito.*;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@@ -17,30 +13,28 @@
import java.util.List;
import java.util.Set;
-import static org.junit.Assert.*;
-import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+import org.mockito.*;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
public class CaptorAnnotationTest extends TestBase {
@Retention(RetentionPolicy.RUNTIME)
- public @interface NotAMock {
- }
+ public @interface NotAMock {}
- @Captor
- final ArgumentCaptor<String> finalCaptor = ArgumentCaptor.forClass(String.class);
+ @Captor final ArgumentCaptor<String> finalCaptor = ArgumentCaptor.forClass(String.class);
- @Captor
- ArgumentCaptor<List<List<String>>> genericsCaptor;
+ @Captor ArgumentCaptor<List<List<String>>> genericsCaptor;
@SuppressWarnings("rawtypes")
@Captor
ArgumentCaptor nonGenericCaptorIsAllowed;
- @Mock
- MockInterface mockInterface;
+ @Mock MockInterface mockInterface;
- @NotAMock
- Set<?> notAMock;
+ @NotAMock Set<?> notAMock;
public interface MockInterface {
void testMe(String simple, List<List<String>> genericList);
@@ -49,7 +43,7 @@
@Test
public void testNormalUsage() {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
// check if assigned correctly
assertNotNull(finalCaptor);
@@ -67,44 +61,41 @@
assertEquals(argForFinalCaptor, finalCaptor.getValue());
assertEquals(argForGenericsCaptor, genericsCaptor.getValue());
-
}
public static class WrongType {
- @Captor
- List<?> wrongType;
+ @Captor List<?> wrongType;
}
@Test
public void shouldScreamWhenWrongTypeForCaptor() {
try {
- MockitoAnnotations.initMocks(new WrongType());
+ MockitoAnnotations.openMocks(new WrongType());
fail();
- } catch (MockitoException e) {}
+ } catch (MockitoException e) {
+ }
}
public static class ToManyAnnotations {
- @Captor
- @Mock
- ArgumentCaptor<List> missingGenericsField;
+ @Captor @Mock ArgumentCaptor<List> missingGenericsField;
}
@Test
public void shouldScreamWhenMoreThanOneMockitoAnnotation() {
try {
- MockitoAnnotations.initMocks(new ToManyAnnotations());
+ MockitoAnnotations.openMocks(new ToManyAnnotations());
fail();
} catch (MockitoException e) {
assertThat(e)
- .hasMessageContaining("missingGenericsField")
- .hasMessageContaining("multiple Mockito annotations");
+ .hasMessageContaining("missingGenericsField")
+ .hasMessageContaining("multiple Mockito annotations");
}
}
@Test
public void shouldScreamWhenInitializingCaptorsForNullClass() throws Exception {
try {
- MockitoAnnotations.initMocks(null);
+ MockitoAnnotations.openMocks(null);
fail();
} catch (MockitoException e) {
}
@@ -113,7 +104,7 @@
@Test
public void shouldLookForAnnotatedCaptorsInSuperClasses() throws Exception {
Sub sub = new Sub();
- MockitoAnnotations.initMocks(sub);
+ MockitoAnnotations.openMocks(sub);
assertNotNull(sub.getCaptor());
assertNotNull(sub.getBaseCaptor());
@@ -121,8 +112,7 @@
}
class SuperBase {
- @Captor
- private ArgumentCaptor<IMethods> mock;
+ @Captor private ArgumentCaptor<IMethods> mock;
public ArgumentCaptor<IMethods> getSuperBaseCaptor() {
return mock;
@@ -130,8 +120,7 @@
}
class Base extends SuperBase {
- @Captor
- private ArgumentCaptor<IMethods> mock;
+ @Captor private ArgumentCaptor<IMethods> mock;
public ArgumentCaptor<IMethods> getBaseCaptor() {
return mock;
@@ -139,8 +128,7 @@
}
class Sub extends Base {
- @Captor
- private ArgumentCaptor<IMethods> mock;
+ @Captor private ArgumentCaptor<IMethods> mock;
public ArgumentCaptor<IMethods> getCaptor() {
return mock;
diff --git a/src/test/java/org/mockitousage/annotation/CaptorAnnotationUnhappyPathTest.java b/src/test/java/org/mockitousage/annotation/CaptorAnnotationUnhappyPathTest.java
index 5f96a28..f49de96 100644
--- a/src/test/java/org/mockitousage/annotation/CaptorAnnotationUnhappyPathTest.java
+++ b/src/test/java/org/mockitousage/annotation/CaptorAnnotationUnhappyPathTest.java
@@ -2,9 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.annotation;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+
+import java.util.List;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.Captor;
@@ -12,11 +16,6 @@
import org.mockito.exceptions.base.MockitoException;
import org.mockitoutil.TestBase;
-import java.util.List;
-
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-
public class CaptorAnnotationUnhappyPathTest extends TestBase {
@Captor List<?> notACaptorField;
@@ -24,20 +23,20 @@
@Before
@Override
public void init() {
- //we need to get rid of parent implementation this time
+ // we need to get rid of parent implementation this time
}
@Test
public void shouldFailIfCaptorHasWrongType() throws Exception {
try {
- //when
- MockitoAnnotations.initMocks(this);
+ // when
+ MockitoAnnotations.openMocks(this);
fail();
} catch (MockitoException e) {
- //then
+ // then
assertThat(e)
- .hasMessageContaining("notACaptorField")
- .hasMessageContaining("wrong type");
+ .hasMessageContaining("notACaptorField")
+ .hasMessageContaining("wrong type");
}
}
}
diff --git a/src/test/java/org/mockitousage/annotation/DeprecatedAnnotationEngineApiTest.java b/src/test/java/org/mockitousage/annotation/DeprecatedAnnotationEngineApiTest.java
index 43b8e63..a02434c 100644
--- a/src/test/java/org/mockitousage/annotation/DeprecatedAnnotationEngineApiTest.java
+++ b/src/test/java/org/mockitousage/annotation/DeprecatedAnnotationEngineApiTest.java
@@ -2,9 +2,10 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.annotation;
+import static org.junit.Assert.*;
+
import org.junit.After;
import org.junit.Test;
import org.mockito.InjectMocks;
@@ -16,8 +17,6 @@
import org.mockito.internal.configuration.IndependentAnnotationEngine;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.*;
-
public class DeprecatedAnnotationEngineApiTest extends TestBase {
@After
@@ -32,6 +31,7 @@
class Tested {
Dependency dependency;
+
public void setDependency(Dependency dependency) {
this.dependency = dependency;
}
@@ -41,15 +41,15 @@
@Test
public void shouldInjectMocksIfThereIsNoUserDefinedEngine() throws Exception {
- //given
+ // given
AnnotationEngine defaultEngine = new DefaultMockitoConfiguration().getAnnotationEngine();
ConfigurationAccess.getConfig().overrideAnnotationEngine(defaultEngine);
SimpleTestCase test = new SimpleTestCase();
- //when
- MockitoAnnotations.initMocks(test);
+ // when
+ MockitoAnnotations.openMocks(test);
- //then
+ // then
assertNotNull(test.mock);
assertNotNull(test.tested.dependency);
assertSame(test.mock, test.tested.dependency);
@@ -57,15 +57,17 @@
@Test
public void shouldRespectUsersEngine() throws Exception {
- //given
- AnnotationEngine customizedEngine = new IndependentAnnotationEngine() { /**/ };
+ // given
+ AnnotationEngine customizedEngine = new IndependentAnnotationEngine() {
+ /**/
+ };
ConfigurationAccess.getConfig().overrideAnnotationEngine(customizedEngine);
SimpleTestCase test = new SimpleTestCase();
- //when
- MockitoAnnotations.initMocks(test);
+ // when
+ MockitoAnnotations.openMocks(test);
- //then
+ // then
assertNotNull(test.mock);
assertNull(test.tested.dependency);
}
diff --git a/src/test/java/org/mockitousage/annotation/InjectionOfInlinedMockDeclarationTest.java b/src/test/java/org/mockitousage/annotation/InjectionOfInlinedMockDeclarationTest.java
index 39ef5f3..defb88a 100644
--- a/src/test/java/org/mockitousage/annotation/InjectionOfInlinedMockDeclarationTest.java
+++ b/src/test/java/org/mockitousage/annotation/InjectionOfInlinedMockDeclarationTest.java
@@ -4,16 +4,16 @@
*/
package org.mockitousage.annotation;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.junit.MockitoJUnitRunner;
-
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.junit.MockitoJUnitRunner;
+
@RunWith(MockitoJUnitRunner.class)
public class InjectionOfInlinedMockDeclarationTest {
@@ -44,7 +44,6 @@
assertSame(antenna, receiver.dvbtAntenna);
}
-
@Test
public void inject_mocks_even_in_declared_spy() throws Exception {
assertNotNull(spiedReceiver.oldAntenna);
@@ -58,10 +57,12 @@
Antenna dvbtAntenna;
Tuner tuner;
- public boolean tune() { return true; }
+ public boolean tune() {
+ return true;
+ }
}
- private static class Antenna { }
- private static class Tuner { }
+ private static class Antenna {}
+ private static class Tuner {}
}
diff --git a/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java b/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java
index eb3e99f..0e5c67f 100644
--- a/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java
+++ b/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorIssue421Test.java
@@ -2,9 +2,10 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.annotation;
+import static org.assertj.core.api.Assertions.assertThat;
+
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -13,8 +14,6 @@
import org.mockito.junit.MockitoJUnitRunner;
import org.mockitousage.examples.use.ArticleCalculator;
-import static org.assertj.core.api.Assertions.assertThat;
-
@RunWith(MockitoJUnitRunner.class)
public class MockInjectionUsingConstructorIssue421Test {
@@ -31,16 +30,14 @@
private ArticleCalculator calculator;
- public Issue421(int a) {
- }
+ public Issue421(int a) {}
public Issue421(ArticleCalculator calculator) {
this.calculator = calculator;
}
- public void checkIfMockIsInjected(){
+ public void checkIfMockIsInjected() {
assertThat(MockUtil.isMock(calculator)).isTrue();
}
}
-
}
diff --git a/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java b/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java
index 38879dc..3a89fd3 100644
--- a/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java
+++ b/src/test/java/org/mockitousage/annotation/MockInjectionUsingConstructorTest.java
@@ -2,9 +2,18 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.annotation;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.when;
+import static org.mockito.MockitoAnnotations.openMocks;
+
+import java.util.AbstractCollection;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Rule;
@@ -25,16 +34,6 @@
import org.mockitousage.examples.use.ArticleDatabase;
import org.mockitousage.examples.use.ArticleManager;
-import java.util.AbstractCollection;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.TimeUnit;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
-
public class MockInjectionUsingConstructorTest {
@Mock private ArticleCalculator calculator;
@@ -43,11 +42,11 @@
@InjectMocks private ArticleManager articleManager;
@Spy @InjectMocks private ArticleManager spiedArticleManager;
- @Rule
- public ExpectedException exception = ExpectedException.none();
+ @Rule public ExpectedException exception = ExpectedException.none();
- @Before public void before() {
- MockitoAnnotations.initMocks(this);
+ @Before
+ public void before() {
+ MockitoAnnotations.openMocks(this);
}
@Test
@@ -88,18 +87,21 @@
}
@Test
- public void should_report_failure_only_when_object_initialization_throws_exception() throws Exception {
+ public void should_report_failure_only_when_object_initialization_throws_exception()
+ throws Exception {
try {
- MockitoAnnotations.initMocks(new ATest());
+ MockitoAnnotations.openMocks(new ATest());
fail();
} catch (MockitoException e) {
- assertThat(e.getMessage()).contains("failingConstructor").contains("constructor").contains("threw an exception");
+ assertThat(e.getMessage())
+ .contains("failingConstructor")
+ .contains("constructor")
+ .contains("threw an exception");
assertThat(e.getCause()).isInstanceOf(IllegalStateException.class);
}
}
-
@RunWith(MockitoJUnitRunner.class)
public static class junit_test_with_3_tests_methods {
private static int constructor_instantiation = 0;
@@ -107,9 +109,14 @@
@Mock List<?> some_collaborator;
@InjectMocks some_class_with_parametered_constructor should_be_initialized_3_times;
- @Test public void test_1() { }
- @Test public void test_2() { }
- @Test public void test_3() { }
+ @Test
+ public void test_1() {}
+
+ @Test
+ public void test_2() {}
+
+ @Test
+ public void test_3() {}
private static class some_class_with_parametered_constructor {
public some_class_with_parametered_constructor(List<?> collaborator) {
@@ -130,72 +137,70 @@
@InjectMocks FailingConstructor failingConstructor;
}
-
@Test
public void injectMocksMustFailWithInterface() throws Exception {
class TestCase {
- @InjectMocks
- IMethods f;
+ @InjectMocks IMethods f;
}
exception.expect(MockitoException.class);
- exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'IMethods' is an interface");
+ exception.expectMessage(
+ "Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'IMethods' is an interface");
-
- initMocks(new TestCase());
+ openMocks(new TestCase());
}
@Test
public void injectMocksMustFailWithEnum() throws Exception {
class TestCase {
- @InjectMocks
- TimeUnit f;
+ @InjectMocks TimeUnit f;
}
exception.expect(MockitoException.class);
- exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'TimeUnit' is an enum");
+ exception.expectMessage(
+ "Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'TimeUnit' is an enum");
- initMocks(new TestCase());
+ openMocks(new TestCase());
}
@Test
public void injectMocksMustFailWithAbstractClass() throws Exception {
class TestCase {
- @InjectMocks
- AbstractCollection<?> f;
+ @InjectMocks AbstractCollection<?> f;
}
exception.expect(MockitoException.class);
- exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'AbstractCollection' is an abstract class");
+ exception.expectMessage(
+ "Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'AbstractCollection' is an abstract class");
- initMocks(new TestCase());
+ openMocks(new TestCase());
}
@Test
public void injectMocksMustFailWithNonStaticInnerClass() throws Exception {
class TestCase {
class InnerClass {}
- @InjectMocks
- InnerClass f;
+
+ @InjectMocks InnerClass f;
}
-
exception.expect(MockitoException.class);
- exception.expectMessage("Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'InnerClass' is an inner non static class");
+ exception.expectMessage(
+ "Cannot instantiate @InjectMocks field named 'f'! Cause: the type 'InnerClass' is an inner non static class");
- initMocks(new TestCase());
+ openMocks(new TestCase());
}
- static class StaticInnerClass {}
+ static class StaticInnerClass {}
+
@Test
public void injectMocksMustSucceedWithStaticInnerClass() throws Exception {
class TestCase {
- @InjectMocks
- StaticInnerClass f;
+ @InjectMocks StaticInnerClass f;
}
TestCase testClass = new TestCase();
- initMocks(testClass);
+ openMocks(testClass);
assertThat(testClass.f).isInstanceOf(StaticInnerClass.class);
}
@@ -203,18 +208,13 @@
@Test
public void injectMocksMustSucceedWithInstance() throws Exception {
class TestCase {
- @InjectMocks
- StaticInnerClass f = new StaticInnerClass();
+ @InjectMocks StaticInnerClass f = new StaticInnerClass();
}
TestCase testClass = new TestCase();
StaticInnerClass original = testClass.f;
- initMocks(testClass);
+ openMocks(testClass);
assertThat(testClass.f).isSameAs(original);
}
-
-
-
-
}
diff --git a/src/test/java/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java b/src/test/java/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java
index c23345a..0d2af98 100644
--- a/src/test/java/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java
+++ b/src/test/java/org/mockitousage/annotation/MockInjectionUsingSetterOrPropertyTest.java
@@ -4,7 +4,15 @@
*/
package org.mockitousage.annotation;
+import static org.junit.Assert.*;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
import org.assertj.core.api.Assertions;
+import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
@@ -16,13 +24,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
-
-import static org.junit.Assert.*;
-
@SuppressWarnings({"unchecked", "unused"})
public class MockInjectionUsingSetterOrPropertyTest extends TestBase {
@@ -31,7 +32,9 @@
@InjectMocks private BaseUnderTesting baseUnderTest = new BaseUnderTesting();
@InjectMocks private SubUnderTesting subUnderTest = new SubUnderTesting();
@InjectMocks private OtherBaseUnderTesting otherBaseUnderTest = new OtherBaseUnderTesting();
- @InjectMocks private HasTwoFieldsWithSameType hasTwoFieldsWithSameType = new HasTwoFieldsWithSameType();
+
+ @InjectMocks
+ private HasTwoFieldsWithSameType hasTwoFieldsWithSameType = new HasTwoFieldsWithSameType();
private BaseUnderTesting baseUnderTestingInstance = new BaseUnderTesting();
@InjectMocks private BaseUnderTesting initializedBase = baseUnderTestingInstance;
@@ -48,10 +51,19 @@
@Spy private TreeSet<String> searchTree = new TreeSet<String>();
+ private AutoCloseable session;
+
@Before
public void enforces_new_instances() {
- // initMocks called in TestBase Before method, so instances are not the same
- MockitoAnnotations.initMocks(this);
+ // openMocks called in TestBase Before method, so instances are not the same
+ session = MockitoAnnotations.openMocks(this);
+ }
+
+ @After
+ public void close_new_instances() throws Exception {
+ if (session != null) {
+ session.close();
+ }
}
@Test
@@ -79,41 +91,43 @@
@Test
public void should_inject_mocks_if_annotated() {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
assertSame(list, superUnderTest.getAList());
}
@Test
public void should_not_inject_if_not_annotated() {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
assertNull(superUnderTestWithoutInjection.getAList());
}
@Test
public void should_inject_mocks_for_class_hierarchy_if_annotated() {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
assertSame(list, baseUnderTest.getAList());
assertSame(map, baseUnderTest.getAMap());
}
@Test
public void should_inject_mocks_by_name() {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
assertSame(histogram1, subUnderTest.getHistogram1());
assertSame(histogram2, subUnderTest.getHistogram2());
}
@Test
public void should_inject_spies() {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
assertSame(searchTree, otherBaseUnderTest.getSearchTree());
}
@Test
- public void should_insert_into_field_with_matching_name_when_multiple_fields_of_same_type_exists_in_injectee() {
- MockitoAnnotations.initMocks(this);
+ public void
+ should_insert_into_field_with_matching_name_when_multiple_fields_of_same_type_exists_in_injectee() {
+ MockitoAnnotations.openMocks(this);
assertNull("not injected, no mock named 'candidate1'", hasTwoFieldsWithSameType.candidate1);
- assertNotNull("injected, there's a mock named 'candidate2'", hasTwoFieldsWithSameType.candidate2);
+ assertNotNull(
+ "injected, there's a mock named 'candidate2'", hasTwoFieldsWithSameType.candidate2);
}
@Test
@@ -128,46 +142,63 @@
@Test
public void should_report_nicely() throws Exception {
- Object failing = new Object() {
- @InjectMocks ThrowingConstructor failingConstructor;
- };
+ Object failing =
+ new Object() {
+ @InjectMocks ThrowingConstructor failingConstructor;
+ };
try {
- MockitoAnnotations.initMocks(failing);
+ MockitoAnnotations.openMocks(failing);
fail();
} catch (MockitoException e) {
- Assertions.assertThat(e.getMessage()).contains("failingConstructor").contains("constructor").contains("threw an exception");
+ Assertions.assertThat(e.getMessage())
+ .contains("failingConstructor")
+ .contains("constructor")
+ .contains("threw an exception");
Assertions.assertThat(e.getCause()).isInstanceOf(RuntimeException.class);
}
}
static class ThrowingConstructor {
- ThrowingConstructor() { throw new RuntimeException("aha"); }
+ ThrowingConstructor() {
+ throw new RuntimeException("aha");
+ }
}
static class SuperUnderTesting {
private List<?> aList;
- public List<?> getAList() { return aList; }
+ public List<?> getAList() {
+ return aList;
+ }
}
static class BaseUnderTesting extends SuperUnderTesting {
private Map<?, ?> aMap;
- public Map<?, ?> getAMap() { return aMap; }
+ public Map<?, ?> getAMap() {
+ return aMap;
+ }
}
static class OtherBaseUnderTesting extends SuperUnderTesting {
private TreeSet<?> searchTree;
- public TreeSet<?> getSearchTree() { return searchTree; }
+ public TreeSet<?> getSearchTree() {
+ return searchTree;
+ }
}
static class SubUnderTesting extends BaseUnderTesting {
private Set<?> histogram1;
private Set<?> histogram2;
- public Set<?> getHistogram1() { return histogram1; }
- public Set<?> getHistogram2() { return histogram2; }
+ public Set<?> getHistogram1() {
+ return histogram1;
+ }
+
+ public Set<?> getHistogram2() {
+ return histogram2;
+ }
}
static class HasTwoFieldsWithSameType {
diff --git a/src/test/java/org/mockitousage/annotation/SpyAnnotationInitializedInBaseClassTest.java b/src/test/java/org/mockitousage/annotation/SpyAnnotationInitializedInBaseClassTest.java
index 5d3b5e6..60f8791 100644
--- a/src/test/java/org/mockitousage/annotation/SpyAnnotationInitializedInBaseClassTest.java
+++ b/src/test/java/org/mockitousage/annotation/SpyAnnotationInitializedInBaseClassTest.java
@@ -4,6 +4,12 @@
*/
package org.mockitousage.annotation;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.internal.util.MockUtil.isMock;
+
+import java.util.LinkedList;
+import java.util.List;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.MockitoAnnotations;
@@ -11,53 +17,42 @@
import org.mockito.internal.util.MockUtil;
import org.mockitoutil.TestBase;
-import java.util.LinkedList;
-import java.util.List;
-
-import static org.junit.Assert.assertTrue;
-import static org.mockito.internal.util.MockUtil.isMock;
-
@SuppressWarnings("unchecked")
public class SpyAnnotationInitializedInBaseClassTest extends TestBase {
class BaseClass {
- @Spy
- List list = new LinkedList();
+ @Spy List list = new LinkedList();
}
- class SubClass extends BaseClass {
-
- }
+ class SubClass extends BaseClass {}
@Test
public void shouldInitSpiesInBaseClass() throws Exception {
- //given
+ // given
SubClass subClass = new SubClass();
- //when
- MockitoAnnotations.initMocks(subClass);
- //then
+ // when
+ MockitoAnnotations.openMocks(subClass);
+ // then
assertTrue(MockUtil.isMock(subClass.list));
}
@Before
@Override
public void init() {
- //we need to get rid of parent implementation this time
+ // we need to get rid of parent implementation this time
}
@Before
public void before() {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
}
- @Spy
- List spyInBaseclass = new LinkedList();
+ @Spy List spyInBaseclass = new LinkedList();
public static class SubTest extends SpyAnnotationInitializedInBaseClassTest {
- @Spy
- List spyInSubclass = new LinkedList();
+ @Spy List spyInSubclass = new LinkedList();
@Test
public void shouldInitSpiesInHierarchy() throws Exception {
diff --git a/src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java b/src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java
index 8fbbe18..8db8ef1 100644
--- a/src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java
+++ b/src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java
@@ -4,11 +4,23 @@
*/
package org.mockitousage.annotation;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
+
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
@@ -19,34 +31,18 @@
import org.mockito.exceptions.base.MockitoException;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.eq;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@SuppressWarnings("unused")
public class SpyAnnotationTest extends TestBase {
- @Spy
- final List<String> spiedList = new ArrayList<String>();
+ @Spy final List<String> spiedList = new ArrayList<String>();
- @Spy
- InnerStaticClassWithNoArgConstructor staticTypeWithNoArgConstructor;
+ @Spy InnerStaticClassWithNoArgConstructor staticTypeWithNoArgConstructor;
- @Spy
- InnerStaticClassWithoutDefinedConstructor staticTypeWithoutDefinedConstructor;
+ @Spy InnerStaticClassWithoutDefinedConstructor staticTypeWithoutDefinedConstructor;
- @Spy
- MockTranslator translator;
+ @Spy MockTranslator translator;
- @Rule
- public final ExpectedException shouldThrow = ExpectedException.none();
+ @Rule public final ExpectedException shouldThrow = ExpectedException.none();
@Test
public void should_init_spy_by_instance() throws Exception {
@@ -66,12 +62,11 @@
@Test
public void should_allow_spying_on_interfaces() throws Exception {
class WithSpy {
- @Spy
- List<String> list;
+ @Spy List<String> list;
}
WithSpy withSpy = new WithSpy();
- MockitoAnnotations.initMocks(withSpy);
+ MockitoAnnotations.openMocks(withSpy);
when(withSpy.list.size()).thenReturn(3);
assertEquals(3, withSpy.list.size());
}
@@ -79,30 +74,29 @@
@Test
public void should_allow_spying_on_interfaces_when_instance_is_concrete() throws Exception {
class WithSpy {
- @Spy
- List<String> list = new LinkedList<String>();
+ @Spy List<String> list = new LinkedList<String>();
}
WithSpy withSpy = new WithSpy();
- //when
- MockitoAnnotations.initMocks(withSpy);
+ // when
+ MockitoAnnotations.openMocks(withSpy);
- //then
+ // then
verify(withSpy.list, never()).clear();
}
@Test
public void should_report_when_no_arg_less_constructor() throws Exception {
class FailingSpy {
- @Spy
- NoValidConstructor noValidConstructor;
+ @Spy NoValidConstructor noValidConstructor;
}
try {
- MockitoAnnotations.initMocks(new FailingSpy());
+ MockitoAnnotations.openMocks(new FailingSpy());
fail();
} catch (MockitoException e) {
- assertThat(e.getMessage()).contains("Please ensure that the type")
+ assertThat(e.getMessage())
+ .contains("Please ensure that the type")
.contains(NoValidConstructor.class.getSimpleName())
.contains("has a no-arg constructor");
}
@@ -111,12 +105,11 @@
@Test
public void should_report_when_constructor_is_explosive() throws Exception {
class FailingSpy {
- @Spy
- ThrowingConstructor throwingConstructor;
+ @Spy ThrowingConstructor throwingConstructor;
}
try {
- MockitoAnnotations.initMocks(new FailingSpy());
+ MockitoAnnotations.openMocks(new FailingSpy());
fail();
} catch (MockitoException e) {
assertThat(e.getMessage()).contains("Unable to create mock instance");
@@ -126,8 +119,7 @@
@Test
public void should_spy_abstract_class() throws Exception {
class SpyAbstractClass {
- @Spy
- AbstractList<String> list;
+ @Spy AbstractList<String> list;
List<String> asSingletonList(String s) {
when(list.size()).thenReturn(1);
@@ -136,7 +128,7 @@
}
}
SpyAbstractClass withSpy = new SpyAbstractClass();
- MockitoAnnotations.initMocks(withSpy);
+ MockitoAnnotations.openMocks(withSpy);
assertEquals(Arrays.asList("a"), withSpy.asSingletonList("a"));
}
@@ -144,10 +136,8 @@
public void should_spy_inner_class() throws Exception {
class WithMockAndSpy {
- @Spy
- private InnerStrength strength;
- @Mock
- private List<String> list;
+ @Spy private InnerStrength strength;
+ @Mock private List<String> list;
abstract class InnerStrength {
private final String name;
@@ -167,7 +157,7 @@
}
}
WithMockAndSpy outer = new WithMockAndSpy();
- MockitoAnnotations.initMocks(outer);
+ MockitoAnnotations.openMocks(outer);
when(outer.strength.strength()).thenReturn("strength");
assertEquals("inner strength", outer.strength.fullStrength());
}
@@ -180,15 +170,13 @@
@Test
public void should_report_when_enclosing_instance_is_needed() throws Exception {
class Outer {
- class Inner {
- }
+ class Inner {}
}
class WithSpy {
- @Spy
- private Outer.Inner inner;
+ @Spy private Outer.Inner inner;
}
try {
- MockitoAnnotations.initMocks(new WithSpy());
+ MockitoAnnotations.openMocks(new WithSpy());
fail();
} catch (MockitoException e) {
assertThat(e).hasMessageContaining("@Spy annotation can only initialize inner classes");
@@ -198,13 +186,14 @@
@Test
public void should_report_private_inner_not_supported() throws Exception {
try {
- MockitoAnnotations.initMocks(new WithInnerPrivate());
+ MockitoAnnotations.openMocks(new WithInnerPrivate());
fail();
} catch (MockitoException e) {
// Currently fails at instantiation time, because the mock subclass don't have the
// 1-arg constructor expected for the outerclass.
// org.mockito.internal.creation.instance.ConstructorInstantiator.withParams()
- assertThat(e).hasMessageContaining("Unable to initialize @Spy annotated field 'spy_field'")
+ assertThat(e)
+ .hasMessageContaining("Unable to initialize @Spy annotated field 'spy_field'")
.hasMessageContaining(WithInnerPrivate.InnerPrivate.class.getSimpleName());
}
}
@@ -212,12 +201,15 @@
@Test
public void should_report_private_abstract_inner_not_supported() throws Exception {
try {
- MockitoAnnotations.initMocks(new WithInnerPrivateAbstract());
+ MockitoAnnotations.openMocks(new WithInnerPrivateAbstract());
fail();
} catch (MockitoException e) {
- assertThat(e).hasMessageContaining("@Spy annotation can't initialize private abstract inner classes")
+ assertThat(e)
+ .hasMessageContaining(
+ "@Spy annotation can't initialize private abstract inner classes")
.hasMessageContaining(WithInnerPrivateAbstract.class.getSimpleName())
- .hasMessageContaining(WithInnerPrivateAbstract.InnerPrivateAbstract.class.getSimpleName())
+ .hasMessageContaining(
+ WithInnerPrivateAbstract.InnerPrivateAbstract.class.getSimpleName())
.hasMessageContaining("You should augment the visibility of this inner class");
}
}
@@ -225,90 +217,86 @@
@Test
public void should_report_private_static_abstract_inner_not_supported() throws Exception {
try {
- MockitoAnnotations.initMocks(new WithInnerPrivateStaticAbstract());
+ MockitoAnnotations.openMocks(new WithInnerPrivateStaticAbstract());
fail();
} catch (MockitoException e) {
- assertThat(e).hasMessageContaining("@Spy annotation can't initialize private abstract inner classes")
+ assertThat(e)
+ .hasMessageContaining(
+ "@Spy annotation can't initialize private abstract inner classes")
.hasMessageContaining(WithInnerPrivateStaticAbstract.class.getSimpleName())
- .hasMessageContaining(WithInnerPrivateStaticAbstract.InnerPrivateStaticAbstract.class.getSimpleName())
+ .hasMessageContaining(
+ WithInnerPrivateStaticAbstract.InnerPrivateStaticAbstract.class
+ .getSimpleName())
.hasMessageContaining("You should augment the visibility of this inner class");
}
}
@Test
public void should_be_able_to_stub_and_verify_via_varargs_for_list_params() throws Exception {
- // You can stub with varargs.
- when(translator.translate("hello", "mockito")).thenReturn(Arrays.asList("you", "too"));
+ // You can stub with varargs.
+ when(translator.translate("hello", "mockito")).thenReturn(Arrays.asList("you", "too"));
- // Pretend the prod code will call translate(List<String>) with these elements.
- assertThat(translator.translate(Arrays.asList("hello", "mockito"))).containsExactly("you", "too");
- assertThat(translator.translate(Arrays.asList("not stubbed"))).isEmpty();
+ // Pretend the prod code will call translate(List<String>) with these elements.
+ assertThat(translator.translate(Arrays.asList("hello", "mockito")))
+ .containsExactly("you", "too");
+ assertThat(translator.translate(Arrays.asList("not stubbed"))).isEmpty();
- // You can verify with varargs.
- verify(translator).translate("hello", "mockito");
+ // You can verify with varargs.
+ verify(translator).translate("hello", "mockito");
}
@Test
- public void should_be_able_to_stub_and_verify_via_varargs_of_matchers_for_list_params() throws Exception {
- // You can stub with varargs of matchers.
- when(translator.translate(Mockito.anyString())).thenReturn(Arrays.asList("huh?"));
- when(translator.translate(eq("hello"))).thenReturn(Arrays.asList("hi"));
+ public void should_be_able_to_stub_and_verify_via_varargs_of_matchers_for_list_params()
+ throws Exception {
+ // You can stub with varargs of matchers.
+ when(translator.translate(Mockito.anyString())).thenReturn(Arrays.asList("huh?"));
+ when(translator.translate(eq("hello"))).thenReturn(Arrays.asList("hi"));
- // Pretend the prod code will call translate(List<String>) with these elements.
- assertThat(translator.translate(Arrays.asList("hello"))).containsExactly("hi");
- assertThat(translator.translate(Arrays.asList("not explicitly stubbed"))).containsExactly("huh?");
+ // Pretend the prod code will call translate(List<String>) with these elements.
+ assertThat(translator.translate(Arrays.asList("hello"))).containsExactly("hi");
+ assertThat(translator.translate(Arrays.asList("not explicitly stubbed")))
+ .containsExactly("huh?");
- // You can verify with varargs of matchers.
- verify(translator).translate(eq("hello"));
+ // You can verify with varargs of matchers.
+ verify(translator).translate(eq("hello"));
}
static class WithInnerPrivateStaticAbstract {
- @Spy
- private InnerPrivateStaticAbstract spy_field;
+ @Spy private InnerPrivateStaticAbstract spy_field;
- private static abstract class InnerPrivateStaticAbstract {
- }
+ private abstract static class InnerPrivateStaticAbstract {}
}
+
static class WithInnerPrivateAbstract {
- @Spy
- private InnerPrivateAbstract spy_field;
+ @Spy private InnerPrivateAbstract spy_field;
public void some_method() {
new InnerPrivateConcrete();
}
- private abstract class InnerPrivateAbstract {
- }
+ private abstract class InnerPrivateAbstract {}
- private class InnerPrivateConcrete extends InnerPrivateAbstract {
-
- }
+ private class InnerPrivateConcrete extends InnerPrivateAbstract {}
}
static class WithInnerPrivate {
- @Spy
- private InnerPrivate spy_field;
+ @Spy private InnerPrivate spy_field;
- private class InnerPrivate {
- }
+ private class InnerPrivate {}
private class InnerPrivateSub extends InnerPrivate {}
}
- static class InnerStaticClassWithoutDefinedConstructor {
- }
+ static class InnerStaticClassWithoutDefinedConstructor {}
static class InnerStaticClassWithNoArgConstructor {
- InnerStaticClassWithNoArgConstructor() {
- }
+ InnerStaticClassWithNoArgConstructor() {}
- InnerStaticClassWithNoArgConstructor(String f) {
- }
+ InnerStaticClassWithNoArgConstructor(String f) {}
}
static class NoValidConstructor {
- NoValidConstructor(String f) {
- }
+ NoValidConstructor(String f) {}
}
static class ThrowingConstructor {
@@ -318,14 +306,15 @@
}
interface Translator {
- List<String> translate(List<String> messages);
+ List<String> translate(List<String> messages);
}
- static abstract class MockTranslator implements Translator {
- @Override public final List<String> translate(List<String> messages) {
- return translate(messages.toArray(new String[0]));
- }
+ abstract static class MockTranslator implements Translator {
+ @Override
+ public final List<String> translate(List<String> messages) {
+ return translate(messages.toArray(new String[0]));
+ }
- abstract List<String> translate(String... messages);
+ abstract List<String> translate(String... messages);
}
}
diff --git a/src/test/java/org/mockitousage/annotation/SpyInjectionTest.java b/src/test/java/org/mockitousage/annotation/SpyInjectionTest.java
index 32b37fd..9961e6e 100644
--- a/src/test/java/org/mockitousage/annotation/SpyInjectionTest.java
+++ b/src/test/java/org/mockitousage/annotation/SpyInjectionTest.java
@@ -4,15 +4,15 @@
*/
package org.mockitousage.annotation;
+import java.util.LinkedList;
+import java.util.List;
+
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Spy;
import org.mockito.internal.util.MockUtil;
import org.mockitoutil.TestBase;
-import java.util.LinkedList;
-import java.util.List;
-
public class SpyInjectionTest extends TestBase {
@Spy List<Object> spy = new LinkedList<Object>();
@@ -20,6 +20,7 @@
static class HasSpy {
private List<?> spy;
+
public void setSpy(List<?> spy) {
this.spy = spy;
}
diff --git a/src/test/java/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java b/src/test/java/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java
index 05cf4f8..f5bf525 100644
--- a/src/test/java/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java
+++ b/src/test/java/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java
@@ -4,29 +4,33 @@
*/
package org.mockitousage.annotation;
+import static org.junit.Assert.fail;
+
+import java.util.List;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.*;
import org.mockito.exceptions.base.MockitoException;
import org.mockitoutil.TestBase;
-import java.util.List;
-
-import static org.junit.Assert.fail;
-
public class WrongSetOfAnnotationsTest extends TestBase {
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void should_not_allow_Mock_and_Spy() throws Exception {
- MockitoAnnotations.initMocks(new Object() {
- @Mock @Spy List<?> mock;
- });
+ MockitoAnnotations.openMocks(
+ new Object() {
+ @Mock @Spy List<?> mock;
+ });
}
@Test
public void should_not_allow_Spy_and_InjectMocks_on_interfaces() throws Exception {
try {
- MockitoAnnotations.initMocks(new Object() { @InjectMocks @Spy List<?> mock; });
+ MockitoAnnotations.openMocks(
+ new Object() {
+ @InjectMocks @Spy List<?> mock;
+ });
fail();
} catch (MockitoException me) {
Assertions.assertThat(me.getMessage()).contains("'List' is an interface");
@@ -35,39 +39,45 @@
@Test
public void should_allow_Spy_and_InjectMocks() throws Exception {
- MockitoAnnotations.initMocks(new Object() {
- @InjectMocks
- @Spy
- WithDependency mock;
- });
+ MockitoAnnotations.openMocks(
+ new Object() {
+ @InjectMocks @Spy WithDependency mock;
+ });
}
- static class WithDependency { List<?> list; }
- @Test(expected=MockitoException.class)
+ static class WithDependency {
+ List<?> list;
+ }
+
+ @Test(expected = MockitoException.class)
public void should_not_allow_Mock_and_InjectMocks() throws Exception {
- MockitoAnnotations.initMocks(new Object() {
- @InjectMocks @Mock List<?> mock;
- });
+ MockitoAnnotations.openMocks(
+ new Object() {
+ @InjectMocks @Mock List<?> mock;
+ });
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void should_not_allow_Captor_and_Mock() throws Exception {
- MockitoAnnotations.initMocks(new Object() {
- @Mock @Captor ArgumentCaptor<?> captor;
- });
+ MockitoAnnotations.openMocks(
+ new Object() {
+ @Mock @Captor ArgumentCaptor<?> captor;
+ });
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void should_not_allow_Captor_and_Spy() throws Exception {
- MockitoAnnotations.initMocks(new Object() {
- @Spy @Captor ArgumentCaptor<?> captor;
- });
+ MockitoAnnotations.openMocks(
+ new Object() {
+ @Spy @Captor ArgumentCaptor<?> captor;
+ });
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void should_not_allow_Captor_and_InjectMocks() throws Exception {
- MockitoAnnotations.initMocks(new Object() {
- @InjectMocks @Captor ArgumentCaptor<?> captor;
- });
+ MockitoAnnotations.openMocks(
+ new Object() {
+ @InjectMocks @Captor ArgumentCaptor<?> captor;
+ });
}
}
diff --git a/src/test/java/org/mockitousage/basicapi/MockAccessTest.java b/src/test/java/org/mockitousage/basicapi/MockAccessTest.java
index 84d45e7..13c0c74 100644
--- a/src/test/java/org/mockitousage/basicapi/MockAccessTest.java
+++ b/src/test/java/org/mockitousage/basicapi/MockAccessTest.java
@@ -4,15 +4,14 @@
*/
package org.mockitousage.basicapi;
-
-import org.junit.Test;
-
-import java.util.Set;
-
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import java.util.Set;
+
+import org.junit.Test;
+
public class MockAccessTest {
@Test
diff --git a/src/test/java/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java b/src/test/java/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java
index ae5edd5..f7c3b00 100644
--- a/src/test/java/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java
+++ b/src/test/java/org/mockitousage/basicapi/MockingMultipleInterfacesTest.java
@@ -2,13 +2,8 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.basicapi;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockitousage.IMethods;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
@@ -16,19 +11,25 @@
import static org.mockitoutil.ClassLoaders.inMemoryClassLoader;
import static org.mockitoutil.SimpleClassGenerator.makeMarkerInterface;
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockitousage.IMethods;
+
// See issue 453
public class MockingMultipleInterfacesTest {
class Foo {}
+
interface IFoo {}
+
interface IBar {}
@Test
public void should_allow_multiple_interfaces() {
- //when
+ // when
Foo mock = mock(Foo.class, withSettings().extraInterfaces(IFoo.class, IBar.class));
- //then
+ // then
assertThat(mock).isInstanceOf(IFoo.class);
assertThat(mock).isInstanceOf(IBar.class);
}
@@ -36,47 +37,50 @@
@Test
public void should_scream_when_null_passed_instead_of_an_interface() {
try {
- //when
+ // when
mock(Foo.class, withSettings().extraInterfaces(IFoo.class, null));
fail();
} catch (MockitoException e) {
- //then
- assertThat(e.getMessage()).contains("extraInterfaces() does not accept null parameters");
+ // then
+ assertThat(e.getMessage())
+ .contains("extraInterfaces() does not accept null parameters");
}
}
@Test
public void should_scream_when_no_args_passed() {
try {
- //when
+ // when
mock(Foo.class, withSettings().extraInterfaces());
fail();
} catch (MockitoException e) {
- //then
- assertThat(e.getMessage()).contains("extraInterfaces() requires at least one interface");
+ // then
+ assertThat(e.getMessage())
+ .contains("extraInterfaces() requires at least one interface");
}
}
@Test
public void should_scream_when_null_passed_instead_of_an_array() {
try {
- //when
+ // when
mock(Foo.class, withSettings().extraInterfaces((Class[]) null));
fail();
} catch (MockitoException e) {
- //then
- assertThat(e.getMessage()).contains("extraInterfaces() requires at least one interface");
+ // then
+ assertThat(e.getMessage())
+ .contains("extraInterfaces() requires at least one interface");
}
}
@Test
public void should_scream_when_non_interface_passed() {
try {
- //when
+ // when
mock(Foo.class, withSettings().extraInterfaces(Foo.class));
fail();
} catch (MockitoException e) {
- //then
+ // then
assertThat(e.getMessage()).contains("Foo which is not an interface");
}
}
@@ -84,29 +88,37 @@
@Test
public void should_scream_when_the_same_interfaces_passed() {
try {
- //when
+ // when
mock(IMethods.class, withSettings().extraInterfaces(IMethods.class));
fail();
} catch (MockitoException e) {
- //then
+ // then
assertThat(e.getMessage()).contains("You mocked following type: IMethods");
}
}
-
@Test
- public void should_mock_class_with_interfaces_of_different_class_loader_AND_different_classpaths() throws ClassNotFoundException {
- // Note : if classes are in the same classpath, SearchingClassLoader can find the class/classes and load them in the first matching classloader
- Class<?> interface1 = inMemoryClassLoader()
- .withClassDefinition("test.Interface1", makeMarkerInterface("test.Interface1"))
- .build()
- .loadClass("test.Interface1");
- Class<?> interface2 = inMemoryClassLoader()
- .withClassDefinition("test.Interface2", makeMarkerInterface("test.Interface2"))
- .build()
- .loadClass("test.Interface2");
+ public void
+ should_mock_class_with_interfaces_of_different_class_loader_AND_different_classpaths()
+ throws ClassNotFoundException {
+ // Note : if classes are in the same classpath, SearchingClassLoader can find the
+ // class/classes and load them in the first matching classloader
+ Class<?> interface1 =
+ inMemoryClassLoader()
+ .withClassDefinition(
+ "test.Interface1", makeMarkerInterface("test.Interface1"))
+ .build()
+ .loadClass("test.Interface1");
+ Class<?> interface2 =
+ inMemoryClassLoader()
+ .withClassDefinition(
+ "test.Interface2", makeMarkerInterface("test.Interface2"))
+ .build()
+ .loadClass("test.Interface2");
Object mocked = mock(interface1, withSettings().extraInterfaces(interface2));
- assertThat(interface2.isInstance(mocked)).describedAs("mock should be assignable from interface2 type").isTrue();
+ assertThat(interface2.isInstance(mocked))
+ .describedAs("mock should be assignable from interface2 type")
+ .isTrue();
}
}
diff --git a/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java b/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java
index b5892ef..241c775 100644
--- a/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java
+++ b/src/test/java/org/mockitousage/basicapi/MocksCreationTest.java
@@ -2,22 +2,8 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.basicapi;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.exceptions.verification.SmartNullPointerException;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
@@ -28,6 +14,19 @@
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.withSettings;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.verification.SmartNullPointerException;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
@SuppressWarnings("unchecked")
public class MocksCreationTest extends TestBase {
@@ -40,62 +39,66 @@
@Test
public void should_combine_mock_name_and_smart_nulls() {
- //given
- IMethods mock = mock(IMethods.class, withSettings()
- .defaultAnswer(RETURNS_SMART_NULLS)
- .name("great mockie"));
+ // given
+ IMethods mock =
+ mock(
+ IMethods.class,
+ withSettings().defaultAnswer(RETURNS_SMART_NULLS).name("great mockie"));
- //when
+ // when
IMethods smartNull = mock.iMethodsReturningMethod();
String name = mock.toString();
- //then
+ // then
assertThat(name).contains("great mockie");
- //and
+ // and
try {
smartNull.simpleMethod();
fail();
- } catch(SmartNullPointerException e) {}
+ } catch (SmartNullPointerException e) {
+ }
}
@Test
public void should_combine_mock_name_and_extra_interfaces() {
- //given
- IMethods mock = mock(IMethods.class, withSettings()
- .extraInterfaces(List.class)
- .name("great mockie"));
+ // given
+ IMethods mock =
+ mock(
+ IMethods.class,
+ withSettings().extraInterfaces(List.class).name("great mockie"));
- //when
+ // when
String name = mock.toString();
- //then
+ // then
assertThat(name).contains("great mockie");
- //and
+ // and
assertTrue(mock instanceof List);
}
@Test
public void should_specify_mock_name_via_settings() {
- //given
+ // given
IMethods mock = mock(IMethods.class, withSettings().name("great mockie"));
- //when
+ // when
String name = mock.toString();
- //then
+ // then
assertThat(name).contains("great mockie");
}
@Test
public void should_scream_when_spy_created_with_wrong_type() {
- //given
+ // given
List list = new LinkedList();
try {
- //when
+ // when
mock(List.class, withSettings().spiedInstance(list));
fail();
- //then
- } catch (MockitoException e) {}
+ // then
+ } catch (MockitoException e) {
+ }
}
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
@@ -113,14 +116,15 @@
@Retention(RetentionPolicy.RUNTIME)
@interface SomeAnnotation {}
- @SomeAnnotation static class Foo {}
+ @SomeAnnotation
+ static class Foo {}
@Test
public void should_strip_annotations() {
Foo withAnnotations = mock(Foo.class);
Foo withoutAnnotations = mock(Foo.class, withSettings().withoutAnnotations());
- //expect:
+ // expect:
assertTrue(withAnnotations.getClass().isAnnotationPresent(SomeAnnotation.class));
assertFalse(withoutAnnotations.getClass().isAnnotationPresent(SomeAnnotation.class));
}
diff --git a/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java b/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java
index 31cdd04..749beeb 100644
--- a/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java
+++ b/src/test/java/org/mockitousage/basicapi/MocksSerializationForAnnotationTest.java
@@ -2,9 +2,18 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.basicapi;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+import static org.mockitoutil.SimpleSerializationUtil.*;
+
+import java.io.ByteArrayOutputStream;
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.List;
+import java.util.Observable;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.InOrder;
@@ -17,35 +26,39 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.io.ByteArrayOutputStream;
-import java.io.Serializable;
-import java.util.Collections;
-import java.util.List;
-import java.util.Observable;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-import static org.mockitoutil.SimpleSerializationUtil.*;
-
@SuppressWarnings({"unchecked", "serial"})
public class MocksSerializationForAnnotationTest extends TestBase implements Serializable {
private static final long serialVersionUID = 6160482220413048624L;
@Mock Any any;
- @Mock(serializable=true) Bar barMock;
- @Mock(serializable=true) IMethods imethodsMock;
- @Mock(serializable=true) IMethods imethodsMock2;
- @Mock(serializable=true) Any anyMock;
- @Mock(serializable=true) AlreadySerializable alreadySerializableMock;
- @Mock(extraInterfaces={List.class},serializable=true) IMethods imethodsWithExtraInterfacesMock;
+
+ @Mock(serializable = true)
+ Bar barMock;
+
+ @Mock(serializable = true)
+ IMethods imethodsMock;
+
+ @Mock(serializable = true)
+ IMethods imethodsMock2;
+
+ @Mock(serializable = true)
+ Any anyMock;
+
+ @Mock(serializable = true)
+ AlreadySerializable alreadySerializableMock;
+
+ @Mock(
+ extraInterfaces = {List.class},
+ serializable = true)
+ IMethods imethodsWithExtraInterfacesMock;
@Test
public void should_allow_throws_exception_to_be_serializable() throws Exception {
// given
when(barMock.doSomething()).thenAnswer(new ThrowsException(new RuntimeException()));
- //when-serialize then-deserialize
+ // when-serialize then-deserialize
serializeAndBack(barMock);
}
@@ -97,7 +110,8 @@
}
@Test
- public void should_serialize_method_call_with_parameters_that_are_serializable() throws Exception {
+ public void should_serialize_method_call_with_parameters_that_are_serializable()
+ throws Exception {
List<?> value = Collections.emptyList();
when(imethodsMock.objectArgMethod(value)).thenReturn(value);
@@ -148,8 +162,9 @@
// then
verify(readObject, times(2)).simpleMethod(1);
- //this test is working because it seems that java serialization mechanism replaces all instances
- //of serialized object in the object graph (if there are any)
+ // this test is working because it seems that java serialization mechanism replaces all
+ // instances
+ // of serialized object in the object graph (if there are any)
}
class Bar implements Serializable {
@@ -162,6 +177,7 @@
class Foo implements Serializable {
Bar bar;
+
Foo() {
bar = new Bar();
bar.foo = this;
@@ -170,17 +186,17 @@
@Test
public void should_serialization_work() throws Exception {
- //given
+ // given
Foo foo = new Foo();
- //when
+ // when
foo = serializeAndBack(foo);
- //then
+ // then
assertSame(foo, foo.bar.foo);
}
@Test
public void should_stub_even_if_some_methods_called_after_serialization() throws Exception {
- //given
+ // given
// when
when(imethodsMock.simpleMethod(1)).thenReturn("foo");
ByteArrayOutputStream serialized = serializeMock(imethodsMock);
@@ -228,7 +244,7 @@
// given
CustomAnswersMustImplementSerializableForSerializationToWork answer =
- new CustomAnswersMustImplementSerializableForSerializationToWork();
+ new CustomAnswersMustImplementSerializableForSerializationToWork();
answer.string = "return value";
when(imethodsMock.objectArgMethod(anyString())).thenAnswer(answer);
@@ -241,8 +257,9 @@
}
static class CustomAnswersMustImplementSerializableForSerializationToWork
- implements Answer<Object>, Serializable {
+ implements Answer<Object>, Serializable {
private String string;
+
public Object answer(InvocationOnMock invocation) throws Throwable {
invocation.getArguments();
invocation.getMock();
@@ -254,10 +271,13 @@
public void should_serialize_with_real_object_spy() throws Exception {
// given
SerializableSample list = new SerializableSample();
- SerializableSample spy = mock(SerializableSample.class, withSettings()
- .spiedInstance(list)
- .defaultAnswer(CALLS_REAL_METHODS)
- .serializable());
+ SerializableSample spy =
+ mock(
+ SerializableSample.class,
+ withSettings()
+ .spiedInstance(list)
+ .defaultAnswer(CALLS_REAL_METHODS)
+ .serializable());
when(spy.foo()).thenReturn("foo");
// when
@@ -306,29 +326,35 @@
@Test
public void should_be_serialize_and_have_extra_interfaces() throws Exception {
- //then
+ // then
Assertions.assertThat((Object) serializeAndBack((List) imethodsWithExtraInterfacesMock))
.isInstanceOf(List.class)
.isInstanceOf(IMethods.class);
}
static class NotSerializableAndNoDefaultConstructor {
- NotSerializableAndNoDefaultConstructor(Observable o) { super(); }
+ NotSerializableAndNoDefaultConstructor(Observable o) {
+ super();
+ }
}
static class SerializableAndNoDefaultConstructor implements Serializable {
- SerializableAndNoDefaultConstructor(Observable o) { super(); }
+ SerializableAndNoDefaultConstructor(Observable o) {
+ super();
+ }
}
public static class TestClassThatHoldValidField {
- @Mock(serializable=true)
+ @Mock(serializable = true)
SerializableAndNoDefaultConstructor serializableAndNoDefaultConstructor;
}
@Test
- public void should_be_able_to_serialize_type_that_implements_Serializable_but_but_dont_declare_a_no_arg_constructor() throws Exception {
+ public void
+ should_be_able_to_serialize_type_that_implements_Serializable_but_but_dont_declare_a_no_arg_constructor()
+ throws Exception {
TestClassThatHoldValidField testClass = new TestClassThatHoldValidField();
- MockitoAnnotations.initMocks(testClass);
+ MockitoAnnotations.openMocks(testClass);
serializeAndBack(testClass.serializableAndNoDefaultConstructor);
}
diff --git a/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java b/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java
index 02bcc3d..f1a4069 100644
--- a/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java
+++ b/src/test/java/org/mockitousage/basicapi/MocksSerializationTest.java
@@ -2,9 +2,20 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.basicapi;
+import static org.junit.Assert.*;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.Mockito.*;
+import static org.mockitoutil.SimpleSerializationUtil.*;
+
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.List;
+import java.util.Observable;
+
import net.bytebuddy.ClassFileVersion;
import org.assertj.core.api.Assertions;
import org.junit.Test;
@@ -18,18 +29,6 @@
import org.mockitoutil.SimpleSerializationUtil;
import org.mockitoutil.TestBase;
-import java.io.ByteArrayOutputStream;
-import java.io.ObjectStreamException;
-import java.io.Serializable;
-import java.util.Collections;
-import java.util.List;
-import java.util.Observable;
-
-import static org.junit.Assert.*;
-import static org.junit.Assume.assumeTrue;
-import static org.mockito.Mockito.*;
-import static org.mockitoutil.SimpleSerializationUtil.*;
-
@SuppressWarnings({"unchecked", "serial"})
public class MocksSerializationTest extends TestBase implements Serializable {
@@ -50,7 +49,7 @@
Foo fooMock = mock(Foo.class);
when(barMock.doSomething()).thenAnswer(new ThrowsException(new RuntimeException()));
- //when-serialize then-deserialize
+ // when-serialize then-deserialize
serializeAndBack(barMock);
}
@@ -108,7 +107,8 @@
}
@Test
- public void should_serialize_method_call_with_parameters_that_are_serializable() throws Exception {
+ public void should_serialize_method_call_with_parameters_that_are_serializable()
+ throws Exception {
IMethods mock = mock(IMethods.class, withSettings().serializable());
List<?> value = Collections.emptyList();
when(mock.objectArgMethod(value)).thenReturn(value);
@@ -152,7 +152,7 @@
@Test
public void should_verify_even_if_some_methods_called_after_serialization() throws Exception {
- //given
+ // given
IMethods mock = mock(IMethods.class, withSettings().serializable());
// when
@@ -164,8 +164,9 @@
// then
verify(readObject, times(2)).simpleMethod(1);
- //this test is working because it seems that java serialization mechanism replaces all instances
- //of serialized object in the object graph (if there are any)
+ // this test is working because it seems that java serialization mechanism replaces all
+ // instances
+ // of serialized object in the object graph (if there are any)
}
class Bar implements Serializable {
@@ -178,6 +179,7 @@
class Foo implements Serializable {
Bar bar;
+
Foo() {
bar = new Bar();
bar.foo = this;
@@ -186,17 +188,17 @@
@Test
public void should_serialization_work() throws Exception {
- //given
+ // given
Foo foo = new Foo();
- //when
+ // when
foo = serializeAndBack(foo);
- //then
+ // then
assertSame(foo, foo.bar.foo);
}
@Test
public void should_stub_even_if_some_methods_called_after_serialization() throws Exception {
- //given
+ // given
IMethods mock = mock(IMethods.class, withSettings().serializable());
// when
@@ -265,6 +267,7 @@
class CustomAnswersMustImplementSerializableForSerializationToWork
implements Answer<Object>, Serializable {
private String string;
+
public Object answer(InvocationOnMock invocation) throws Throwable {
invocation.getArguments();
invocation.getMock();
@@ -276,10 +279,13 @@
public void should_serialize_with_real_object_spy() throws Exception {
// given
SerializableClass sample = new SerializableClass();
- SerializableClass spy = mock(SerializableClass.class, withSettings()
- .spiedInstance(sample)
- .defaultAnswer(CALLS_REAL_METHODS)
- .serializable());
+ SerializableClass spy =
+ mock(
+ SerializableClass.class,
+ withSettings()
+ .spiedInstance(sample)
+ .defaultAnswer(CALLS_REAL_METHODS)
+ .serializable());
when(spy.foo()).thenReturn("foo");
// when
@@ -333,11 +339,13 @@
@Test
public void should_be_serialize_and_have_extra_interfaces() throws Exception {
- //when
- IMethods mock = mock(IMethods.class, withSettings().serializable().extraInterfaces(List.class));
- IMethods mockTwo = mock(IMethods.class, withSettings().extraInterfaces(List.class).serializable());
+ // when
+ IMethods mock =
+ mock(IMethods.class, withSettings().serializable().extraInterfaces(List.class));
+ IMethods mockTwo =
+ mock(IMethods.class, withSettings().extraInterfaces(List.class).serializable());
- //then
+ // then
Assertions.assertThat((Object) serializeAndBack((List) mock))
.isInstanceOf(List.class)
.isInstanceOf(IMethods.class);
@@ -347,28 +355,34 @@
}
static class SerializableAndNoDefaultConstructor implements Serializable {
- SerializableAndNoDefaultConstructor(Observable o) { super(); }
+ SerializableAndNoDefaultConstructor(Observable o) {
+ super();
+ }
}
@Test
- public void should_be_able_to_serialize_type_that_implements_Serializable_but_but_dont_declare_a_no_arg_constructor() throws Exception {
+ public void
+ should_be_able_to_serialize_type_that_implements_Serializable_but_but_dont_declare_a_no_arg_constructor()
+ throws Exception {
serializeAndBack(mock(SerializableAndNoDefaultConstructor.class));
}
-
-
public static class AClassWithPrivateNoArgConstructor {
private AClassWithPrivateNoArgConstructor() {}
- List returningSomething() { return Collections.emptyList(); }
+
+ List returningSomething() {
+ return Collections.emptyList();
+ }
}
@Test
- public void private_constructor_currently_not_supported_at_the_moment_at_deserialization_time() throws Exception {
+ public void private_constructor_currently_not_supported_at_the_moment_at_deserialization_time()
+ throws Exception {
// given
- AClassWithPrivateNoArgConstructor mockWithPrivateConstructor = Mockito.mock(
- AClassWithPrivateNoArgConstructor.class,
- Mockito.withSettings().serializable()
- );
+ AClassWithPrivateNoArgConstructor mockWithPrivateConstructor =
+ Mockito.mock(
+ AClassWithPrivateNoArgConstructor.class,
+ Mockito.withSettings().serializable());
try {
// when
@@ -380,14 +394,17 @@
}
}
-
@Test
public void BUG_ISSUE_399_try_some_mocks_with_current_answers() throws Exception {
assumeTrue(ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V7));
- IMethods iMethods = mock(IMethods.class, withSettings().serializable().defaultAnswer(RETURNS_DEEP_STUBS));
+ IMethods iMethods =
+ mock(
+ IMethods.class,
+ withSettings().serializable().defaultAnswer(RETURNS_DEEP_STUBS));
- when(iMethods.iMethodsReturningMethod().linkedListReturningMethod().contains(anyString())).thenReturn(false);
+ when(iMethods.iMethodsReturningMethod().linkedListReturningMethod().contains(anyString()))
+ .thenReturn(false);
serializeAndBack(iMethods);
}
diff --git a/src/test/java/org/mockitousage/basicapi/ObjectsSerializationTest.java b/src/test/java/org/mockitousage/basicapi/ObjectsSerializationTest.java
index 6ada79d..c3c668c 100644
--- a/src/test/java/org/mockitousage/basicapi/ObjectsSerializationTest.java
+++ b/src/test/java/org/mockitousage/basicapi/ObjectsSerializationTest.java
@@ -2,25 +2,27 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.basicapi;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
-import java.io.Serializable;
-
import static org.junit.Assert.assertSame;
import static org.mockitoutil.SimpleSerializationUtil.serializeAndBack;
+import java.io.Serializable;
+
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
@SuppressWarnings("serial")
public class ObjectsSerializationTest extends TestBase implements Serializable {
- //Ok, this test has nothing to do with mocks but it shows fundamental feature of java serialization that
- //plays important role in mocking:
- //Serialization/deserialization actually replaces all instances of serialized object in the object graph (if there are any)
- //thanks to that mechanizm, stubbing & verification can correctly match method invocations because
- //one of the parts of invocation matching is checking if mock object is the same
+ // Ok, this test has nothing to do with mocks but it shows fundamental feature of java
+ // serialization that
+ // plays important role in mocking:
+ // Serialization/deserialization actually replaces all instances of serialized object in the
+ // object graph (if there are any)
+ // thanks to that mechanizm, stubbing & verification can correctly match method invocations
+ // because
+ // one of the parts of invocation matching is checking if mock object is the same
class Bar implements Serializable {
Foo foo;
@@ -28,6 +30,7 @@
class Foo implements Serializable {
Bar bar;
+
Foo() {
bar = new Bar();
bar.foo = this;
@@ -36,11 +39,11 @@
@Test
public void shouldSerializationWork() throws Exception {
- //given
+ // given
Foo foo = new Foo();
- //when
+ // when
foo = serializeAndBack(foo);
- //then
+ // then
assertSame(foo, foo.bar.foo);
}
}
diff --git a/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java b/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java
index 52be3ff..72903f9 100644
--- a/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java
+++ b/src/test/java/org/mockitousage/basicapi/ReplacingObjectMethodsTest.java
@@ -2,28 +2,30 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.basicapi;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
import org.junit.Test;
import org.mockito.Mockito;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-
public class ReplacingObjectMethodsTest extends TestBase {
private interface DummyInterface {}
+
private class DummyClass {}
@Test
public void shouldProvideMockyImplementationOfToString() {
DummyClass dummyClass = Mockito.mock(DummyClass.class);
- assertEquals("Mock for DummyClass, hashCode: " + dummyClass.hashCode(), dummyClass.toString());
+ assertEquals(
+ "Mock for DummyClass, hashCode: " + dummyClass.hashCode(), dummyClass.toString());
DummyInterface dummyInterface = Mockito.mock(DummyInterface.class);
- assertEquals("Mock for DummyInterface, hashCode: " + dummyInterface.hashCode(), dummyInterface.toString());
+ assertEquals(
+ "Mock for DummyInterface, hashCode: " + dummyInterface.hashCode(),
+ dummyInterface.toString());
}
@Test
@@ -52,16 +54,20 @@
public static class ObjectMethodsOverridden {
public boolean equals(Object o) {
- throw new RuntimeException("Should not be called. MethodInterceptorFilter provides implementation");
+ throw new RuntimeException(
+ "Should not be called. MethodInterceptorFilter provides implementation");
}
+
public int hashCode() {
- throw new RuntimeException("Should not be called. MethodInterceptorFilter provides implementation");
+ throw new RuntimeException(
+ "Should not be called. MethodInterceptorFilter provides implementation");
}
+
public String toString() {
- throw new RuntimeException("Should not be called. MethodInterceptorFilter provides implementation");
+ throw new RuntimeException(
+ "Should not be called. MethodInterceptorFilter provides implementation");
}
}
- public static class ObjectMethodsOverriddenSubclass extends ObjectMethodsOverridden {
- }
+ public static class ObjectMethodsOverriddenSubclass extends ObjectMethodsOverridden {}
}
diff --git a/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java b/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java
index d9ad35d..e6f2caf 100644
--- a/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java
+++ b/src/test/java/org/mockitousage/basicapi/ResetInvocationsTest.java
@@ -4,22 +4,20 @@
*/
package org.mockitousage.basicapi;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.exceptions.misusing.NotAMockException;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.*;
-
public class ResetInvocationsTest extends TestBase {
- @Mock
- IMethods methods;
+ @Mock IMethods methods;
- @Mock
- IMethods moarMethods;
+ @Mock IMethods moarMethods;
@Test
public void reset_invocations_should_reset_only_invocations() {
@@ -51,6 +49,6 @@
@Test(expected = NotAMockException.class)
public void resettingNullIsSafe() {
- clearInvocations(new Object[]{null});
+ clearInvocations(new Object[] {null});
}
}
diff --git a/src/test/java/org/mockitousage/basicapi/ResetTest.java b/src/test/java/org/mockitousage/basicapi/ResetTest.java
index ef199a5..8f4d723 100644
--- a/src/test/java/org/mockitousage/basicapi/ResetTest.java
+++ b/src/test/java/org/mockitousage/basicapi/ResetTest.java
@@ -4,6 +4,10 @@
*/
package org.mockitousage.basicapi;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.exceptions.misusing.MissingMethodInvocationException;
@@ -12,17 +16,11 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.*;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
-
public class ResetTest extends TestBase {
- @Mock
- private IMethods mock;
+ @Mock private IMethods mock;
- @Mock
- private IMethods mockTwo;
+ @Mock private IMethods mockTwo;
@Test
public void shouldResetOngoingStubbingSoThatMoreMeaningfulExceptionsAreRaised() {
@@ -42,7 +40,7 @@
@Test(expected = NotAMockException.class)
public void resettingNullIsSafe() {
- reset(new Object[]{null});
+ reset(new Object[] {null});
}
@Test
@@ -51,7 +49,8 @@
when(mock.objectReturningMethod(200)).thenReturn(200);
reset(mock);
assertNull(mock.objectReturningMethod(200));
- assertEquals("default behavior should return null", null, mock.objectReturningMethod("blah"));
+ assertEquals(
+ "default behavior should return null", null, mock.objectReturningMethod("blah"));
}
@Test
@@ -62,6 +61,13 @@
}
@Test
+ public void shouldRemoveAllInteractionsVerifyNoInteractions() throws Exception {
+ mock.simpleMethod(1);
+ reset(mock);
+ verifyNoInteractions(mock);
+ }
+
+ @Test
public void shouldRemoveStubbingToString() throws Exception {
IMethods mockTwo = mock(IMethods.class);
when(mockTwo.toString()).thenReturn("test");
@@ -78,6 +84,14 @@
}
@Test
+ public void shouldStubbingNotBeTreatedAsInteractionVerifyNoInteractions() {
+ when(mock.simpleMethod("one")).thenThrow(new RuntimeException());
+ doThrow(new RuntimeException()).when(mock).simpleMethod("two");
+ reset(mock);
+ verifyNoInteractions(mock);
+ }
+
+ @Test
public void shouldNotAffectMockName() {
IMethods mock = mock(IMethods.class, "mockie");
IMethods mockTwo = mock(IMethods.class);
@@ -97,7 +111,7 @@
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
@Test
public void shouldValidateStateWhenResetting() {
- //invalid verify:
+ // invalid verify:
verify(mock);
try {
@@ -109,11 +123,11 @@
@Test
public void shouldMaintainPreviousDefaultAnswer() {
- //given
+ // given
mock = mock(IMethods.class, RETURNS_MOCKS);
- //when
+ // when
reset(mock);
- //then
+ // then
assertNotNull(mock.iMethodsReturningMethod());
}
}
diff --git a/src/test/java/org/mockitousage/basicapi/UsingVarargsTest.java b/src/test/java/org/mockitousage/basicapi/UsingVarargsTest.java
index 3e4faaf..4e9fc59 100644
--- a/src/test/java/org/mockitousage/basicapi/UsingVarargsTest.java
+++ b/src/test/java/org/mockitousage/basicapi/UsingVarargsTest.java
@@ -2,30 +2,33 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.basicapi;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
-import org.mockitoutil.TestBase;
-
-import java.util.ArrayList;
-
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.*;
+import java.util.ArrayList;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockitoutil.TestBase;
+
public class UsingVarargsTest extends TestBase {
private interface IVarArgs {
void withStringVarargs(int value, String... s);
+
String withStringVarargsReturningString(int value, String... s);
+
void withObjectVarargs(int value, Object... o);
+
boolean withBooleanVarargs(int value, boolean... b);
- int foo(Object ... objects);
+
+ int foo(Object... objects);
}
@Mock IVarArgs mock;
@@ -83,7 +86,8 @@
try {
verify(mock).withStringVarargs(2, "1", "2", "79", "4");
fail();
- } catch (ArgumentsAreDifferent e) {}
+ } catch (ArgumentsAreDifferent e) {
+ }
}
@Test
@@ -97,7 +101,8 @@
try {
verifyNoMoreInteractions(mock);
fail();
- } catch (NoInteractionsWanted e) {}
+ } catch (NoInteractionsWanted e) {
+ }
}
@Test
@@ -111,7 +116,8 @@
try {
verify(mock).withBooleanVarargs(3, true, true, true, true);
fail();
- } catch (ArgumentsAreDifferent e) {}
+ } catch (ArgumentsAreDifferent e) {
+ }
}
@Test
@@ -136,41 +142,42 @@
interface MixedVarargs {
String doSomething(String one, String... varargs);
+
String doSomething(String one, String two, String... varargs);
}
@SuppressWarnings("all")
@Test
- //See bug #31
+ // See bug #31
public void shouldStubCorrectlyWhenMixedVarargsUsed() {
MixedVarargs mixedVarargs = mock(MixedVarargs.class);
- when(mixedVarargs.doSomething("hello", (String[])null)).thenReturn("hello");
- when(mixedVarargs.doSomething("goodbye", (String[])null)).thenReturn("goodbye");
+ when(mixedVarargs.doSomething("hello", (String[]) null)).thenReturn("hello");
+ when(mixedVarargs.doSomething("goodbye", (String[]) null)).thenReturn("goodbye");
- String result = mixedVarargs.doSomething("hello",(String[]) null);
+ String result = mixedVarargs.doSomething("hello", (String[]) null);
assertEquals("hello", result);
- verify(mixedVarargs).doSomething("hello", (String[])null);
+ verify(mixedVarargs).doSomething("hello", (String[]) null);
}
@SuppressWarnings("all")
@Test
public void shouldStubCorrectlyWhenDoubleStringAndMixedVarargsUsed() {
MixedVarargs mixedVarargs = mock(MixedVarargs.class);
- when(mixedVarargs.doSomething("one", "two", (String[])null)).thenReturn("hello");
- when(mixedVarargs.doSomething("1", "2", (String[])null)).thenReturn("goodbye");
+ when(mixedVarargs.doSomething("one", "two", (String[]) null)).thenReturn("hello");
+ when(mixedVarargs.doSomething("1", "2", (String[]) null)).thenReturn("goodbye");
- String result = mixedVarargs.doSomething("one", "two", (String[])null);
+ String result = mixedVarargs.doSomething("one", "two", (String[]) null);
assertEquals("hello", result);
}
@Test
- //See bug #157
+ // See bug #157
public void shouldMatchEasilyEmptyVararg() throws Exception {
- //when
+ // when
when(mock.foo(anyVararg())).thenReturn(-1);
- //then
+ // then
assertEquals(-1, mock.foo());
}
}
diff --git a/src/test/java/org/mockitousage/bugs/AIOOBExceptionWithAtLeastTest.java b/src/test/java/org/mockitousage/bugs/AIOOBExceptionWithAtLeastTest.java
index 58c83f5..f712724 100644
--- a/src/test/java/org/mockitousage/bugs/AIOOBExceptionWithAtLeastTest.java
+++ b/src/test/java/org/mockitousage/bugs/AIOOBExceptionWithAtLeastTest.java
@@ -2,20 +2,21 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockitoutil.TestBase;
-import static org.mockito.Mockito.*;
-
-//see bug 116
+// see bug 116
public class AIOOBExceptionWithAtLeastTest extends TestBase {
interface IProgressMonitor {
void beginTask(String s, int i);
+
void worked(int i);
+
void done();
}
diff --git a/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java b/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java
index 632c8c9..c426e91 100644
--- a/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java
+++ b/src/test/java/org/mockitousage/bugs/ActualInvocationHasNullArgumentNPEBugTest.java
@@ -2,15 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.fail;
import static org.mockito.Mockito.*;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
public class ActualInvocationHasNullArgumentNPEBugTest extends TestBase {
public interface Fun {
@@ -19,18 +18,18 @@
@Test
public void shouldAllowPassingNullArgument() {
- //given
+ // given
Fun mockFun = mock(Fun.class);
when(mockFun.doFun((String) anyObject())).thenReturn("value");
- //when
+ // when
mockFun.doFun(null);
- //then
+ // then
try {
verify(mockFun).doFun("hello");
- } catch(AssertionError r) {
- //it's ok, we just want to reproduce the bug
+ } catch (AssertionError r) {
+ // it's ok, we just want to reproduce the bug
return;
}
fail();
diff --git a/src/test/java/org/mockitousage/bugs/ArgumentCaptorDontCapturePreviouslyVerifiedTest.java b/src/test/java/org/mockitousage/bugs/ArgumentCaptorDontCapturePreviouslyVerifiedTest.java
index 78181b2..0e6fcb3 100644
--- a/src/test/java/org/mockitousage/bugs/ArgumentCaptorDontCapturePreviouslyVerifiedTest.java
+++ b/src/test/java/org/mockitousage/bugs/ArgumentCaptorDontCapturePreviouslyVerifiedTest.java
@@ -4,15 +4,15 @@
*/
package org.mockitousage.bugs;
-import org.junit.Test;
-import org.mockito.ArgumentCaptor;
-import org.mockitousage.IMethods;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockitousage.IMethods;
+
public class ArgumentCaptorDontCapturePreviouslyVerifiedTest {
@Test
public void previous_verified_invocation_should_still_capture_args() {
diff --git a/src/test/java/org/mockitousage/bugs/AtLeastMarksAllInvocationsVerified.java b/src/test/java/org/mockitousage/bugs/AtLeastMarksAllInvocationsVerified.java
index 5cefa01..fc582ee 100644
--- a/src/test/java/org/mockitousage/bugs/AtLeastMarksAllInvocationsVerified.java
+++ b/src/test/java/org/mockitousage/bugs/AtLeastMarksAllInvocationsVerified.java
@@ -4,23 +4,22 @@
*/
package org.mockitousage.bugs;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockitoutil.TestBase;
-import static org.mockito.Mockito.*;
-
// see issue 112
public class AtLeastMarksAllInvocationsVerified extends TestBase {
public static class SomeMethods {
- public void allowedMethod() {
- }
- public void disallowedMethod() {
- }
+ public void allowedMethod() {}
+
+ public void disallowedMethod() {}
}
@Test(expected = org.mockito.exceptions.verification.NoInteractionsWanted.class)
- public void shouldFailBecauseDisallowedMethodWasCalled(){
+ public void shouldFailBecauseDisallowedMethodWasCalled() {
SomeMethods someMethods = mock(SomeMethods.class);
someMethods.allowedMethod();
diff --git a/src/test/java/org/mockitousage/bugs/BridgeMethodsHitAgainTest.java b/src/test/java/org/mockitousage/bugs/BridgeMethodsHitAgainTest.java
index 515758e..c5f1b63 100644
--- a/src/test/java/org/mockitousage/bugs/BridgeMethodsHitAgainTest.java
+++ b/src/test/java/org/mockitousage/bugs/BridgeMethodsHitAgainTest.java
@@ -2,59 +2,59 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import java.io.Serializable;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockitoutil.TestBase;
-import java.io.Serializable;
-
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-//see issue 101
+// see issue 101
public class BridgeMethodsHitAgainTest extends TestBase {
- public interface Factory {}
- public interface ExtendedFactory extends Factory {}
+ public interface Factory {}
- public interface SomeInterface {
- Factory factory();
- }
+ public interface ExtendedFactory extends Factory {}
- public interface SomeSubInterface extends SomeInterface {
- ExtendedFactory factory();
- }
+ public interface SomeInterface {
+ Factory factory();
+ }
- public interface Base<T extends Serializable> {
- int test(T value);
- }
+ public interface SomeSubInterface extends SomeInterface {
+ ExtendedFactory factory();
+ }
- public interface Extended extends Base<String> {
- @Override
- int test(String value);
- }
+ public interface Base<T extends Serializable> {
+ int test(T value);
+ }
- @Mock SomeSubInterface someSubInterface;
- @Mock ExtendedFactory extendedFactory;
+ public interface Extended extends Base<String> {
+ @Override
+ int test(String value);
+ }
- @Test
- public void basicCheck() {
- Mockito.when((someSubInterface).factory()).thenReturn(extendedFactory);
- SomeInterface si = someSubInterface;
- assertTrue(si.factory() != null);
- }
+ @Mock SomeSubInterface someSubInterface;
+ @Mock ExtendedFactory extendedFactory;
- @Test
- public void checkWithExtraCast() {
- Mockito.when(((SomeInterface) someSubInterface).factory()).thenReturn(extendedFactory);
- SomeInterface si = someSubInterface;
- assertTrue(si.factory() != null);
- }
+ @Test
+ public void basicCheck() {
+ Mockito.when((someSubInterface).factory()).thenReturn(extendedFactory);
+ SomeInterface si = someSubInterface;
+ assertTrue(si.factory() != null);
+ }
+
+ @Test
+ public void checkWithExtraCast() {
+ Mockito.when(((SomeInterface) someSubInterface).factory()).thenReturn(extendedFactory);
+ SomeInterface si = someSubInterface;
+ assertTrue(si.factory() != null);
+ }
@Test
public void testBridgeInvocationIsRecordedForInterceptedMethod() {
diff --git a/src/test/java/org/mockitousage/bugs/CaptorAnnotationAutoboxingTest.java b/src/test/java/org/mockitousage/bugs/CaptorAnnotationAutoboxingTest.java
index e5898a2..78c70e9 100644
--- a/src/test/java/org/mockitousage/bugs/CaptorAnnotationAutoboxingTest.java
+++ b/src/test/java/org/mockitousage/bugs/CaptorAnnotationAutoboxingTest.java
@@ -2,24 +2,24 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-
-//see issue 188
+// see issue 188
public class CaptorAnnotationAutoboxingTest extends TestBase {
interface Fun {
void doFun(double prmitive);
+
void moreFun(int howMuch);
}
@@ -28,10 +28,10 @@
@Test
public void shouldAutoboxSafely() {
- //given
+ // given
fun.doFun(1.0);
- //then
+ // then
verify(fun).doFun(captor.capture());
assertEquals(Double.valueOf(1.0), captor.getValue());
}
diff --git a/src/test/java/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java b/src/test/java/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java
index 46aa271..e9b9c11 100644
--- a/src/test/java/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java
+++ b/src/test/java/org/mockitousage/bugs/ClassCastExOnVerifyZeroInteractionsTest.java
@@ -4,15 +4,15 @@
*/
package org.mockitousage.bugs;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
import org.junit.Test;
import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
import org.mockito.exceptions.verification.NoInteractionsWanted;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verifyZeroInteractions;
-
public class ClassCastExOnVerifyZeroInteractionsTest {
public interface TestMock {
boolean m1();
@@ -20,23 +20,29 @@
@Test(expected = NoInteractionsWanted.class)
public void should_not_throw_ClassCastException_when_mock_verification_fails() {
- TestMock test = mock(TestMock.class, new Answer<Object>() {
- public Object answer(InvocationOnMock invocation) throws Throwable {
- return false;
- }
- });
+ TestMock test =
+ mock(
+ TestMock.class,
+ new Answer<Object>() {
+ public Object answer(InvocationOnMock invocation) throws Throwable {
+ return false;
+ }
+ });
test.m1();
verifyZeroInteractions(test);
}
@Test(expected = WrongTypeOfReturnValue.class)
public void should_report_bogus_default_answer() throws Exception {
- TestMock test = mock(TestMock.class, new Answer<Object>() {
- public Object answer(InvocationOnMock invocation) throws Throwable {
- return false;
- }
- });
+ TestMock test =
+ mock(
+ TestMock.class,
+ new Answer<Object>() {
+ public Object answer(InvocationOnMock invocation) throws Throwable {
+ return false;
+ }
+ });
- test.toString();
+ String ignored = test.toString();
}
}
diff --git a/src/test/java/org/mockitousage/bugs/CompareMatcherTest.java b/src/test/java/org/mockitousage/bugs/CompareMatcherTest.java
index bc80a56..2401995 100644
--- a/src/test/java/org/mockitousage/bugs/CompareMatcherTest.java
+++ b/src/test/java/org/mockitousage/bugs/CompareMatcherTest.java
@@ -12,6 +12,7 @@
import static org.mockito.Mockito.when;
import java.util.Date;
+
import org.junit.Rule;
import org.junit.Test;
import org.mockito.ArgumentMatcher;
@@ -23,11 +24,9 @@
public class CompareMatcherTest {
private static final Object NOT_A_COMPARABLE = new Object();
- @Rule
- public MockitoRule mockitoRule = MockitoJUnit.rule();
+ @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
- @Mock
- public IMethods mock;
+ @Mock public IMethods mock;
/**
* Should not throw an {@link NullPointerException}
@@ -40,7 +39,7 @@
when(mock.forInteger(leq(5))).thenReturn("");
- assertThat(mock.forInteger(null)).isNull();// a default value must be returned
+ assertThat(mock.forInteger(null)).isNull(); // a default value must be returned
}
/**
@@ -50,7 +49,7 @@
public void compareToNonCompareable() {
when(mock.forObject(leq(5))).thenReturn("");
- assertThat(mock.forObject(NOT_A_COMPARABLE)).isNull();// a default value must be returned
+ assertThat(mock.forObject(NOT_A_COMPARABLE)).isNull(); // a default value must be returned
}
/**
@@ -60,7 +59,7 @@
public void compareToNull() {
when(mock.forInteger(leq((Integer) null))).thenReturn("");
- assertThat(mock.forInteger(null)).isNull();// a default value must be returned
+ assertThat(mock.forInteger(null)).isNull(); // a default value must be returned
}
/**
@@ -70,7 +69,7 @@
public void compareToStringVsInt() {
when(mock.forObject(startsWith("Hello"))).thenReturn("");
- assertThat(mock.forObject(123)).isNull();// a default value must be returned
+ assertThat(mock.forObject(123)).isNull(); // a default value must be returned
}
@Test
@@ -97,7 +96,6 @@
public boolean matches(Integer arg, Void v) {
throw new UnsupportedOperationException();
}
-
}
when(mock.forObject(argThat(new TestMatcher()))).thenReturn("x");
@@ -131,5 +129,4 @@
assertThat(mock.forObject(123)).isNull();
}
-
}
diff --git a/src/test/java/org/mockitousage/bugs/ConcurrentModificationExceptionOnMultiThreadedVerificationTest.java b/src/test/java/org/mockitousage/bugs/ConcurrentModificationExceptionOnMultiThreadedVerificationTest.java
index bc52c41..46cbb95 100644
--- a/src/test/java/org/mockitousage/bugs/ConcurrentModificationExceptionOnMultiThreadedVerificationTest.java
+++ b/src/test/java/org/mockitousage/bugs/ConcurrentModificationExceptionOnMultiThreadedVerificationTest.java
@@ -4,16 +4,16 @@
*/
package org.mockitousage.bugs;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mockito;
+import static org.mockito.Mockito.*;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
-import static org.mockito.Mockito.*;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
// issue 322
// the only evidence of this failing test was shown on a RHEL with IBM J9 JVM 64bits
@@ -39,7 +39,8 @@
@Test
public void shouldSuccessfullyVerifyConcurrentInvocationsWithTimeout() throws Exception {
- int potentialOverhead = 1000; // Leave 1000ms extra before timing out as leeway for test overheads
+ int potentialOverhead =
+ 1000; // Leave 1000ms extra before timing out as leeway for test overheads
int expectedMaxTestLength = TIMES * INTERVAL_MILLIS + potentialOverhead;
reset(target);
@@ -49,13 +50,11 @@
verifyNoMoreInteractions(target);
}
- private void startInvocations() throws InterruptedException,
- ExecutionException {
+ private void startInvocations() throws InterruptedException, ExecutionException {
- for(int i=0; i<nThreads; i++) {
+ for (int i = 0; i < nThreads; i++) {
fixedThreadPool.submit(new TargetInvoker(i));
}
-
}
public class TargetInvoker implements Callable<Object> {
@@ -75,11 +74,9 @@
System.err.println("finished" + seq);
return seq;
}
-
}
public interface ITarget {
String targetMethod(String arg);
}
-
}
diff --git a/src/test/java/org/mockitousage/bugs/ConfusedSignatureTest.java b/src/test/java/org/mockitousage/bugs/ConfusedSignatureTest.java
index 8d79b54..99c638c 100644
--- a/src/test/java/org/mockitousage/bugs/ConfusedSignatureTest.java
+++ b/src/test/java/org/mockitousage/bugs/ConfusedSignatureTest.java
@@ -13,7 +13,8 @@
public class ConfusedSignatureTest {
@Test
- public void should_mock_method_which_has_generic_return_type_in_superclass_and_concrete_one_in_interface() {
+ public void
+ should_mock_method_which_has_generic_return_type_in_superclass_and_concrete_one_in_interface() {
Sub mock = mock(Sub.class);
// The following line resulted in
// org.mockito.exceptions.misusing.MissingMethodInvocationException:
@@ -31,12 +32,12 @@
this.value = value;
}
- public T getFoo() { return value; }
+ public T getFoo() {
+ return value;
+ }
}
- public class Sub
- extends Super<String>
- implements iInterface {
+ public class Sub extends Super<String> implements iInterface {
public Sub(String s) {
super(s);
diff --git a/src/test/java/org/mockitousage/bugs/CovariantOverrideTest.java b/src/test/java/org/mockitousage/bugs/CovariantOverrideTest.java
index 56f68a9..91d2486 100644
--- a/src/test/java/org/mockitousage/bugs/CovariantOverrideTest.java
+++ b/src/test/java/org/mockitousage/bugs/CovariantOverrideTest.java
@@ -2,16 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.*;
-//see issue 101
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
+// see issue 101
public class CovariantOverrideTest extends TestBase {
public interface ReturnsObject {
diff --git a/src/test/java/org/mockitousage/bugs/DiamondInheritanceIsConfusingMockitoTest.java b/src/test/java/org/mockitousage/bugs/DiamondInheritanceIsConfusingMockitoTest.java
index 4861dd5..e678594 100644
--- a/src/test/java/org/mockitousage/bugs/DiamondInheritanceIsConfusingMockitoTest.java
+++ b/src/test/java/org/mockitousage/bugs/DiamondInheritanceIsConfusingMockitoTest.java
@@ -31,12 +31,12 @@
this.value = value;
}
- public T getFoo() { return value; }
+ public T getFoo() {
+ return value;
+ }
}
- public class Sub
- extends Super<String>
- implements iInterface {
+ public class Sub extends Super<String> implements iInterface {
public Sub(String s) {
super(s);
diff --git a/src/test/java/org/mockitousage/bugs/EqualsWithDeltaTest.java b/src/test/java/org/mockitousage/bugs/EqualsWithDeltaTest.java
index 172b337..c87df91 100644
--- a/src/test/java/org/mockitousage/bugs/EqualsWithDeltaTest.java
+++ b/src/test/java/org/mockitousage/bugs/EqualsWithDeltaTest.java
@@ -4,12 +4,12 @@
*/
package org.mockitousage.bugs;
+import static org.assertj.core.api.Assertions.assertThat;
+
import org.junit.Test;
import org.mockito.ArgumentMatcher;
import org.mockito.internal.matchers.EqualsWithDelta;
-import static org.assertj.core.api.Assertions.assertThat;
-
public class EqualsWithDeltaTest {
@Test
diff --git a/src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java b/src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java
index 5e3193e..e22505a 100644
--- a/src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java
+++ b/src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java
@@ -4,14 +4,14 @@
*/
package org.mockitousage.bugs;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.when;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.when;
-
/**
* These tests check that ThrowsException#answer throws an instance returned
* by Throwable#fillInStackTrace of the provided throwable.
@@ -42,14 +42,15 @@
}
}
- //issue 866
+ // issue 866
@Test
public void avoids_NPE() {
when(mock.simpleMethod()).thenThrow(new NullStackTraceException());
try {
mock.simpleMethod();
fail();
- } catch(NullStackTraceException e) {}
+ } catch (NullStackTraceException e) {
+ }
}
@Test
@@ -58,6 +59,7 @@
try {
mock.simpleMethod();
fail();
- } catch(SomeException e) {}
+ } catch (SomeException e) {
+ }
}
}
diff --git a/src/test/java/org/mockitousage/bugs/FinalHashCodeAndEqualsRaiseNPEInInitMocksTest.java b/src/test/java/org/mockitousage/bugs/FinalHashCodeAndEqualsRaiseNPEInInitMocksTest.java
index e6c82cf..a2569cc 100644
--- a/src/test/java/org/mockitousage/bugs/FinalHashCodeAndEqualsRaiseNPEInInitMocksTest.java
+++ b/src/test/java/org/mockitousage/bugs/FinalHashCodeAndEqualsRaiseNPEInInitMocksTest.java
@@ -4,13 +4,13 @@
*/
package org.mockitousage.bugs;
+import java.nio.charset.Charset;
+
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import java.nio.charset.Charset;
-
// issue 327
public class FinalHashCodeAndEqualsRaiseNPEInInitMocksTest {
@Mock private Charset charset;
@@ -19,7 +19,7 @@
@Test
public void dont_raise_NullPointerException() throws Exception {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
}
private static class FieldCharsetHolder {
@@ -27,7 +27,6 @@
}
private static class ConstructorCharsetHolder {
- public ConstructorCharsetHolder(Charset charset) {
- }
+ public ConstructorCharsetHolder(Charset charset) {}
}
}
diff --git a/src/test/java/org/mockitousage/bugs/GenericsMockitoAnnotationsTest.java b/src/test/java/org/mockitousage/bugs/GenericsMockitoAnnotationsTest.java
index 51f2369..7c3f17e 100644
--- a/src/test/java/org/mockitousage/bugs/GenericsMockitoAnnotationsTest.java
+++ b/src/test/java/org/mockitousage/bugs/GenericsMockitoAnnotationsTest.java
@@ -4,27 +4,29 @@
*/
package org.mockitousage.bugs;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.MockitoAnnotations.openMocks;
import java.util.ArrayList;
import java.util.Collection;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.MockitoAnnotations.initMocks;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.mockito.Mock;
/**
* This was an issue reported in #1174.
*/
public class GenericsMockitoAnnotationsTest {
- @Mock
- private TestCollectionSourceProvider testCollectionSourceProvider;
+ @Mock private TestCollectionSourceProvider testCollectionSourceProvider;
+ @Ignore
@Test
public void should_not_throw_class_cast_exception() {
- given(testCollectionSourceProvider.getCollection(new ArrayList<Integer>())).willReturn(new ArrayList<Integer>());
+ given(testCollectionSourceProvider.getCollection(new ArrayList<Integer>()))
+ .willReturn(new ArrayList<Integer>());
}
static class TestCollectionSourceProvider {
@@ -35,6 +37,6 @@
@Before
public void setUp() throws Exception {
- initMocks(this);
+ openMocks(this);
}
}
diff --git a/src/test/java/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java b/src/test/java/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java
index 7d47a64..3d8db84 100644
--- a/src/test/java/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java
+++ b/src/test/java/org/mockitousage/bugs/IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest.java
@@ -4,18 +4,18 @@
*/
package org.mockitousage.bugs;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.stubbing.OngoingStubbing;
-
-import java.util.Map;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import java.util.Map;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.stubbing.OngoingStubbing;
+
public class IOOBExceptionShouldNotBeThrownWhenNotCodingFluentlyTest {
@Test
diff --git a/src/test/java/org/mockitousage/bugs/ImplementationOfGenericAbstractMethodNotInvokedOnSpyTest.java b/src/test/java/org/mockitousage/bugs/ImplementationOfGenericAbstractMethodNotInvokedOnSpyTest.java
index ad22bda..8dccfcb 100644
--- a/src/test/java/org/mockitousage/bugs/ImplementationOfGenericAbstractMethodNotInvokedOnSpyTest.java
+++ b/src/test/java/org/mockitousage/bugs/ImplementationOfGenericAbstractMethodNotInvokedOnSpyTest.java
@@ -4,11 +4,11 @@
*/
package org.mockitousage.bugs;
-import org.junit.Test;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.spy;
+import org.junit.Test;
+
public class ImplementationOfGenericAbstractMethodNotInvokedOnSpyTest {
public abstract class GenericAbstract<T> {
protected abstract String method_to_implement(T value);
diff --git a/src/test/java/org/mockitousage/bugs/InheritedGenericsPolimorphicCallTest.java b/src/test/java/org/mockitousage/bugs/InheritedGenericsPolimorphicCallTest.java
index ca5d92c..69cde91 100644
--- a/src/test/java/org/mockitousage/bugs/InheritedGenericsPolimorphicCallTest.java
+++ b/src/test/java/org/mockitousage/bugs/InheritedGenericsPolimorphicCallTest.java
@@ -2,12 +2,11 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockitoutil.TestBase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.verify;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
@@ -16,12 +15,12 @@
import java.util.LinkedList;
import java.util.List;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.verify;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockitoutil.TestBase;
@SuppressWarnings("unchecked")
-//see issue 200
+// see issue 200
public class InheritedGenericsPolimorphicCallTest extends TestBase {
protected interface MyIterable<T> extends Iterable<T> {
@@ -44,7 +43,7 @@
@Test
public void shouldVerificationWorks() {
- iterable.iterator();
+ MyIterator<String> unused = iterable.iterator();
verify(iterable).iterator();
verify((Iterable<String>) iterable).iterator();
@@ -52,24 +51,29 @@
@Test
public void shouldWorkExactlyAsJavaProxyWould() {
- //given
+ // given
final List<Method> methods = new LinkedList<Method>();
- InvocationHandler handler = new InvocationHandler() {
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- methods.add(method);
- return null;
- }};
+ InvocationHandler handler =
+ new InvocationHandler() {
+ public Object invoke(Object proxy, Method method, Object[] args)
+ throws Throwable {
+ methods.add(method);
+ return null;
+ }
+ };
- iterable = (MyIterable<String>) Proxy.newProxyInstance(
- this.getClass().getClassLoader(),
- new Class<?>[] { MyIterable.class },
- handler);
+ iterable =
+ (MyIterable<String>)
+ Proxy.newProxyInstance(
+ this.getClass().getClassLoader(),
+ new Class<?>[] {MyIterable.class},
+ handler);
- //when
- iterable.iterator();
- ((Iterable<String>) iterable).iterator();
+ // when
+ MyIterator<String> unused = iterable.iterator();
+ Iterator<String> unused2 = ((Iterable<String>) iterable).iterator();
- //then
+ // then
assertEquals(2, methods.size());
assertEquals(methods.get(0), methods.get(1));
}
diff --git a/src/test/java/org/mockitousage/bugs/ListenersLostOnResetMockTest.java b/src/test/java/org/mockitousage/bugs/ListenersLostOnResetMockTest.java
index 61a5268..c9b2bcd 100644
--- a/src/test/java/org/mockitousage/bugs/ListenersLostOnResetMockTest.java
+++ b/src/test/java/org/mockitousage/bugs/ListenersLostOnResetMockTest.java
@@ -4,15 +4,14 @@
*/
package org.mockitousage.bugs;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
import org.junit.Test;
import org.mockito.listeners.InvocationListener;
import org.mockito.listeners.MethodInvocationReport;
-import java.util.List;
-
-import static org.mockito.Mockito.*;
-
public class ListenersLostOnResetMockTest {
@Test
diff --git a/src/test/java/org/mockitousage/bugs/MockitoRunnerBreaksWhenNoTestMethodsTest.java b/src/test/java/org/mockitousage/bugs/MockitoRunnerBreaksWhenNoTestMethodsTest.java
index 9abb4f5..312984c 100644
--- a/src/test/java/org/mockitousage/bugs/MockitoRunnerBreaksWhenNoTestMethodsTest.java
+++ b/src/test/java/org/mockitousage/bugs/MockitoRunnerBreaksWhenNoTestMethodsTest.java
@@ -2,11 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
import java.io.OutputStream;
import java.io.PrintStream;
+
import org.junit.Test;
import org.junit.internal.TextListener;
import org.junit.runner.JUnitCore;
@@ -16,18 +20,13 @@
import org.mockito.junit.MockitoJUnitRunner;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-
// @Ignore("for demo only. this test cannot be enabled as it fails :)")
public class MockitoRunnerBreaksWhenNoTestMethodsTest extends TestBase {
@Test
public void ensure_the_test_runner_breaks() throws Exception {
JUnitCore runner = new JUnitCore();
-// runner.addListener(new TextListener(System.out));
+ // runner.addListener(new TextListener(System.out));
runner.addListener(new TextListener(DevNull.out));
Result result = runner.run(TestClassWithoutTestMethod.class);
@@ -39,17 +38,22 @@
@RunWith(MockitoJUnitRunner.class)
static class TestClassWithoutTestMethod { // package visibility is important
- public void notATestMethod() { }
+ public void notATestMethod() {}
}
public static final class DevNull {
- public final static PrintStream out = new PrintStream(new OutputStream() {
- public void close() {}
- public void flush() {}
- public void write(byte[] b) {}
- public void write(byte[] b, int off, int len) {}
- public void write(int b) {}
+ public static final PrintStream out =
+ new PrintStream(
+ new OutputStream() {
+ public void close() {}
- } );
+ public void flush() {}
+
+ public void write(byte[] b) {}
+
+ public void write(byte[] b, int off, int len) {}
+
+ public void write(int b) {}
+ });
}
}
diff --git a/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java b/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java
index d9720f9..1cf9268 100644
--- a/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java
+++ b/src/test/java/org/mockitousage/bugs/MockitoStubbedCallInAnswerTest.java
@@ -4,15 +4,15 @@
*/
package org.mockitousage.bugs;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.when;
-
/**
* @see <a href="https://github.com/mockito/mockito/issues/1279">Issue #1279</a>
*/
@@ -23,81 +23,92 @@
@Test
public void stubbing_the_right_mock() throws Exception {
- //stubbing on different mock should not be altered
+ // stubbing on different mock should not be altered
when(bar.doInt()).thenReturn(0);
- when(foo.doInt()).thenAnswer(new Answer<Integer>() {
- @Override
- public Integer answer(InvocationOnMock invocation) throws Throwable {
- return bar.doInt();
- }
- });
+ when(foo.doInt())
+ .thenAnswer(
+ new Answer<Integer>() {
+ @Override
+ public Integer answer(InvocationOnMock invocation) throws Throwable {
+ return bar.doInt();
+ }
+ });
assertEquals(0, foo.doInt());
assertEquals(0, bar.doInt());
- //when we override the stubbing
+ // when we override the stubbing
when(foo.doInt()).thenReturn(1);
- //we expect it to be reflected:
+ // we expect it to be reflected:
assertEquals(1, foo.doInt());
- //but the stubbing on a different mock should not be altered:
+ // but the stubbing on a different mock should not be altered:
assertEquals(0, bar.doInt());
}
@Test
public void return_type_validation() throws Exception {
- when(foo.doString()).thenAnswer(new Answer<String>() {
- public String answer(InvocationOnMock invocation) throws Throwable {
- //invoking a method on a different mock, with different return type
- return String.valueOf(bar.doInt());
- }
- });
+ when(foo.doString())
+ .thenAnswer(
+ new Answer<String>() {
+ public String answer(InvocationOnMock invocation) throws Throwable {
+ // invoking a method on a different mock, with different return type
+ return String.valueOf(bar.doInt());
+ }
+ });
assertEquals("0", foo.doString());
- //we can override stubbing without misleading return type validation errors:
+ // we can override stubbing without misleading return type validation errors:
when(foo.doString()).thenReturn("");
assertEquals("", foo.doString());
}
@Test
public void prevents_stack_overflow() throws Exception {
- when(foo.doInt()).thenAnswer(new Answer<Integer>() {
- public Integer answer(InvocationOnMock invocation) throws Throwable {
- return bar.doInt();
- }
- });
+ when(foo.doInt())
+ .thenAnswer(
+ new Answer<Integer>() {
+ public Integer answer(InvocationOnMock invocation) throws Throwable {
+ return bar.doInt();
+ }
+ });
assertEquals(0, foo.doInt());
- when(foo.doInt()).thenAnswer(new Answer<Integer>() {
- public Integer answer(InvocationOnMock invocation) throws Throwable {
- return bar.doInt() + 1;
- }
- });
+ when(foo.doInt())
+ .thenAnswer(
+ new Answer<Integer>() {
+ public Integer answer(InvocationOnMock invocation) throws Throwable {
+ return bar.doInt() + 1;
+ }
+ });
- //calling below used to cause SO error
+ // calling below used to cause SO error
assertEquals(1, foo.doInt());
}
@Test
public void overriding_stubbing() throws Exception {
when(bar.doInt()).thenReturn(10);
- when(foo.doInt()).thenAnswer(new Answer<Integer>() {
- public Integer answer(InvocationOnMock invocation) throws Throwable {
- return bar.doInt() + 1;
- }
- });
+ when(foo.doInt())
+ .thenAnswer(
+ new Answer<Integer>() {
+ public Integer answer(InvocationOnMock invocation) throws Throwable {
+ return bar.doInt() + 1;
+ }
+ });
assertEquals(11, foo.doInt());
- //when we override the stubbing with a different one
+ // when we override the stubbing with a different one
when(foo.doInt()).thenReturn(100);
- //we expect it to be reflected:
+ // we expect it to be reflected:
assertEquals(100, foo.doInt());
}
interface Foo {
String doString();
+
int doInt();
}
diff --git a/src/test/java/org/mockitousage/bugs/MultipleInOrdersTest.java b/src/test/java/org/mockitousage/bugs/MultipleInOrdersTest.java
index 41bde29..65472ff 100644
--- a/src/test/java/org/mockitousage/bugs/MultipleInOrdersTest.java
+++ b/src/test/java/org/mockitousage/bugs/MultipleInOrdersTest.java
@@ -4,21 +4,21 @@
*/
package org.mockitousage.bugs;
-import org.junit.Test;
-import org.mockito.InOrder;
-
-import java.util.List;
-
import static org.junit.Assert.assertNotSame;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+
@SuppressWarnings("unchecked")
public class MultipleInOrdersTest {
@Test
- public void inOrderTest(){
- List<String> list= mock(List.class);
+ public void inOrderTest() {
+ List<String> list = mock(List.class);
list.add("a");
list.add("x");
diff --git a/src/test/java/org/mockitousage/bugs/MultithreadedStubbingHalfManualTest.java b/src/test/java/org/mockitousage/bugs/MultithreadedStubbingHalfManualTest.java
index c0549b3..30a8eae 100644
--- a/src/test/java/org/mockitousage/bugs/MultithreadedStubbingHalfManualTest.java
+++ b/src/test/java/org/mockitousage/bugs/MultithreadedStubbingHalfManualTest.java
@@ -4,9 +4,11 @@
*/
package org.mockitousage.bugs;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
+import static java.util.Collections.synchronizedList;
+
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
import java.util.LinkedList;
import java.util.List;
@@ -14,10 +16,9 @@
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
-import static java.util.Collections.synchronizedList;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
@Ignore
public class MultithreadedStubbingHalfManualTest {
@@ -66,9 +67,9 @@
}
@Test
- //this problem shows at 4 out of 5 executions
- //it is not strictly a bug because Mockito does not support simultanous stubbing (see FAQ)
- //however I decided to synchronize some calls in order to make the exceptions nicer
+ // this problem shows at 4 out of 5 executions
+ // it is not strictly a bug because Mockito does not support simultanous stubbing (see FAQ)
+ // however I decided to synchronize some calls in order to make the exceptions nicer
public void tryToRevealTheProblem() {
ToMock toMock = mock(ToMock.class);
for (int i = 0; i < 100; i++) {
@@ -76,8 +77,8 @@
// Repeated mocking
when(toMock.getValue(i)).thenReturn(j);
- //TODO make it also showing errors for doReturn()
-// doReturn(j).when(toMock).getValue(i);
+ // TODO make it also showing errors for doReturn()
+ // doReturn(j).when(toMock).getValue(i);
while (true) {
try {
@@ -90,7 +91,7 @@
}
try {
- Thread.sleep(10 / ((i % 10) + 1)); //NOPMD
+ Thread.sleep(10 / ((i % 10) + 1)); // NOPMD
} catch (InterruptedException e) {
}
}
diff --git a/src/test/java/org/mockitousage/bugs/NPEOnAnyClassMatcherAutounboxTest.java b/src/test/java/org/mockitousage/bugs/NPEOnAnyClassMatcherAutounboxTest.java
index b047a08..daa61c7 100644
--- a/src/test/java/org/mockitousage/bugs/NPEOnAnyClassMatcherAutounboxTest.java
+++ b/src/test/java/org/mockitousage/bugs/NPEOnAnyClassMatcherAutounboxTest.java
@@ -2,15 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockitoutil.TestBase;
-import static org.mockito.Mockito.*;
-
-//see issue 221
+// see issue 221
public class NPEOnAnyClassMatcherAutounboxTest extends TestBase {
interface Foo {
diff --git a/src/test/java/org/mockitousage/bugs/NPEWhenMockingThrowablesTest.java b/src/test/java/org/mockitousage/bugs/NPEWhenMockingThrowablesTest.java
index 712ee9b..a266efd 100644
--- a/src/test/java/org/mockitousage/bugs/NPEWhenMockingThrowablesTest.java
+++ b/src/test/java/org/mockitousage/bugs/NPEWhenMockingThrowablesTest.java
@@ -2,17 +2,16 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.when;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.when;
-
public class NPEWhenMockingThrowablesTest extends TestBase {
@Mock IMethods mock;
@@ -22,13 +21,14 @@
private static final long serialVersionUID = 1L;
}
- //issue 70
+ // issue 70
@Test
public void shouldNotThrowNPE() {
when(mock.simpleMethod()).thenThrow(mock2);
try {
mock.simpleMethod();
fail();
- } catch(DummyException e) {}
+ } catch (DummyException e) {
+ }
}
}
diff --git a/src/test/java/org/mockitousage/bugs/NPEWithCertainMatchersTest.java b/src/test/java/org/mockitousage/bugs/NPEWithCertainMatchersTest.java
index d1475d0..8864de8 100644
--- a/src/test/java/org/mockitousage/bugs/NPEWithCertainMatchersTest.java
+++ b/src/test/java/org/mockitousage/bugs/NPEWithCertainMatchersTest.java
@@ -4,16 +4,16 @@
*/
package org.mockitousage.bugs;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
import org.junit.After;
import org.junit.Test;
import org.mockito.Mock;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-
public class NPEWithCertainMatchersTest extends TestBase {
@Mock IMethods mock;
diff --git a/src/test/java/org/mockitousage/bugs/ShouldMocksCompareToBeConsistentWithEqualsTest.java b/src/test/java/org/mockitousage/bugs/ShouldMocksCompareToBeConsistentWithEqualsTest.java
index 085fffe..a695be9 100644
--- a/src/test/java/org/mockitousage/bugs/ShouldMocksCompareToBeConsistentWithEqualsTest.java
+++ b/src/test/java/org/mockitousage/bugs/ShouldMocksCompareToBeConsistentWithEqualsTest.java
@@ -2,72 +2,71 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.*;
import java.util.Date;
import java.util.Set;
import java.util.TreeSet;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.*;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
-//see issue 184
+// see issue 184
public class ShouldMocksCompareToBeConsistentWithEqualsTest extends TestBase {
@Test
public void should_compare_to_be_consistent_with_equals() {
- //given
- Date today = mock(Date.class);
+ // given
+ Date today = mock(Date.class);
Date tomorrow = mock(Date.class);
- //when
+ // when
Set<Date> set = new TreeSet<Date>();
set.add(today);
set.add(tomorrow);
- //then
+ // then
assertEquals(2, set.size());
}
@Test
public void should_compare_to_be_consistent_with_equals_when_comparing_the_same_reference() {
- //given
- Date today = mock(Date.class);
+ // given
+ Date today = mock(Date.class);
- //when
+ // when
Set<Date> set = new TreeSet<Date>();
set.add(today);
set.add(today);
- //then
+ // then
assertEquals(1, set.size());
}
@Test
public void should_allow_stubbing_and_verifying_compare_to() {
- //given
- Date mock = mock(Date.class);
+ // given
+ Date mock = mock(Date.class);
when(mock.compareTo(any(Date.class))).thenReturn(10);
- //when
+ // when
mock.compareTo(new Date());
- //then
+ // then
assertEquals(10, mock.compareTo(new Date()));
verify(mock, atLeastOnce()).compareTo(any(Date.class));
}
@Test
public void should_reset_not_remove_default_stubbing() {
- //given
- Date mock = mock(Date.class);
+ // given
+ Date mock = mock(Date.class);
reset(mock);
- //then
+ // then
assertEquals(1, mock.compareTo(new Date()));
}
}
diff --git a/src/test/java/org/mockitousage/bugs/ShouldNotDeadlockAnswerExecutionTest.java b/src/test/java/org/mockitousage/bugs/ShouldNotDeadlockAnswerExecutionTest.java
index f0424f7..e1c8dbd 100644
--- a/src/test/java/org/mockitousage/bugs/ShouldNotDeadlockAnswerExecutionTest.java
+++ b/src/test/java/org/mockitousage/bugs/ShouldNotDeadlockAnswerExecutionTest.java
@@ -6,17 +6,17 @@
import static org.junit.Assert.fail;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
-//see bug 190
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+// see bug 190
public class ShouldNotDeadlockAnswerExecutionTest {
@Test
@@ -91,7 +91,6 @@
return null;
}
-
}
static class ServiceRunner implements Runnable {
@@ -105,14 +104,10 @@
public void run() {
service.verySlowMethod();
}
-
}
interface Service {
String verySlowMethod();
-
}
-
}
-
diff --git a/src/test/java/org/mockitousage/bugs/ShouldOnlyModeAllowCapturingArgumentsTest.java b/src/test/java/org/mockitousage/bugs/ShouldOnlyModeAllowCapturingArgumentsTest.java
index d145f9d..7da4f7e 100644
--- a/src/test/java/org/mockitousage/bugs/ShouldOnlyModeAllowCapturingArgumentsTest.java
+++ b/src/test/java/org/mockitousage/bugs/ShouldOnlyModeAllowCapturingArgumentsTest.java
@@ -2,34 +2,33 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.only;
+import static org.mockito.Mockito.verify;
+
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.verify;
-
-//bug 197
+// bug 197
public class ShouldOnlyModeAllowCapturingArgumentsTest extends TestBase {
@Mock IMethods mock;
@Test
public void shouldAllowCapturingArguments() {
- //given
+ // given
mock.simpleMethod("o");
ArgumentCaptor<String> arg = ArgumentCaptor.forClass(String.class);
- //when
+ // when
verify(mock, only()).simpleMethod(arg.capture());
- //then
+ // then
assertEquals("o", arg.getValue());
}
}
diff --git a/src/test/java/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java b/src/test/java/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java
index dbc3007..353b405 100644
--- a/src/test/java/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java
+++ b/src/test/java/org/mockitousage/bugs/SpyShouldHaveNiceNameTest.java
@@ -2,34 +2,33 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.verify;
+
+import java.util.LinkedList;
+import java.util.List;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.Spy;
import org.mockitoutil.TestBase;
-import java.util.LinkedList;
-import java.util.List;
-
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.verify;
-
-//see issue 216
+// see issue 216
public class SpyShouldHaveNiceNameTest extends TestBase {
@Spy List<Integer> veryCoolSpy = new LinkedList<Integer>();
@Test
public void shouldPrintNiceName() {
- //when
+ // when
veryCoolSpy.add(1);
try {
verify(veryCoolSpy).add(2);
fail();
- } catch(AssertionError e) {
+ } catch (AssertionError e) {
Assertions.assertThat(e.getMessage()).contains("veryCoolSpy");
}
}
diff --git a/src/test/java/org/mockitousage/bugs/StubbingMocksThatAreConfiguredToReturnMocksTest.java b/src/test/java/org/mockitousage/bugs/StubbingMocksThatAreConfiguredToReturnMocksTest.java
index bc31297..19043e4 100644
--- a/src/test/java/org/mockitousage/bugs/StubbingMocksThatAreConfiguredToReturnMocksTest.java
+++ b/src/test/java/org/mockitousage/bugs/StubbingMocksThatAreConfiguredToReturnMocksTest.java
@@ -2,16 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.mockito.Mockito.*;
-
-//issue 151
+// issue 151
public class StubbingMocksThatAreConfiguredToReturnMocksTest extends TestBase {
@Test
diff --git a/src/test/java/org/mockitousage/bugs/VerifyingWithAnExtraCallToADifferentMockTest.java b/src/test/java/org/mockitousage/bugs/VerifyingWithAnExtraCallToADifferentMockTest.java
index a997cbc..eb64989 100644
--- a/src/test/java/org/mockitousage/bugs/VerifyingWithAnExtraCallToADifferentMockTest.java
+++ b/src/test/java/org/mockitousage/bugs/VerifyingWithAnExtraCallToADifferentMockTest.java
@@ -2,19 +2,18 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.exceptions.verification.NeverWantedButInvoked;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
-//see bug 138
+// see bug 138
public class VerifyingWithAnExtraCallToADifferentMockTest extends TestBase {
@Mock IMethods mock;
@@ -22,17 +21,18 @@
@Test
public void shouldAllowVerifyingWhenOtherMockCallIsInTheSameLine() {
- //given
+ // given
when(mock.otherMethod()).thenReturn("foo");
- //when
+ // when
mockTwo.simpleMethod("foo");
- //then
+ // then
verify(mockTwo).simpleMethod(mock.otherMethod());
try {
verify(mockTwo, never()).simpleMethod(mock.otherMethod());
fail();
- } catch (NeverWantedButInvoked e) {}
+ } catch (NeverWantedButInvoked e) {
+ }
}
}
diff --git a/src/test/java/org/mockitousage/bugs/creation/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java b/src/test/java/org/mockitousage/bugs/creation/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java
index 3f20c6a..ccd14d9 100644
--- a/src/test/java/org/mockitousage/bugs/creation/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java
+++ b/src/test/java/org/mockitousage/bugs/creation/ConstructorInvokingMethodShouldNotRaiseExceptionTest.java
@@ -4,68 +4,73 @@
*/
package org.mockitousage.bugs.creation;
+import java.util.Random;
+
import org.junit.Test;
import org.junit.experimental.runners.Enclosed;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.mockito.Spy;
-import java.util.Random;
-
@RunWith(Enclosed.class)
public class ConstructorInvokingMethodShouldNotRaiseExceptionTest {
public static class WithDumbMethod {
- @Spy
- HasConstructorInvokingMethod hasConstructorInvokingMethod;
+ @Spy HasConstructorInvokingMethod hasConstructorInvokingMethod;
@Test
public void should_be_able_to_create_spy() throws Exception {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
}
private static class HasConstructorInvokingMethod {
- public HasConstructorInvokingMethod() { someMethod(); }
+ public HasConstructorInvokingMethod() {
+ someMethod();
+ }
- void someMethod() { }
+ void someMethod() {}
}
}
public static class UsingMethodObjectReferenceResult {
- @Spy
- HasConstructorInvokingMethod hasConstructorInvokingMethod;
+ @Spy HasConstructorInvokingMethod hasConstructorInvokingMethod;
@Test
public void should_be_able_to_create_spy() throws Exception {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
}
private static class HasConstructorInvokingMethod {
private final boolean doesIt;
+
public HasConstructorInvokingMethod() {
doesIt = someMethod().contains("yup");
}
- String someMethod() { return "tada!"; }
+ String someMethod() {
+ return "tada!";
+ }
}
}
public static class UsingMethodPrimitiveResult {
- @Spy
- HasConstructorInvokingMethod hasConstructorInvokingMethod;
+ @Spy HasConstructorInvokingMethod hasConstructorInvokingMethod;
@Test
public void should_be_able_to_create_spy() throws Exception {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
}
private static class HasConstructorInvokingMethod {
private final boolean doesIt;
+
public HasConstructorInvokingMethod() {
doesIt = someMethod();
}
- boolean someMethod() { return new Random().nextBoolean(); }
+ boolean someMethod() {
+ return new Random().nextBoolean();
+ }
}
}
}
diff --git a/src/test/java/org/mockitousage/bugs/creation/PackagePrivateWithContextClassLoaderTest.java b/src/test/java/org/mockitousage/bugs/creation/PackagePrivateWithContextClassLoaderTest.java
new file mode 100644
index 0000000..95095f3
--- /dev/null
+++ b/src/test/java/org/mockitousage/bugs/creation/PackagePrivateWithContextClassLoaderTest.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.bugs.creation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Method;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/** Regression tests for issue #2303*/
+public class PackagePrivateWithContextClassLoaderTest {
+
+ private ClassLoader oldContextClassloader;
+
+ public abstract static class PublicClass {
+ int packagePrivateMethod() {
+ return 0;
+ }
+
+ abstract void packagePrivateAbstractMethod();
+ }
+
+ public interface PublicInterfaceWithPackagePrivateMethodParam {
+ void doSomething(PackagePrivateInterface i);
+ }
+
+ public interface PublicInterfaceWithPackagePrivateMethodReturn {
+ PackagePrivateInterface doSomething();
+ }
+
+ public interface PublicInterfaceOverridesPackagePrivateMethodReturn {
+ PublicChildOfPackagePrivate doSomething();
+ }
+
+ public interface PublicInterface {}
+
+ interface PackagePrivateInterface {}
+
+ public interface PublicChildOfPackagePrivate extends PackagePrivateInterface {}
+
+ static class PackagePrivateClass {}
+
+ @Before
+ public void setUp() {
+ oldContextClassloader = Thread.currentThread().getContextClassLoader();
+ Thread.currentThread().setContextClassLoader(new ClassLoader(oldContextClassloader) {});
+ }
+
+ @After
+ public void teardown() {
+ Thread.currentThread().setContextClassLoader(oldContextClassloader);
+ }
+
+ @Test
+ public void should_be_able_to_mock_package_private_method() throws Exception {
+ PublicClass publicClass = mock(PublicClass.class);
+ when(publicClass.packagePrivateMethod()).thenReturn(3);
+ assertThat(publicClass.packagePrivateMethod()).isEqualTo(3);
+ }
+
+ @Test
+ public void should_be_able_to_mock_interface_method_package_private_param() throws Exception {
+ PublicInterfaceWithPackagePrivateMethodParam publicClass =
+ mock(PublicInterfaceWithPackagePrivateMethodParam.class);
+ publicClass.doSomething(null);
+ }
+
+ @Test
+ public void should_be_able_to_mock_interface_method_package_private_return() throws Exception {
+ PublicInterfaceWithPackagePrivateMethodReturn publicClass =
+ mock(PublicInterfaceWithPackagePrivateMethodReturn.class);
+ PackagePrivateInterface packagePrivateInterface = publicClass.doSomething();
+ }
+
+ @Test
+ public void should_be_able_to_mock_interface_method_package_private_return_override()
+ throws Exception {
+ PublicInterfaceOverridesPackagePrivateMethodReturn publicClass =
+ mock(PublicInterfaceOverridesPackagePrivateMethodReturn.class);
+ PackagePrivateInterface packagePrivateInterface = publicClass.doSomething();
+ }
+
+ @Test
+ public void should_be_able_to_mock_package_private_class() throws Exception {
+ PackagePrivateClass mock = mock(PackagePrivateClass.class);
+ }
+
+ @Test
+ public void should_be_able_to_mock_package_private_interface() throws Exception {
+ PackagePrivateInterface mock = mock(PackagePrivateInterface.class);
+ }
+
+ @Test
+ public void should_be_able_to_mock_package_private_extra_interface() throws Exception {
+ PackagePrivateInterface mock =
+ (PackagePrivateInterface)
+ mock(
+ PublicInterface.class,
+ withSettings().extraInterfaces(PackagePrivateInterface.class));
+ }
+
+ /**
+ * In this test we have a class that delegates loading of mockito/JDK classes to its parent,
+ * but defines in its own for others. If mockito selects the defining classloader of the mock
+ * to the classloader of mockito, calling the abstract package-private method will fail - the
+ * defining classloader of the mocked type's package is different from the generated mock class
+ * package. Because the nonDelegatingLoader is a child of mockito's loader, it's more specific
+ * and should be preferred.
+ */
+ @Test
+ public void classloader_with_parent_but_does_not_delegate() throws Exception {
+ ClassLoader nonDelegatingLoader = new NotAlwaysDelegatingClassLoader();
+ Thread.currentThread().setContextClassLoader(nonDelegatingLoader);
+ Class<?> loaded =
+ Class.forName(LoadedByCustomLoader.class.getName(), false, nonDelegatingLoader);
+ Method attemptMock = loaded.getDeclaredMethod("attemptMock");
+ attemptMock.invoke(null);
+ }
+
+ public static class LoadedByCustomLoader {
+ public static void attemptMock() {
+ PublicClass mock = mock(PublicClass.class);
+ mock.packagePrivateAbstractMethod();
+ }
+ }
+
+ /**
+ * This classloader has a parent, but doesn't always delegate to it.
+ */
+ public static final class NotAlwaysDelegatingClassLoader extends ClassLoader {
+
+ /**
+ * Initial size of buffer used to read class data.
+ */
+ /* Note: should be enough for most classes, and is not a hard limit. */
+ private static final int BUF_SIZE = 4096;
+
+ public NotAlwaysDelegatingClassLoader() {
+ super(NotAlwaysDelegatingClassLoader.class.getClassLoader());
+ }
+
+ @Override
+ protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+ // First, check if the class has already been loaded. If not, load it
+ // ourselves or delegate to the parent.
+ Class<?> result = findLoadedClass(name);
+ if (result == null) {
+ // All classes defined in this testsuite should be loaded by this classloader,
+ // but any other class (e.g. those coming from java.* or org.mockito.* packages)
+ // will be loaded by the parent.
+ if (name.startsWith("org.mockitousage.")) {
+ result = findClass(name);
+ } else {
+ return super.loadClass(name, resolve);
+ }
+ }
+ if (resolve) {
+ resolveClass(result);
+ }
+ return result;
+ }
+
+ @Override
+ public Class<?> findClass(String className) throws ClassNotFoundException {
+ try {
+ // Create a package for this class, unless it's in the default package.
+ int dotpos = className.lastIndexOf('.');
+ if (dotpos != -1) {
+ String pkgname = className.substring(0, dotpos);
+ if (getPackage(pkgname) == null) {
+ definePackage(pkgname, null, null, null, null, null, null, null);
+ }
+ }
+ String resourceName = className.replace('.', File.separatorChar) + ".class";
+ InputStream input = getSystemResourceAsStream(resourceName);
+ if (input == null) {
+ throw new ClassNotFoundException("Couldn't find resource " + resourceName);
+ }
+ byte[] classData = loadClassData(input);
+ return defineClass(className, classData, 0, classData.length, null);
+ } catch (IOException e) {
+ throw new ClassNotFoundException("Cannot load " + className, e);
+ }
+ }
+
+ /**
+ * Load class data from a given input stream.
+ */
+ private byte[] loadClassData(InputStream input) throws IOException {
+ ByteArrayOutputStream output = new ByteArrayOutputStream(BUF_SIZE);
+ byte[] buffer = new byte[BUF_SIZE];
+ int readCount;
+ while ((readCount = input.read(buffer, 0, BUF_SIZE)) >= 0) {
+ output.write(buffer, 0, readCount);
+ }
+ return output.toByteArray();
+ }
+ }
+}
diff --git a/src/test/java/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java b/src/test/java/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java
index 5a5e43d..93c77e4 100644
--- a/src/test/java/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java
+++ b/src/test/java/org/mockitousage/bugs/creation/PublicMethodInParentWithNonPublicTypeInSignatureTest.java
@@ -4,7 +4,6 @@
*/
package org.mockitousage.bugs.creation;
-
import org.junit.Test;
import org.mockito.Mockito;
import org.mockitousage.bugs.creation.api.PublicClass;
diff --git a/src/test/java/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java b/src/test/java/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java
index 9ed8f21..fab68e3 100644
--- a/src/test/java/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java
+++ b/src/test/java/org/mockitousage/bugs/creation/ShouldAllowInlineMockCreationTest.java
@@ -2,21 +2,20 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs.creation;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockitoutil.TestBase;
-
-import java.util.List;
-import java.util.Set;
-
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-//see issue 191
+import java.util.List;
+import java.util.Set;
+
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockitoutil.TestBase;
+
+// see issue 191
public class ShouldAllowInlineMockCreationTest extends TestBase {
@Mock List list;
diff --git a/src/test/java/org/mockitousage/bugs/creation/api/PublicClass.java b/src/test/java/org/mockitousage/bugs/creation/api/PublicClass.java
index 834ef86..048208c 100644
--- a/src/test/java/org/mockitousage/bugs/creation/api/PublicClass.java
+++ b/src/test/java/org/mockitousage/bugs/creation/api/PublicClass.java
@@ -6,5 +6,4 @@
import org.mockitousage.bugs.creation.otherpackage.PublicParentClass;
-public class PublicClass extends PublicParentClass {
-}
+public class PublicClass extends PublicParentClass {}
diff --git a/src/test/java/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java b/src/test/java/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java
index df7f79a..3de5f2c 100644
--- a/src/test/java/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java
+++ b/src/test/java/org/mockitousage/bugs/creation/otherpackage/PublicParentClass.java
@@ -5,6 +5,7 @@
package org.mockitousage.bugs.creation.otherpackage;
public class PublicParentClass {
- public void method_with_non_public_argument(PackageLocalArg arg) { }
- static class PackageLocalArg { }
+ public void method_with_non_public_argument(PackageLocalArg arg) {}
+
+ static class PackageLocalArg {}
}
diff --git a/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubFailingWhenGenericNestedAsRawTypeTest.java b/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubFailingWhenGenericNestedAsRawTypeTest.java
index 8f3510a..ac9029c 100644
--- a/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubFailingWhenGenericNestedAsRawTypeTest.java
+++ b/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubFailingWhenGenericNestedAsRawTypeTest.java
@@ -4,27 +4,27 @@
*/
package org.mockitousage.bugs.deepstubs;
-import org.junit.Test;
-
import static org.mockito.Mockito.*;
+import org.junit.Test;
+
public class DeepStubFailingWhenGenericNestedAsRawTypeTest {
- interface MyClass1<MC2 extends MyClass2> {
- MC2 getNested();
- }
+ interface MyClass1<MC2 extends MyClass2> {
+ MC2 getNested();
+ }
- interface MyClass2<MC3 extends MyClass3> {
- MC3 getNested();
- }
+ interface MyClass2<MC3 extends MyClass3> {
+ MC3 getNested();
+ }
- interface MyClass3 {
- String returnSomething();
- }
+ interface MyClass3 {
+ String returnSomething();
+ }
- @Test
- public void discoverDeepMockingOfGenerics() {
- MyClass1 myMock1 = mock(MyClass1.class, RETURNS_DEEP_STUBS);
- when(myMock1.getNested().getNested().returnSomething()).thenReturn("Hello World.");
- }
+ @Test
+ public void discoverDeepMockingOfGenerics() {
+ MyClass1 myMock1 = mock(MyClass1.class, RETURNS_DEEP_STUBS);
+ when(myMock1.getNested().getNested().returnSomething()).thenReturn("Hello World.");
+ }
}
diff --git a/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java b/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java
index e26f00b..7f61dc6 100644
--- a/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java
+++ b/src/test/java/org/mockitousage/bugs/deepstubs/DeepStubsWronglyReportsSerializationProblemsTest.java
@@ -4,25 +4,27 @@
*/
package org.mockitousage.bugs.deepstubs;
-import org.junit.Test;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
+import org.junit.Test;
+
/**
* In GH issue 99 : https://github.com/mockito/mockito/issues/99
*/
public class DeepStubsWronglyReportsSerializationProblemsTest {
@Test
- public void should_not_raise_a_mockito_exception_about_serialization_when_accessing_deep_stub() {
- NotSerializableShouldBeMocked the_deep_stub = mock(ToBeDeepStubbed.class, RETURNS_DEEP_STUBS).getSomething();
+ public void
+ should_not_raise_a_mockito_exception_about_serialization_when_accessing_deep_stub() {
+ NotSerializableShouldBeMocked the_deep_stub =
+ mock(ToBeDeepStubbed.class, RETURNS_DEEP_STUBS).getSomething();
assertThat(the_deep_stub).isNotNull();
}
public static class ToBeDeepStubbed {
- public ToBeDeepStubbed() { }
+ public ToBeDeepStubbed() {}
public NotSerializableShouldBeMocked getSomething() {
return null;
@@ -30,7 +32,6 @@
}
public static class NotSerializableShouldBeMocked {
- NotSerializableShouldBeMocked(String mandatory_param) { }
+ NotSerializableShouldBeMocked(String mandatory_param) {}
}
-
}
diff --git a/src/test/java/org/mockitousage/bugs/injection/ChildWithSameParentFieldInjectionTest.java b/src/test/java/org/mockitousage/bugs/injection/ChildWithSameParentFieldInjectionTest.java
index c7f02c3..8570db1 100644
--- a/src/test/java/org/mockitousage/bugs/injection/ChildWithSameParentFieldInjectionTest.java
+++ b/src/test/java/org/mockitousage/bugs/injection/ChildWithSameParentFieldInjectionTest.java
@@ -4,22 +4,20 @@
*/
package org.mockitousage.bugs.injection;
+import static org.junit.Assert.assertNotNull;
+
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import static org.junit.Assert.assertNotNull;
-
// issue 289
@RunWith(MockitoJUnitRunner.class)
public class ChildWithSameParentFieldInjectionTest {
- @InjectMocks
- private System system;
+ @InjectMocks private System system;
- @Mock
- private SomeService someService;
+ @Mock private SomeService someService;
@Test
public void parent_field_is_not_null() {
@@ -48,7 +46,6 @@
}
public static class SomeService {
- public void doSomething() {
- }
+ public void doSomething() {}
}
}
diff --git a/src/test/java/org/mockitousage/bugs/injection/InjectMocksShouldTryPropertySettersFirstBeforeFieldAccessTest.java b/src/test/java/org/mockitousage/bugs/injection/InjectMocksShouldTryPropertySettersFirstBeforeFieldAccessTest.java
index 10070c6..0869f58 100644
--- a/src/test/java/org/mockitousage/bugs/injection/InjectMocksShouldTryPropertySettersFirstBeforeFieldAccessTest.java
+++ b/src/test/java/org/mockitousage/bugs/injection/InjectMocksShouldTryPropertySettersFirstBeforeFieldAccessTest.java
@@ -4,17 +4,17 @@
*/
package org.mockitousage.bugs.injection;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
/**
* Issue 211 : @InjectMocks should carry out their work by the method (and not by field) if available
*/
@@ -44,5 +44,4 @@
propertySetterUsed = true;
}
}
-
}
diff --git a/src/test/java/org/mockitousage/bugs/injection/InjectionByTypeShouldFirstLookForExactTypeThenAncestorTest.java b/src/test/java/org/mockitousage/bugs/injection/InjectionByTypeShouldFirstLookForExactTypeThenAncestorTest.java
index e4957d3..5a8b415 100644
--- a/src/test/java/org/mockitousage/bugs/injection/InjectionByTypeShouldFirstLookForExactTypeThenAncestorTest.java
+++ b/src/test/java/org/mockitousage/bugs/injection/InjectionByTypeShouldFirstLookForExactTypeThenAncestorTest.java
@@ -4,16 +4,16 @@
*/
package org.mockitousage.bugs.injection;
+import static org.junit.Assert.*;
+
+import java.lang.reflect.Field;
+
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import java.lang.reflect.Field;
-
-import static org.junit.Assert.*;
-
@RunWith(MockitoJUnitRunner.class)
public class InjectionByTypeShouldFirstLookForExactTypeThenAncestorTest {
@@ -22,7 +22,10 @@
@Mock private Bean mockedBean;
@InjectMocks private Service illegalInjectionExample = new Service();
- @InjectMocks private ServiceWithReversedOrder reversedOrderService = new ServiceWithReversedOrder();
+
+ @InjectMocks
+ private ServiceWithReversedOrder reversedOrderService = new ServiceWithReversedOrder();
+
@InjectMocks private WithNullObjectField withNullObjectField = new WithNullObjectField();
@Test
@@ -63,7 +66,7 @@
public final Object mockShouldNotGoInHere = REFERENCE;
}
- class WithNullObjectField{
+ class WithNullObjectField {
Bean injectMePlease;
Object keepMeNull = null;
}
diff --git a/src/test/java/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java b/src/test/java/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java
index 7d154fc..3023e32 100644
--- a/src/test/java/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java
+++ b/src/test/java/org/mockitousage/bugs/injection/Issue353InjectionMightNotHappenInCertainConfigurationTest.java
@@ -4,6 +4,11 @@
*/
package org.mockitousage.bugs.injection;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertSame;
+
+import java.util.HashMap;
+import java.util.Map;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -11,12 +16,6 @@
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertSame;
-
@RunWith(MockitoJUnitRunner.class)
public class Issue353InjectionMightNotHappenInCertainConfigurationTest {
@Mock Map<String, String> stringString_that_matches_field;
@@ -24,8 +23,12 @@
@InjectMocks FooService fooService;
@Test
- public void when_identical_types_and_the_correct_mock_name_is_greater_than_the_non_matching_name_then_injection_occurs_only_on_the_named_one() {
- assertThat("stringString_that_matches_field".compareTo("mockStringInteger_was_not_injected")).isGreaterThanOrEqualTo(1);
+ public void
+ when_identical_types_and_the_correct_mock_name_is_greater_than_the_non_matching_name_then_injection_occurs_only_on_the_named_one() {
+ assertThat(
+ "stringString_that_matches_field"
+ .compareTo("mockStringInteger_was_not_injected"))
+ .isGreaterThanOrEqualTo(1);
assertSame(stringString_that_matches_field, fooService.stringString_that_matches_field);
assertSame(mockStringInteger_was_not_injected, fooService.stringInteger_field);
@@ -35,5 +38,4 @@
Map<String, Integer> stringInteger_field = new HashMap<String, Integer>();
Map<String, String> stringString_that_matches_field = new HashMap<String, String>();
}
-
}
diff --git a/src/test/java/org/mockitousage/bugs/injection/ParentTestMockInjectionTest.java b/src/test/java/org/mockitousage/bugs/injection/ParentTestMockInjectionTest.java
index 660883f..6c11880 100644
--- a/src/test/java/org/mockitousage/bugs/injection/ParentTestMockInjectionTest.java
+++ b/src/test/java/org/mockitousage/bugs/injection/ParentTestMockInjectionTest.java
@@ -4,6 +4,8 @@
*/
package org.mockitousage.bugs.injection;
+import static org.junit.Assert.assertNotNull;
+
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
@@ -11,15 +13,13 @@
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import static org.junit.Assert.assertNotNull;
-
// issue 229 : @Mock fields in super test class are not injected on @InjectMocks fields
public class ParentTestMockInjectionTest {
@Test
public void injectMocksShouldInjectMocksFromTestSuperClasses() {
ImplicitTest it = new ImplicitTest();
- MockitoAnnotations.initMocks(it);
+ MockitoAnnotations.openMocks(it);
assertNotNull(it.daoFromParent);
assertNotNull(it.daoFromSub);
@@ -28,7 +28,7 @@
}
@Ignore
- public static abstract class BaseTest {
+ public abstract static class BaseTest {
@Mock protected DaoA daoFromParent;
}
@@ -40,7 +40,7 @@
@Before
public void setup() {
- MockitoAnnotations.initMocks(this);
+ MockitoAnnotations.openMocks(this);
}
@Test
@@ -59,13 +59,11 @@
}
}
-
public static class DaoA {
- public void doQuery() { }
+ public void doQuery() {}
}
public static class DaoB {
- public void doQuery() { }
+ public void doQuery() {}
}
-
}
diff --git a/src/test/java/org/mockitousage/bugs/injection/ShouldNotTryToInjectInFinalOrStaticFieldsTest.java b/src/test/java/org/mockitousage/bugs/injection/ShouldNotTryToInjectInFinalOrStaticFieldsTest.java
index bbe5233..c98103d 100644
--- a/src/test/java/org/mockitousage/bugs/injection/ShouldNotTryToInjectInFinalOrStaticFieldsTest.java
+++ b/src/test/java/org/mockitousage/bugs/injection/ShouldNotTryToInjectInFinalOrStaticFieldsTest.java
@@ -2,9 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs.injection;
+import static org.junit.Assert.assertNotSame;
+
+import java.util.*;
+
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -12,10 +15,6 @@
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
-import java.util.*;
-
-import static org.junit.Assert.assertNotSame;
-
// issue 262
@RunWith(MockitoJUnitRunner.class)
public class ShouldNotTryToInjectInFinalOrStaticFieldsTest {
@@ -31,12 +30,10 @@
@InjectMocks private ExampleService exampleService = new ExampleService();
@Test
- public void dont_fail_with_CONSTANTS() throws Exception {
- }
+ public void dont_fail_with_CONSTANTS() throws Exception {}
@Test
public void dont_inject_in_final() {
assertNotSame(unrelatedSet, exampleService.aSet);
}
-
}
diff --git a/src/test/java/org/mockitousage/bugs/varargs/VarargsAndAnyObjectPicksUpExtraInvocationsTest.java b/src/test/java/org/mockitousage/bugs/varargs/VarargsAndAnyObjectPicksUpExtraInvocationsTest.java
index 7bf4271..c9112fa 100644
--- a/src/test/java/org/mockitousage/bugs/varargs/VarargsAndAnyObjectPicksUpExtraInvocationsTest.java
+++ b/src/test/java/org/mockitousage/bugs/varargs/VarargsAndAnyObjectPicksUpExtraInvocationsTest.java
@@ -2,52 +2,50 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs.varargs;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockitoutil.TestBase;
-
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockitoutil.TestBase;
+
public class VarargsAndAnyObjectPicksUpExtraInvocationsTest extends TestBase {
public interface TableBuilder {
void newRow(String trAttributes, String... cells);
}
- @Mock
- TableBuilder table;
+ @Mock TableBuilder table;
@Test
public void shouldVerifyCorrectlyWithAnyVarargs() {
- //when
+ // when
table.newRow("qux", "foo", "bar", "baz");
table.newRow("abc", "def");
- //then
+ // then
verify(table, times(2)).newRow(anyString(), (String[]) anyVararg());
}
@Test
public void shouldVerifyCorrectlyNumberOfInvocationsUsingAnyVarargAndEqualArgument() {
- //when
+ // when
table.newRow("x", "foo", "bar", "baz");
table.newRow("x", "def");
- //then
+ // then
verify(table, times(2)).newRow(eq("x"), (String[]) anyVararg());
}
@Test
public void shouldVerifyCorrectlyNumberOfInvocationsWithVarargs() {
- //when
+ // when
table.newRow("qux", "foo", "bar", "baz");
table.newRow("abc", "def");
- //then
+ // then
verify(table).newRow(anyString(), eq("foo"), anyString(), anyString());
verify(table).newRow(anyString(), anyString());
}
diff --git a/src/test/java/org/mockitousage/bugs/varargs/VarargsErrorWhenCallingRealMethodTest.java b/src/test/java/org/mockitousage/bugs/varargs/VarargsErrorWhenCallingRealMethodTest.java
index 2380c81..2238221 100644
--- a/src/test/java/org/mockitousage/bugs/varargs/VarargsErrorWhenCallingRealMethodTest.java
+++ b/src/test/java/org/mockitousage/bugs/varargs/VarargsErrorWhenCallingRealMethodTest.java
@@ -2,19 +2,18 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs.varargs;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.*;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
public class VarargsErrorWhenCallingRealMethodTest extends TestBase {
class Foo {
- int blah(String a, String b, Object ... c) {
+ int blah(String a, String b, Object... c) {
return 1;
}
}
diff --git a/src/test/java/org/mockitousage/bugs/varargs/VarargsNotPlayingWithAnyObjectTest.java b/src/test/java/org/mockitousage/bugs/varargs/VarargsNotPlayingWithAnyObjectTest.java
index 2b0cbff..a77782b 100644
--- a/src/test/java/org/mockitousage/bugs/varargs/VarargsNotPlayingWithAnyObjectTest.java
+++ b/src/test/java/org/mockitousage/bugs/varargs/VarargsNotPlayingWithAnyObjectTest.java
@@ -2,13 +2,8 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.bugs.varargs;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.anyObject;
import static org.mockito.Mockito.anyString;
@@ -18,7 +13,11 @@
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-//see issue 62
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockitoutil.TestBase;
+
+// see issue 62
public class VarargsNotPlayingWithAnyObjectTest extends TestBase {
interface VarargMethod {
diff --git a/src/test/java/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java b/src/test/java/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java
index edc0a8b..7d9c950 100644
--- a/src/test/java/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java
+++ b/src/test/java/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java
@@ -4,50 +4,62 @@
*/
package org.mockitousage.configuration;
+import static org.mockito.Mockito.mock;
+
+import java.util.concurrent.Callable;
import org.junit.Test;
import org.mockito.internal.configuration.ConfigurationAccess;
import org.mockitoutil.SimplePerRealmReloadingClassLoader;
-import java.util.concurrent.Callable;
-
-import static org.mockito.Mockito.mock;
-
public class ClassCacheVersusClassReloadingTest {
// TODO refactor to use ClassLoaders
- private SimplePerRealmReloadingClassLoader testMethodClassLoaderRealm = new SimplePerRealmReloadingClassLoader(reloadMockito());
+ private SimplePerRealmReloadingClassLoader testMethodClassLoaderRealm =
+ new SimplePerRealmReloadingClassLoader(reloadMockito());
@Test
- public void should_not_throw_ClassCastException_when_objenesis_cache_disabled() throws Exception {
+ public void should_not_throw_ClassCastException_when_objenesis_cache_disabled()
+ throws Exception {
prepareMockitoAndDisableObjenesisCache();
- doInNewChildRealm(testMethodClassLoaderRealm, "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking");
- doInNewChildRealm(testMethodClassLoaderRealm, "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking");
+ doInNewChildRealm(
+ testMethodClassLoaderRealm,
+ "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking");
+ doInNewChildRealm(
+ testMethodClassLoaderRealm,
+ "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking");
}
public static class DoTheMocking implements Callable<Object> {
public Object call() throws Exception {
- Class<?> clazz = this.getClass().getClassLoader().loadClass("org.mockitousage.configuration.ClassToBeMocked");
+ Class<?> clazz =
+ this.getClass()
+ .getClassLoader()
+ .loadClass("org.mockitousage.configuration.ClassToBeMocked");
return mock(clazz);
}
}
- private static void doInNewChildRealm(ClassLoader parentRealm, String callableCalledInClassLoaderRealm) throws Exception {
- new SimplePerRealmReloadingClassLoader(parentRealm, reloadScope()).doInRealm(callableCalledInClassLoaderRealm);
+ private static void doInNewChildRealm(
+ ClassLoader parentRealm, String callableCalledInClassLoaderRealm) throws Exception {
+ new SimplePerRealmReloadingClassLoader(parentRealm, reloadScope())
+ .doInRealm(callableCalledInClassLoaderRealm);
}
private static SimplePerRealmReloadingClassLoader.ReloadClassPredicate reloadScope() {
return new SimplePerRealmReloadingClassLoader.ReloadClassPredicate() {
public boolean acceptReloadOf(String qualifiedName) {
- return "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking".equals(qualifiedName)
- || "org.mockitousage.configuration.ClassToBeMocked".equals(qualifiedName);
+ return "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$DoTheMocking"
+ .equals(qualifiedName)
+ || "org.mockitousage.configuration.ClassToBeMocked".equals(qualifiedName);
}
};
}
private void prepareMockitoAndDisableObjenesisCache() throws Exception {
- testMethodClassLoaderRealm.doInRealm("org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$PrepareMockito");
+ testMethodClassLoaderRealm.doInRealm(
+ "org.mockitousage.configuration.ClassCacheVersusClassReloadingTest$PrepareMockito");
}
public static class PrepareMockito implements Callable<Boolean> {
@@ -61,9 +73,9 @@
private static SimplePerRealmReloadingClassLoader.ReloadClassPredicate reloadMockito() {
return new SimplePerRealmReloadingClassLoader.ReloadClassPredicate() {
public boolean acceptReloadOf(String qualifiedName) {
- return (!qualifiedName.contains("net.bytebuddy") && qualifiedName.contains("org.mockito"));
+ return (!qualifiedName.contains("net.bytebuddy")
+ && qualifiedName.contains("org.mockito"));
}
};
}
-
}
diff --git a/src/test/java/org/mockitousage/configuration/ClassToBeMocked.java b/src/test/java/org/mockitousage/configuration/ClassToBeMocked.java
index adc863d..fbb852d 100644
--- a/src/test/java/org/mockitousage/configuration/ClassToBeMocked.java
+++ b/src/test/java/org/mockitousage/configuration/ClassToBeMocked.java
@@ -7,4 +7,4 @@
/**
* Some class to mock that is created via Class.forClass
*/
-public class ClassToBeMocked { }
+public class ClassToBeMocked {}
diff --git a/src/test/java/org/mockitousage/configuration/CustomizedAnnotationForSmartMockTest.java b/src/test/java/org/mockitousage/configuration/CustomizedAnnotationForSmartMockTest.java
index c8a8bbf..b487063 100644
--- a/src/test/java/org/mockitousage/configuration/CustomizedAnnotationForSmartMockTest.java
+++ b/src/test/java/org/mockitousage/configuration/CustomizedAnnotationForSmartMockTest.java
@@ -4,12 +4,18 @@
*/
package org.mockitousage.configuration;
+import static java.lang.annotation.ElementType.FIELD;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.verify;
+
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Set;
+
import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.configuration.MockitoConfiguration;
@@ -17,11 +23,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static java.lang.annotation.ElementType.FIELD;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.verify;
-
-
/**
* @see MockitoConfiguration#getAnnotationEngine() for the custom smartmock injection engine
*/
@@ -31,22 +32,29 @@
@Test
public void shouldUseCustomAnnotation() {
- assertEquals("SmartMock should return empty String by default", "", smartMock.simpleMethod(1));
+ assertEquals(
+ "SmartMock should return empty String by default", "", smartMock.simpleMethod(1));
verify(smartMock).simpleMethod(1);
}
- @Target({FIELD })
+ @Target({FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface SmartMock {}
public static class CustomInjectingAnnotationEngine extends InjectingAnnotationEngine {
@Override
- protected void onInjection(Object testClassInstance, Class<?> clazz, Set<Field> mockDependentFields, Set<Object> mocks) {
+ protected void onInjection(
+ Object testClassInstance,
+ Class<?> clazz,
+ Set<Field> mockDependentFields,
+ Set<Object> mocks) {
for (Field field : clazz.getDeclaredFields()) {
if (field.isAnnotationPresent(SmartMock.class)) {
field.setAccessible(true);
try {
- field.set(Modifier.isStatic(field.getModifiers()) ? null : testClassInstance, Mockito.mock(field.getType(), Mockito.RETURNS_SMART_NULLS));
+ field.set(
+ Modifier.isStatic(field.getModifiers()) ? null : testClassInstance,
+ Mockito.mock(field.getType(), Mockito.RETURNS_SMART_NULLS));
} catch (Exception exception) {
throw new AssertionError(exception.getMessage());
}
diff --git a/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java b/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java
index fe626b0..a70b5b2 100644
--- a/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java
+++ b/src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java
@@ -4,54 +4,66 @@
*/
package org.mockitousage.constructor;
-import java.util.List;
-import org.junit.Test;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockito.mock.SerializableMode;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.CALLS_REAL_METHODS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.withSettings;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockito.mock.SerializableMode;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
public class CreatingMocksWithConstructorTest extends TestBase {
- static abstract class AbstractMessage {
+ abstract static class AbstractMessage {
private final String message;
+
AbstractMessage() {
this.message = "hey!";
}
+
AbstractMessage(String message) {
this.message = message;
}
+
AbstractMessage(int i) {
this.message = String.valueOf(i);
}
+
String getMessage() {
return message;
}
}
static class Message extends AbstractMessage {}
+
class InnerClass extends AbstractMessage {}
@Test
public void can_create_mock_with_constructor() {
- Message mock = mock(Message.class, withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
- //the message is a part of state of the mocked type that gets initialized in constructor
+ Message mock =
+ mock(
+ Message.class,
+ withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
+ // the message is a part of state of the mocked type that gets initialized in constructor
assertEquals("hey!", mock.getMessage());
}
@Test
public void can_mock_abstract_classes() {
- AbstractMessage mock = mock(AbstractMessage.class, withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
+ AbstractMessage mock =
+ mock(
+ AbstractMessage.class,
+ withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
assertEquals("hey!", mock.getMessage());
}
@@ -63,46 +75,72 @@
@Test
public void can_spy_abstract_classes_with_constructor_args() {
- AbstractMessage mock = mock(AbstractMessage.class, withSettings().useConstructor("hello!").defaultAnswer(CALLS_REAL_METHODS));
+ AbstractMessage mock =
+ mock(
+ AbstractMessage.class,
+ withSettings().useConstructor("hello!").defaultAnswer(CALLS_REAL_METHODS));
assertEquals("hello!", mock.getMessage());
}
@Test
public void can_spy_abstract_classes_with_constructor_primitive_args() {
- AbstractMessage mock = mock(AbstractMessage.class, withSettings().useConstructor(7).defaultAnswer(CALLS_REAL_METHODS));
+ AbstractMessage mock =
+ mock(
+ AbstractMessage.class,
+ withSettings().useConstructor(7).defaultAnswer(CALLS_REAL_METHODS));
assertEquals("7", mock.getMessage());
}
@Test
public void can_spy_abstract_classes_with_constructor_array_of_nulls() {
- AbstractMessage mock = mock(AbstractMessage.class, withSettings().useConstructor(new Object[]{null}).defaultAnswer(CALLS_REAL_METHODS));
+ AbstractMessage mock =
+ mock(
+ AbstractMessage.class,
+ withSettings()
+ .useConstructor(new Object[] {null})
+ .defaultAnswer(CALLS_REAL_METHODS));
assertNull(mock.getMessage());
}
@Test
public void can_spy_abstract_classes_with_casted_null() {
- AbstractMessage mock = mock(AbstractMessage.class, withSettings().useConstructor((String) null).defaultAnswer(CALLS_REAL_METHODS));
+ AbstractMessage mock =
+ mock(
+ AbstractMessage.class,
+ withSettings()
+ .useConstructor((String) null)
+ .defaultAnswer(CALLS_REAL_METHODS));
assertNull(mock.getMessage());
}
@Test
public void can_spy_abstract_classes_with_null_varargs() {
try {
- mock(AbstractMessage.class, withSettings().useConstructor(null).defaultAnswer(CALLS_REAL_METHODS));
+ mock(
+ AbstractMessage.class,
+ withSettings().useConstructor(null).defaultAnswer(CALLS_REAL_METHODS));
fail();
} catch (IllegalArgumentException e) {
- assertThat(e).hasMessageContaining("constructorArgs should not be null. " +
- "If you need to pass null, please cast it to the right type, e.g.: useConstructor((String) null)");
+ assertThat(e)
+ .hasMessageContaining(
+ "constructorArgs should not be null. "
+ + "If you need to pass null, please cast it to the right type, e.g.: useConstructor((String) null)");
}
}
@Test
public void can_mock_inner_classes() {
- InnerClass mock = mock(InnerClass.class, withSettings().useConstructor().outerInstance(this).defaultAnswer(CALLS_REAL_METHODS));
+ InnerClass mock =
+ mock(
+ InnerClass.class,
+ withSettings()
+ .useConstructor()
+ .outerInstance(this)
+ .defaultAnswer(CALLS_REAL_METHODS));
assertEquals("hey!", mock.getMessage());
}
- public static class ThrowingConstructorClass{
+ public static class ThrowingConstructorClass {
public ThrowingConstructorClass() {
throw new RuntimeException();
}
@@ -111,11 +149,15 @@
@Test
public void explains_constructor_exceptions() {
try {
- mock(ThrowingConstructorClass.class, withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
+ mock(
+ ThrowingConstructorClass.class,
+ withSettings().useConstructor().defaultAnswer(CALLS_REAL_METHODS));
fail();
} catch (MockitoException e) {
assertThat(e).hasRootCauseInstanceOf(RuntimeException.class);
- assertThat(e.getCause()).hasMessageContaining("Please ensure the target class has a 0-arg constructor and executes cleanly.");
+ assertThat(e.getCause())
+ .hasMessageContaining(
+ "Please ensure the target class has a 0-arg constructor and executes cleanly.");
}
}
@@ -126,29 +168,35 @@
@Test
public void exception_message_when_constructor_not_found() {
try {
- //when
+ // when
spy(HasConstructor.class);
- //then
+ // then
fail();
} catch (MockitoException e) {
assertThat(e).hasMessage("Unable to create mock instance of type 'HasConstructor'");
- assertThat(e.getCause()).hasMessageContaining("Please ensure that the target class has a 0-arg constructor.");
+ assertThat(e.getCause())
+ .hasMessageContaining(
+ "Please ensure that the target class has a 0-arg constructor.");
}
}
static class Base {}
+
static class ExtendsBase extends Base {}
+
static class ExtendsExtendsBase extends ExtendsBase {}
static class UsesBase {
public UsesBase(Base b) {
constructorUsed = "Base";
}
+
public UsesBase(ExtendsBase b) {
constructorUsed = "ExtendsBase";
}
private String constructorUsed = null;
+
String getConstructorUsed() {
return constructorUsed;
}
@@ -156,19 +204,34 @@
@Test
public void can_mock_unambigous_constructor_with_inheritance_base_class_exact_match() {
- UsesBase u = mock(UsesBase.class, withSettings().useConstructor(new Base()).defaultAnswer(CALLS_REAL_METHODS));
+ UsesBase u =
+ mock(
+ UsesBase.class,
+ withSettings()
+ .useConstructor(new Base())
+ .defaultAnswer(CALLS_REAL_METHODS));
assertEquals("Base", u.getConstructorUsed());
}
@Test
public void can_mock_unambigous_constructor_with_inheritance_extending_class_exact_match() {
- UsesBase u = mock(UsesBase.class, withSettings().useConstructor(new ExtendsBase()).defaultAnswer(CALLS_REAL_METHODS));
+ UsesBase u =
+ mock(
+ UsesBase.class,
+ withSettings()
+ .useConstructor(new ExtendsBase())
+ .defaultAnswer(CALLS_REAL_METHODS));
assertEquals("ExtendsBase", u.getConstructorUsed());
}
@Test
public void can_mock_unambigous_constructor_with_inheritance_non_exact_match() {
- UsesBase u = mock(UsesBase.class, withSettings().useConstructor(new ExtendsExtendsBase()).defaultAnswer(CALLS_REAL_METHODS));
+ UsesBase u =
+ mock(
+ UsesBase.class,
+ withSettings()
+ .useConstructor(new ExtendsExtendsBase())
+ .defaultAnswer(CALLS_REAL_METHODS));
assertEquals("ExtendsBase", u.getConstructorUsed());
}
@@ -176,14 +239,17 @@
public UsesTwoBases(Base b1, Base b2) {
constructorUsed = "Base,Base";
}
+
public UsesTwoBases(ExtendsBase b1, Base b2) {
constructorUsed = "ExtendsBase,Base";
}
+
public UsesTwoBases(Base b1, ExtendsBase b2) {
constructorUsed = "Base,ExtendsBase";
}
private String constructorUsed = null;
+
String getConstructorUsed() {
return constructorUsed;
}
@@ -192,67 +258,93 @@
@Test
public void can_mock_unambigous_constructor_with_inheritance_multiple_base_class_exact_match() {
UsesTwoBases u =
- mock(UsesTwoBases.class, withSettings().useConstructor(new Base(), new Base()).defaultAnswer(CALLS_REAL_METHODS));
+ mock(
+ UsesTwoBases.class,
+ withSettings()
+ .useConstructor(new Base(), new Base())
+ .defaultAnswer(CALLS_REAL_METHODS));
assertEquals("Base,Base", u.getConstructorUsed());
}
@Test
- public void can_mock_unambigous_constructor_with_inheritance_first_extending_class_exact_match() {
+ public void
+ can_mock_unambigous_constructor_with_inheritance_first_extending_class_exact_match() {
UsesTwoBases u =
- mock(UsesTwoBases.class, withSettings().useConstructor(new ExtendsBase(), new Base()).defaultAnswer(CALLS_REAL_METHODS));
+ mock(
+ UsesTwoBases.class,
+ withSettings()
+ .useConstructor(new ExtendsBase(), new Base())
+ .defaultAnswer(CALLS_REAL_METHODS));
assertEquals("ExtendsBase,Base", u.getConstructorUsed());
}
@Test
- public void can_mock_unambigous_constructor_with_inheritance_second_extending_class_exact_match() {
+ public void
+ can_mock_unambigous_constructor_with_inheritance_second_extending_class_exact_match() {
UsesTwoBases u =
- mock(UsesTwoBases.class, withSettings().useConstructor(new Base(), new ExtendsBase()).defaultAnswer(CALLS_REAL_METHODS));
+ mock(
+ UsesTwoBases.class,
+ withSettings()
+ .useConstructor(new Base(), new ExtendsBase())
+ .defaultAnswer(CALLS_REAL_METHODS));
assertEquals("Base,ExtendsBase", u.getConstructorUsed());
}
@Test
public void fail_when_multiple_matching_constructors_with_inheritence() {
try {
- //when
- mock(UsesTwoBases.class, withSettings().useConstructor(new ExtendsBase(), new ExtendsBase()));
- //then
+ // when
+ mock(
+ UsesTwoBases.class,
+ withSettings().useConstructor(new ExtendsBase(), new ExtendsBase()));
+ // then
fail();
} catch (MockitoException e) {
- //TODO the exception message includes Mockito internals like the name of the generated class name.
- //I suspect that we could make this exception message nicer.
+ // TODO the exception message includes Mockito internals like the name of the generated
+ // class name.
+ // I suspect that we could make this exception message nicer.
assertThat(e).hasMessage("Unable to create mock instance of type 'UsesTwoBases'");
assertThat(e.getCause())
- .hasMessageContaining("Multiple constructors could be matched to arguments of types "
- + "[org.mockitousage.constructor.CreatingMocksWithConstructorTest$ExtendsBase, "
- + "org.mockitousage.constructor.CreatingMocksWithConstructorTest$ExtendsBase]")
- .hasMessageContaining("If you believe that Mockito could do a better job deciding on which constructor to use, please let us know.\n" +
- "Ticket 685 contains the discussion and a workaround for ambiguous constructors using inner class.\n" +
- "See https://github.com/mockito/mockito/issues/685");
+ .hasMessageContaining(
+ "Multiple constructors could be matched to arguments of types "
+ + "[org.mockitousage.constructor.CreatingMocksWithConstructorTest$ExtendsBase, "
+ + "org.mockitousage.constructor.CreatingMocksWithConstructorTest$ExtendsBase]")
+ .hasMessageContaining(
+ "If you believe that Mockito could do a better job deciding on which constructor to use, please let us know.\n"
+ + "Ticket 685 contains the discussion and a workaround for ambiguous constructors using inner class.\n"
+ + "See https://github.com/mockito/mockito/issues/685");
}
}
@Test
public void mocking_inner_classes_with_wrong_outer_instance() {
try {
- //when
- mock(InnerClass.class, withSettings().useConstructor().outerInstance(123).defaultAnswer(CALLS_REAL_METHODS));
- //then
+ // when
+ mock(
+ InnerClass.class,
+ withSettings()
+ .useConstructor()
+ .outerInstance(123)
+ .defaultAnswer(CALLS_REAL_METHODS));
+ // then
fail();
} catch (MockitoException e) {
assertThat(e).hasMessage("Unable to create mock instance of type 'InnerClass'");
- //TODO it would be nice if all useful information was in the top level exception, instead of in the exception's cause
- //also applies to other scenarios in this test
- assertThat(e.getCause()).hasMessageContaining(
- "Please ensure that the target class has a 0-arg constructor"
- + " and provided outer instance is correct.");
+ // TODO it would be nice if all useful information was in the top level exception,
+ // instead of in the exception's cause
+ // also applies to other scenarios in this test
+ assertThat(e.getCause())
+ .hasMessageContaining(
+ "Please ensure that the target class has a 0-arg constructor"
+ + " and provided outer instance is correct.");
}
}
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
@Test
public void mocking_interfaces_with_constructor() {
- //at the moment this is allowed however we can be more strict if needed
- //there is not much sense in creating a spy of an interface
+ // at the moment this is allowed however we can be more strict if needed
+ // there is not much sense in creating a spy of an interface
mock(IMethods.class, withSettings().useConstructor());
spy(IMethods.class);
}
@@ -260,17 +352,26 @@
@Test
public void prevents_across_jvm_serialization_with_constructor() {
try {
- //when
- mock(AbstractMessage.class, withSettings().useConstructor().serializable(SerializableMode.ACROSS_CLASSLOADERS));
- //then
+ // when
+ mock(
+ AbstractMessage.class,
+ withSettings()
+ .useConstructor()
+ .serializable(SerializableMode.ACROSS_CLASSLOADERS));
+ // then
fail();
} catch (MockitoException e) {
- assertEquals("Mocks instantiated with constructor cannot be combined with " + SerializableMode.ACROSS_CLASSLOADERS + " serialization mode.", e.getMessage());
+ assertEquals(
+ "Mocks instantiated with constructor cannot be combined with "
+ + SerializableMode.ACROSS_CLASSLOADERS
+ + " serialization mode.",
+ e.getMessage());
}
}
- static abstract class AbstractThing {
+ abstract static class AbstractThing {
abstract String name();
+
String fullName() {
return "abstract " + name();
}
@@ -329,11 +430,13 @@
public AmbiguousWithPrimitive(String s, int i) {
data = s;
}
+
public AmbiguousWithPrimitive(Object o, int i) {
data = "just an object";
}
private String data;
+
public String getData() {
return data;
}
@@ -341,7 +444,12 @@
@Test
public void can_spy_ambiguius_constructor_with_primitive() {
- AmbiguousWithPrimitive mock = mock(AmbiguousWithPrimitive.class, withSettings().useConstructor("String", 7).defaultAnswer(CALLS_REAL_METHODS));
+ AmbiguousWithPrimitive mock =
+ mock(
+ AmbiguousWithPrimitive.class,
+ withSettings()
+ .useConstructor("String", 7)
+ .defaultAnswer(CALLS_REAL_METHODS));
assertEquals("String", mock.getData());
}
}
diff --git a/src/test/java/org/mockitousage/customization/BDDMockitoTest.java b/src/test/java/org/mockitousage/customization/BDDMockitoTest.java
index 518c071..89ed109 100644
--- a/src/test/java/org/mockitousage/customization/BDDMockitoTest.java
+++ b/src/test/java/org/mockitousage/customization/BDDMockitoTest.java
@@ -4,6 +4,11 @@
*/
package org.mockitousage.customization;
+import static org.junit.Assert.fail;
+import static org.mockito.BDDMockito.*;
+
+import java.util.Set;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.InOrder;
@@ -18,15 +23,9 @@
import org.mockitousage.MethodsImpl;
import org.mockitoutil.TestBase;
-import java.util.Set;
-
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.*;
-
public class BDDMockitoTest extends TestBase {
- @Mock
- IMethods mock;
+ @Mock IMethods mock;
@Test
public void should_stub() throws Exception {
@@ -62,7 +61,8 @@
@SuppressWarnings("unchecked")
public void should_stub_with_throwable_classes() throws Exception {
// unavoidable 'unchecked generic array creation' warning (from JDK7 onward)
- given(mock.simpleMethod("foo")).willThrow(SomethingWasWrong.class, AnotherThingWasWrong.class);
+ given(mock.simpleMethod("foo"))
+ .willThrow(SomethingWasWrong.class, AnotherThingWasWrong.class);
try {
Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
@@ -73,31 +73,33 @@
@Test
public void should_stub_with_answer() throws Exception {
- given(mock.simpleMethod(anyString())).willAnswer(new Answer<String>() {
- public String answer(InvocationOnMock invocation) throws Throwable {
- return invocation.getArgument(0);
- }
- });
+ given(mock.simpleMethod(anyString()))
+ .willAnswer(
+ new Answer<String>() {
+ public String answer(InvocationOnMock invocation) throws Throwable {
+ return invocation.getArgument(0);
+ }
+ });
Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
}
@Test
public void should_stub_with_will_answer_alias() throws Exception {
- given(mock.simpleMethod(anyString())).will(new Answer<String>() {
- public String answer(InvocationOnMock invocation) throws Throwable {
- return invocation.getArgument(0);
- }
- });
+ given(mock.simpleMethod(anyString()))
+ .will(
+ new Answer<String>() {
+ public String answer(InvocationOnMock invocation) throws Throwable {
+ return invocation.getArgument(0);
+ }
+ });
Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
}
@Test
public void should_stub_consecutively() throws Exception {
- given(mock.simpleMethod(anyString()))
- .willReturn("foo")
- .willReturn("bar");
+ given(mock.simpleMethod(anyString())).willReturn("foo").willReturn("bar");
Assertions.assertThat(mock.simpleMethod("whatever")).isEqualTo("foo");
Assertions.assertThat(mock.simpleMethod("whatever")).isEqualTo("bar");
@@ -105,8 +107,7 @@
@Test
public void should_return_consecutively() throws Exception {
- given(mock.objectReturningMethodNoArgs())
- .willReturn("foo", "bar", 12L, new byte[0]);
+ given(mock.objectReturningMethodNoArgs()).willReturn("foo", "bar", 12L, new byte[0]);
Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("foo");
Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("bar");
@@ -117,8 +118,7 @@
@Test
public void should_stub_consecutively_with_call_real_method() throws Exception {
MethodsImpl mock = mock(MethodsImpl.class);
- willReturn("foo").willCallRealMethod()
- .given(mock).simpleMethod();
+ willReturn("foo").willCallRealMethod().given(mock).simpleMethod();
Assertions.assertThat(mock.simpleMethod()).isEqualTo("foo");
Assertions.assertThat(mock.simpleMethod()).isEqualTo(null);
@@ -160,9 +160,7 @@
@Test
public void should_stub_void_consecutively() throws Exception {
- willDoNothing()
- .willThrow(new SomethingWasWrong())
- .given(mock).voidMethod();
+ willDoNothing().willThrow(new SomethingWasWrong()).given(mock).voidMethod();
mock.voidMethod();
try {
@@ -174,9 +172,7 @@
@Test
public void should_stub_void_consecutively_with_exception_class() throws Exception {
- willDoNothing()
- .willThrow(SomethingWasWrong.class)
- .given(mock).voidMethod();
+ willDoNothing().willThrow(SomethingWasWrong.class).given(mock).voidMethod();
mock.voidMethod();
try {
@@ -196,33 +192,36 @@
@Test
public void should_stub_using_do_answer_style() throws Exception {
- willAnswer(new Answer<String>() {
- public String answer(InvocationOnMock invocation) throws Throwable {
- return invocation.getArgument(0);
- }
- })
- .given(mock).simpleMethod(anyString());
+ willAnswer(
+ new Answer<String>() {
+ public String answer(InvocationOnMock invocation) throws Throwable {
+ return invocation.getArgument(0);
+ }
+ })
+ .given(mock)
+ .simpleMethod(anyString());
Assertions.assertThat(mock.simpleMethod("foo")).isEqualTo("foo");
}
@Test
public void should_stub_by_delegating_to_real_method() throws Exception {
- //given
+ // given
Dog dog = mock(Dog.class);
- //when
+ // when
willCallRealMethod().given(dog).bark();
- //then
+ // then
Assertions.assertThat(dog.bark()).isEqualTo("woof");
}
@Test
- public void should_stub_by_delegating_to_real_method_using_typical_stubbing_syntax() throws Exception {
- //given
+ public void should_stub_by_delegating_to_real_method_using_typical_stubbing_syntax()
+ throws Exception {
+ // given
Dog dog = mock(Dog.class);
- //when
+ // when
given(dog.bark()).willCallRealMethod();
- //then
+ // then
Assertions.assertThat(dog.bark()).isEqualTo("woof");
}
@@ -269,6 +268,11 @@
}
@Test
+ public void should_validate_that_mock_had_no_interactions() {
+ then(mock).shouldHaveNoInteractions();
+ }
+
+ @Test
public void should_fail_when_mock_had_unwanted_interactions() {
mock.booleanObjectReturningMethod();
@@ -367,25 +371,18 @@
static class Person {
- void ride(Bike bike) {
- }
+ void ride(Bike bike) {}
- void drive(Car car) {
- }
+ void drive(Car car) {}
}
- static class Bike {
+ static class Bike {}
- }
-
- static class Car {
-
- }
+ static class Car {}
static class Police {
- void chase(Car car) {
- }
+ void chase(Car car) {}
}
class Dog {
@@ -395,11 +392,7 @@
}
}
- private class SomethingWasWrong extends RuntimeException {
+ private class SomethingWasWrong extends RuntimeException {}
- }
-
- private class AnotherThingWasWrong extends RuntimeException {
-
- }
+ private class AnotherThingWasWrong extends RuntimeException {}
}
diff --git a/src/test/java/org/mockitousage/debugging/Foo.java b/src/test/java/org/mockitousage/debugging/Foo.java
index be52a98..6a3c747 100644
--- a/src/test/java/org/mockitousage/debugging/Foo.java
+++ b/src/test/java/org/mockitousage/debugging/Foo.java
@@ -6,5 +6,6 @@
interface Foo {
String giveMeSomeString(String param);
+
void doSomething(String param);
}
diff --git a/src/test/java/org/mockitousage/debugging/InvocationListenerCallbackTest.java b/src/test/java/org/mockitousage/debugging/InvocationListenerCallbackTest.java
index e263047..be69b70 100644
--- a/src/test/java/org/mockitousage/debugging/InvocationListenerCallbackTest.java
+++ b/src/test/java/org/mockitousage/debugging/InvocationListenerCallbackTest.java
@@ -4,16 +4,6 @@
*/
package org.mockitousage.debugging;
-import org.assertj.core.api.Condition;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.invocation.DescribedInvocation;
-import org.mockito.listeners.InvocationListener;
-import org.mockito.listeners.MethodInvocationReport;
-
-import java.util.ArrayList;
-import java.util.List;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
import static org.mockito.BDDMockito.given;
@@ -24,6 +14,15 @@
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.withSettings;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.assertj.core.api.Condition;
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.invocation.DescribedInvocation;
+import org.mockito.listeners.InvocationListener;
+import org.mockito.listeners.MethodInvocationReport;
/**
* Ensures that custom listeners can be registered and will be called every time
@@ -113,7 +112,8 @@
}
}
- private static Condition<RememberingListener> notifiedFor(final Object returned, final String location) {
+ private static Condition<RememberingListener> notifiedFor(
+ final Object returned, final String location) {
return new Condition<RememberingListener>() {
public boolean matches(RememberingListener toBeAsserted) {
assertThat(toBeAsserted.returnValue).isEqualTo(returned);
@@ -142,9 +142,9 @@
this.invocation = mcr.getInvocation();
this.returnValue = mcr.getReturnedValue();
this.locationOfStubbing = mcr.getLocationOfStubbing();
- listenerContainer.add(this); //so that we can assert on order
+ listenerContainer.add(this); // so that we can assert on order
}
}
- private static class OvenNotWorking extends RuntimeException { }
+ private static class OvenNotWorking extends RuntimeException {}
}
diff --git a/src/test/java/org/mockitousage/debugging/InvocationsPrinterTest.java b/src/test/java/org/mockitousage/debugging/InvocationsPrinterTest.java
index 6c44403..41761ef 100644
--- a/src/test/java/org/mockitousage/debugging/InvocationsPrinterTest.java
+++ b/src/test/java/org/mockitousage/debugging/InvocationsPrinterTest.java
@@ -4,74 +4,88 @@
*/
package org.mockitousage.debugging;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.internal.debugging.InvocationsPrinter;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.when;
-
public class InvocationsPrinterTest extends TestBase {
@Mock IMethods mock;
- @Test public void no_invocations() {
- assertThat(new InvocationsPrinter().printInvocations(mock)).isEqualTo("No interactions and stubbings found for mock: mock");
+ @Test
+ public void no_invocations() {
+ assertThat(new InvocationsPrinter().printInvocations(mock))
+ .isEqualTo("No interactions and stubbings found for mock: mock");
}
- @Test public void prints_invocations() {
+ @Test
+ public void prints_invocations() {
mock.simpleMethod(100);
triggerInteraction();
assertThat(filterLineNo(new InvocationsPrinter().printInvocations(mock)))
- .isEqualTo(filterLineNo("[Mockito] Interactions of: mock\n" +
- " 1. mock.simpleMethod(100);\n" +
- " -> at org.mockitousage.debugging.InvocationsPrinterTest.prints_invocations(InvocationsPrinterTest.java:0)\n" +
- " 2. mock.otherMethod();\n" +
- " -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerInteraction(InvocationsPrinterTest.java:0)\n"));
+ .isEqualTo(
+ filterLineNo(
+ "[Mockito] Interactions of: mock\n"
+ + " 1. mock.simpleMethod(100);\n"
+ + " -> at org.mockitousage.debugging.InvocationsPrinterTest.prints_invocations(InvocationsPrinterTest.java:0)\n"
+ + " 2. mock.otherMethod();\n"
+ + " -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerInteraction(InvocationsPrinterTest.java:0)\n"));
}
- @Test public void prints_stubbings() {
+ @Test
+ public void prints_stubbings() {
triggerStubbing();
assertThat(filterLineNo(new InvocationsPrinter().printInvocations(mock)))
- .isEqualTo(filterLineNo("[Mockito] Unused stubbings of: mock\n" +
- " 1. mock.simpleMethod(\"a\");\n" +
- " - stubbed -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerStubbing(InvocationsPrinterTest.java:70)\n"));
+ .isEqualTo(
+ filterLineNo(
+ "[Mockito] Unused stubbings of: mock\n"
+ + " 1. mock.simpleMethod(\"a\");\n"
+ + " - stubbed -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerStubbing(InvocationsPrinterTest.java:70)\n"));
}
- @Test public void prints_invocations_and_stubbings() {
+ @Test
+ public void prints_invocations_and_stubbings() {
triggerStubbing();
mock.simpleMethod("a");
triggerInteraction();
assertThat(filterLineNo(new InvocationsPrinter().printInvocations(mock)))
- .isEqualTo(filterLineNo("[Mockito] Interactions of: mock\n" +
- " 1. mock.simpleMethod(\"a\");\n" +
- " -> at org.mockitousage.debugging.InvocationsPrinterTest.prints_invocations_and_stubbings(InvocationsPrinterTest.java:49)\n" +
- " - stubbed -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerStubbing(InvocationsPrinterTest.java:73)\n" +
- " 2. mock.otherMethod();\n" +
- " -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerInteraction(InvocationsPrinterTest.java:34)\n"));
+ .isEqualTo(
+ filterLineNo(
+ "[Mockito] Interactions of: mock\n"
+ + " 1. mock.simpleMethod(\"a\");\n"
+ + " -> at org.mockitousage.debugging.InvocationsPrinterTest.prints_invocations_and_stubbings(InvocationsPrinterTest.java:49)\n"
+ + " - stubbed -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerStubbing(InvocationsPrinterTest.java:73)\n"
+ + " 2. mock.otherMethod();\n"
+ + " -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerInteraction(InvocationsPrinterTest.java:34)\n"));
}
- @Test public void prints_invocations_and_unused_stubbings() {
+ @Test
+ public void prints_invocations_and_unused_stubbings() {
triggerStubbing();
mock.simpleMethod("b");
triggerInteraction();
assertThat(filterLineNo(new InvocationsPrinter().printInvocations(mock)))
- .isEqualTo(filterLineNo("[Mockito] Interactions of: mock\n" +
- " 1. mock.simpleMethod(\"b\");\n" +
- " -> at org.mockitousage.debugging.InvocationsPrinterTest.prints_invocations_and_unused_stubbings(InvocationsPrinterTest.java:55)\n" +
- " 2. mock.otherMethod();\n" +
- " -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerInteraction(InvocationsPrinterTest.java:34)\n" +
- "[Mockito] Unused stubbings of: mock\n" +
- " 1. mock.simpleMethod(\"a\");\n" +
- " - stubbed -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerStubbing(InvocationsPrinterTest.java:62)\n"));
+ .isEqualTo(
+ filterLineNo(
+ "[Mockito] Interactions of: mock\n"
+ + " 1. mock.simpleMethod(\"b\");\n"
+ + " -> at org.mockitousage.debugging.InvocationsPrinterTest.prints_invocations_and_unused_stubbings(InvocationsPrinterTest.java:55)\n"
+ + " 2. mock.otherMethod();\n"
+ + " -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerInteraction(InvocationsPrinterTest.java:34)\n"
+ + "[Mockito] Unused stubbings of: mock\n"
+ + " 1. mock.simpleMethod(\"a\");\n"
+ + " - stubbed -> at org.mockitousage.debugging.InvocationsPrinterTest.triggerStubbing(InvocationsPrinterTest.java:62)\n"));
}
private void triggerInteraction() {
diff --git a/src/test/java/org/mockitousage/debugging/NewMockito.java b/src/test/java/org/mockitousage/debugging/NewMockito.java
index e8cf272..07cb625 100644
--- a/src/test/java/org/mockitousage/debugging/NewMockito.java
+++ b/src/test/java/org/mockitousage/debugging/NewMockito.java
@@ -8,7 +8,7 @@
import org.mockito.MockitoDebugger;
import org.mockito.internal.debugging.MockitoDebuggerImpl;
-//TODO get rid when debug() finally is out
+// TODO get rid when debug() finally is out
public class NewMockito extends Mockito {
public static MockitoDebugger debug() {
diff --git a/src/test/java/org/mockitousage/debugging/StubbingLookupListenerCallbackTest.java b/src/test/java/org/mockitousage/debugging/StubbingLookupListenerCallbackTest.java
new file mode 100644
index 0000000..5a57833
--- /dev/null
+++ b/src/test/java/org/mockitousage/debugging/StubbingLookupListenerCallbackTest.java
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.debugging;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.InOrder;
+import org.mockito.listeners.StubbingLookupEvent;
+import org.mockito.listeners.StubbingLookupListener;
+import org.mockito.mock.MockCreationSettings;
+import org.mockitousage.IMethods;
+import org.mockitoutil.ConcurrentTesting;
+import org.mockitoutil.TestBase;
+
+public class StubbingLookupListenerCallbackTest extends TestBase {
+
+ StubbingLookupListener listener = mock(StubbingLookupListener.class);
+ StubbingLookupListener listener2 = mock(StubbingLookupListener.class);
+ Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener));
+
+ @Test
+ public void should_call_listener_when_mock_return_normally_with_stubbed_answer() {
+ // given
+ doReturn("coke").when(mock).giveMeSomeString("soda");
+ doReturn("java").when(mock).giveMeSomeString("coffee");
+
+ // when
+ mock.giveMeSomeString("soda");
+
+ // then
+ verify(listener)
+ .onStubbingLookup(
+ argThat(
+ new ArgumentMatcher<StubbingLookupEvent>() {
+ @Override
+ public boolean matches(StubbingLookupEvent argument) {
+ assertEquals(
+ "soda", argument.getInvocation().getArgument(0));
+ assertEquals(
+ "mock",
+ argument.getMockSettings()
+ .getMockName()
+ .toString());
+ assertEquals(2, argument.getAllStubbings().size());
+ assertNotNull(argument.getStubbingFound());
+ return true;
+ }
+ }));
+ }
+
+ @Test
+ public void should_call_listener_when_mock_return_normally_with_default_answer() {
+ // given
+ doReturn("java").when(mock).giveMeSomeString("coffee");
+
+ // when
+ mock.giveMeSomeString("soda");
+
+ // then
+ verify(listener)
+ .onStubbingLookup(
+ argThat(
+ new ArgumentMatcher<StubbingLookupEvent>() {
+ @Override
+ public boolean matches(StubbingLookupEvent argument) {
+ assertEquals(
+ "soda", argument.getInvocation().getArgument(0));
+ assertEquals(
+ "mock",
+ argument.getMockSettings()
+ .getMockName()
+ .toString());
+ assertEquals(1, argument.getAllStubbings().size());
+ assertNull(argument.getStubbingFound());
+ return true;
+ }
+ }));
+ }
+
+ @Test
+ public void should_not_call_listener_when_mock_is_not_called() {
+ // when stubbing is recorded
+ doReturn("java").when(mock).giveMeSomeString("coffee");
+
+ // then
+ verifyZeroInteractions(listener);
+ }
+
+ @Test
+ public void should_allow_same_listener() {
+ // given
+ Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener));
+
+ // when
+ mock.giveMeSomeString("tea");
+ mock.giveMeSomeString("coke");
+
+ // then each listener was notified 2 times (notified 4 times in total)
+ verify(listener, times(4)).onStubbingLookup(any(StubbingLookupEvent.class));
+ }
+
+ @Test
+ public void should_call_all_listeners_in_order() {
+ // given
+ Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener2));
+ doReturn("sprite").when(mock).giveMeSomeString("soda");
+
+ // when
+ mock.giveMeSomeString("soda");
+
+ // then
+ InOrder inOrder = inOrder(listener, listener2);
+ inOrder.verify(listener).onStubbingLookup(any(StubbingLookupEvent.class));
+ inOrder.verify(listener2).onStubbingLookup(any(StubbingLookupEvent.class));
+ }
+
+ @Test
+ public void should_call_all_listeners_when_mock_throws_exception() {
+ // given
+ Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener2));
+ doThrow(new NoWater()).when(mock).giveMeSomeString("tea");
+
+ // when
+ try {
+ mock.giveMeSomeString("tea");
+ fail();
+ } catch (NoWater e) {
+ // then
+ verify(listener).onStubbingLookup(any(StubbingLookupEvent.class));
+ verify(listener2).onStubbingLookup(any(StubbingLookupEvent.class));
+ }
+ }
+
+ @Test
+ public void should_delete_listener() {
+ // given
+ Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener2));
+
+ // when
+ mock.doSomething("1");
+ mockingDetails(mock)
+ .getMockCreationSettings()
+ .getStubbingLookupListeners()
+ .remove(listener2);
+ mock.doSomething("2");
+
+ // then
+ verify(listener, times(2)).onStubbingLookup(any(StubbingLookupEvent.class));
+ verify(listener2, times(1)).onStubbingLookup(any(StubbingLookupEvent.class));
+ }
+
+ @Test
+ public void should_clear_listeners() {
+ // given
+ Foo mock = mock(Foo.class, withSettings().stubbingLookupListeners(listener, listener2));
+
+ // when
+ mockingDetails(mock).getMockCreationSettings().getStubbingLookupListeners().clear();
+ mock.doSomething("foo");
+
+ // then
+ verifyZeroInteractions(listener, listener2);
+ }
+
+ @Test
+ public void add_listeners_concurrently_sanity_check() throws Exception {
+ // given
+ final IMethods mock = mock(IMethods.class);
+ final MockCreationSettings<?> settings = mockingDetails(mock).getMockCreationSettings();
+
+ List<Runnable> runnables = new LinkedList<Runnable>();
+ for (int i = 0; i < 50; i++) {
+ runnables.add(
+ new Runnable() {
+ public void run() {
+ StubbingLookupListener listener1 = mock(StubbingLookupListener.class);
+ StubbingLookupListener listener2 = mock(StubbingLookupListener.class);
+ settings.getStubbingLookupListeners().add(listener1);
+ settings.getStubbingLookupListeners().add(listener2);
+ settings.getStubbingLookupListeners().remove(listener1);
+ }
+ });
+ }
+
+ // when
+ ConcurrentTesting.concurrently(runnables.toArray(new Runnable[runnables.size()]));
+
+ // then
+ // This assertion may be flaky. If it is let's fix it or remove the test. For now, I'm
+ // keeping the test.
+ assertEquals(50, settings.getStubbingLookupListeners().size());
+ }
+
+ private static class NoWater extends RuntimeException {}
+}
diff --git a/src/test/java/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java b/src/test/java/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java
index df985ce..6696c12 100644
--- a/src/test/java/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java
+++ b/src/test/java/org/mockitousage/debugging/VerboseLoggingOfInvocationsOnMockTest.java
@@ -4,6 +4,13 @@
*/
package org.mockitousage.debugging;
+import static org.junit.Assert.fail;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.*;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Before;
@@ -13,13 +20,6 @@
import org.mockito.internal.util.MockUtil;
import org.mockito.junit.MockitoJUnitRunner;
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
-
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.*;
-
/**
* Tests the verbose logging of invocation on mock methods.
*
@@ -123,8 +123,8 @@
@Test
public void shouldPrintRealInvocationOnSpyToStdOut() {
// given
- FooImpl fooSpy = mock(FooImpl.class,
- withSettings().spiedInstance(new FooImpl()).verboseLogging());
+ FooImpl fooSpy =
+ mock(FooImpl.class, withSettings().spiedInstance(new FooImpl()).verboseLogging());
doCallRealMethod().when(fooSpy).doSomething("Klipsch");
// when
@@ -142,8 +142,7 @@
public void usage() {
// given
Foo foo = mock(Foo.class, withSettings().verboseLogging());
- given(foo.giveMeSomeString("Apple")).willReturn(
- "earbuds");
+ given(foo.giveMeSomeString("Apple")).willReturn("earbuds");
// when
foo.giveMeSomeString("Shure");
@@ -160,8 +159,7 @@
}
private static class UnrelatedClass {
- void unrelatedMethod(String anotherStringValue) {
- }
+ void unrelatedMethod(String anotherStringValue) {}
}
/**
@@ -177,7 +175,6 @@
return null;
}
- public void doSomething(String param) {
- }
+ public void doSomething(String param) {}
}
}
diff --git a/src/test/java/org/mockitousage/debugging/VerificationListenerCallBackTest.java b/src/test/java/org/mockitousage/debugging/VerificationListenerCallBackTest.java
index 37537a6..7ce75f1 100644
--- a/src/test/java/org/mockitousage/debugging/VerificationListenerCallBackTest.java
+++ b/src/test/java/org/mockitousage/debugging/VerificationListenerCallBackTest.java
@@ -4,6 +4,12 @@
*/
package org.mockitousage.debugging;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
+import java.lang.reflect.Method;
+
import org.assertj.core.api.Condition;
import org.junit.After;
import org.junit.Test;
@@ -18,12 +24,6 @@
import org.mockito.verification.VerificationMode;
import org.mockitoutil.TestBase;
-import java.lang.reflect.Method;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
public class VerificationListenerCallBackTest extends TestBase {
@After
@@ -33,7 +33,7 @@
@Test
public void should_call_single_listener_on_verify() throws NoSuchMethodException {
- //given
+ // given
RememberingListener listener = new RememberingListener();
MockitoFramework mockitoFramework = Mockito.framework();
mockitoFramework.addListener(listener);
@@ -41,17 +41,17 @@
Method invocationWanted = Foo.class.getDeclaredMethod("doSomething", String.class);
Foo foo = mock(Foo.class);
- //when
+ // when
VerificationMode never = never();
verify(foo, never).doSomething("");
- //then
+ // then
assertThat(listener).is(notifiedFor(foo, never, invocationWanted));
}
@Test
public void should_call_all_listeners_on_verify() throws NoSuchMethodException {
- //given
+ // given
RememberingListener listener1 = new RememberingListener();
RememberingListener2 listener2 = new RememberingListener2();
Mockito.framework().addListener(listener1).addListener(listener2);
@@ -59,18 +59,18 @@
Method invocationWanted = Foo.class.getDeclaredMethod("doSomething", String.class);
Foo foo = mock(Foo.class);
- //when
+ // when
VerificationMode never = never();
verify(foo, never).doSomething("");
- //then
+ // then
assertThat(listener1).is(notifiedFor(foo, never, invocationWanted));
assertThat(listener2).is(notifiedFor(foo, never, invocationWanted));
}
@Test
public void should_not_call_listener_when_verify_was_called_incorrectly() {
- //when
+ // when
VerificationListener listener = mock(VerificationListener.class);
framework().addListener(listener);
Foo foo = null;
@@ -79,59 +79,59 @@
verify(foo).doSomething("");
fail("Exception expected.");
} catch (Exception e) {
- //then
+ // then
verify(listener, never()).onVerification(any(VerificationEvent.class));
}
}
@Test
public void should_notify_when_verification_throws_type_error() {
- //given
+ // given
RememberingListener listener = new RememberingListener();
MockitoFramework mockitoFramework = Mockito.framework();
mockitoFramework.addListener(listener);
Foo foo = mock(Foo.class);
- //when
+ // when
try {
verify(foo).doSomething("");
fail("Exception expected.");
} catch (Throwable e) {
- //then
+ // then
assertThat(listener.cause).isInstanceOf(MockitoAssertionError.class);
}
}
@Test
public void should_notify_when_verification_throws_runtime_exception() {
- //given
+ // given
RememberingListener listener = new RememberingListener();
MockitoFramework mockitoFramework = Mockito.framework();
mockitoFramework.addListener(listener);
Foo foo = mock(Foo.class);
- //when
+ // when
try {
verify(foo, new RuntimeExceptionVerificationMode()).doSomething("");
fail("Exception expected.");
} catch (Throwable e) {
- //then
+ // then
assertThat(listener.cause).isInstanceOf(RuntimeException.class);
}
}
@Test
public void should_call_verification_listeners() {
- //given
+ // given
RememberingListener listener = new RememberingListener();
MockitoFramework mockitoFramework = Mockito.framework();
mockitoFramework.addListener(listener);
JUnitCore runner = new JUnitCore();
- //when
+ // when
runner.run(VerificationListenerSample.class);
- //then
+ // then
assertThat(listener.mock).isNotNull();
assertThat(listener.mode).isEqualToComparingFieldByField(times(1));
}
@@ -160,16 +160,16 @@
}
}
- private static class RememberingListener2 extends RememberingListener {
+ private static class RememberingListener2 extends RememberingListener {}
- }
-
- private static Condition<RememberingListener> notifiedFor(final Object mock, final VerificationMode mode, final Method wantedMethod) {
+ private static Condition<RememberingListener> notifiedFor(
+ final Object mock, final VerificationMode mode, final Method wantedMethod) {
return new Condition<RememberingListener>() {
public boolean matches(RememberingListener listener) {
assertThat(listener.mock).isEqualTo(mock);
assertThat(listener.mode).isEqualTo(mode);
- assertThat(listener.data.getTarget().getInvocation().getMethod()).isEqualTo(wantedMethod);
+ assertThat(listener.data.getTarget().getInvocation().getMethod())
+ .isEqualTo(wantedMethod);
return true;
}
diff --git a/src/test/java/org/mockitousage/examples/use/Article.java b/src/test/java/org/mockitousage/examples/use/Article.java
index 6c0d360..f5aef64 100644
--- a/src/test/java/org/mockitousage/examples/use/Article.java
+++ b/src/test/java/org/mockitousage/examples/use/Article.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.examples.use;
public class Article {
diff --git a/src/test/java/org/mockitousage/examples/use/ArticleCalculator.java b/src/test/java/org/mockitousage/examples/use/ArticleCalculator.java
index 8a96f36..b3b5412 100644
--- a/src/test/java/org/mockitousage/examples/use/ArticleCalculator.java
+++ b/src/test/java/org/mockitousage/examples/use/ArticleCalculator.java
@@ -2,12 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.examples.use;
public interface ArticleCalculator {
int countArticles(String newspaper);
+
int countArticlesInPolish(String newspaper);
+
int countNumberOfRelatedArticles(Article article);
- int countAllArticles(String ... publications);
+
+ int countAllArticles(String... publications);
}
diff --git a/src/test/java/org/mockitousage/examples/use/ArticleDatabase.java b/src/test/java/org/mockitousage/examples/use/ArticleDatabase.java
index 7041f54..f459902 100644
--- a/src/test/java/org/mockitousage/examples/use/ArticleDatabase.java
+++ b/src/test/java/org/mockitousage/examples/use/ArticleDatabase.java
@@ -2,26 +2,21 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.examples.use;
import java.util.List;
public class ArticleDatabase {
- public void updateNumberOfArticles(String newspaper, int articles) {
- }
+ public void updateNumberOfArticles(String newspaper, int articles) {}
- public void updateNumberOfPolishArticles(String newspaper, int polishArticles) {
- }
+ public void updateNumberOfPolishArticles(String newspaper, int polishArticles) {}
- public void updateNumberOfEnglishArticles(String newspaper, int i) {
- }
+ public void updateNumberOfEnglishArticles(String newspaper, int i) {}
public List<Article> getArticlesFor(String string) {
return null;
}
- public void save(Article article) {
- }
+ public void save(Article article) {}
}
diff --git a/src/test/java/org/mockitousage/examples/use/ArticleManager.java b/src/test/java/org/mockitousage/examples/use/ArticleManager.java
index 6b6acd9..0468662 100644
--- a/src/test/java/org/mockitousage/examples/use/ArticleManager.java
+++ b/src/test/java/org/mockitousage/examples/use/ArticleManager.java
@@ -2,7 +2,6 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.examples.use;
import java.util.List;
diff --git a/src/test/java/org/mockitousage/examples/use/ExampleTest.java b/src/test/java/org/mockitousage/examples/use/ExampleTest.java
index 87b400c..ec2f407 100644
--- a/src/test/java/org/mockitousage/examples/use/ExampleTest.java
+++ b/src/test/java/org/mockitousage/examples/use/ExampleTest.java
@@ -2,9 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.examples.use;
+import static org.mockito.Mockito.*;
+
+import java.util.Arrays;
+
import org.junit.Rule;
import org.junit.Test;
import org.mockito.InOrder;
@@ -13,10 +16,6 @@
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
-import java.util.Arrays;
-
-import static org.mockito.Mockito.*;
-
public class ExampleTest {
@Rule public MockitoRule rule = MockitoJUnit.rule();
@@ -65,7 +64,8 @@
when(mockCalculator.countNumberOfRelatedArticles(articleTwo)).thenReturn(12);
when(mockCalculator.countNumberOfRelatedArticles(articleThree)).thenReturn(0);
- when(mockDatabase.getArticlesFor("Guardian")).thenReturn(Arrays.asList(articleOne, articleTwo, articleThree));
+ when(mockDatabase.getArticlesFor("Guardian"))
+ .thenReturn(Arrays.asList(articleOne, articleTwo, articleThree));
articleManager.updateRelatedArticlesCounters("Guardian");
@@ -82,7 +82,8 @@
when(mockCalculator.countNumberOfRelatedArticles(articleOne)).thenReturn(1);
when(mockCalculator.countNumberOfRelatedArticles(articleTwo)).thenReturn(12);
- when(mockDatabase.getArticlesFor("Guardian")).thenReturn(Arrays.asList(articleOne, articleTwo));
+ when(mockDatabase.getArticlesFor("Guardian"))
+ .thenReturn(Arrays.asList(articleOne, articleTwo));
articleManager.updateRelatedArticlesCounters("Guardian");
diff --git a/src/test/java/org/mockitousage/internal/debugging/LocationImplTest.java b/src/test/java/org/mockitousage/internal/debugging/LocationImplTest.java
index 1cd495c..d20bfce 100644
--- a/src/test/java/org/mockitousage/internal/debugging/LocationImplTest.java
+++ b/src/test/java/org/mockitousage/internal/debugging/LocationImplTest.java
@@ -5,36 +5,59 @@
package org.mockitousage.internal.debugging;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
import org.junit.Test;
import org.mockito.internal.debugging.LocationImpl;
import org.mockito.internal.exceptions.stacktrace.StackTraceFilter;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-
@SuppressWarnings("serial")
public class LocationImplTest extends TestBase {
@Test
public void shouldLocationNotContainGetStackTraceMethod() {
- assertThat(new LocationImpl().toString()).contains("shouldLocationNotContainGetStackTraceMethod");
+ assertThat(new LocationImpl().toString())
+ .contains("shouldLocationNotContainGetStackTraceMethod");
}
@Test
public void shouldBeSafeInCaseForSomeReasonFilteredStackTraceIsEmpty() {
- //given
- StackTraceFilter filterReturningEmptyArray = new StackTraceFilter() {
- @Override
- public StackTraceElement[] filter(StackTraceElement[] target, boolean keepTop) {
- return new StackTraceElement[0];
- }
- };
+ // given
+ StackTraceFilter filterReturningEmptyArray =
+ new StackTraceFilter() {
+ @Override
+ public StackTraceElement[] filter(StackTraceElement[] target, boolean keepTop) {
+ return new StackTraceElement[0];
+ }
- //when
+ @Override
+ public StackTraceElement filterFirst(Throwable target, boolean isInline) {
+ return null;
+ }
+ };
+
+ // when
String loc = new LocationImpl(filterReturningEmptyArray).toString();
- //then
+ // then
assertEquals("-> at <<unknown line>>", loc);
}
+
+ @Test
+ public void provides_location_class() {
+ // when
+ final List<String> files = new ArrayList<String>();
+ new Runnable() { // anonymous inner class adds stress to the check
+ public void run() {
+ files.add(new LocationImpl().getSourceFile());
+ }
+ }.run();
+
+ // then
+ assertEquals("LocationImplTest.java", files.get(0));
+ }
}
diff --git a/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java b/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java
index 0eb3d7d..38db251 100644
--- a/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java
+++ b/src/test/java/org/mockitousage/internal/junit/UnusedStubbingsFinderTest.java
@@ -4,6 +4,15 @@
*/
package org.mockitousage.internal.junit;
+import static java.util.Arrays.asList;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
+
+import java.util.Collection;
+import java.util.List;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.internal.junit.UnusedStubbings;
@@ -11,14 +20,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.util.Collection;
-import java.util.List;
-
-import static java.util.Arrays.asList;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.when;
-
/**
* This unit test lives in 'org.mockitousage' package for a reason.
* It makes it easy to write tests that depend on the stack trace filtering logic.
@@ -33,38 +34,38 @@
@Test
public void no_interactions() throws Exception {
- //expect
+ // expect
assertEquals(0, finder.getUnusedStubbings((List) asList(mock1, mock2)).size());
assertEquals(0, finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2)).size());
}
@Test
public void no_stubbings() throws Exception {
- //when
+ // when
mock1.simpleMethod();
- //then
+ // then
assertEquals(0, finder.getUnusedStubbings((List) asList(mock1, mock2)).size());
assertEquals(0, finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2)).size());
}
@Test
public void no_unused_stubbings() throws Exception {
- //when
+ // when
when(mock1.simpleMethod()).thenReturn("1");
mock1.simpleMethod();
- //then
+ // then
assertEquals(0, finder.getUnusedStubbings((List) asList(mock1, mock2)).size());
assertEquals(0, finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2)).size());
}
@Test
public void unused_stubbings() throws Exception {
- //when
+ // when
when(mock1.simpleMethod()).thenReturn("1");
- //then
+ // then
assertEquals(1, finder.getUnusedStubbings((List) asList(mock1, mock2)).size());
assertEquals(1, finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2)).size());
}
@@ -77,12 +78,13 @@
mock2.simpleMethod(2);
- //when
+ // when
UnusedStubbings stubbings = finder.getUnusedStubbings((List) asList(mock1, mock2));
- //then
+ // then
assertEquals(2, stubbings.size());
- assertEquals("[mock1.simpleMethod(1); stubbed with: [Returns: 1], mock2.simpleMethod(3); stubbed with: [Returns: 3]]",
+ assertEquals(
+ "[mock1.simpleMethod(1); stubbed with: [Returns: 1], mock2.simpleMethod(3); stubbed with: [Returns: 3]]",
stubbings.toString());
}
@@ -94,13 +96,12 @@
mock1.simpleMethod(1);
- //when
+ // when
UnusedStubbings stubbings = finder.getUnusedStubbings((List) asList(mock1, mock2));
- //then
+ // then
assertEquals(1, stubbings.size());
- assertEquals("[mock1.simpleMethod(2); stubbed with: [Returns: 2]]",
- stubbings.toString());
+ assertEquals("[mock1.simpleMethod(2); stubbed with: [Returns: 2]]", stubbings.toString());
}
@Test
@@ -108,43 +109,43 @@
when(mock1.simpleMethod(1)).thenReturn("1");
when(mock2.simpleMethod(2)).thenReturn("2");
when(mock2.simpleMethod(3)).thenReturn("3");
- lenient().when(mock2.differentMethod()).thenReturn("4"); //will not be included in results
+ lenient().when(mock2.differentMethod()).thenReturn("4"); // will not be included in results
mock2.simpleMethod(2);
- //when
+ // when
Collection stubbings = finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2));
- //then
+ // then
assertEquals(2, stubbings.size());
assertEquals("[mock1.simpleMethod(1);, mock2.simpleMethod(3);]", stubbings.toString());
}
@Test
public void stubbing_used_by_location() throws Exception {
- //when
- //Emulating stubbing in the same location by putting stubbing in the same line:
+ // when
+ // Emulating stubbing in the same location by putting stubbing in the same line:
when(mock1.simpleMethod(1)).thenReturn("1"); when(mock2.simpleMethod(1)).thenReturn("1");
- //End of emulation
+ // End of emulation
mock1.simpleMethod(1);
- //then technically unused stubbings exist
+ // then technically unused stubbings exist
assertEquals(1, finder.getUnusedStubbings((List) asList(mock1, mock2)).size());
- //however if we consider stubbings in the same location as the same stubbing, all is used:
+ // however if we consider stubbings in the same location as the same stubbing, all is used:
assertEquals(0, finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2)).size());
}
@Test
public void deduplicates_stubbings_by_location() throws Exception {
- //when
- //Emulating stubbing in the same location by putting stubbing in the same line:
+ // when
+ // Emulating stubbing in the same location by putting stubbing in the same line:
when(mock1.simpleMethod(1)).thenReturn("1"); when(mock2.simpleMethod(1)).thenReturn("1");
- //End of emulation
+ // End of emulation
- //when
+ // when
Collection stubbings = finder.getUnusedStubbingsByLocation((List) asList(mock1, mock2));
- //then
+ // then
assertEquals(1, stubbings.size());
}
}
diff --git a/src/test/java/org/mockitousage/jls/JLS_15_12_2_5Test.java b/src/test/java/org/mockitousage/jls/JLS_15_12_2_5Test.java
index b427b30..1c3dcb5 100644
--- a/src/test/java/org/mockitousage/jls/JLS_15_12_2_5Test.java
+++ b/src/test/java/org/mockitousage/jls/JLS_15_12_2_5Test.java
@@ -4,13 +4,6 @@
*/
package org.mockitousage.jls;
-import net.bytebuddy.ClassFileVersion;
-import org.junit.Assume;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.experimental.runners.Enclosed;
-import org.junit.runner.RunWith;
-
import static net.bytebuddy.ClassFileVersion.JAVA_V6;
import static net.bytebuddy.ClassFileVersion.JAVA_V7;
import static net.bytebuddy.ClassFileVersion.JAVA_V8;
@@ -19,6 +12,12 @@
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import net.bytebuddy.ClassFileVersion;
+import org.junit.Assume;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
/**
* Illustrate differences in the JLS depending on the Java version.
@@ -46,8 +45,10 @@
public static class JLS_15_12_2_5_Java6_Java7_Test {
@Before
public void setUp() throws Exception {
- Assume.assumeTrue(ClassFileVersion.of(JLS_15_12_2_5_Java6_Java7_Test.class).equals(JAVA_V6)
- || ClassFileVersion.of(JLS_15_12_2_5_Java6_Java7_Test.class).equals(JAVA_V7));
+ Assume.assumeTrue(
+ ClassFileVersion.of(JLS_15_12_2_5_Java6_Java7_Test.class).equals(JAVA_V6)
+ || ClassFileVersion.of(JLS_15_12_2_5_Java6_Java7_Test.class)
+ .equals(JAVA_V7));
}
@Test
@@ -56,10 +57,12 @@
when(mock.oneArg(isNull())).thenReturn("ok");
- assertThat(mock.oneArg(null)).describedAs("Most generic method chosen for matcher " +
- "(isNull generic upper bound is Object), but null applies " +
- "to select most specific method")
- .isEqualTo(null);
+ assertThat(mock.oneArg(null))
+ .describedAs(
+ "Most generic method chosen for matcher "
+ + "(isNull generic upper bound is Object), but null applies "
+ + "to select most specific method")
+ .isEqualTo(null);
}
@Test
@@ -68,7 +71,9 @@
when(mock.oneArg((String) isNull())).thenReturn("ok");
- assertThat(mock.oneArg(null)).describedAs("Most specific method enforced for matcher via cast").isEqualTo("ok");
+ assertThat(mock.oneArg(null))
+ .describedAs("Most specific method enforced for matcher via cast")
+ .isEqualTo("ok");
}
@Test
@@ -78,7 +83,9 @@
when(mock.oneArg(isNull())).thenReturn("ok");
Object arg = null;
- assertThat(mock.oneArg(arg)).describedAs("Most generic method chosen for matcher").isEqualTo("ok");
+ assertThat(mock.oneArg(arg))
+ .describedAs("Most generic method chosen for matcher")
+ .isEqualTo("ok");
}
@Test
@@ -87,10 +94,12 @@
when(mock.varargs(isNull())).thenReturn("ok");
- assertThat(mock.varargs(null)).describedAs("Most generic method chosen for matcher " +
- "(isNull generic upper bound is Object), but null applies " +
- "to select most specific method")
- .isEqualTo(null);
+ assertThat(mock.varargs(null))
+ .describedAs(
+ "Most generic method chosen for matcher "
+ + "(isNull generic upper bound is Object), but null applies "
+ + "to select most specific method")
+ .isEqualTo(null);
}
@Test
@@ -99,7 +108,9 @@
when(mock.varargs((String) isNull())).thenReturn("ok");
- assertThat(mock.varargs(null)).describedAs("Most specific method enforced for matcher via String cast").isEqualTo("ok");
+ assertThat(mock.varargs(null))
+ .describedAs("Most specific method enforced for matcher via String cast")
+ .isEqualTo("ok");
}
@Test
@@ -108,7 +119,9 @@
when(mock.varargs((String[]) isNull())).thenReturn("ok");
- assertThat(mock.varargs(null)).describedAs("Most specific method enforced for matcher via String[] cast").isEqualTo("ok");
+ assertThat(mock.varargs(null))
+ .describedAs("Most specific method enforced for matcher via String[] cast")
+ .isEqualTo("ok");
}
@Test
@@ -118,7 +131,9 @@
when(mock.varargs(isNull())).thenReturn("ok");
Object[] args = null;
- assertThat(mock.varargs(args)).describedAs("isNull matcher generic upper bound is Object").isEqualTo("ok");
+ assertThat(mock.varargs(args))
+ .describedAs("isNull matcher generic upper bound is Object")
+ .isEqualTo("ok");
}
@Test
@@ -128,7 +143,9 @@
when(mock.varargs(isNull())).thenReturn("ok");
Object arg = null;
- assertThat(mock.varargs(arg)).describedAs("isNull matcher generic upper bound is Object").isEqualTo("ok");
+ assertThat(mock.varargs(arg))
+ .describedAs("isNull matcher generic upper bound is Object")
+ .isEqualTo("ok");
}
}
@@ -181,7 +198,8 @@
public static class JLS_15_12_2_5_Java8_Test {
@Before
public void setUp() throws Exception {
- Assume.assumeTrue(ClassFileVersion.of(JLS_15_12_2_5_Java8_Test.class).isAtLeast(JAVA_V8));
+ Assume.assumeTrue(
+ ClassFileVersion.of(JLS_15_12_2_5_Java8_Test.class).isAtLeast(JAVA_V8));
}
@Test
@@ -190,7 +208,9 @@
when(mock.oneArg(isNull())).thenReturn("ok");
- assertThat(mock.oneArg(null)).describedAs("Most specific method chosen for matcher and for null").isEqualTo("ok");
+ assertThat(mock.oneArg(null))
+ .describedAs("Most specific method chosen for matcher and for null")
+ .isEqualTo("ok");
}
@Test
@@ -209,7 +229,9 @@
when(mock.varargs(isNull())).thenReturn("ok");
- assertThat(mock.varargs(null)).describedAs("Most specific method chosen for matcher and for null").isEqualTo("ok");
+ assertThat(mock.varargs(null))
+ .describedAs("Most specific method chosen for matcher and for null")
+ .isEqualTo("ok");
}
@Test
@@ -219,7 +241,9 @@
when(mock.varargs(isNull())).thenReturn("ok");
Object[] args = null;
- assertThat(mock.varargs(args)).describedAs("Most specific method chosen for matcher").isEqualTo(null);
+ assertThat(mock.varargs(args))
+ .describedAs("Most specific method chosen for matcher")
+ .isEqualTo(null);
}
@Test
@@ -229,16 +253,19 @@
when(mock.varargs(isNull())).thenReturn("ok");
Object arg = null;
- assertThat(mock.varargs(arg)).describedAs("Most specific method chosen for matcher").isEqualTo(null);
+ assertThat(mock.varargs(arg))
+ .describedAs("Most specific method chosen for matcher")
+ .isEqualTo(null);
}
-
}
interface SingleOverload {
String oneArg(Object arg);
+
String oneArg(String arg);
+
String varargs(Object... args);
+
String varargs(String... args);
}
-
}
diff --git a/src/test/java/org/mockitousage/junitrule/InvalidTargetMockitoJUnitRuleTest.java b/src/test/java/org/mockitousage/junitrule/InvalidTargetMockitoJUnitRuleTest.java
index ce0eb07..b206151 100644
--- a/src/test/java/org/mockitousage/junitrule/InvalidTargetMockitoJUnitRuleTest.java
+++ b/src/test/java/org/mockitousage/junitrule/InvalidTargetMockitoJUnitRuleTest.java
@@ -4,6 +4,8 @@
*/
package org.mockitousage.junitrule;
+import static org.junit.Assert.assertNotNull;
+
import org.junit.Rule;
import org.junit.Test;
import org.mockito.InjectMocks;
@@ -11,18 +13,13 @@
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
-import static org.junit.Assert.assertNotNull;
-
public class InvalidTargetMockitoJUnitRuleTest {
- @Rule
- public MockitoRule mockitoJUnitRule = MockitoJUnit.rule();
+ @Rule public MockitoRule mockitoJUnitRule = MockitoJUnit.rule();
- @Mock
- private Injected injected;
+ @Mock private Injected injected;
- @InjectMocks
- private InjectInto injectInto;
+ @InjectMocks private InjectInto injectInto;
@Test
public void shouldInjectWithInvalidReference() throws Exception {
@@ -30,7 +27,7 @@
assertNotNull("Test object created", injectInto);
}
- public static class Injected { }
+ public static class Injected {}
public static class InjectInto {
private Injected injected;
diff --git a/src/test/java/org/mockitousage/junitrule/JUnitTestRuleIntegratesWithRuleChainTest.java b/src/test/java/org/mockitousage/junitrule/JUnitTestRuleIntegratesWithRuleChainTest.java
new file mode 100644
index 0000000..498d2bc
--- /dev/null
+++ b/src/test/java/org/mockitousage/junitrule/JUnitTestRuleIntegratesWithRuleChainTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2020 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrule;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.RuleChain;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runners.model.Statement;
+import org.mockito.Mock;
+import org.mockito.internal.util.MockUtil;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitoutil.JUnitResultAssert;
+
+public class JUnitTestRuleIntegratesWithRuleChainTest {
+
+ JUnitCore runner = new JUnitCore();
+
+ @Test
+ public void rule_can_be_changed_to_strict() {
+ // when
+ Result result = runner.run(StrictByDefault.class);
+
+ // then
+ JUnitResultAssert.assertThat(result).succeeds(1).fails(1, RuntimeException.class);
+ }
+
+ @Test
+ public void rule_can_be_changed_to_lenient() {
+ // when
+ Result result = runner.run(LenientByDefault.class);
+
+ // then
+ JUnitResultAssert.assertThat(result).isSuccessful();
+ }
+
+ public static class LenientByDefault {
+ @Rule
+ public final RuleChain chain =
+ RuleChain.outerRule(MockitoJUnit.testRule(this))
+ .around(
+ (base, description) ->
+ new Statement() {
+ @Override
+ public void evaluate() throws Throwable {
+ assertThat(MockUtil.isMock(mock)).isTrue();
+ called.set(true);
+ base.evaluate();
+ }
+ });
+
+ @Mock public IMethods mock;
+
+ private AtomicBoolean called = new AtomicBoolean(false);
+
+ @Test
+ public void creates_mocks_in_correct_rulechain_ordering() {
+ assertThat(MockUtil.isMock(mock)).isTrue();
+ assertThat(called.get()).isTrue();
+ }
+ }
+
+ public static class StrictByDefault {
+ @Rule
+ public final RuleChain chain =
+ RuleChain.outerRule(MockitoJUnit.testRule(this).strictness(Strictness.STRICT_STUBS))
+ .around(
+ (base, description) ->
+ new Statement() {
+ @Override
+ public void evaluate() throws Throwable {
+ assertThat(MockUtil.isMock(mock)).isTrue();
+ called.set(true);
+ base.evaluate();
+ }
+ });
+
+ @Mock public IMethods mock;
+
+ private AtomicBoolean called = new AtomicBoolean(false);
+
+ @Test
+ public void creates_mocks_in_correct_rulechain_ordering() {
+ assertThat(MockUtil.isMock(mock)).isTrue();
+ assertThat(called.get()).isTrue();
+ }
+
+ @Test
+ public void unused_stub() throws Throwable {
+ when(mock.simpleMethod()).thenReturn("1");
+ assertThat(called.get()).isTrue();
+ }
+ }
+}
diff --git a/src/test/java/org/mockitousage/junitrule/LenientJUnitRuleTest.java b/src/test/java/org/mockitousage/junitrule/LenientJUnitRuleTest.java
index 2e13171..c72e0ce 100644
--- a/src/test/java/org/mockitousage/junitrule/LenientJUnitRuleTest.java
+++ b/src/test/java/org/mockitousage/junitrule/LenientJUnitRuleTest.java
@@ -4,38 +4,43 @@
*/
package org.mockitousage.junitrule;
+import static org.mockito.Mockito.when;
+
import org.junit.Rule;
import org.junit.Test;
import org.mockito.Mock;
-import org.mockito.quality.Strictness;
import org.mockito.internal.junit.JUnitRule;
-import org.mockito.internal.util.MockitoLogger;
import org.mockito.junit.MockitoRule;
+import org.mockito.plugins.MockitoLogger;
+import org.mockito.quality.Strictness;
import org.mockitousage.IMethods;
-import static org.mockito.Mockito.when;
-
public class LenientJUnitRuleTest {
- private MockitoLogger explosiveLogger = new MockitoLogger() {
- public void log(Object what) {
- throw new RuntimeException("Silent rule should not write anything to the logger");
- }
- };
+ private MockitoLogger explosiveLogger =
+ new MockitoLogger() {
+ public void log(Object what) {
+ throw new RuntimeException(
+ "Silent rule should not write anything to the logger");
+ }
+ };
@Mock private IMethods mock;
@Rule public MockitoRule mockitoRule = new JUnitRule(explosiveLogger, Strictness.LENIENT);
- @Test public void no_warning_for_unused_stubbing() throws Exception {
+ @Test
+ public void no_warning_for_unused_stubbing() throws Exception {
when(mock.simpleMethod(1)).thenReturn("1");
}
- @Test public void no_warning_for_stubbing_arg_mismatch() throws Exception {
+ @Test
+ public void no_warning_for_stubbing_arg_mismatch() throws Exception {
when(mock.simpleMethod(1)).thenReturn("1");
mock.simpleMethod(2);
}
- @Test(expected = IllegalStateException.class) public void no_warning_for_stubbing_arg_mismatch_on_failure() throws Exception {
+ @Test(expected = IllegalStateException.class)
+ public void no_warning_for_stubbing_arg_mismatch_on_failure() throws Exception {
when(mock.simpleMethod(1)).thenReturn("1");
mock.simpleMethod(2);
throw new IllegalStateException("hey!");
diff --git a/src/test/java/org/mockitousage/junitrule/MockitoJUnitRuleTest.java b/src/test/java/org/mockitousage/junitrule/MockitoJUnitRuleTest.java
index dfec883..1c6930e 100644
--- a/src/test/java/org/mockitousage/junitrule/MockitoJUnitRuleTest.java
+++ b/src/test/java/org/mockitousage/junitrule/MockitoJUnitRuleTest.java
@@ -4,6 +4,9 @@
*/
package org.mockitousage.junitrule;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
import org.junit.Rule;
import org.junit.Test;
import org.mockito.InjectMocks;
@@ -11,19 +14,16 @@
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
public class MockitoJUnitRuleTest {
- @Rule
- public MockitoRule mockitoRule = MockitoJUnit.rule();
+ @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
- @Mock
- private Injected injected;
+ // Fixes #1578: Protect against multiple execution.
+ @Rule public MockitoRule mockitoRule2 = mockitoRule;
- @InjectMocks
- private InjectInto injectInto;
+ @Mock private Injected injected;
+
+ @InjectMocks private InjectInto injectInto;
@Test
public void testInjectMocks() throws Exception {
@@ -32,7 +32,7 @@
assertEquals("A injected into B", injected, injectInto.getInjected());
}
- public static class Injected { }
+ public static class Injected {}
public static class InjectInto {
private Injected injected;
diff --git a/src/test/java/org/mockitousage/junitrule/MockitoJUnitTestRuleTest.java b/src/test/java/org/mockitousage/junitrule/MockitoJUnitTestRuleTest.java
new file mode 100644
index 0000000..122b3c1
--- /dev/null
+++ b/src/test/java/org/mockitousage/junitrule/MockitoJUnitTestRuleTest.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrule;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoTestRule;
+
+public class MockitoJUnitTestRuleTest {
+
+ @Rule public MockitoTestRule mockitoRule = MockitoJUnit.testRule(this);
+
+ // Fixes #1578: Protect against multiple execution.
+ @Rule public MockitoTestRule mockitoRule2 = mockitoRule;
+
+ @Mock private Injected injected;
+
+ @InjectMocks private InjectInto injectInto;
+
+ @Test
+ public void testInjectMocks() throws Exception {
+ assertNotNull("Mock created", injected);
+ assertNotNull("Object created", injectInto);
+ assertEquals("A injected into B", injected, injectInto.getInjected());
+ }
+
+ public static class Injected {}
+
+ public static class InjectInto {
+ private Injected injected;
+
+ public Injected getInjected() {
+ return injected;
+ }
+ }
+}
diff --git a/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitRuleTest.java b/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitRuleTest.java
index b9208e5..b0efc2c 100644
--- a/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitRuleTest.java
+++ b/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitRuleTest.java
@@ -4,6 +4,8 @@
*/
package org.mockitousage.junitrule;
+import static org.mockito.Mockito.when;
+
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.JUnitCore;
@@ -15,42 +17,40 @@
import org.mockitousage.IMethods;
import org.mockitoutil.JUnitResultAssert;
-import static org.mockito.Mockito.when;
-
public class MutableStrictJUnitRuleTest {
JUnitCore runner = new JUnitCore();
- @Test public void rule_can_be_changed_to_strict() throws Throwable {
- //when
+ @Test
+ public void rule_can_be_changed_to_strict() throws Throwable {
+ // when
Result result = runner.run(LenientByDefault.class);
- //then
- JUnitResultAssert.assertThat(result)
- .succeeds(1)
- .fails(1, RuntimeException.class);
+ // then
+ JUnitResultAssert.assertThat(result).succeeds(1).fails(1, RuntimeException.class);
}
- @Test public void rule_can_be_changed_to_lenient() throws Throwable {
- //when
+ @Test
+ public void rule_can_be_changed_to_lenient() throws Throwable {
+ // when
Result result = runner.run(StrictByDefault.class);
- //then
- JUnitResultAssert.assertThat(result)
- .succeeds(1)
- .fails(1, RuntimeException.class);
+ // then
+ JUnitResultAssert.assertThat(result).succeeds(1).fails(1, RuntimeException.class);
}
public static class LenientByDefault {
@Rule public MockitoRule mockito = MockitoJUnit.rule().strictness(Strictness.LENIENT);
@Mock IMethods mock;
- @Test public void unused_stub() throws Throwable {
+ @Test
+ public void unused_stub() throws Throwable {
when(mock.simpleMethod()).thenReturn("1");
}
- @Test public void unused_stub_with_strictness() throws Throwable {
- //making Mockito strict only for this test method
+ @Test
+ public void unused_stub_with_strictness() throws Throwable {
+ // making Mockito strict only for this test method
mockito.strictness(Strictness.STRICT_STUBS);
when(mock.simpleMethod()).thenReturn("1");
@@ -61,12 +61,14 @@
@Rule public MockitoRule mockito = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
@Mock IMethods mock;
- @Test public void unused_stub() throws Throwable {
+ @Test
+ public void unused_stub() throws Throwable {
when(mock.simpleMethod()).thenReturn("1");
}
- @Test public void unused_stub_with_lenient() throws Throwable {
- //making Mockito lenient only for this test method
+ @Test
+ public void unused_stub_with_lenient() throws Throwable {
+ // making Mockito lenient only for this test method
mockito.strictness(Strictness.LENIENT);
when(mock.simpleMethod()).thenReturn("1");
diff --git a/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitTestRuleTest.java b/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitTestRuleTest.java
new file mode 100644
index 0000000..1e2faac
--- /dev/null
+++ b/src/test/java/org/mockitousage/junitrule/MutableStrictJUnitTestRuleTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.junitrule;
+
+import static org.mockito.Mockito.when;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoTestRule;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitoutil.JUnitResultAssert;
+
+public class MutableStrictJUnitTestRuleTest {
+
+ JUnitCore runner = new JUnitCore();
+
+ @Test
+ public void rule_can_be_changed_to_strict() throws Throwable {
+ // when
+ Result result = runner.run(LenientByDefault.class);
+
+ // then
+ JUnitResultAssert.assertThat(result).succeeds(1).fails(1, RuntimeException.class);
+ }
+
+ @Test
+ public void rule_can_be_changed_to_lenient() throws Throwable {
+ // when
+ Result result = runner.run(StrictByDefault.class);
+
+ // then
+ JUnitResultAssert.assertThat(result).succeeds(1).fails(1, RuntimeException.class);
+ }
+
+ public static class LenientByDefault {
+ @Rule
+ public MockitoTestRule mockito = MockitoJUnit.testRule(this).strictness(Strictness.LENIENT);
+
+ @Mock IMethods mock;
+
+ @Test
+ public void unused_stub() throws Throwable {
+ when(mock.simpleMethod()).thenReturn("1");
+ }
+
+ @Test
+ public void unused_stub_with_strictness() throws Throwable {
+ // making Mockito strict only for this test method
+ mockito.strictness(Strictness.STRICT_STUBS);
+
+ when(mock.simpleMethod()).thenReturn("1");
+ }
+ }
+
+ public static class StrictByDefault {
+ @Rule
+ public MockitoTestRule mockito =
+ MockitoJUnit.testRule(this).strictness(Strictness.STRICT_STUBS);
+
+ @Mock IMethods mock;
+
+ @Test
+ public void unused_stub() throws Throwable {
+ when(mock.simpleMethod()).thenReturn("1");
+ }
+
+ @Test
+ public void unused_stub_with_lenient() throws Throwable {
+ // making Mockito lenient only for this test method
+ mockito.strictness(Strictness.LENIENT);
+
+ when(mock.simpleMethod()).thenReturn("1");
+ }
+ }
+}
diff --git a/src/test/java/org/mockitousage/junitrule/RuleTestWithFactoryMethodTest.java b/src/test/java/org/mockitousage/junitrule/RuleTestWithFactoryMethodTest.java
index 626e581..e7d6130 100644
--- a/src/test/java/org/mockitousage/junitrule/RuleTestWithFactoryMethodTest.java
+++ b/src/test/java/org/mockitousage/junitrule/RuleTestWithFactoryMethodTest.java
@@ -4,6 +4,9 @@
*/
package org.mockitousage.junitrule;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
import org.junit.Rule;
import org.junit.Test;
import org.mockito.InjectMocks;
@@ -11,30 +14,22 @@
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
public class RuleTestWithFactoryMethodTest {
- @Rule
- public MockitoRule mockitoRule = MockitoJUnit.rule();
+ @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
- @Mock
- private Injected injected;
+ @Mock private Injected injected;
- @InjectMocks
- private InjectInto injectInto;
+ @InjectMocks private InjectInto injectInto;
@Test
public void testInjectMocks() throws Exception {
assertNotNull("Mock created", injected);
assertNotNull("Object created", injectInto);
assertEquals("A injected into B", injected, injectInto.getInjected());
-
}
- public static class Injected {
- }
+ public static class Injected {}
public static class InjectInto {
diff --git a/src/test/java/org/mockitousage/junitrule/RuleTestWithParameterConstructorTest.java b/src/test/java/org/mockitousage/junitrule/RuleTestWithParameterConstructorTest.java
index 78196f6..be56e87 100644
--- a/src/test/java/org/mockitousage/junitrule/RuleTestWithParameterConstructorTest.java
+++ b/src/test/java/org/mockitousage/junitrule/RuleTestWithParameterConstructorTest.java
@@ -4,6 +4,9 @@
*/
package org.mockitousage.junitrule;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
import org.junit.Rule;
import org.junit.Test;
import org.mockito.InjectMocks;
@@ -11,30 +14,22 @@
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
public class RuleTestWithParameterConstructorTest {
- @Rule
- public MockitoRule mockitoJUnitRule = MockitoJUnit.rule();
+ @Rule public MockitoRule mockitoJUnitRule = MockitoJUnit.rule();
- @Mock
- private Injected injected;
+ @Mock private Injected injected;
- @InjectMocks
- private InjectInto injectInto;
+ @InjectMocks private InjectInto injectInto;
@Test
public void testInjectMocks() throws Exception {
assertNotNull("Mock created", injected);
assertNotNull("Object created", injectInto);
assertEquals("A injected into B", injected, injectInto.getInjected());
-
}
- public static class Injected {
- }
+ public static class Injected {}
public static class InjectInto {
diff --git a/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java b/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
index b802013..6c6d1ac 100644
--- a/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
+++ b/src/test/java/org/mockitousage/junitrule/StrictJUnitRuleTest.java
@@ -4,6 +4,14 @@
*/
package org.mockitousage.junitrule;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.willReturn;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+import static org.mockitoutil.TestBase.filterLineNo;
+
import org.assertj.core.api.Assertions;
import org.junit.Rule;
import org.junit.Test;
@@ -14,155 +22,167 @@
import org.mockito.junit.MockitoJUnit;
import org.mockito.quality.Strictness;
import org.mockitousage.IMethods;
+import org.mockitousage.strictness.ProductionCode;
import org.mockitoutil.SafeJUnitRule;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.BDDMockito.willReturn;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-import static org.mockitoutil.TestBase.filterLineNo;
-
public class StrictJUnitRuleTest {
- @Rule public SafeJUnitRule rule = new SafeJUnitRule(MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS));
+ @Rule
+ public SafeJUnitRule rule =
+ new SafeJUnitRule(MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS));
@Mock IMethods mock;
@Mock IMethods mock2;
- @Test public void ok_when_no_stubbings() throws Throwable {
+ @Test
+ public void ok_when_no_stubbings() throws Throwable {
mock.simpleMethod();
verify(mock).simpleMethod();
}
- @Test public void ok_when_all_stubbings_used() throws Throwable {
+ @Test
+ public void ok_when_all_stubbings_used() throws Throwable {
given(mock.simpleMethod(10)).willReturn("foo");
mock.simpleMethod(10);
}
- @Test public void ok_when_used_and_mismatched_argument() throws Throwable {
+ @Test
+ public void ok_when_used_and_mismatched_argument() throws Throwable {
given(mock.simpleMethod(10)).willReturn("foo");
mock.simpleMethod(10);
mock.simpleMethod(15);
}
- @Test public void fails_when_unused_stubbings() throws Throwable {
- //expect
+ @Test
+ public void fails_when_unused_stubbings() throws Throwable {
+ // expect
rule.expectFailure(UnnecessaryStubbingException.class);
- //when
+ // when
given(mock.simpleMethod(10)).willReturn("foo");
mock2.simpleMethod(10);
}
- @Test public void test_failure_trumps_unused_stubbings() throws Throwable {
- //expect
+ @Test
+ public void test_failure_trumps_unused_stubbings() throws Throwable {
+ // expect
rule.expectFailure(AssertionError.class, "x");
- //when
+ // when
given(mock.simpleMethod(10)).willReturn("foo");
mock.otherMethod();
throw new AssertionError("x");
}
- @Test public void why_do_return_syntax_is_useful() throws Throwable {
- //Trade-off of Mockito strictness documented in test
+ @Test
+ public void why_do_return_syntax_is_useful() throws Throwable {
+ // Trade-off of Mockito strictness documented in test
- //expect
+ // expect
rule.expectFailure(PotentialStubbingProblem.class);
- //when
+ // when
when(mock.simpleMethod(10)).thenReturn("10");
- when(mock.simpleMethod(20)).thenReturn("20");
+ ProductionCode.simpleMethod(mock, 20);
}
- @Test public void fails_fast_when_stubbing_invoked_with_different_argument() throws Throwable {
- //expect
- rule.expectFailure(new SafeJUnitRule.FailureAssert() {
- public void doAssert(Throwable t) {
- Assertions.assertThat(t).isInstanceOf(PotentialStubbingProblem.class);
- assertEquals(filterLineNo("\n" +
- "Strict stubbing argument mismatch. Please check:\n" +
- " - this invocation of 'simpleMethod' method:\n" +
- " mock.simpleMethod(15);\n" +
- " -> at org.mockitousage.junitrule.StrictJUnitRuleTest.fails_fast_when_stubbing_invoked_with_different_argument(StrictJUnitRuleTest.java:0)\n" +
- " - has following stubbing(s) with different arguments:\n" +
- " 1. mock.simpleMethod(20);\n" +
- " -> at org.mockitousage.junitrule.StrictJUnitRuleTest.fails_fast_when_stubbing_invoked_with_different_argument(StrictJUnitRuleTest.java:0)\n" +
- " 2. mock.simpleMethod(30);\n" +
- " -> at org.mockitousage.junitrule.StrictJUnitRuleTest.fails_fast_when_stubbing_invoked_with_different_argument(StrictJUnitRuleTest.java:0)\n" +
- "Typically, stubbing argument mismatch indicates user mistake when writing tests.\n" +
- "Mockito fails early so that you can debug potential problem easily.\n" +
- "However, there are legit scenarios when this exception generates false negative signal:\n" +
- " - stubbing the same method multiple times using 'given().will()' or 'when().then()' API\n" +
- " Please use 'will().given()' or 'doReturn().when()' API for stubbing.\n" +
- " - stubbed method is intentionally invoked with different arguments by code under test\n" +
- " Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).\n" +
- "For more information see javadoc for PotentialStubbingProblem class."),
- filterLineNo(t.getMessage()));
- }
- });
+ @Test
+ public void fails_fast_when_stubbing_invoked_with_different_argument() throws Throwable {
+ // expect
+ rule.expectFailure(
+ new SafeJUnitRule.FailureAssert() {
+ public void doAssert(Throwable t) {
+ Assertions.assertThat(t).isInstanceOf(PotentialStubbingProblem.class);
+ assertEquals(
+ filterLineNo(
+ "\n"
+ + "Strict stubbing argument mismatch. Please check:\n"
+ + " - this invocation of 'simpleMethod' method:\n"
+ + " mock.simpleMethod(15);\n"
+ + " -> at org.mockitousage.strictness.ProductionCode.simpleMethod(ProductionCode.java:0)\n"
+ + " - has following stubbing(s) with different arguments:\n"
+ + " 1. mock.simpleMethod(20);\n"
+ + " -> at org.mockitousage.junitrule.StrictJUnitRuleTest.fails_fast_when_stubbing_invoked_with_different_argument(StrictJUnitRuleTest.java:0)\n"
+ + " 2. mock.simpleMethod(30);\n"
+ + " -> at org.mockitousage.junitrule.StrictJUnitRuleTest.fails_fast_when_stubbing_invoked_with_different_argument(StrictJUnitRuleTest.java:0)\n"
+ + "Typically, stubbing argument mismatch indicates user mistake when writing tests.\n"
+ + "Mockito fails early so that you can debug potential problem easily.\n"
+ + "However, there are legit scenarios when this exception generates false negative signal:\n"
+ + " - stubbing the same method multiple times using 'given().will()' or 'when().then()' API\n"
+ + " Please use 'will().given()' or 'doReturn().when()' API for stubbing.\n"
+ + " - stubbed method is intentionally invoked with different arguments by code under test\n"
+ + " Please use default or 'silent' JUnit Rule (equivalent of Strictness.LENIENT).\n"
+ + "For more information see javadoc for PotentialStubbingProblem class."),
+ filterLineNo(t.getMessage()));
+ }
+ });
- //when stubbings in the test code:
- willReturn("10").given(mock).simpleMethod(10) ; //used
- willReturn("20").given(mock).simpleMethod(20) ; //unused
- willReturn("30").given(mock).simpleMethod(30) ; //unused
+ // when stubbings in the test code:
+ willReturn("10").given(mock).simpleMethod(10); // used
+ willReturn("20").given(mock).simpleMethod(20); // unused
+ willReturn("30").given(mock).simpleMethod(30); // unused
- //then
- mock.otherMethod(); //ok, different method
- mock.simpleMethod(10); //ok, stubbed with this argument
+ // then
+ mock.otherMethod(); // ok, different method
+ mock.simpleMethod(10); // ok, stubbed with this argument
- //invocation in the code under test uses different argument and should fail immediately
- //this helps with debugging and is essential for Mockito strictness
- mock.simpleMethod(15);
+ // invocation in the code under test uses different argument and should fail immediately
+ // this helps with debugging and is essential for Mockito strictness
+ ProductionCode.simpleMethod(mock, 15);
}
- @Test public void verify_no_more_interactions_ignores_stubs() throws Throwable {
- //when stubbing in test:
+ @Test
+ public void verify_no_more_interactions_ignores_stubs() throws Throwable {
+ // when stubbing in test:
given(mock.simpleMethod(10)).willReturn("foo");
- //and code under test does:
- mock.simpleMethod(10); //implicitly verifies the stubbing
+ // and code under test does:
+ mock.simpleMethod(10); // implicitly verifies the stubbing
mock.otherMethod();
- //and in test we:
+ // and in test we:
verify(mock).otherMethod();
verifyNoMoreInteractions(mock);
}
- @Test public void unused_stubs_with_multiple_mocks() throws Throwable {
- //expect
- rule.expectFailure(new SafeJUnitRule.FailureAssert() {
- public void doAssert(Throwable t) {
- assertEquals(filterLineNo("\n" +
- "Unnecessary stubbings detected.\n" +
- "Clean & maintainable test code requires zero unnecessary code.\n" +
- "Following stubbings are unnecessary (click to navigate to relevant line of code):\n" +
- " 1. -> at org.mockitousage.junitrule.StrictJUnitRuleTest.unused_stubs_with_multiple_mocks(StrictJUnitRuleTest.java:0)\n" +
- " 2. -> at org.mockitousage.junitrule.StrictJUnitRuleTest.unused_stubs_with_multiple_mocks(StrictJUnitRuleTest.java:0)\n" +
- "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class."), filterLineNo(t.getMessage()));
- }
- });
+ @Test
+ public void unused_stubs_with_multiple_mocks() throws Throwable {
+ // expect
+ rule.expectFailure(
+ new SafeJUnitRule.FailureAssert() {
+ public void doAssert(Throwable t) {
+ assertEquals(
+ filterLineNo(
+ "\n"
+ + "Unnecessary stubbings detected.\n"
+ + "Clean & maintainable test code requires zero unnecessary code.\n"
+ + "Following stubbings are unnecessary (click to navigate to relevant line of code):\n"
+ + " 1. -> at org.mockitousage.junitrule.StrictJUnitRuleTest.unused_stubs_with_multiple_mocks(StrictJUnitRuleTest.java:0)\n"
+ + " 2. -> at org.mockitousage.junitrule.StrictJUnitRuleTest.unused_stubs_with_multiple_mocks(StrictJUnitRuleTest.java:0)\n"
+ + "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class."),
+ filterLineNo(t.getMessage()));
+ }
+ });
- //when test has
+ // when test has
given(mock.simpleMethod(10)).willReturn("foo");
given(mock2.simpleMethod(20)).willReturn("foo");
- given(mock.otherMethod()).willReturn("foo"); //used and should not be reported
+ given(mock.otherMethod()).willReturn("foo"); // used and should not be reported
- //and code has
+ // and code has
mock.otherMethod();
mock2.booleanObjectReturningMethod();
}
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
- @Test public void rule_validates_mockito_usage() throws Throwable {
- //expect
+ @Test
+ public void rule_validates_mockito_usage() throws Throwable {
+ // expect
rule.expectFailure(UnfinishedVerificationException.class);
- //when test contains unfinished verification
+ // when test contains unfinished verification
verify(mock);
}
}
diff --git a/src/test/java/org/mockitousage/junitrule/StubbingWarningsJUnitRuleTest.java b/src/test/java/org/mockitousage/junitrule/StubbingWarningsJUnitRuleTest.java
index c851a6b..7f77eeb 100644
--- a/src/test/java/org/mockitousage/junitrule/StubbingWarningsJUnitRuleTest.java
+++ b/src/test/java/org/mockitousage/junitrule/StubbingWarningsJUnitRuleTest.java
@@ -4,20 +4,20 @@
*/
package org.mockitousage.junitrule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.quality.Strictness;
-import org.mockito.internal.junit.JUnitRule;
-import org.mockito.internal.util.SimpleMockitoLogger;
-import org.mockitousage.IMethods;
-import org.mockitoutil.SafeJUnitRule;
-
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;
import static org.mockitoutil.TestBase.filterLineNo;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.internal.junit.JUnitRule;
+import org.mockito.internal.util.SimpleMockitoLogger;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitoutil.SafeJUnitRule;
+
public class StubbingWarningsJUnitRuleTest {
private SimpleMockitoLogger logger = new SimpleMockitoLogger();
@@ -26,49 +26,53 @@
@Test
public void no_unused_stubs_reported_on_failure() throws Throwable {
- //expect
- rule.expectFailure(new SafeJUnitRule.FailureAssert() {
- public void doAssert(Throwable t) {
- assertEquals("x", t.getMessage());
- assertTrue(logger.getLoggedInfo().isEmpty());
- }
- });
+ // expect
+ rule.expectFailure(
+ new SafeJUnitRule.FailureAssert() {
+ public void doAssert(Throwable t) {
+ assertEquals("x", t.getMessage());
+ assertTrue(logger.getLoggedInfo().isEmpty());
+ }
+ });
- //when
+ // when
declareStubbing(mock);
throw new AssertionError("x");
}
@Test
public void stubbing_arg_mismatch_on_failure() throws Throwable {
- //expect
- rule.expectFailure(new SafeJUnitRule.FailureAssert() {
- public void doAssert(Throwable t) {
- assertEquals("x", t.getMessage());
- assertEquals(
- "[MockitoHint] StubbingWarningsJUnitRuleTest.stubbing_arg_mismatch_on_failure (see javadoc for MockitoHint):\n" +
- "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
- "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
- filterLineNo(logger.getLoggedInfo()));
- }
- });
+ // expect
+ rule.expectFailure(
+ new SafeJUnitRule.FailureAssert() {
+ public void doAssert(Throwable t) {
+ assertEquals("x", t.getMessage());
+ assertEquals(
+ "[MockitoHint] StubbingWarningsJUnitRuleTest.stubbing_arg_mismatch_on_failure (see javadoc for MockitoHint):\n"
+ + "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+ + "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
+ filterLineNo(logger.getLoggedInfo()));
+ }
+ });
- //when
+ // when
declareStubbingWithArg(mock, "a");
useStubbingWithArg(mock, "b");
throw new AssertionError("x");
}
- @Test public void no_stubbing_arg_mismatch_when_no_mismatch_on_fail() throws Throwable {
- //expect
- rule.expectFailure(new SafeJUnitRule.FailureAssert() {
- public void doAssert(Throwable t) {
- assertEquals("x", t.getMessage());
- assertTrue(logger.getLoggedInfo().isEmpty());
- }
- });
+ @Test
+ public void no_stubbing_arg_mismatch_when_no_mismatch_on_fail() throws Throwable {
+ // expect
+ rule.expectFailure(
+ new SafeJUnitRule.FailureAssert() {
+ public void doAssert(Throwable t) {
+ assertEquals("x", t.getMessage());
+ assertTrue(logger.getLoggedInfo().isEmpty());
+ }
+ });
- //when
+ // when
declareStubbingWithArg(mock, "a");
useStubbingWithArg(mock, "a");
throw new AssertionError("x");
@@ -76,37 +80,39 @@
@Test
public void no_stubbing_warning_on_pass() throws Throwable {
- //expect
- rule.expectSuccess(new Runnable() {
- public void run() {
- assertTrue(logger.isEmpty());
- }
- });
+ // expect
+ rule.expectSuccess(
+ new Runnable() {
+ public void run() {
+ assertTrue(logger.isEmpty());
+ }
+ });
- //when
+ // when
declareStubbingWithArg(mock, "a");
useStubbingWithArg(mock, "a");
}
@Test
public void multiple_stubbing_arg_mismatch_on_failure() throws Throwable {
- //expect
- rule.expectFailure(new SafeJUnitRule.FailureAssert() {
- public void doAssert(Throwable t) {
- assertEquals("x", t.getMessage());
- assertEquals(
- "[MockitoHint] StubbingWarningsJUnitRuleTest.multiple_stubbing_arg_mismatch_on_failure (see javadoc for MockitoHint):\n" +
- "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
- "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
- "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
- "[MockitoHint] 2. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
- "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
- "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
- filterLineNo(logger.getLoggedInfo()));
- }
- });
+ // expect
+ rule.expectFailure(
+ new SafeJUnitRule.FailureAssert() {
+ public void doAssert(Throwable t) {
+ assertEquals("x", t.getMessage());
+ assertEquals(
+ "[MockitoHint] StubbingWarningsJUnitRuleTest.multiple_stubbing_arg_mismatch_on_failure (see javadoc for MockitoHint):\n"
+ + "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+ + "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+ + "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+ + "[MockitoHint] 2. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+ + "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+ + "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
+ filterLineNo(logger.getLoggedInfo()));
+ }
+ });
- //when
+ // when
declareStubbingWithArg(mock, "a");
declareStubbingWithArg(mock, "b");
@@ -118,19 +124,20 @@
@Test
public void reports_only_mismatching_stubs() throws Throwable {
- //expect
- rule.expectFailure(new SafeJUnitRule.FailureAssert() {
- public void doAssert(Throwable t) {
- assertEquals("x", t.getMessage());
- assertEquals(
- "[MockitoHint] StubbingWarningsJUnitRuleTest.reports_only_mismatching_stubs (see javadoc for MockitoHint):\n" +
- "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n" +
- "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
- filterLineNo(logger.getLoggedInfo()));
- }
- });
+ // expect
+ rule.expectFailure(
+ new SafeJUnitRule.FailureAssert() {
+ public void doAssert(Throwable t) {
+ assertEquals("x", t.getMessage());
+ assertEquals(
+ "[MockitoHint] StubbingWarningsJUnitRuleTest.reports_only_mismatching_stubs (see javadoc for MockitoHint):\n"
+ + "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n"
+ + "[MockitoHint] ...args ok? -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.useStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
+ filterLineNo(logger.getLoggedInfo()));
+ }
+ });
- //when
+ // when
declareStubbingWithArg(mock, "a"); // <-- used
declareStubbingWithArg(mock, "b"); // <-- unused
@@ -142,15 +149,16 @@
@Test
public void no_mismatch_when_stub_was_used() throws Throwable {
- //expect
- rule.expectFailure(new SafeJUnitRule.FailureAssert() {
- public void doAssert(Throwable t) {
- assertEquals("x", t.getMessage());
- assertTrue(logger.getLoggedInfo().isEmpty());
- }
- });
+ // expect
+ rule.expectFailure(
+ new SafeJUnitRule.FailureAssert() {
+ public void doAssert(Throwable t) {
+ assertEquals("x", t.getMessage());
+ assertTrue(logger.getLoggedInfo().isEmpty());
+ }
+ });
- //when
+ // when
declareStubbingWithArg(mock, "a");
useStubbingWithArg(mock, "a");
@@ -161,35 +169,36 @@
@Test
public void no_stubbing_arg_mismatch_on_pass() throws Throwable {
- //expect
- rule.expectSuccess(new Runnable() {
- public void run() {
- assertEquals(
- "[MockitoHint] StubbingWarningsJUnitRuleTest.no_stubbing_arg_mismatch_on_pass (see javadoc for MockitoHint):\n" +
- "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
- filterLineNo(logger.getLoggedInfo()));
- }
- });
+ // expect
+ rule.expectSuccess(
+ new Runnable() {
+ public void run() {
+ assertEquals(
+ "[MockitoHint] StubbingWarningsJUnitRuleTest.no_stubbing_arg_mismatch_on_pass (see javadoc for MockitoHint):\n"
+ + "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbingWithArg(StubbingWarningsJUnitRuleTest.java:0)\n",
+ filterLineNo(logger.getLoggedInfo()));
+ }
+ });
- //when
+ // when
declareStubbingWithArg(mock, "a");
useStubbingWithArg(mock, "b");
}
@Test
public void warns_about_unused_stubs_when_passed() throws Throwable {
- //expect
- rule.expectSuccess(new Runnable() {
- public void run() {
- assertEquals(
- "[MockitoHint] StubbingWarningsJUnitRuleTest.warns_about_unused_stubs_when_passed (see javadoc for MockitoHint):\n" +
- "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbing(StubbingWarningsJUnitRuleTest.java:0)\n",
- filterLineNo(logger.getLoggedInfo()));
+ // expect
+ rule.expectSuccess(
+ new Runnable() {
+ public void run() {
+ assertEquals(
+ "[MockitoHint] StubbingWarningsJUnitRuleTest.warns_about_unused_stubs_when_passed (see javadoc for MockitoHint):\n"
+ + "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsJUnitRuleTest.declareStubbing(StubbingWarningsJUnitRuleTest.java:0)\n",
+ filterLineNo(logger.getLoggedInfo()));
+ }
+ });
- }
- });
-
- //when
+ // when
declareStubbing(mock);
}
diff --git a/src/test/java/org/mockitousage/junitrule/StubbingWarningsMultiThreadingTest.java b/src/test/java/org/mockitousage/junitrule/StubbingWarningsMultiThreadingTest.java
index 5bd4008..683a9e8 100644
--- a/src/test/java/org/mockitousage/junitrule/StubbingWarningsMultiThreadingTest.java
+++ b/src/test/java/org/mockitousage/junitrule/StubbingWarningsMultiThreadingTest.java
@@ -4,66 +4,71 @@
*/
package org.mockitousage.junitrule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.quality.Strictness;
-import org.mockito.internal.junit.JUnitRule;
-import org.mockito.internal.util.SimpleMockitoLogger;
-import org.mockitousage.IMethods;
-import org.mockitoutil.ConcurrentTesting;
-import org.mockitoutil.SafeJUnitRule;
-
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;
import static org.mockitoutil.TestBase.filterLineNo;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.internal.junit.JUnitRule;
+import org.mockito.internal.util.SimpleMockitoLogger;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+import org.mockitoutil.ConcurrentTesting;
+import org.mockitoutil.SafeJUnitRule;
+
public class StubbingWarningsMultiThreadingTest {
private SimpleMockitoLogger logger = new SimpleMockitoLogger();
@Rule public SafeJUnitRule rule = new SafeJUnitRule(new JUnitRule(logger, Strictness.WARN));
@Mock IMethods mock;
- @Test public void using_stubbing_from_different_thread() throws Throwable {
- //expect no warnings
- rule.expectSuccess(new Runnable() {
- public void run() {
- assertTrue(logger.getLoggedInfo().isEmpty());
- }
- });
+ @Test
+ public void using_stubbing_from_different_thread() throws Throwable {
+ // expect no warnings
+ rule.expectSuccess(
+ new Runnable() {
+ public void run() {
+ assertTrue(logger.getLoggedInfo().isEmpty());
+ }
+ });
- //when stubbing is declared
+ // when stubbing is declared
when(mock.simpleMethod()).thenReturn("1");
- //and used from a different thread
- ConcurrentTesting.inThread(new Runnable() {
+ // and used from a different thread
+ ConcurrentTesting.inThread(
+ new Runnable() {
public void run() {
mock.simpleMethod();
}
});
}
- @Test public void unused_stub_from_different_thread() throws Throwable {
- //expect warnings
- rule.expectSuccess(new Runnable() {
- public void run() {
- assertEquals(
- "[MockitoHint] StubbingWarningsMultiThreadingTest.unused_stub_from_different_thread (see javadoc for MockitoHint):\n" +
- "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsMultiThreadingTest.unused_stub_from_different_thread(StubbingWarningsMultiThreadingTest.java:0)\n",
- filterLineNo(logger.getLoggedInfo()));
- }
- });
+ @Test
+ public void unused_stub_from_different_thread() throws Throwable {
+ // expect warnings
+ rule.expectSuccess(
+ new Runnable() {
+ public void run() {
+ assertEquals(
+ "[MockitoHint] StubbingWarningsMultiThreadingTest.unused_stub_from_different_thread (see javadoc for MockitoHint):\n"
+ + "[MockitoHint] 1. Unused -> at org.mockitousage.junitrule.StubbingWarningsMultiThreadingTest.unused_stub_from_different_thread(StubbingWarningsMultiThreadingTest.java:0)\n",
+ filterLineNo(logger.getLoggedInfo()));
+ }
+ });
- //when stubbings are declared
+ // when stubbings are declared
when(mock.simpleMethod(1)).thenReturn("1");
when(mock.simpleMethod(2)).thenReturn("2");
- //and one of the stubbings is used from a different thread
- ConcurrentTesting.inThread(new Runnable() {
- public void run() {
- mock.simpleMethod(1);
- }
- });
+ // and one of the stubbings is used from a different thread
+ ConcurrentTesting.inThread(
+ new Runnable() {
+ public void run() {
+ mock.simpleMethod(1);
+ }
+ });
}
-
}
diff --git a/src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java b/src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java
index 8f4c420..1500bcf 100644
--- a/src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java
+++ b/src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java
@@ -4,19 +4,20 @@
*/
package org.mockitousage.junitrule;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.failBecauseExceptionWasNotThrown;
+import static org.mockito.Mockito.*;
+
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
+import org.mockito.ArgumentMatcher;
import org.mockito.exceptions.base.MockitoAssertionError;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.VerificationCollector;
import org.mockitousage.IMethods;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
public class VerificationCollectorImplTest {
@Test
@@ -46,14 +47,60 @@
IMethods methods = mock(IMethods.class);
+ methods.intArgumentMethod(6);
+
verify(methods).simpleMethod();
verify(methods).byteReturningMethod();
+ verify(methods).intArgumentMethod(8);
+ verify(methods).longArg(8L);
try {
collector.collectAndReport();
- fail();
+ failBecauseExceptionWasNotThrown(MockitoAssertionError.class);
} catch (MockitoAssertionError error) {
assertThat(error).hasMessageContaining("1. Wanted but not invoked:");
assertThat(error).hasMessageContaining("2. Wanted but not invoked:");
+ assertThat(error).hasMessageContaining("3. Argument(s) are different! Wanted:");
+ assertThat(error).hasMessageContaining("4. Wanted but not invoked:");
+ }
+ }
+
+ @Test
+ public void should_collect_matching_error_from_non_matching_arguments() {
+ VerificationCollector collector = MockitoJUnit.collector().assertLazily();
+
+ IMethods methods = mock(IMethods.class);
+
+ methods.intArgumentMethod(6);
+ methods.longArg(8L);
+ methods.forShort((short) 6);
+
+ verify(methods).intArgumentMethod(8);
+ verify(methods)
+ .longArg(
+ longThat(
+ new ArgumentMatcher<Long>() {
+ @Override
+ public boolean matches(Long argument) {
+ throw new AssertionError("custom error message");
+ }
+ }));
+ verify(methods)
+ .forShort(
+ shortThat(
+ new ArgumentMatcher<Short>() {
+ @Override
+ public boolean matches(Short argument) {
+ return false;
+ }
+ }));
+
+ try {
+ collector.collectAndReport();
+ failBecauseExceptionWasNotThrown(MockitoAssertionError.class);
+ } catch (MockitoAssertionError error) {
+ assertThat(error).hasMessageContaining("1. Argument(s) are different! Wanted:");
+ assertThat(error).hasMessageContaining("2. custom error message");
+ assertThat(error).hasMessageContaining("3. Argument(s) are different! Wanted:");
}
}
@@ -66,7 +113,7 @@
verify(methods, never()).simpleMethod();
verify(methods).byteReturningMethod();
- this.assertAtLeastOneFailure(collector);
+ this.assertExactlyOneFailure(collector);
}
@Test
@@ -79,13 +126,13 @@
verify(methods).byteReturningMethod();
verify(methods).simpleMethod();
- this.assertAtLeastOneFailure(collector);
+ this.assertExactlyOneFailure(collector);
}
- private void assertAtLeastOneFailure(VerificationCollector collector) {
+ private void assertExactlyOneFailure(VerificationCollector collector) {
try {
collector.collectAndReport();
- fail();
+ failBecauseExceptionWasNotThrown(MockitoAssertionError.class);
} catch (MockitoAssertionError error) {
assertThat(error).hasMessageContaining("1. Wanted but not invoked:");
assertThat(error.getMessage()).doesNotContain("2.");
@@ -97,15 +144,20 @@
JUnitCore runner = new JUnitCore();
Result result = runner.run(VerificationCollectorRuleInner.class);
- assertThat(result.getFailureCount()).isEqualTo(1);
- assertThat(result.getFailures().get(0).getMessage()).contains("1. Wanted but not invoked:");
+ assertThat(result.getFailureCount()).as("failureCount").isEqualTo(2);
+ assertThat(result.getFailures().get(0).getMessage())
+ .as("failure1")
+ .contains("1. Wanted but not invoked:");
+ assertThat(result.getFailures().get(1).getMessage())
+ .as("failure2")
+ .contains("1. Argument(s) are different! Wanted:")
+ .contains("2. Wanted but not invoked:");
}
// This class is picked up when running a test suite using an IDE. It fails on purpose.
public static class VerificationCollectorRuleInner {
- @Rule
- public VerificationCollector collector = MockitoJUnit.collector();
+ @Rule public VerificationCollector collector = MockitoJUnit.collector();
@Test
public void should_fail() {
@@ -121,5 +173,14 @@
verify(methods).simpleMethod();
}
+
+ @Test
+ public void should_fail_with_args() {
+ IMethods methods = mock(IMethods.class);
+ methods.intArgumentMethod(8);
+
+ verify(methods).intArgumentMethod(9);
+ verify(methods).byteReturningMethod();
+ }
}
}
diff --git a/src/test/java/org/mockitousage/junitrunner/DeepStubbingWithJUnitRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/DeepStubbingWithJUnitRunnerTest.java
index be42213..7236f1b 100644
--- a/src/test/java/org/mockitousage/junitrunner/DeepStubbingWithJUnitRunnerTest.java
+++ b/src/test/java/org/mockitousage/junitrunner/DeepStubbingWithJUnitRunnerTest.java
@@ -15,14 +15,15 @@
private final SomeClass someClass = new SomeClass();
- @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Root root;
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+ private Root root;
@Test
public void deep_stubs_dont_trigger_unnecessary_stubbing_exception() {
- //when
+ // when
someClass.someMethod(root);
- //then unnecessary stubbing exception is not thrown
+ // then unnecessary stubbing exception is not thrown
}
public static class SomeClass {
@@ -39,7 +40,5 @@
Bar getBar();
}
- interface Bar {
-
- }
+ interface Bar {}
}
diff --git a/src/test/java/org/mockitousage/junitrunner/JUnit45RunnerTest.java b/src/test/java/org/mockitousage/junitrunner/JUnit45RunnerTest.java
index fe942e6..bd9b485 100644
--- a/src/test/java/org/mockitousage/junitrunner/JUnit45RunnerTest.java
+++ b/src/test/java/org/mockitousage/junitrunner/JUnit45RunnerTest.java
@@ -4,18 +4,18 @@
*/
package org.mockitousage.junitrunner;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.verify;
+import static org.mockitousage.junitrunner.Filters.methodNameContains;
+
+import java.util.List;
+
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import java.util.List;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.verify;
-import static org.mockitousage.junitrunner.Filters.methodNameContains;
-
@RunWith(MockitoJUnitRunner.class)
public class JUnit45RunnerTest {
@@ -35,7 +35,7 @@
}
@Test
- public void shouldFilterTestMethodsCorrectly() throws Exception{
+ public void shouldFilterTestMethodsCorrectly() throws Exception {
MockitoJUnitRunner runner = new MockitoJUnitRunner(this.getClass());
runner.filter(methodNameContains("shouldInitMocksUsingRunner"));
diff --git a/src/test/java/org/mockitousage/junitrunner/ModellingVerboseMockitoTest.java b/src/test/java/org/mockitousage/junitrunner/ModellingVerboseMockitoTest.java
index adb8b66..193a30b 100644
--- a/src/test/java/org/mockitousage/junitrunner/ModellingVerboseMockitoTest.java
+++ b/src/test/java/org/mockitousage/junitrunner/ModellingVerboseMockitoTest.java
@@ -4,6 +4,11 @@
*/
package org.mockitousage.junitrunner;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
@@ -13,12 +18,7 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-//@RunWith(ConsoleSpammingMockitoJUnitRunner.class)
+// @RunWith(ConsoleSpammingMockitoJUnitRunner.class)
@RunWith(MockitoJUnitRunner.class)
@Ignore
public class ModellingVerboseMockitoTest extends TestBase {
@@ -36,22 +36,23 @@
when(mock.otherMethod()).thenReturn("foo");
when(mock.booleanObjectReturningMethod()).thenReturn(false);
- //TODO: stubbed with those args here -> stubbed with certain args here
+ // TODO: stubbed with those args here -> stubbed with certain args here
String ret = mock.simpleMethod(2);
assertEquals("foo", ret);
- //TODO: should show message from actual failure not at the bottom but at least below 'the actual failure is ...'
+ // TODO: should show message from actual failure not at the bottom but at least below 'the
+ // actual failure is ...'
}
@Test
public void shouldNotLogAnythingWhenNoWarnings() throws Exception {
- //stub
+ // stub
when(mock.simpleMethod()).thenReturn("foo");
- //use stub:
+ // use stub:
mock.simpleMethod();
- //verify:
+ // verify:
verify(mock).simpleMethod();
- //should be no warnings:
+ // should be no warnings:
fail();
}
}
diff --git a/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java
index f22d7ac..afb375d 100644
--- a/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java
+++ b/src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java
@@ -4,78 +4,78 @@
*/
package org.mockitousage.junitrunner;
-import java.util.List;
-import org.junit.Test;
-import org.junit.runner.JUnitCore;
-import org.junit.runner.Result;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.exceptions.misusing.UnfinishedStubbingException;
-import org.mockito.exceptions.verification.TooLittleActualInvocations;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockitousage.IMethods;
-import org.mockitoutil.JUnitResultAssert;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.util.List;
+
+import org.junit.Test;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.UnfinishedStubbingException;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockitousage.IMethods;
+import org.mockitoutil.JUnitResultAssert;
+import org.mockitoutil.TestBase;
+
public class SilentRunnerTest extends TestBase {
JUnitCore runner = new JUnitCore();
- @Test public void passing_test() {
- //when
- Result result = runner.run(
- SomeFeature.class
- );
- //then
+ @Test
+ public void passing_test() {
+ // when
+ Result result = runner.run(SomeFeature.class);
+ // then
JUnitResultAssert.assertThat(result).isSuccessful();
}
- @Test public void failing_test() {
- //when
- Result result = runner.run(
- SomeFailingFeature.class
- );
- //then
- JUnitResultAssert.assertThat(result).fails(1, TooLittleActualInvocations.class);
+ @Test
+ public void failing_test() {
+ // when
+ Result result = runner.run(SomeFailingFeature.class);
+ // then
+ JUnitResultAssert.assertThat(result).fails(1, TooFewActualInvocations.class);
}
- @Test public void failing_test_in_constructor() {
- //when
- Result result = runner.run(
- FailsInConstructor.class
- );
- //then
+ @Test
+ public void failing_test_in_constructor() {
+ // when
+ Result result = runner.run(FailsInConstructor.class);
+ // then
JUnitResultAssert.assertThat(result).fails(1, IllegalArgumentException.class);
}
- @Test public void validates_framework_usage() {
- //when
- Result result = runner.run(
- UsesFrameworkIncorrectly.class
- );
- //then
- JUnitResultAssert.assertThat(result).fails(1, "unfinished_stubbing_test_method", UnfinishedStubbingException.class);
+ @Test
+ public void validates_framework_usage() {
+ // when
+ Result result = runner.run(UsesFrameworkIncorrectly.class);
+ // then
+ JUnitResultAssert.assertThat(result)
+ .fails(1, "unfinished_stubbing_test_method", UnfinishedStubbingException.class);
}
@Test
public void ignores_unused_stubs() {
JUnitCore runner = new JUnitCore();
- //when
+ // when
Result result = runner.run(HasUnnecessaryStubs.class);
- //then
+ // then
JUnitResultAssert.assertThat(result).isSuccessful();
}
@RunWith(MockitoJUnitRunner.Silent.class)
public static class SomeFeature {
@Mock List<String> list;
- @Test public void some_behavior() {
+
+ @Test
+ public void some_behavior() {
when(list.get(0)).thenReturn("0");
assertEquals("0", list.get(0));
}
@@ -84,7 +84,9 @@
@RunWith(MockitoJUnitRunner.Silent.class)
public static class SomeFailingFeature {
@Mock List<String> list;
- @Test public void some_failing_behavior() {
+
+ @Test
+ public void some_failing_behavior() {
list.clear();
verify(list, times(2)).clear();
}
@@ -97,8 +99,11 @@
throw new IllegalArgumentException("Boo!");
}
}
+
@Mock List<String> list;
- @Test public void some_behavior() {}
+
+ @Test
+ public void some_behavior() {}
}
@RunWith(MockitoJUnitRunner.Silent.class)
@@ -106,8 +111,9 @@
@Mock List<?> list;
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
- @Test public void unfinished_stubbing_test_method() {
- when(list.get(0)); //unfinished stubbing
+ @Test
+ public void unfinished_stubbing_test_method() {
+ when(list.get(0)); // unfinished stubbing
}
}
diff --git a/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java
index e627749..47ed688 100644
--- a/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java
+++ b/src/test/java/org/mockitousage/junitrunner/StrictRunnerTest.java
@@ -4,6 +4,10 @@
*/
package org.mockitousage.junitrunner;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
@@ -13,87 +17,93 @@
import org.mockito.Mock;
import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.MockitoRule;
import org.mockitousage.IMethods;
import org.mockitoutil.JUnitResultAssert;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-
public class StrictRunnerTest extends TestBase {
JUnitCore runner = new JUnitCore();
- @Test public void succeeds_when_all_stubs_were_used() {
- //when
- Result result = runner.run(
- StubbingInConstructorUsed.class,
- StubbingInBeforeUsed.class,
- StubbingInTestUsed.class
- );
- //then
+ @Test
+ public void succeeds_when_all_stubs_were_used() {
+ // when
+ Result result =
+ runner.run(
+ StubbingInConstructorUsed.class,
+ StubbingInBeforeUsed.class,
+ StubbingInTestUsed.class);
+ // then
JUnitResultAssert.assertThat(result).isSuccessful();
}
- @Test public void fails_when_stubs_were_not_used() {
- Class[] tests = {StubbingInConstructorUnused.class,
- StubbingInBeforeUnused.class,
- StubbingInTestUnused.class};
+ @Test
+ public void fails_when_stubs_were_not_used() {
+ Class[] tests = {
+ StubbingInConstructorUnused.class,
+ StubbingInBeforeUnused.class,
+ StubbingInTestUnused.class
+ };
- //when
+ // when
Result result = runner.run(tests);
- //then
+ // then
JUnitResultAssert.assertThat(result).fails(3, UnnecessaryStubbingException.class);
}
- @Test public void does_not_report_unused_stubs_when_different_failure_is_present() {
- //when
+ @Test
+ public void does_not_report_unused_stubs_when_different_failure_is_present() {
+ // when
Result result = runner.run(WithUnrelatedAssertionFailure.class);
- //then
+ // then
JUnitResultAssert.assertThat(result).fails(1, MyAssertionError.class);
}
- @Test public void runner_can_coexist_with_rule() {
- //I don't believe that this scenario is useful
- //I only wish that Mockito does not break awkwardly when both: runner & rule is used
+ @Test
+ public void runner_can_coexist_with_rule() {
+ // I don't believe that this scenario is useful
+ // I only wish that Mockito does not break awkwardly when both: runner & rule is used
- //when
+ // when
Result result = runner.run(RunnerAndRule.class);
- //then
+ // then
JUnitResultAssert.assertThat(result).fails(1, UnnecessaryStubbingException.class);
}
- @Test public void runner_in_multi_threaded_tests() {
- //when
+ @Test
+ public void runner_in_multi_threaded_tests() {
+ // when
Result result = runner.run(StubUsedFromDifferentThread.class);
- //then
+ // then
JUnitResultAssert.assertThat(result).isSuccessful();
}
@RunWith(MockitoJUnitRunner.class)
public static class StubbingInConstructorUsed extends StubbingInConstructorUnused {
- @Test public void test() {
+ @Test
+ public void test() {
assertEquals("1", mock.simpleMethod(1));
}
}
- @RunWith(MockitoJUnitRunner.Strict.class) //using Strict to make sure it does the right thing
+ @RunWith(MockitoJUnitRunner.Strict.class) // using Strict to make sure it does the right thing
public static class StubbingInConstructorUnused {
IMethods mock = when(mock(IMethods.class).simpleMethod(1)).thenReturn("1").getMock();
- @Test public void dummy() {}
+
+ @Test
+ public void dummy() {}
}
@RunWith(MockitoJUnitRunner.class)
public static class StubbingInBeforeUsed extends StubbingInBeforeUnused {
- @Test public void test() {
+ @Test
+ public void test() {
assertEquals("1", mock.simpleMethod(1));
}
}
@@ -101,15 +111,20 @@
@RunWith(MockitoJUnitRunner.class)
public static class StubbingInBeforeUnused {
@Mock IMethods mock;
- @Before public void before() {
+
+ @Before
+ public void before() {
when(mock.simpleMethod(1)).thenReturn("1");
}
- @Test public void dummy() {}
+
+ @Test
+ public void dummy() {}
}
@RunWith(MockitoJUnitRunner.class)
public static class StubbingInTestUsed {
- @Test public void test() {
+ @Test
+ public void test() {
IMethods mock = mock(IMethods.class);
when(mock.simpleMethod(1)).thenReturn("1");
assertEquals("1", mock.simpleMethod(1));
@@ -118,10 +133,11 @@
@RunWith(MockitoJUnitRunner.class)
public static class StubbingInTestUnused {
- @Test public void test() {
+ @Test
+ public void test() {
IMethods mock = mock(IMethods.class);
when(mock.simpleMethod(1)).thenReturn("1");
- mock.simpleMethod(2); //different arg
+ mock.simpleMethod(2); // different arg
}
}
@@ -133,16 +149,19 @@
IMethods mock = mock(IMethods.class);
IMethods mock2 = mock(IMethods.class);
- @Before public void before() {
+ @Before
+ public void before() {
when(mock2.simpleMethod("unused stubbing")).thenReturn("");
}
- @Test public void passing_test() {
+ @Test
+ public void passing_test() {
when(mock.simpleMethod(1)).thenReturn("1");
assertEquals("1", mock.simpleMethod(1));
}
- @Test public void failing_test() {
+ @Test
+ public void failing_test() {
throw new MyAssertionError();
}
}
@@ -153,7 +172,8 @@
public @Rule MockitoRule rule = MockitoJUnit.rule();
IMethods mock = mock(IMethods.class);
- @Test public void passing_test() {
+ @Test
+ public void passing_test() {
when(mock.simpleMethod(1)).thenReturn("1");
mock.simpleMethod(2);
}
@@ -164,17 +184,19 @@
IMethods mock = mock(IMethods.class);
- @Test public void passing_test() throws Exception {
- //stubbing is done in main thread:
+ @Test
+ public void passing_test() throws Exception {
+ // stubbing is done in main thread:
when(mock.simpleMethod(1)).thenReturn("1");
- //stubbing is used in a different thread
- //stubbing should not be reported as unused by the runner
- Thread t = new Thread() {
- public void run() {
- mock.simpleMethod(1);
- }
- };
+ // stubbing is used in a different thread
+ // stubbing should not be reported as unused by the runner
+ Thread t =
+ new Thread() {
+ public void run() {
+ mock.simpleMethod(1);
+ }
+ };
t.start();
t.join();
}
diff --git a/src/test/java/org/mockitousage/junitrunner/StrictStubsRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/StrictStubsRunnerTest.java
index f61572b..efe2f74 100644
--- a/src/test/java/org/mockitousage/junitrunner/StrictStubsRunnerTest.java
+++ b/src/test/java/org/mockitousage/junitrunner/StrictStubsRunnerTest.java
@@ -4,6 +4,8 @@
*/
package org.mockitousage.junitrunner;
+import static org.mockito.Mockito.when;
+
import org.junit.Test;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
@@ -13,43 +15,48 @@
import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockitousage.IMethods;
+import org.mockitousage.strictness.ProductionCode;
import org.mockitoutil.JUnitResultAssert;
import org.mockitoutil.TestBase;
-import static org.mockito.Mockito.when;
-
public class StrictStubsRunnerTest extends TestBase {
JUnitCore runner = new JUnitCore();
- @Test public void detects_unnecessary_stubbings() {
- //when
+ @Test
+ public void detects_unnecessary_stubbings() {
+ // when
Result result = runner.run(UnnecessaryStubbing.class);
- //then
+ // then
JUnitResultAssert.assertThat(result)
.fails(1, UnnecessaryStubbingException.class)
.succeeds(2);
}
- @Test public void fails_fast_on_argument_mismatch() {
- //when
+ @Test
+ public void fails_fast_on_argument_mismatch() {
+ // when
Result result = runner.run(StubbingArgMismatch.class);
- //then
- JUnitResultAssert.assertThat(result)
- .succeeds(2)
- .fails(1, PotentialStubbingProblem.class);
+ // then
+ JUnitResultAssert.assertThat(result).succeeds(2).fails(1, PotentialStubbingProblem.class);
}
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public static class UnnecessaryStubbing {
@Mock IMethods mock;
- @Test public void unused_stubbing_1() {
+
+ @Test
+ public void unused_stubbing_1() {
when(mock.simpleMethod()).thenReturn("");
}
- @Test public void unused_stubbing_2() {
+
+ @Test
+ public void unused_stubbing_2() {
when(mock.simpleMethod()).thenReturn("");
}
- @Test public void correct_stubbing() {
+
+ @Test
+ public void correct_stubbing() {
when(mock.simpleMethod()).thenReturn("");
mock.simpleMethod();
}
@@ -58,14 +65,20 @@
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public static class StubbingArgMismatch {
@Mock IMethods mock;
- @Test public void passing1() {}
- @Test public void passing2() {
+
+ @Test
+ public void passing1() {}
+
+ @Test
+ public void passing2() {
when(mock.simpleMethod()).thenReturn("");
mock.simpleMethod();
}
- @Test public void argument_mismatch() {
+
+ @Test
+ public void argument_mismatch() {
when(mock.simpleMethod(10)).thenReturn("");
- mock.simpleMethod(20);
+ ProductionCode.simpleMethod(mock, 20);
}
}
}
diff --git a/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java
index 7d8d537..05be05d 100644
--- a/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java
+++ b/src/test/java/org/mockitousage/junitrunner/StubbingWarningsJUnitRunnerTest.java
@@ -4,6 +4,11 @@
*/
package org.mockitousage.junitrunner;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockitoutil.JUnitResultAssert.assertThat;
+
import org.junit.Test;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
@@ -15,56 +20,64 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-import static org.mockitoutil.JUnitResultAssert.assertThat;
-
public class StubbingWarningsJUnitRunnerTest extends TestBase {
JUnitCore runner = new JUnitCore();
SimpleMockitoLogger logger = TestableJUnitRunner.refreshedLogger();
- @Test public void no_arg_mismatch_warnings() {
- //when
- runner.run(PassingArgMismatch.class, FailingWithMatchingArgs.class, MismatchButStubAlreadyUsed.class);
+ @Test
+ public void no_arg_mismatch_warnings() {
+ // when
+ runner.run(
+ PassingArgMismatch.class,
+ FailingWithMatchingArgs.class,
+ MismatchButStubAlreadyUsed.class);
- //then
+ // then
assertEquals("", filterLineNo(logger.getLoggedInfo()));
}
- @Test public void shows_arg_mismatch_warnings_when_test_fails() {
- //when
+ @Test
+ public void shows_arg_mismatch_warnings_when_test_fails() {
+ // when
runner.run(FailingWithArgMismatch.class);
- //then
- assertEquals("[MockitoHint] FailingWithArgMismatch.test (see javadoc for MockitoHint):\n" +
- "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithArgMismatch.test(StubbingWarningsJUnitRunnerTest.java:0)\n" +
- "[MockitoHint] ...args ok? -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithArgMismatch.test(StubbingWarningsJUnitRunnerTest.java:0)\n", filterLineNo(logger.getLoggedInfo()));
+ // then
+ assertEquals(
+ "[MockitoHint] FailingWithArgMismatch.test (see javadoc for MockitoHint):\n"
+ + "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithArgMismatch.test(StubbingWarningsJUnitRunnerTest.java:0)\n"
+ + "[MockitoHint] ...args ok? -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithArgMismatch.test(StubbingWarningsJUnitRunnerTest.java:0)\n",
+ filterLineNo(logger.getLoggedInfo()));
}
- @Test public void shows_arg_mismatch_warnings_only_for_mismatches() {
- //when
+ @Test
+ public void shows_arg_mismatch_warnings_only_for_mismatches() {
+ // when
runner.run(FailingWithSomeStubMismatches.class);
- //then
- assertEquals("[MockitoHint] FailingWithSomeStubMismatches.test (see javadoc for MockitoHint):\n" +
- "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithSomeStubMismatches.test(StubbingWarningsJUnitRunnerTest.java:0)\n" +
- "[MockitoHint] ...args ok? -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithSomeStubMismatches.test(StubbingWarningsJUnitRunnerTest.java:0)\n", filterLineNo(logger.getLoggedInfo()));
+ // then
+ assertEquals(
+ "[MockitoHint] FailingWithSomeStubMismatches.test (see javadoc for MockitoHint):\n"
+ + "[MockitoHint] 1. Unused... -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithSomeStubMismatches.test(StubbingWarningsJUnitRunnerTest.java:0)\n"
+ + "[MockitoHint] ...args ok? -> at org.mockitousage.junitrunner.StubbingWarningsJUnitRunnerTest$FailingWithSomeStubMismatches.test(StubbingWarningsJUnitRunnerTest.java:0)\n",
+ filterLineNo(logger.getLoggedInfo()));
}
- @Test public void validates_mockito_usage() {
- //when
+ @Test
+ public void validates_mockito_usage() {
+ // when
Result result = runner.run(InvalidMockitoUsage.class);
- //then
+ // then
assertThat(result).fails(1, UnfinishedStubbingException.class);
}
@RunWith(TestableJUnitRunner.class)
public static class PassingArgMismatch {
IMethods mock = mock(IMethods.class);
- @Test public void test() throws Exception {
+
+ @Test
+ public void test() throws Exception {
when(mock.simpleMethod(1)).thenReturn("1");
mock.simpleMethod(2);
}
@@ -73,7 +86,9 @@
@RunWith(TestableJUnitRunner.class)
public static class FailingWithArgMismatch {
@Mock IMethods mock;
- @Test public void test() throws Exception {
+
+ @Test
+ public void test() throws Exception {
when(mock.simpleMethod(1)).thenReturn("1");
mock.simpleMethod(2);
throw new RuntimeException("x");
@@ -83,7 +98,9 @@
@RunWith(TestableJUnitRunner.class)
public static class FailingWithMatchingArgs {
@Mock IMethods mock;
- @Test public void test() throws Exception {
+
+ @Test
+ public void test() throws Exception {
when(mock.simpleMethod(1)).thenReturn("1");
mock.simpleMethod(1);
throw new RuntimeException("x");
@@ -93,7 +110,9 @@
@RunWith(TestableJUnitRunner.class)
public static class FailingWithSomeStubMismatches {
@Mock IMethods mock;
- @Test public void test() throws Exception {
+
+ @Test
+ public void test() throws Exception {
when(mock.simpleMethod(1)).thenReturn("1"); // <- used
when(mock.simpleMethod(2)).thenReturn("2"); // <- unused
@@ -107,7 +126,9 @@
@RunWith(TestableJUnitRunner.class)
public static class MismatchButStubAlreadyUsed {
@Mock IMethods mock;
- @Test public void test() throws Exception {
+
+ @Test
+ public void test() throws Exception {
when(mock.simpleMethod(1)).thenReturn("1");
mock.simpleMethod(1); // <-- used
mock.simpleMethod(2); // <-- arg mismatch, but the stub was already used
@@ -119,8 +140,10 @@
@RunWith(TestableJUnitRunner.class)
public static class InvalidMockitoUsage {
@Mock IMethods mock;
+
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
- @Test public void test() throws Exception {
+ @Test
+ public void test() throws Exception {
when(mock.simpleMethod()); // <-- unfinished stubbing
}
}
diff --git a/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java b/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java
index 6b6017a..db804f8 100644
--- a/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java
+++ b/src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java
@@ -4,6 +4,10 @@
*/
package org.mockitousage.junitrunner;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
import org.junit.Test;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
@@ -13,15 +17,12 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
public class UnusedStubsExceptionMessageTest extends TestBase {
- //Moving the code around this class is tricky and may cause the test to fail
- //We're asserting on full exception message which contains line numbers
- //Let's leave it for now, updating the test is cheap and if it turns out hindrance we can make the assertion smarter.
+ // Moving the code around this class is tricky and may cause the test to fail
+ // We're asserting on full exception message which contains line numbers
+ // Let's leave it for now, updating the test is cheap and if it turns out hindrance we can make
+ // the assertion smarter.
@RunWith(MockitoJUnitRunner.class)
public static class HasUnnecessaryStubs {
IMethods mock1 = when(mock(IMethods.class).simpleMethod(1)).thenReturn("1").getMock();
@@ -43,17 +44,18 @@
@Test
public void lists_all_unused_stubs_cleanly() {
JUnitCore runner = new JUnitCore();
- //when
+ // when
Result result = runner.run(HasUnnecessaryStubs.class);
- //then
+ // then
Failure failure = result.getFailures().get(0);
- assertEquals("\n" +
- "Unnecessary stubbings detected in test class: HasUnnecessaryStubs\n" +
- "Clean & maintainable test code requires zero unnecessary code.\n" +
- "Following stubbings are unnecessary (click to navigate to relevant line of code):\n" +
- " 1. -> at org.mockitousage.junitrunner.UnusedStubsExceptionMessageTest$HasUnnecessaryStubs.<init>(UnusedStubsExceptionMessageTest.java:0)\n" +
- " 2. -> at org.mockitousage.junitrunner.UnusedStubsExceptionMessageTest$HasUnnecessaryStubs.<init>(UnusedStubsExceptionMessageTest.java:0)\n" +
- "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class.",
- filterLineNo(failure.getException().getMessage()));
+ assertEquals(
+ "\n"
+ + "Unnecessary stubbings detected in test class: HasUnnecessaryStubs\n"
+ + "Clean & maintainable test code requires zero unnecessary code.\n"
+ + "Following stubbings are unnecessary (click to navigate to relevant line of code):\n"
+ + " 1. -> at org.mockitousage.junitrunner.UnusedStubsExceptionMessageTest$HasUnnecessaryStubs.<init>(UnusedStubsExceptionMessageTest.java:0)\n"
+ + " 2. -> at org.mockitousage.junitrunner.UnusedStubsExceptionMessageTest$HasUnnecessaryStubs.<init>(UnusedStubsExceptionMessageTest.java:0)\n"
+ + "Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class.",
+ filterLineNo(failure.getException().getMessage()));
}
}
diff --git a/src/test/java/org/mockitousage/junitrunner/VerboseMockitoRunnerTest.java b/src/test/java/org/mockitousage/junitrunner/VerboseMockitoRunnerTest.java
index 37010b0..d6cfd6e 100644
--- a/src/test/java/org/mockitousage/junitrunner/VerboseMockitoRunnerTest.java
+++ b/src/test/java/org/mockitousage/junitrunner/VerboseMockitoRunnerTest.java
@@ -4,6 +4,10 @@
*/
package org.mockitousage.junitrunner;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.*;
+
import junit.framework.TestCase;
import org.junit.Ignore;
import org.junit.Test;
@@ -16,13 +20,9 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.*;
-
-//@RunWith(ConsoleSpammingMockitoJUnitRunner.class)
+// @RunWith(ConsoleSpammingMockitoJUnitRunner.class)
@RunWith(VerboseMockitoJUnitRunner.class)
-//TODO
+// TODO
public class VerboseMockitoRunnerTest extends TestBase {
@Mock private IMethods mock;
@@ -52,15 +52,15 @@
public void _test() {
IMethods mock = mock(IMethods.class);
- //some stubbing
+ // some stubbing
when(mock.simpleMethod(1)).thenReturn("foo");
when(mock.otherMethod()).thenReturn("foo");
when(mock.booleanObjectReturningMethod()).thenReturn(false);
- //stub called with different args:
+ // stub called with different args:
String ret = mock.simpleMethod(2);
- //assertion fails due to stub called with different args
+ // assertion fails due to stub called with different args
assertEquals("foo", ret);
}
}
@@ -72,9 +72,9 @@
@Test
@Ignore
public void shouldContainWarnings() throws Exception {
- //when
+ // when
Result result = new JUnitCore().run(new ContainsWarnings());
- //then
+ // then
assertEquals(1, result.getFailures().size());
Throwable exception = result.getFailures().get(0).getException();
assertTrue(exception instanceof ExceptionIncludingMockitoWarnings);
diff --git a/src/test/java/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java b/src/test/java/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java
index 0f6ea2d..4701870 100644
--- a/src/test/java/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java
+++ b/src/test/java/org/mockitousage/matchers/AnyXMatchersAcceptNullsTest.java
@@ -4,16 +4,16 @@
*/
package org.mockitousage.matchers;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.when;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.when;
-
@SuppressWarnings("unchecked")
public class AnyXMatchersAcceptNullsTest extends TestBase {
diff --git a/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java b/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java
index b7aa78b..b4b6e1a 100644
--- a/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java
+++ b/src/test/java/org/mockitousage/matchers/CapturingArgumentsTest.java
@@ -2,9 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.matchers;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
@@ -13,13 +19,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.junit.Assert.*;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
-
public class CapturingArgumentsTest extends TestBase {
class Person {
@@ -43,7 +42,7 @@
this.service = service;
}
- public void email(Integer ... personId) {
+ public void email(Integer... personId) {
for (Integer i : personId) {
Person person = new Person(i);
service.sendEmailTo(person);
@@ -62,26 +61,26 @@
@SuppressWarnings("deprecation")
@Test
public void should_allow_assertions_on_captured_argument() {
- //given
+ // given
ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
- //when
+ // when
bulkEmailService.email(12);
- //then
+ // then
verify(emailService).sendEmailTo(argument.capture());
assertEquals(12, argument.getValue().getAge());
}
@Test
public void should_allow_assertions_on_all_captured_arguments() {
- //given
+ // given
ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
- //when
+ // when
bulkEmailService.email(11, 12);
- //then
+ // then
verify(emailService, times(2)).sendEmailTo(argument.capture());
assertEquals(11, argument.getAllValues().get(0).getAge());
assertEquals(12, argument.getAllValues().get(1).getAge());
@@ -89,84 +88,84 @@
@Test
public void should_allow_assertions_on_last_argument() {
- //given
+ // given
ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
- //when
+ // when
bulkEmailService.email(11, 12, 13);
- //then
+ // then
verify(emailService, times(3)).sendEmailTo(argument.capture());
assertEquals(13, argument.getValue().getAge());
}
@Test
public void should_print_captor_matcher() {
- //given
+ // given
ArgumentCaptor<Person> person = ArgumentCaptor.forClass(Person.class);
try {
- //when
+ // when
verify(emailService).sendEmailTo(person.capture());
fail();
- } catch(WantedButNotInvoked e) {
- //then
+ } catch (WantedButNotInvoked e) {
+ // then
assertThat(e).hasMessageContaining("<Capturing argument>");
}
}
@Test
public void should_allow_assertions_on_captured_null() {
- //given
+ // given
ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
- //when
+ // when
emailService.sendEmailTo(null);
- //then
+ // then
verify(emailService).sendEmailTo(argument.capture());
assertEquals(null, argument.getValue());
}
@Test
- public void should_allow_construction_of_captor_for_parameterized_type_in_a_convenient_way() {
- //the test passes if this expression compiles
+ public void should_allow_construction_of_captor_for_parameterized_type_in_a_convenient_way() {
+ // the test passes if this expression compiles
@SuppressWarnings("unchecked")
ArgumentCaptor<List<Person>> argument = ArgumentCaptor.forClass(List.class);
assertNotNull(argument);
}
@Test
- public void should_allow_construction_of_captor_for_a_more_specific_type() {
- //the test passes if this expression compiles
+ public void should_allow_construction_of_captor_for_a_more_specific_type() {
+ // the test passes if this expression compiles
ArgumentCaptor<List<?>> argument = ArgumentCaptor.forClass(ArrayList.class);
assertNotNull(argument);
}
@Test
public void should_allow_capturing_for_stubbing() {
- //given
+ // given
ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
when(emailService.sendEmailTo(argument.capture())).thenReturn(false);
- //when
+ // when
emailService.sendEmailTo(new Person(10));
- //then
+ // then
assertEquals(10, argument.getValue().getAge());
}
@Test
public void should_capture_when_stubbing_only_when_entire_invocation_matches() {
- //given
+ // given
ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);
when(mock.simpleMethod(argument.capture(), eq(2))).thenReturn("blah");
- //when
+ // when
mock.simpleMethod("foo", 200);
mock.simpleMethod("bar", 2);
- //then
+ // then
Assertions.assertThat(argument.getAllValues()).containsOnly("bar");
}
@@ -176,19 +175,20 @@
try {
argument.getValue();
fail();
- } catch (MockitoException expected) { }
+ } catch (MockitoException expected) {
+ }
}
@Test
public void should_capture_when_full_arg_list_matches() throws Exception {
- //given
+ // given
ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
- //when
+ // when
mock.simpleMethod("foo", 1);
mock.simpleMethod("bar", 2);
- //then
+ // then
verify(mock).simpleMethod(captor.capture(), eq(1));
assertEquals(1, captor.getAllValues().size());
assertEquals("foo", captor.getValue());
@@ -196,26 +196,26 @@
@Test
public void should_capture_int_by_creating_captor_with_primitive_wrapper() {
- //given
+ // given
ArgumentCaptor<Integer> argument = ArgumentCaptor.forClass(Integer.class);
- //when
+ // when
mock.intArgumentMethod(10);
- //then
+ // then
verify(mock).intArgumentMethod(argument.capture());
assertEquals(10, (int) argument.getValue());
}
@Test
public void should_capture_int_by_creating_captor_with_primitive() throws Exception {
- //given
+ // given
ArgumentCaptor<Integer> argument = ArgumentCaptor.forClass(int.class);
- //when
+ // when
mock.intArgumentMethod(10);
- //then
+ // then
verify(mock).intArgumentMethod(argument.capture());
assertEquals(10, (int) argument.getValue());
}
@@ -235,7 +235,8 @@
}
@Test
- public void should_capture_byte_vararg_by_creating_captor_with_primitive_wrapper() throws Exception {
+ public void should_capture_byte_vararg_by_creating_captor_with_primitive_wrapper()
+ throws Exception {
// given
ArgumentCaptor<Byte> argumentCaptor = ArgumentCaptor.forClass(Byte.class);
@@ -273,11 +274,13 @@
// then
verify(mock, times(2)).mixedVarargs(any(), argumentCaptor.capture());
- Assertions.assertThat(argumentCaptor.getAllValues()).containsExactly("a", "b", "c", "again ?!");
+ Assertions.assertThat(argumentCaptor.getAllValues())
+ .containsExactly("a", "b", "c", "again ?!");
}
@Test
- public void should_capture_one_arg_even_when_using_vararg_captor_on_nonvararg_method() throws Exception {
+ public void should_capture_one_arg_even_when_using_vararg_captor_on_nonvararg_method()
+ throws Exception {
// given
ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
@@ -299,7 +302,12 @@
// then
// this is only for backwards compatibility. It does not make sense in real to do so.
- verify(mock).mixedVarargs(any(), argumentCaptor.capture(), argumentCaptor.capture(), argumentCaptor.capture());
+ verify(mock)
+ .mixedVarargs(
+ any(),
+ argumentCaptor.capture(),
+ argumentCaptor.capture(),
+ argumentCaptor.capture());
Assertions.assertThat(argumentCaptor.getAllValues()).containsExactly("a", "b", "c");
}
diff --git a/src/test/java/org/mockitousage/matchers/CustomMatcherDoesYieldCCETest.java b/src/test/java/org/mockitousage/matchers/CustomMatcherDoesYieldCCETest.java
index 3114834..540f36a 100644
--- a/src/test/java/org/mockitousage/matchers/CustomMatcherDoesYieldCCETest.java
+++ b/src/test/java/org/mockitousage/matchers/CustomMatcherDoesYieldCCETest.java
@@ -4,21 +4,20 @@
*/
package org.mockitousage.matchers;
-import org.junit.Test;
-import org.mockito.ArgumentMatcher;
-import org.mockito.Mock;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.fail;
import static org.mockito.Matchers.argThat;
import static org.mockito.Mockito.verify;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Mock;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
public class CustomMatcherDoesYieldCCETest extends TestBase {
- @Mock
- private IMethods mock;
+ @Mock private IMethods mock;
@Test
public void shouldNotThrowCCE() {
diff --git a/src/test/java/org/mockitousage/matchers/CustomMatchersTest.java b/src/test/java/org/mockitousage/matchers/CustomMatchersTest.java
index 90bb44c..ddcb32a 100644
--- a/src/test/java/org/mockitousage/matchers/CustomMatchersTest.java
+++ b/src/test/java/org/mockitousage/matchers/CustomMatchersTest.java
@@ -2,9 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.matchers;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentMatcher;
@@ -12,13 +18,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
public class CustomMatchersTest extends TestBase {
private final class ContainsFoo implements ArgumentMatcher<String> {
@@ -146,15 +145,20 @@
mock.simpleMethod("foo");
try {
- verify(mock).simpleMethod((String) argThat(new ArgumentMatcher<Object>() {
- public boolean matches(Object argument) {
- return false;
- }}));
+ verify(mock)
+ .simpleMethod(
+ (String)
+ argThat(
+ new ArgumentMatcher<Object>() {
+ public boolean matches(Object argument) {
+ return false;
+ }
+ }));
fail();
} catch (AssertionError e) {
assertThat(e)
- .hasMessageContaining("<custom argument matcher>")
- .hasMessageContaining("foo");
+ .hasMessageContaining("<custom argument matcher>")
+ .hasMessageContaining("foo");
}
}
}
diff --git a/src/test/java/org/mockitousage/matchers/GenericMatchersTest.java b/src/test/java/org/mockitousage/matchers/GenericMatchersTest.java
index 89387c3..83a53bd 100644
--- a/src/test/java/org/mockitousage/matchers/GenericMatchersTest.java
+++ b/src/test/java/org/mockitousage/matchers/GenericMatchersTest.java
@@ -2,24 +2,24 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.matchers;
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.when;
+
+import java.util.Date;
+import java.util.List;
+
import org.junit.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockitoutil.TestBase;
-import java.util.Date;
-import java.util.List;
-
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Mockito.when;
-
public class GenericMatchersTest extends TestBase {
private interface Foo {
List<String> sort(List<String> otherList);
+
String convertDate(Date date);
}
@@ -31,7 +31,7 @@
when(sorter.convertDate(new Date())).thenReturn("one");
when(sorter.convertDate((Date) anyObject())).thenReturn("two");
- //following requires warning suppression but allows setting anyList()
+ // following requires warning suppression but allows setting anyList()
when(sorter.sort(ArgumentMatchers.<String>anyList())).thenReturn(null);
}
}
diff --git a/src/test/java/org/mockitousage/matchers/HamcrestMatchersTest.java b/src/test/java/org/mockitousage/matchers/HamcrestMatchersTest.java
index bee9569..3f16618 100644
--- a/src/test/java/org/mockitousage/matchers/HamcrestMatchersTest.java
+++ b/src/test/java/org/mockitousage/matchers/HamcrestMatchersTest.java
@@ -2,26 +2,25 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.matchers;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.mockito.hamcrest.MockitoHamcrest.*;
+
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.junit.Test;
import org.mockito.ArgumentMatcher;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.*;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.hamcrest.CoreMatchers.is;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.mockito.hamcrest.MockitoHamcrest.*;
-
public class HamcrestMatchersTest extends TestBase {
private final class ContainsX extends BaseMatcher<String> {
@@ -34,8 +33,7 @@
}
}
- @Mock
- private IMethods mock;
+ @Mock private IMethods mock;
@Test
public void stubs_with_hamcrest_matcher() {
@@ -60,6 +58,7 @@
public boolean matches(Object o) {
return true;
}
+
public void describeTo(Description description) {}
}
@@ -93,6 +92,7 @@
public boolean matches(Object o) {
return true;
}
+
public void describeTo(Description description) {}
}
@@ -110,11 +110,14 @@
@Test
public void coexists_with_mockito_matcher() {
- when(mock.simpleMethod(Mockito.argThat(new ArgumentMatcher<String>() {
- public boolean matches(String argument) {
- return true;
- }
- }))).thenReturn("x");
+ when(mock.simpleMethod(
+ Mockito.argThat(
+ new ArgumentMatcher<String>() {
+ public boolean matches(String argument) {
+ return true;
+ }
+ })))
+ .thenReturn("x");
assertEquals("x", mock.simpleMethod("x"));
}
diff --git a/src/test/java/org/mockitousage/matchers/InvalidUseOfMatchersTest.java b/src/test/java/org/mockitousage/matchers/InvalidUseOfMatchersTest.java
index a562f1f..338c072 100644
--- a/src/test/java/org/mockitousage/matchers/InvalidUseOfMatchersTest.java
+++ b/src/test/java/org/mockitousage/matchers/InvalidUseOfMatchersTest.java
@@ -2,9 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.matchers;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.when;
+
import org.junit.Test;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
@@ -16,13 +22,6 @@
import org.mockito.junit.MockitoJUnitRunner;
import org.mockitousage.IMethods;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.when;
-
@RunWith(MockitoJUnitRunner.Silent.class)
public class InvalidUseOfMatchersTest {
@@ -35,9 +34,7 @@
when(mock.threeArgumentMethod(1, eq("2"), "3")).thenReturn(null);
fail();
} catch (InvalidUseOfMatchersException e) {
- assertThat(e.getMessage())
- .contains("3 matchers expected")
- .contains("1 recorded");
+ assertThat(e.getMessage()).contains("3 matchers expected").contains("1 recorded");
}
}
@@ -75,7 +72,7 @@
}
@Test
- public void should_scream_when_not_enough_matchers_inside_or_AddtionalMatcher() {
+ public void should_scream_when_not_enough_matchers_inside_or_AdditionalMatcher() {
try {
mock.simpleMethod(AdditionalMatchers.or(eq("jkl"), "asd"));
fail();
@@ -93,9 +90,7 @@
mock.threeArgumentMethod(1, "asd", eq("asd"));
fail();
} catch (InvalidUseOfMatchersException e) {
- assertThat(e.getMessage())
- .contains("3 matchers expected")
- .contains("1 recorded");
+ assertThat(e.getMessage()).contains("3 matchers expected").contains("1 recorded");
}
}
@@ -103,19 +98,18 @@
public void should_mention_matcher_when_misuse_detected() {
// Given
-
// When
Result run = new JUnitCore().run(ObjectMatcherMisuseOnPrimitiveSite.class);
// Then
assertThat(run.getFailures()).hasSize(2);
- assertThat(run.getFailures().get(0).getException()).isInstanceOf(NullPointerException.class)
- .hasMessage(null);
- assertThat(run.getFailures().get(1).getException()).isInstanceOf(InvalidUseOfMatchersException.class)
- .hasMessageContaining("primitive alternatives");
+ assertThat(run.getFailures().get(0).getException())
+ .isInstanceOf(NullPointerException.class);
+ assertThat(run.getFailures().get(1).getException())
+ .isInstanceOf(InvalidUseOfMatchersException.class)
+ .hasMessageContaining("primitive alternatives");
new StateMaster().reset();
-
}
@RunWith(MockitoJUnitRunner.class)
@@ -123,10 +117,9 @@
@Test
public void fails_with_NPE() {
IMethods mock = Mockito.mock(IMethods.class);
- doNothing().when(mock)
- .twoArgumentMethod(eq(73),
- (Integer) any()); // <= Raise NPE on this call site
+ doNothing()
+ .when(mock)
+ .twoArgumentMethod(eq(73), (Integer) any()); // <= Raise NPE on this call site
}
-
}
}
diff --git a/src/test/java/org/mockitousage/matchers/MatchersMixedWithRawArgumentsTest.java b/src/test/java/org/mockitousage/matchers/MatchersMixedWithRawArgumentsTest.java
index 99cf81b..bea1960 100644
--- a/src/test/java/org/mockitousage/matchers/MatchersMixedWithRawArgumentsTest.java
+++ b/src/test/java/org/mockitousage/matchers/MatchersMixedWithRawArgumentsTest.java
@@ -2,37 +2,37 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.matchers;
+import static org.mockito.Matchers.anyBoolean;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.verify;
+
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.Mock;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.mockito.Matchers.anyBoolean;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.verify;
-
public class MatchersMixedWithRawArgumentsTest extends TestBase {
@Mock private IMethods mock;
- //description of an idea:
- //types of arguments and descriptor value that identifies matcher:
- //Object: objenesis instance to check for identity
- //boolean: false
- //byte: max-1
- //short: max-1
- //int: max-1
- //long: max-1
- //char: 'x'
- //double: max-1
- //float: max-1
+ // description of an idea:
+ // types of arguments and descriptor value that identifies matcher:
+ // Object: objenesis instance to check for identity
+ // boolean: false
+ // byte: max-1
+ // short: max-1
+ // int: max-1
+ // long: max-1
+ // char: 'x'
+ // double: max-1
+ // float: max-1
- //1. how objenesis deal with primitive arrays (like byte[])?
- //2. Analisys of all matchers used by R2 project finished before anyObject() and so far proves it's a good idea.
+ // 1. how objenesis deal with primitive arrays (like byte[])?
+ // 2. Analisys of all matchers used by R2 project finished before anyObject() and so far proves
+ // it's a good idea.
@Ignore("prototyping new feature that allows to avoid eq() matchers when raw args passed")
@Test
diff --git a/src/test/java/org/mockitousage/matchers/MatchersTest.java b/src/test/java/org/mockitousage/matchers/MatchersTest.java
index 9c4dcb0..606cc76 100644
--- a/src/test/java/org/mockitousage/matchers/MatchersTest.java
+++ b/src/test/java/org/mockitousage/matchers/MatchersTest.java
@@ -2,26 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.matchers;
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.RandomAccess;
-import java.util.regex.Pattern;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.AdditionalMatchers.and;
import static org.mockito.AdditionalMatchers.aryEq;
import static org.mockito.AdditionalMatchers.cmpEq;
@@ -60,6 +46,19 @@
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.RandomAccess;
+import java.util.regex.Pattern;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
@SuppressWarnings("unchecked")
public class MatchersTest extends TestBase {
@@ -286,7 +285,7 @@
when(mock.oneArg(anyLong())).thenReturn("6");
when(mock.oneArg(anyShort())).thenReturn("7");
when(mock.oneArg((String) anyObject())).thenReturn("8");
- when(mock.oneArg(anyObject())).thenReturn("9");
+ when(mock.oneArg(Mockito.<Object>anyObject())).thenReturn("9");
when(mock.oneArg(any(RandomAccess.class))).thenReturn("10");
assertEquals("0", mock.oneArg(true));
@@ -326,59 +325,61 @@
@Test
public void should_use_smart_equals_for_arrays() throws Exception {
- //issue 143
- mock.arrayMethod(new String[]{"one"});
- verify(mock).arrayMethod(eq(new String[]{"one"}));
- verify(mock).arrayMethod(new String[]{"one"});
+ // issue 143
+ mock.arrayMethod(new String[] {"one"});
+ verify(mock).arrayMethod(eq(new String[] {"one"}));
+ verify(mock).arrayMethod(new String[] {"one"});
}
@Test
public void should_use_smart_equals_for_primitive_arrays() throws Exception {
- //issue 143
- mock.objectArgMethod(new int[]{1, 2});
- verify(mock).objectArgMethod(eq(new int[]{1, 2}));
- verify(mock).objectArgMethod(new int[]{1, 2});
+ // issue 143
+ mock.objectArgMethod(new int[] {1, 2});
+ verify(mock).objectArgMethod(eq(new int[] {1, 2}));
+ verify(mock).objectArgMethod(new int[] {1, 2});
}
+ @SuppressWarnings("ReturnValueIgnored")
@Test(expected = ArgumentsAreDifferent.class)
- public void array_equals_should_throw_ArgumentsAreDifferentException_for_non_matching_arguments() {
+ public void
+ array_equals_should_throw_ArgumentsAreDifferentException_for_non_matching_arguments() {
List<Object> list = Mockito.mock(List.class);
list.add("test"); // testing fix for issue 20
- list.contains(new Object[]{"1"});
+ list.contains(new Object[] {"1"});
- Mockito.verify(list).contains(new Object[]{"1", "2", "3"});
+ Mockito.verify(list).contains(new Object[] {"1", "2", "3"});
}
@Test
public void array_equals_matcher() {
- when(mock.oneArray(aryEq(new boolean[]{true, false, false}))).thenReturn("0");
- when(mock.oneArray(aryEq(new byte[]{1}))).thenReturn("1");
- when(mock.oneArray(aryEq(new char[]{1}))).thenReturn("2");
- when(mock.oneArray(aryEq(new double[]{1}))).thenReturn("3");
- when(mock.oneArray(aryEq(new float[]{1}))).thenReturn("4");
- when(mock.oneArray(aryEq(new int[]{1}))).thenReturn("5");
- when(mock.oneArray(aryEq(new long[]{1}))).thenReturn("6");
- when(mock.oneArray(aryEq(new short[]{1}))).thenReturn("7");
- when(mock.oneArray(aryEq(new String[]{"Test"}))).thenReturn("8");
- when(mock.oneArray(aryEq(new Object[]{"Test", new Integer(4)}))).thenReturn("9");
+ when(mock.oneArray(aryEq(new boolean[] {true, false, false}))).thenReturn("0");
+ when(mock.oneArray(aryEq(new byte[] {1}))).thenReturn("1");
+ when(mock.oneArray(aryEq(new char[] {1}))).thenReturn("2");
+ when(mock.oneArray(aryEq(new double[] {1}))).thenReturn("3");
+ when(mock.oneArray(aryEq(new float[] {1}))).thenReturn("4");
+ when(mock.oneArray(aryEq(new int[] {1}))).thenReturn("5");
+ when(mock.oneArray(aryEq(new long[] {1}))).thenReturn("6");
+ when(mock.oneArray(aryEq(new short[] {1}))).thenReturn("7");
+ when(mock.oneArray(aryEq(new String[] {"Test"}))).thenReturn("8");
+ when(mock.oneArray(aryEq(new Object[] {"Test", new Integer(4)}))).thenReturn("9");
- assertEquals("0", mock.oneArray(new boolean[]{true, false, false}));
- assertEquals("1", mock.oneArray(new byte[]{1}));
- assertEquals("2", mock.oneArray(new char[]{1}));
- assertEquals("3", mock.oneArray(new double[]{1}));
- assertEquals("4", mock.oneArray(new float[]{1}));
- assertEquals("5", mock.oneArray(new int[]{1}));
- assertEquals("6", mock.oneArray(new long[]{1}));
- assertEquals("7", mock.oneArray(new short[]{1}));
- assertEquals("8", mock.oneArray(new String[]{"Test"}));
- assertEquals("9", mock.oneArray(new Object[]{"Test", new Integer(4)}));
+ assertEquals("0", mock.oneArray(new boolean[] {true, false, false}));
+ assertEquals("1", mock.oneArray(new byte[] {1}));
+ assertEquals("2", mock.oneArray(new char[] {1}));
+ assertEquals("3", mock.oneArray(new double[] {1}));
+ assertEquals("4", mock.oneArray(new float[] {1}));
+ assertEquals("5", mock.oneArray(new int[] {1}));
+ assertEquals("6", mock.oneArray(new long[] {1}));
+ assertEquals("7", mock.oneArray(new short[] {1}));
+ assertEquals("8", mock.oneArray(new String[] {"Test"}));
+ assertEquals("9", mock.oneArray(new Object[] {"Test", new Integer(4)}));
- assertEquals(null, mock.oneArray(new Object[]{"Test", new Integer(999)}));
- assertEquals(null, mock.oneArray(new Object[]{"Test", new Integer(4), "x"}));
+ assertEquals(null, mock.oneArray(new Object[] {"Test", new Integer(999)}));
+ assertEquals(null, mock.oneArray(new Object[] {"Test", new Integer(4), "x"}));
- assertEquals(null, mock.oneArray(new boolean[]{true, false}));
- assertEquals(null, mock.oneArray(new boolean[]{true, true, false}));
+ assertEquals(null, mock.oneArray(new boolean[] {true, false}));
+ assertEquals(null, mock.oneArray(new boolean[] {true, true, false}));
}
@Test
@@ -512,6 +513,14 @@
}
@Test
+ public void matches_Pattern_matcher_in_subregion() {
+ when(mock.oneArg(matches(Pattern.compile("[a-z]")))).thenReturn("1");
+
+ assertEquals("1", mock.oneArg("3a45"));
+ assertEquals(null, mock.oneArg("3445"));
+ }
+
+ @Test
public void contains_matcher() {
when(mock.oneArg(contains("ell"))).thenReturn("1");
when(mock.oneArg(contains("ld"))).thenReturn("2");
@@ -594,21 +603,21 @@
public void eq_matcher_and_nulls() {
mock.simpleMethod((Object) null);
- verify(mock).simpleMethod(eq(null));
+ verify(mock).simpleMethod(Mockito.<Object>eq(null));
}
@Test
public void same_matcher_and_nulls() {
mock.simpleMethod((Object) null);
- verify(mock).simpleMethod(same(null));
+ verify(mock).simpleMethod(Mockito.<Object>same(null));
}
@Test
public void nullable_matcher() throws Exception {
// imagine a Stream.of(...).map(c -> mock.oneArg(c))...
mock.oneArg((Character) null);
- mock.oneArg(Character.valueOf('€'));
+ mock.oneArg(Character.valueOf('\u20AC'));
verify(mock, times(2)).oneArg(nullable(Character.class));
}
diff --git a/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java b/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java
index 46773b8..825902f 100644
--- a/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java
+++ b/src/test/java/org/mockitousage/matchers/MoreMatchersTest.java
@@ -2,23 +2,24 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.matchers;
-import org.assertj.core.api.ThrowableAssert;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-import java.util.*;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import java.util.*;
+
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
public class MoreMatchersTest extends TestBase {
@Mock private IMethods mock;
@@ -34,8 +35,8 @@
public void any_should_be_actual_alias_to_anyObject() {
mock.simpleMethod((Object) null);
- verify(mock).simpleMethod(any());
- verify(mock).simpleMethod(anyObject());
+ verify(mock).simpleMethod(Mockito.<Object>any());
+ verify(mock).simpleMethod(Mockito.<Object>anyObject());
}
@Test
@@ -47,25 +48,29 @@
mock.simpleMethod((String) null);
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() {
- verify(mock).simpleMethod(isA(String.class));
- }
- }).isInstanceOf(ArgumentsAreDifferent.class);
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ @Override
+ public void call() {
+ verify(mock).simpleMethod(isA(String.class));
+ }
+ })
+ .isInstanceOf(ArgumentsAreDifferent.class);
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() {
- verify(mock).simpleMethod(any(String.class));
- }
- }).isInstanceOf(ArgumentsAreDifferent.class);
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ @Override
+ public void call() {
+ verify(mock).simpleMethod(any(String.class));
+ }
+ })
+ .isInstanceOf(ArgumentsAreDifferent.class);
}
@Test
public void should_help_out_with_unnecessary_casting_of_lists() {
- //Below yields compiler warning:
- //when(mock.listArgMethod(anyList())).thenReturn("list");
+ // Below yields compiler warning:
+ // when(mock.listArgMethod(anyList())).thenReturn("list");
when(mock.listArgMethod(anyListOf(String.class))).thenReturn("list");
assertEquals("list", mock.listArgMethod(new LinkedList<String>()));
@@ -74,8 +79,8 @@
@Test
public void should_help_out_with_unnecessary_casting_of_sets() {
- //Below yields compiler warning:
- //when(mock.setArgMethod(anySet())).thenReturn("set");
+ // Below yields compiler warning:
+ // when(mock.setArgMethod(anySet())).thenReturn("set");
when(mock.setArgMethod(anySetOf(String.class))).thenReturn("set");
assertEquals("set", mock.setArgMethod(new HashSet<String>()));
@@ -84,8 +89,8 @@
@Test
public void should_help_out_with_unnecessary_casting_of_maps() {
- //Below yields compiler warning:
- //when(mock.setArgMethod(anySet())).thenReturn("set");
+ // Below yields compiler warning:
+ // when(mock.setArgMethod(anySet())).thenReturn("set");
when(mock.forMap(anyMapOf(String.class, String.class))).thenReturn("map");
assertEquals("map", mock.forMap(new HashMap<String, String>()));
@@ -94,8 +99,8 @@
@Test
public void should_help_out_with_unnecessary_casting_of_collections() {
- //Below yields compiler warning:
- //when(mock.setArgMethod(anySet())).thenReturn("set");
+ // Below yields compiler warning:
+ // when(mock.setArgMethod(anySet())).thenReturn("set");
when(mock.collectionArgMethod(anyCollectionOf(String.class))).thenReturn("collection");
assertEquals("collection", mock.collectionArgMethod(new ArrayList<String>()));
@@ -104,8 +109,8 @@
@Test
public void should_help_out_with_unnecessary_casting_of_iterables() {
- //Below yields compiler warning:
- //when(mock.setArgMethod(anySet())).thenReturn("set");
+ // Below yields compiler warning:
+ // when(mock.setArgMethod(anySet())).thenReturn("set");
when(mock.iterableArgMethod(anyIterableOf(String.class))).thenReturn("iterable");
assertEquals("iterable", mock.iterableArgMethod(new ArrayList<String>()));
@@ -122,5 +127,4 @@
assertEquals("string", mock.objectArgMethod("foo"));
assertEquals("string", mock.objectArgMethod("foo"));
}
-
}
diff --git a/src/test/java/org/mockitousage/matchers/NewMatchersTest.java b/src/test/java/org/mockitousage/matchers/NewMatchersTest.java
index 2f6cbc3..6b26311 100644
--- a/src/test/java/org/mockitousage/matchers/NewMatchersTest.java
+++ b/src/test/java/org/mockitousage/matchers/NewMatchersTest.java
@@ -4,18 +4,18 @@
*/
package org.mockitousage.matchers;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.*;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.*;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
@SuppressWarnings("unchecked")
public class NewMatchersTest extends TestBase {
diff --git a/src/test/java/org/mockitousage/matchers/ReflectionMatchersTest.java b/src/test/java/org/mockitousage/matchers/ReflectionMatchersTest.java
index 84ad482..a2d497e 100644
--- a/src/test/java/org/mockitousage/matchers/ReflectionMatchersTest.java
+++ b/src/test/java/org/mockitousage/matchers/ReflectionMatchersTest.java
@@ -2,24 +2,24 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.matchers;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
-import org.mockitoutil.TestBase;
-
import static org.mockito.Matchers.refEq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
+import org.mockitoutil.TestBase;
+
@SuppressWarnings("all")
public class ReflectionMatchersTest extends TestBase {
class Parent {
private int parentField;
protected String protectedParentField;
+
public Parent(int parentField, String protectedParentField) {
this.parentField = parentField;
this.protectedParentField = protectedParentField;
@@ -29,7 +29,12 @@
class Child extends Parent {
private int childFieldOne;
private Object childFieldTwo;
- public Child(int parentField, String protectedParentField, int childFieldOne, Object childFieldTwo) {
+
+ public Child(
+ int parentField,
+ String protectedParentField,
+ int childFieldOne,
+ Object childFieldTwo) {
super(parentField, protectedParentField);
this.childFieldOne = childFieldOne;
this.childFieldTwo = childFieldTwo;
@@ -56,25 +61,25 @@
verify(mock).run(refEq(wanted));
}
- @Test(expected=ArgumentsAreDifferent.class)
+ @Test(expected = ArgumentsAreDifferent.class)
public void shouldNotMatchWhenFieldValuesDiffer() throws Exception {
Child wanted = new Child(1, "foo", 2, "bar XXX");
verify(mock).run(refEq(wanted));
}
- @Test(expected=ArgumentsAreDifferent.class)
+ @Test(expected = ArgumentsAreDifferent.class)
public void shouldNotMatchAgain() throws Exception {
Child wanted = new Child(1, "foo", 999, "bar");
verify(mock).run(refEq(wanted));
}
- @Test(expected=ArgumentsAreDifferent.class)
+ @Test(expected = ArgumentsAreDifferent.class)
public void shouldNotMatchYetAgain() throws Exception {
Child wanted = new Child(1, "XXXXX", 2, "bar");
verify(mock).run(refEq(wanted));
}
- @Test(expected=ArgumentsAreDifferent.class)
+ @Test(expected = ArgumentsAreDifferent.class)
public void shouldNotMatch() throws Exception {
Child wanted = new Child(234234, "foo", 2, "bar");
verify(mock).run(refEq(wanted));
@@ -93,7 +98,7 @@
verify(mock).run(refEq(wanted, "parentField", "childFieldTwo"));
}
- @Test(expected=ArgumentsAreDifferent.class)
+ @Test(expected = ArgumentsAreDifferent.class)
public void shouldNotMatchWithFieldsExclusion() throws Exception {
Child wanted = new Child(234234, "foo", 2, "excluded");
verify(mock).run(refEq(wanted, "childFieldTwo"));
diff --git a/src/test/java/org/mockitousage/matchers/VarargsTest.java b/src/test/java/org/mockitousage/matchers/VarargsTest.java
index 685c918..dbcee31 100644
--- a/src/test/java/org/mockitousage/matchers/VarargsTest.java
+++ b/src/test/java/org/mockitousage/matchers/VarargsTest.java
@@ -21,31 +21,29 @@
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
import org.mockito.Captor;
import org.mockito.Mock;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
import org.mockitousage.IMethods;
public class VarargsTest {
- @Rule
- public MockitoRule mockitoRule = MockitoJUnit.rule();
- @Rule
- public ExpectedException exception = ExpectedException.none();
- @Captor
- private ArgumentCaptor<String> captor;
- @Mock
- private IMethods mock;
+ @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
+ @Rule public ExpectedException exception = ExpectedException.none();
+ @Captor private ArgumentCaptor<String> captor;
+ @Mock private IMethods mock;
- private static final Condition<Object> NULL = new Condition<Object>() {
+ private static final Condition<Object> NULL =
+ new Condition<Object>() {
- @Override
- public boolean matches(Object value) {
- return value == null;
- }
- };
+ @Override
+ public boolean matches(Object value) {
+ return value == null;
+ }
+ };
@Test
public void shouldMatchVarArgs_noArgs() {
@@ -83,7 +81,7 @@
Object arg = null;
mock.varargs(arg);
- verify(mock).varargs(eq(null));
+ verify(mock).varargs(ArgumentMatchers.<Object[]>eq(null));
}
@Test
@@ -91,7 +89,7 @@
Object arg = null;
mock.varargs(arg);
- verify(mock).varargs(isNull());
+ verify(mock).varargs(ArgumentMatchers.<Object[]>isNull());
}
@Test
@@ -99,7 +97,7 @@
Object[] argArray = null;
mock.varargs(argArray);
- verify(mock).varargs(isNull());
+ verify(mock).varargs(ArgumentMatchers.<Object[]>isNull());
}
@Test
@@ -115,28 +113,28 @@
public void shouldMatchVarArgs_emptyVarArgsOneAnyMatcher() {
mock.varargs();
- verify(mock).varargs((String[])any()); // any() -> VarargMatcher
+ verify(mock).varargs((String[]) any()); // any() -> VarargMatcher
}
@Test
public void shouldMatchVarArgs_oneArgsOneAnyMatcher() {
mock.varargs(1);
- verify(mock).varargs(any()); // any() -> VarargMatcher
+ verify(mock).varargs(ArgumentMatchers.<Object[]>any()); // any() -> VarargMatcher
}
@Test
public void shouldMatchVarArgs_twoArgsOneAnyMatcher() {
mock.varargs(1, 2);
- verify(mock).varargs(any()); // any() -> VarargMatcher
+ verify(mock).varargs(ArgumentMatchers.<Object[]>any()); // any() -> VarargMatcher
}
@Test
public void shouldMatchVarArgs_twoArgsTwoAnyMatcher() {
mock.varargs(1, 2);
- verify(mock).varargs(any(), any()); // any() -> VarargMatcher
+ verify(mock).varargs(any(), ArgumentMatchers.<Object>any()); // any() -> VarargMatcher
}
@Test
@@ -145,7 +143,7 @@
exception.expectMessage("Argument(s) are different");
- verify(mock).varargs(any(), any(), any()); //any() -> VarargMatcher
+ verify(mock).varargs(any(), any(), any()); // any() -> VarargMatcher
}
@Test
@@ -266,7 +264,6 @@
exception.expect(ArgumentsAreDifferent.class);
verify(mock).varargs(captor.capture(), captor.capture());
-
}
@Test
@@ -276,7 +273,6 @@
verify(mock).varargs(captor.capture(), eq("2"), captor.capture());
assertThat(captor).containsExactly("1", "3");
-
}
@Test
@@ -290,7 +286,6 @@
}
assertThat(captor).isEmpty();
-
}
@Test
@@ -300,7 +295,6 @@
exception.expect(ArgumentsAreDifferent.class);
verify(mock).varargs(captor.capture(), captor.capture());
-
}
/**
@@ -320,25 +314,27 @@
verify(mock).varargs(varargCaptor.capture());
- assertThat(varargCaptor).containsExactly(new String[] { "1", "2" });
+ assertThat(varargCaptor).containsExactly(new String[] {"1", "2"});
}
@Test
- public void shouldNotMatchRegualrAndVaraArgs() {
- mock.varargsString(1, "a","b");
+ public void shouldNotMatchRegualrAndVaraArgs() {
+ mock.varargsString(1, "a", "b");
exception.expect(ArgumentsAreDifferent.class);
verify(mock).varargsString(1);
}
+
@Test
- public void shouldNotMatchVaraArgs() {
- when(mock.varargsObject(1, "a","b")).thenReturn("OK");
+ public void shouldNotMatchVaraArgs() {
+ when(mock.varargsObject(1, "a", "b")).thenReturn("OK");
Assertions.assertThat(mock.varargsObject(1)).isNull();
}
- private static <T> AbstractListAssert<?, ?, T, ObjectAssert<T>> assertThat(ArgumentCaptor<T> captor) {
+ private static <T> AbstractListAssert<?, ?, T, ObjectAssert<T>> assertThat(
+ ArgumentCaptor<T> captor) {
return Assertions.assertThat(captor.getAllValues());
}
}
diff --git a/src/test/java/org/mockitousage/matchers/VerificationAndStubbingUsingMatchersTest.java b/src/test/java/org/mockitousage/matchers/VerificationAndStubbingUsingMatchersTest.java
index eea1111..d0d9cf9 100644
--- a/src/test/java/org/mockitousage/matchers/VerificationAndStubbingUsingMatchersTest.java
+++ b/src/test/java/org/mockitousage/matchers/VerificationAndStubbingUsingMatchersTest.java
@@ -2,19 +2,18 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.matchers;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.exceptions.verification.WantedButNotInvoked;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
public class VerificationAndStubbingUsingMatchersTest extends TestBase {
private IMethods one;
private IMethods two;
@@ -45,7 +44,8 @@
try {
three.simpleMethod("test three again");
fail();
- } catch (RuntimeException e) {}
+ } catch (RuntimeException e) {
+ }
}
@Test
@@ -56,7 +56,8 @@
try {
one.oneArg(true);
fail();
- } catch (RuntimeException e) {}
+ } catch (RuntimeException e) {
+ }
one.simpleMethod(100);
two.simpleMethod("test Mockito");
@@ -75,6 +76,7 @@
try {
verify(three).varargsObject(eq(10), eq("first arg"), startsWith("third"));
fail();
- } catch (WantedButNotInvoked e) {}
+ } catch (WantedButNotInvoked e) {
+ }
}
}
diff --git a/src/test/java/org/mockitousage/misuse/CleaningUpPotentialStubbingTest.java b/src/test/java/org/mockitousage/misuse/CleaningUpPotentialStubbingTest.java
index 7e8a658..7a67d7b 100644
--- a/src/test/java/org/mockitousage/misuse/CleaningUpPotentialStubbingTest.java
+++ b/src/test/java/org/mockitousage/misuse/CleaningUpPotentialStubbingTest.java
@@ -4,6 +4,9 @@
*/
package org.mockitousage.misuse;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockito.InOrder;
import org.mockito.Mock;
@@ -11,9 +14,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
public class CleaningUpPotentialStubbingTest extends TestBase {
@Mock private IMethods mock;
@@ -45,10 +45,11 @@
private void assertOngoingStubbingIsReset() {
try {
- //In real, there might be a call to real object or a final method call
- //I'm modelling it with null
+ // In real, there might be a call to real object or a final method call
+ // I'm modelling it with null
when(null).thenReturn("anything");
fail();
- } catch (MissingMethodInvocationException e) {}
+ } catch (MissingMethodInvocationException e) {
+ }
}
}
diff --git a/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java b/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java
index 41e4a16..196f9d0 100644
--- a/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java
+++ b/src/test/java/org/mockitousage/misuse/DescriptiveMessagesOnMisuseTest.java
@@ -2,9 +2,10 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.misuse;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.exceptions.base.MockitoException;
@@ -13,8 +14,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.mockito.Mockito.*;
-
public class DescriptiveMessagesOnMisuseTest extends TestBase {
@Mock private IMethods mock;
@@ -30,74 +29,74 @@
public void tryDescriptiveMessagesOnMisuse() {
Foo foo = mock(Foo.class);
-// when(foo.finalMethod()).thenReturn("foo");
-// doReturn("foo").when(foo).finalMethod();
-// verify(foo).finalMethod();
+ // when(foo.finalMethod()).thenReturn("foo");
+ // doReturn("foo").when(foo).finalMethod();
+ // verify(foo).finalMethod();
-// doReturn("foo");
-// doReturn("bar");
+ // doReturn("foo");
+ // doReturn("bar");
-// verifyNoMoreInteractions();
-// verifyNoMoreInteractions(null);
-// verifyNoMoreInteractions("");
-// verifyZeroInteractions();
-// verifyZeroInteractions(null);
-// verifyZeroInteractions("");
-//
-// inOrder();
-// inOrder(null);
-// inOrder("test");
-// InOrder inOrder = inOrder(mock(List.class));
-// inOrder.verify(mock).simpleMethod();
+ // verifyNoMoreInteractions();
+ // verifyNoMoreInteractions(null);
+ // verifyNoMoreInteractions("");
+ // verifyZeroInteractions();
+ // verifyZeroInteractions(null);
+ // verifyZeroInteractions("");
+ //
+ // inOrder();
+ // inOrder(null);
+ // inOrder("test");
+ // InOrder inOrder = inOrder(mock(List.class));
+ // inOrder.verify(mock).simpleMethod();
-// verify(null);
-// verify(mock.booleanReturningMethod());
+ // verify(null);
+ // verify(mock.booleanReturningMethod());
-// verify(mock).varargs("test", anyString());
+ // verify(mock).varargs("test", anyString());
-// when("x").thenReturn("x");
+ // when("x").thenReturn("x");
-// when(mock.simpleMethod());
-// when(mock.differentMethod()).thenReturn("");
+ // when(mock.simpleMethod());
+ // when(mock.differentMethod()).thenReturn("");
}
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
- @Test(expected=NotAMockException.class)
+ @Test(expected = NotAMockException.class)
public void shouldScreamWhenWholeMethodPassedToVerify() {
verify(mock.booleanReturningMethod());
}
- @Test(expected=NotAMockException.class)
+ @Test(expected = NotAMockException.class)
public void shouldScreamWhenWholeMethodPassedToVerifyNoMoreInteractions() {
verifyNoMoreInteractions(mock.byteReturningMethod());
}
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
- @Test(expected=NotAMockException.class)
+ @Test(expected = NotAMockException.class)
public void shouldScreamWhenInOrderCreatedWithDodgyMock() {
inOrder("not a mock");
}
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
- @Test(expected=NullInsteadOfMockException.class)
+ @Test(expected = NullInsteadOfMockException.class)
public void shouldScreamWhenInOrderCreatedWithNulls() {
inOrder(mock, null);
}
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
- @Test(expected=NullInsteadOfMockException.class)
+ @Test(expected = NullInsteadOfMockException.class)
public void shouldScreamNullPassedToVerify() {
verify(null);
}
- @Test(expected=NullInsteadOfMockException.class)
+ @Test(expected = NullInsteadOfMockException.class)
public void shouldScreamWhenNotMockPassedToVerifyNoMoreInteractions() {
verifyNoMoreInteractions(null, "blah");
}
@SuppressWarnings("all")
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void shouldScreamWhenNullPassedToVerifyNoMoreInteractions() {
- verifyNoMoreInteractions((Object[])null);
+ verifyNoMoreInteractions((Object[]) null);
}
}
diff --git a/src/test/java/org/mockitousage/misuse/DetectingFinalMethodsTest.java b/src/test/java/org/mockitousage/misuse/DetectingFinalMethodsTest.java
index a351c09..71b507b 100644
--- a/src/test/java/org/mockitousage/misuse/DetectingFinalMethodsTest.java
+++ b/src/test/java/org/mockitousage/misuse/DetectingFinalMethodsTest.java
@@ -4,16 +4,16 @@
*/
package org.mockitousage.misuse;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.exceptions.misusing.MissingMethodInvocationException;
import org.mockito.exceptions.misusing.UnfinishedVerificationException;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
-import static org.mockito.Mockito.*;
-
public class DetectingFinalMethodsTest extends TestBase {
class WithFinal {
@@ -31,7 +31,8 @@
try {
verify(withFinal).foo();
fail();
- } catch (UnfinishedVerificationException e) {}
+ } catch (UnfinishedVerificationException e) {
+ }
}
@Test
@@ -41,6 +42,7 @@
try {
when(withFinal.foo()).thenReturn(null);
fail();
- } catch (MissingMethodInvocationException e) {}
+ } catch (MissingMethodInvocationException e) {
+ }
}
}
diff --git a/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java b/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java
index 267e93c..04690b9 100644
--- a/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java
+++ b/src/test/java/org/mockitousage/misuse/DetectingMisusedMatchersTest.java
@@ -4,17 +4,8 @@
*/
package org.mockitousage.misuse;
-import java.util.Observer;
-import org.junit.After;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;
-import org.mockito.exceptions.misusing.UnfinishedVerificationException;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
-
-import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
import static org.junit.Assume.assumeTrue;
import static org.mockito.Mockito.anyBoolean;
import static org.mockito.Mockito.anyInt;
@@ -23,6 +14,16 @@
import static org.mockito.Mockito.validateMockitoUsage;
import static org.mockito.Mockito.verify;
+import java.util.Observer;
+
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.InvalidUseOfMatchersException;
+import org.mockito.exceptions.misusing.UnfinishedVerificationException;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
public class DetectingMisusedMatchersTest extends TestBase {
class WithFinal {
@@ -39,15 +40,15 @@
}
private void misplaced_anyObject_argument_matcher() {
- anyObject();
+ Object ignored = anyObject();
}
private void misplaced_anyInt_argument_matcher() {
- anyInt();
+ int ignored = anyInt();
}
private void misplaced_anyBoolean_argument_matcher() {
- anyBoolean();
+ boolean ignored = anyBoolean();
}
@Test
@@ -76,13 +77,15 @@
fail();
} catch (InvalidUseOfMatchersException e) {
assertThat(e)
- .hasMessageContaining("DetectingMisusedMatchersTest.misplaced_anyInt_argument_matcher")
- .hasMessageContaining("DetectingMisusedMatchersTest.misplaced_anyObject_argument_matcher")
- .hasMessageContaining("DetectingMisusedMatchersTest.misplaced_anyBoolean_argument_matcher");
+ .hasMessageContaining(
+ "DetectingMisusedMatchersTest.misplaced_anyInt_argument_matcher")
+ .hasMessageContaining(
+ "DetectingMisusedMatchersTest.misplaced_anyObject_argument_matcher")
+ .hasMessageContaining(
+ "DetectingMisusedMatchersTest.misplaced_anyBoolean_argument_matcher");
}
}
-
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
@Test
public void shouldSayUnfinishedVerificationButNotInvalidUseOfMatchers() {
@@ -91,6 +94,7 @@
try {
verify(withFinal);
fail();
- } catch (UnfinishedVerificationException e) {}
+ } catch (UnfinishedVerificationException e) {
+ }
}
}
diff --git a/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java b/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java
index 9ebc690..3fc1f56 100644
--- a/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java
+++ b/src/test/java/org/mockitousage/misuse/ExplicitFrameworkValidationTest.java
@@ -2,9 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.misuse;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -14,11 +18,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
public class ExplicitFrameworkValidationTest extends TestBase {
@Mock IMethods mock;
@@ -30,7 +29,8 @@
try {
Mockito.validateMockitoUsage();
fail();
- } catch (UnfinishedVerificationException e) {}
+ } catch (UnfinishedVerificationException e) {
+ }
}
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
@@ -40,7 +40,8 @@
try {
Mockito.validateMockitoUsage();
fail();
- } catch (UnfinishedStubbingException e) {}
+ } catch (UnfinishedStubbingException e) {
+ }
}
@Test
@@ -49,6 +50,7 @@
try {
Mockito.validateMockitoUsage();
fail();
- } catch (InvalidUseOfMatchersException e) {}
+ } catch (InvalidUseOfMatchersException e) {
+ }
}
}
diff --git a/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java b/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
index 2197300..db690b4 100644
--- a/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
+++ b/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
@@ -2,9 +2,11 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.misuse;
+import static org.junit.Assume.assumeFalse;
+import static org.mockito.Mockito.*;
+
import org.junit.After;
import org.junit.Test;
import org.mockito.InOrder;
@@ -14,9 +16,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assume.assumeFalse;
-import static org.mockito.Mockito.*;
-
public class InvalidUsageTest extends TestBase {
@Mock private IMethods mock;
@@ -27,71 +26,81 @@
super.resetState();
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void shouldRequireArgumentsWhenVerifyingNoMoreInteractions() {
verifyNoMoreInteractions();
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void shouldRequireArgumentsWhenVerifyingZeroInteractions() {
verifyZeroInteractions();
}
+ @Test(expected = MockitoException.class)
+ public void shouldRequireArgumentsWhenVerifyingNoInteractions() {
+ verifyNoInteractions();
+ }
+
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void shouldNotCreateInOrderObjectWithoutMocks() {
inOrder();
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void shouldNotAllowVerifyingInOrderUnfamilarMocks() {
InOrder inOrder = inOrder(mock);
inOrder.verify(mockTwo).simpleMethod();
}
- @Test(expected=MissingMethodInvocationException.class)
+ @Test(expected = MissingMethodInvocationException.class)
public void shouldReportMissingMethodInvocationWhenStubbing() {
- when(mock.simpleMethod()).thenReturn("this stubbing is required to make sure Stubbable is pulled");
+ when(mock.simpleMethod())
+ .thenReturn("this stubbing is required to make sure Stubbable is pulled");
when("".toString()).thenReturn("x");
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void shouldNotAllowSettingInvalidCheckedException() throws Exception {
when(mock.simpleMethod()).thenThrow(new Exception());
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void shouldNotAllowSettingNullThrowable() throws Exception {
when(mock.simpleMethod()).thenThrow(new Throwable[] {null});
}
@SuppressWarnings("all")
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void shouldNotAllowSettingNullThrowableVararg() throws Exception {
when(mock.simpleMethod()).thenThrow((Throwable) null);
}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void shouldNotAllowSettingNullConsecutiveThrowable() throws Exception {
when(mock.simpleMethod()).thenThrow(new RuntimeException(), null);
}
final class FinalClass {}
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void shouldNotAllowMockingFinalClassesIfDisabled() throws Exception {
- assumeFalse("Inlining mock allows mocking final classes", mock(FinalClass.class).getClass() == FinalClass.class);
+ assumeFalse(
+ "Inlining mock allows mocking final classes",
+ mock(FinalClass.class).getClass() == FinalClass.class);
}
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
- @Test(expected=MockitoException.class)
+ @Test(expected = MockitoException.class)
public void shouldNotAllowMockingPrimitives() throws Exception {
mock(Integer.TYPE);
}
interface ObjectLikeInterface {
boolean equals(Object o);
+
String toString();
+
int hashCode();
}
@@ -99,21 +108,43 @@
public void shouldNotMockObjectMethodsOnInterface() throws Exception {
ObjectLikeInterface inter = mock(ObjectLikeInterface.class);
- inter.equals(null);
- inter.toString();
- inter.hashCode();
+ Object ignored = inter.equals(null);
+ ignored = inter.toString();
+ ignored = inter.hashCode();
verifyZeroInteractions(inter);
}
@Test
+ public void shouldNotMockObjectMethodsOnInterfaceVerifyNoInteractions() throws Exception {
+ ObjectLikeInterface inter = mock(ObjectLikeInterface.class);
+
+ Object ignored = inter.equals(null);
+ ignored = inter.toString();
+ ignored = inter.hashCode();
+
+ verifyNoInteractions(inter);
+ }
+
+ @Test
public void shouldNotMockObjectMethodsOnClass() throws Exception {
Object clazz = mock(ObjectLikeInterface.class);
- clazz.equals(null);
- clazz.toString();
- clazz.hashCode();
+ Object ignored = clazz.equals(null);
+ ignored = clazz.toString();
+ ignored = clazz.hashCode();
verifyZeroInteractions(clazz);
}
+
+ @Test
+ public void shouldNotMockObjectMethodsOnClassVerifyNoInteractions() throws Exception {
+ Object clazz = mock(ObjectLikeInterface.class);
+
+ Object ignored = clazz.equals(null);
+ ignored = clazz.toString();
+ ignored = clazz.hashCode();
+
+ verifyNoInteractions(clazz);
+ }
}
diff --git a/src/test/java/org/mockitousage/misuse/RestrictedObjectMethodsTest.java b/src/test/java/org/mockitousage/misuse/RestrictedObjectMethodsTest.java
index da5df23..0132340 100644
--- a/src/test/java/org/mockitousage/misuse/RestrictedObjectMethodsTest.java
+++ b/src/test/java/org/mockitousage/misuse/RestrictedObjectMethodsTest.java
@@ -2,9 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.misuse;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.verify;
+
+import java.util.List;
+
import org.junit.After;
import org.junit.Test;
import org.mockito.InOrder;
@@ -12,13 +18,6 @@
import org.mockito.exceptions.base.MockitoException;
import org.mockitoutil.TestBase;
-import java.util.List;
-
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.verify;
-
public class RestrictedObjectMethodsTest extends TestBase {
@Mock List<?> mock;
@@ -40,24 +39,24 @@
@Test
public void shouldBeSilentWhenVerifyHashCode() {
- //because it leads to really weird behavior sometimes
- //it's because cglib & my code can occasionelly call those methods
+ // because it leads to really weird behavior sometimes
+ // it's because cglib & my code can occasionelly call those methods
// and when user has verification started at that time there will be a mess
verify(mock).hashCode();
}
@Test
public void shouldBeSilentWhenVerifyEquals() {
- //because it leads to really weird behavior sometimes
- //it's because cglib & my code can occasionelly call those methods
+ // because it leads to really weird behavior sometimes
+ // it's because cglib & my code can occasionelly call those methods
// and when user has verification started at that time there will be a mess
verify(mock).equals(null);
}
@Test
public void shouldBeSilentWhenVerifyEqualsInOrder() {
- //because it leads to really weird behavior sometimes
- //it's because cglib & my code can occasionelly call those methods
+ // because it leads to really weird behavior sometimes
+ // it's because cglib & my code can occasionelly call those methods
// and when user has verification started at that time there will be a mess
InOrder inOrder = inOrder(mock);
inOrder.verify(mock).equals(null);
diff --git a/src/test/java/org/mockitousage/misuse/SpyStubbingMisuseTest.java b/src/test/java/org/mockitousage/misuse/SpyStubbingMisuseTest.java
index a36c66a..9f0acfe 100644
--- a/src/test/java/org/mockitousage/misuse/SpyStubbingMisuseTest.java
+++ b/src/test/java/org/mockitousage/misuse/SpyStubbingMisuseTest.java
@@ -4,13 +4,13 @@
*/
package org.mockitousage.misuse;
-import org.junit.Test;
-import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.*;
+import org.junit.Test;
+import org.mockito.exceptions.misusing.WrongTypeOfReturnValue;
+
public class SpyStubbingMisuseTest {
@Test
@@ -23,11 +23,14 @@
when(out.produce()).thenReturn(mpoo);
fail();
} catch (WrongTypeOfReturnValue e) {
- assertThat(e.getMessage()).contains("spy").contains("syntax").contains("doReturn|Throw");
+ assertThat(e.getMessage())
+ .contains("spy")
+ .contains("syntax")
+ .contains("doReturn|Throw");
}
}
- public class Sample { }
+ public class Sample {}
public class Strategy {
Sample getSample() {
@@ -37,6 +40,7 @@
public class Sampler {
Sample sample;
+
Sampler(Strategy f) {
sample = f.getSample();
}
@@ -44,9 +48,11 @@
public class Producer {
Strategy strategy;
+
Producer(Strategy f) {
strategy = f;
}
+
Sampler produce() {
return new Sampler(strategy);
}
diff --git a/src/test/java/org/mockitousage/packageprotected/MockingPackageProtectedTest.java b/src/test/java/org/mockitousage/packageprotected/MockingPackageProtectedTest.java
index b740508..b72ce39 100644
--- a/src/test/java/org/mockitousage/packageprotected/MockingPackageProtectedTest.java
+++ b/src/test/java/org/mockitousage/packageprotected/MockingPackageProtectedTest.java
@@ -2,14 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.packageprotected;
+import static org.mockito.Mockito.mock;
+
import org.junit.Test;
import org.mockitoutil.TestBase;
-import static org.mockito.Mockito.mock;
-
public class MockingPackageProtectedTest extends TestBase {
static class Foo {}
diff --git a/src/test/java/org/mockitousage/packageprotected/PackageProtected.java b/src/test/java/org/mockitousage/packageprotected/PackageProtected.java
index 0c1ed91..627b0de 100644
--- a/src/test/java/org/mockitousage/packageprotected/PackageProtected.java
+++ b/src/test/java/org/mockitousage/packageprotected/PackageProtected.java
@@ -4,6 +4,4 @@
*/
package org.mockitousage.packageprotected;
-class PackageProtected {
-
-}
+class PackageProtected {}
diff --git a/src/test/java/org/mockitousage/performance/LoadsOfMocksTest.java b/src/test/java/org/mockitousage/performance/LoadsOfMocksTest.java
index 1b9c24d..c03aa70 100644
--- a/src/test/java/org/mockitousage/performance/LoadsOfMocksTest.java
+++ b/src/test/java/org/mockitousage/performance/LoadsOfMocksTest.java
@@ -2,20 +2,19 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.performance;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.*;
+
+import java.util.LinkedList;
+import java.util.List;
+
import org.junit.Ignore;
import org.junit.Test;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.util.LinkedList;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.*;
-
public class LoadsOfMocksTest extends TestBase {
@Ignore("Use it for performance checks")
diff --git a/src/test/java/org/mockitousage/performance/StubOnlyAvoidMemoryConsumptionTest.java b/src/test/java/org/mockitousage/performance/StubOnlyAvoidMemoryConsumptionTest.java
index 4f02fb0..60a08f2 100644
--- a/src/test/java/org/mockitousage/performance/StubOnlyAvoidMemoryConsumptionTest.java
+++ b/src/test/java/org/mockitousage/performance/StubOnlyAvoidMemoryConsumptionTest.java
@@ -4,11 +4,11 @@
*/
package org.mockitousage.performance;
+import static org.mockito.Mockito.*;
+
import org.junit.Ignore;
import org.junit.Test;
-import static org.mockito.Mockito.*;
-
public class StubOnlyAvoidMemoryConsumptionTest {
@Test
@@ -17,7 +17,7 @@
when(obj.toString()).thenReturn("asdf");
for (int i = 0; i < 1000000; i++) {
- obj.toString();
+ String ignored = obj.toString();
}
}
@@ -28,7 +28,7 @@
when(obj.toString()).thenReturn("asdf");
for (int i = 0; i < 1000000; i++) {
- obj.toString();
+ String ignored = obj.toString();
}
}
}
diff --git a/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java b/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java
index a1a3500..a0b993d 100644
--- a/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java
+++ b/src/test/java/org/mockitousage/plugins/MockitoPluginsTest.java
@@ -4,6 +4,9 @@
*/
package org.mockitousage.plugins;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.withSettings;
+
import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.internal.creation.instance.Instantiator;
@@ -11,14 +14,12 @@
import org.mockito.plugins.InstantiatorProvider;
import org.mockito.plugins.InstantiatorProvider2;
import org.mockito.plugins.MockMaker;
+import org.mockito.plugins.MockitoLogger;
import org.mockito.plugins.MockitoPlugins;
import org.mockito.plugins.PluginSwitch;
import org.mockito.plugins.StackTraceCleanerProvider;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.withSettings;
-
public class MockitoPluginsTest extends TestBase {
private final MockitoPlugins plugins = Mockito.framework().getPlugins();
@@ -32,13 +33,15 @@
assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider.class));
assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider2.class));
assertNotNull(plugins.getDefaultPlugin(AnnotationEngine.class));
+ assertNotNull(plugins.getDefaultPlugin(MockitoLogger.class));
}
@SuppressWarnings("deprecation")
@Test
public void instantiator_provider_backwards_compatibility() {
InstantiatorProvider provider = plugins.getDefaultPlugin(InstantiatorProvider.class);
- Instantiator instantiator = provider.getInstantiator(withSettings().build(MockitoPluginsTest.class));
+ Instantiator instantiator =
+ provider.getInstantiator(withSettings().build(MockitoPluginsTest.class));
assertNotNull(instantiator.newInstance(MockitoPluginsTest.class));
}
diff --git a/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java b/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java
index a4805c4..849a16a 100644
--- a/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java
+++ b/src/test/java/org/mockitousage/puzzlers/BridgeMethodPuzzleTest.java
@@ -2,18 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.puzzlers;
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockitoutil.Conditions.bridgeMethod;
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
/**
* Bridge method is generated by compiler when erasure in parent class is
* different. When is different then it means that in runtime we will have
@@ -32,7 +31,7 @@
private class Sub extends Super<String> {
@Override
- public String say(String t) {
+ public String say(String t) {
return "Dummy says: " + t;
}
}
@@ -49,8 +48,8 @@
@Test
public void shouldVerifyCorrectlyWhenBridgeMethodCalled() throws Exception {
- //Super has following erasure: say(Object) which differs from Dummy.say(String)
- //mock has to detect it and do the super.say()
+ // Super has following erasure: say(Object) which differs from Dummy.say(String)
+ // mock has to detect it and do the super.say()
Sub s = mock(Sub.class);
Super<String> s_down = s;
s_down.say("Hello");
@@ -60,8 +59,8 @@
@Test
public void shouldVerifyCorrectlyWhenBridgeMethodVerified() throws Exception {
- //Super has following erasure: say(Object) which differs from Dummy.say(String)
- //mock has to detect it and do the super.say()
+ // Super has following erasure: say(Object) which differs from Dummy.say(String)
+ // mock has to detect it and do the super.say()
Sub s = mock(Sub.class);
Super<String> s_down = s;
s.say("Hello");
diff --git a/src/test/java/org/mockitousage/puzzlers/OverloadingPuzzleTest.java b/src/test/java/org/mockitousage/puzzlers/OverloadingPuzzleTest.java
index 03441b9..981dee5 100644
--- a/src/test/java/org/mockitousage/puzzlers/OverloadingPuzzleTest.java
+++ b/src/test/java/org/mockitousage/puzzlers/OverloadingPuzzleTest.java
@@ -4,14 +4,14 @@
*/
package org.mockitousage.puzzlers;
-import org.junit.Test;
-import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import org.junit.Test;
+import org.mockito.exceptions.verification.WantedButNotInvoked;
+import org.mockitoutil.TestBase;
+
public class OverloadingPuzzleTest extends TestBase {
private Super mock;
@@ -40,6 +40,7 @@
try {
verify(sub).say("Hello");
fail();
- } catch (WantedButNotInvoked e) {}
+ } catch (WantedButNotInvoked e) {
+ }
}
}
diff --git a/src/test/java/org/mockitousage/serialization/AcrossClassLoaderSerializationTest.java b/src/test/java/org/mockitousage/serialization/AcrossClassLoaderSerializationTest.java
index 3c6601b..2b21067 100644
--- a/src/test/java/org/mockitousage/serialization/AcrossClassLoaderSerializationTest.java
+++ b/src/test/java/org/mockitousage/serialization/AcrossClassLoaderSerializationTest.java
@@ -2,9 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.serialization;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.ByteArrayInputStream;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Callable;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
@@ -13,12 +19,6 @@
import org.mockitoutil.SimplePerRealmReloadingClassLoader;
import org.mockitoutil.SimpleSerializationUtil;
-import java.io.ByteArrayInputStream;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.Callable;
-
-
public class AcrossClassLoaderSerializationTest {
public IMethods mock;
@@ -29,45 +29,49 @@
}
@Test
- public void check_that_mock_can_be_serialized_in_a_classloader_and_deserialized_in_another() throws Exception {
+ public void check_that_mock_can_be_serialized_in_a_classloader_and_deserialized_in_another()
+ throws Exception {
byte[] bytes = create_mock_and_serialize_it_in_class_loader_A();
Object the_deserialized_mock = read_stream_and_deserialize_it_in_class_loader_B(bytes);
+ assertThat(the_deserialized_mock.getClass().getName())
+ .startsWith("org.mockito.codegen.AClassToBeMockedInThisTestOnlyAndInCallablesOnly");
}
private Object read_stream_and_deserialize_it_in_class_loader_B(byte[] bytes) throws Exception {
- return new SimplePerRealmReloadingClassLoader(this.getClass().getClassLoader(), isolating_test_classes())
+ return new SimplePerRealmReloadingClassLoader(
+ this.getClass().getClassLoader(), isolating_test_classes())
.doInRealm(
"org.mockitousage.serialization.AcrossClassLoaderSerializationTest$ReadStreamAndDeserializeIt",
- new Class<?>[]{ byte[].class },
- new Object[]{ bytes }
- );
+ new Class<?>[] {byte[].class},
+ new Object[] {bytes});
}
private byte[] create_mock_and_serialize_it_in_class_loader_A() throws Exception {
- return (byte[]) new SimplePerRealmReloadingClassLoader(this.getClass().getClassLoader(), isolating_test_classes())
- .doInRealm("org.mockitousage.serialization.AcrossClassLoaderSerializationTest$CreateMockAndSerializeIt");
+ return (byte[])
+ new SimplePerRealmReloadingClassLoader(
+ this.getClass().getClassLoader(), isolating_test_classes())
+ .doInRealm(
+ "org.mockitousage.serialization.AcrossClassLoaderSerializationTest$CreateMockAndSerializeIt");
}
-
private SimplePerRealmReloadingClassLoader.ReloadClassPredicate isolating_test_classes() {
return new SimplePerRealmReloadingClassLoader.ReloadClassPredicate() {
public boolean acceptReloadOf(String qualifiedName) {
return qualifiedName.contains("org.mockitousage")
- || qualifiedName.contains("org.mockitoutil")
- ;
+ || qualifiedName.contains("org.mockitoutil");
}
};
}
-
// see create_mock_and_serialize_it_in_class_loader_A
public static class CreateMockAndSerializeIt implements Callable<byte[]> {
public byte[] call() throws Exception {
- AClassToBeMockedInThisTestOnlyAndInCallablesOnly mock = Mockito.mock(
- AClassToBeMockedInThisTestOnlyAndInCallablesOnly.class,
- Mockito.withSettings().serializable(SerializableMode.ACROSS_CLASSLOADERS)
- );
+ AClassToBeMockedInThisTestOnlyAndInCallablesOnly mock =
+ Mockito.mock(
+ AClassToBeMockedInThisTestOnlyAndInCallablesOnly.class,
+ Mockito.withSettings()
+ .serializable(SerializableMode.ACROSS_CLASSLOADERS));
// use MethodProxy before
mock.returningSomething();
@@ -86,14 +90,13 @@
public Object call() throws Exception {
ByteArrayInputStream to_unserialize = new ByteArrayInputStream(bytes);
return SimpleSerializationUtil.deserializeMock(
- to_unserialize,
- AClassToBeMockedInThisTestOnlyAndInCallablesOnly.class
- );
+ to_unserialize, AClassToBeMockedInThisTestOnlyAndInCallablesOnly.class);
}
}
-
public static class AClassToBeMockedInThisTestOnlyAndInCallablesOnly {
- List returningSomething() { return Collections.emptyList(); }
+ List returningSomething() {
+ return Collections.emptyList();
+ }
}
}
diff --git a/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java b/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java
index 3294614..856e89b 100644
--- a/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java
+++ b/src/test/java/org/mockitousage/serialization/DeepStubsSerializableTest.java
@@ -4,22 +4,28 @@
*/
package org.mockitousage.serialization;
-import org.junit.Test;
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+import static org.mockitoutil.SimpleSerializationUtil.serializeAndBack;
import java.io.Serializable;
import java.util.Iterator;
import java.util.List;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
-import static org.mockitoutil.SimpleSerializationUtil.serializeAndBack;
+import org.junit.Test;
public class DeepStubsSerializableTest {
@Test
public void should_serialize_and_deserialize_mock_created_with_deep_stubs() throws Exception {
// given
- SampleClass sampleClass = mock(SampleClass.class, withSettings().defaultAnswer(RETURNS_DEEP_STUBS).serializable());
+ SampleClass sampleClass =
+ mock(
+ SampleClass.class,
+ withSettings().defaultAnswer(RETURNS_DEEP_STUBS).serializable());
when(sampleClass.getSample().isFalse()).thenReturn(true);
when(sampleClass.getSample().number()).thenReturn(999);
@@ -32,31 +38,42 @@
}
@Test
- public void should_serialize_and_deserialize_parameterized_class_mocked_with_deep_stubs() throws Exception {
+ public void should_serialize_and_deserialize_parameterized_class_mocked_with_deep_stubs()
+ throws Exception {
// given
- ListContainer deep_stubbed = mock(ListContainer.class, withSettings().defaultAnswer(RETURNS_DEEP_STUBS).serializable());
+ ListContainer deep_stubbed =
+ mock(
+ ListContainer.class,
+ withSettings().defaultAnswer(RETURNS_DEEP_STUBS).serializable());
when(deep_stubbed.iterator().next().add("yes")).thenReturn(true);
// when
ListContainer deserialized_deep_stub = serializeAndBack(deep_stubbed);
// then
- assertThat(deserialized_deep_stub.iterator().next().add("not stubbed but mock already previously resolved")).isEqualTo(false);
+ assertThat(
+ deserialized_deep_stub
+ .iterator()
+ .next()
+ .add("not stubbed but mock already previously resolved"))
+ .isEqualTo(false);
assertThat(deserialized_deep_stub.iterator().next().add("yes")).isEqualTo(true);
}
- @Test(expected = ClassCastException.class)
- public void should_discard_generics_metadata_when_serialized_then_disabling_deep_stubs_with_generics() throws Exception {
+ @Test
+ public void
+ should_discard_generics_metadata_when_serialized_then_disabling_deep_stubs_with_generics()
+ throws Exception {
// given
- ListContainer deep_stubbed = mock(ListContainer.class, withSettings().defaultAnswer(RETURNS_DEEP_STUBS).serializable());
+ ListContainer deep_stubbed =
+ mock(
+ ListContainer.class,
+ withSettings().defaultAnswer(RETURNS_DEEP_STUBS).serializable());
when(deep_stubbed.iterator().hasNext()).thenReturn(true);
ListContainer deserialized_deep_stub = serializeAndBack(deep_stubbed);
- // when stubbing on a deserialized mock
- when(deserialized_deep_stub.iterator().next().get(42)).thenReturn("no");
-
- // then revert to the default RETURNS_DEEP_STUBS and the code will raise a ClassCastException
+ assertThat(deserialized_deep_stub.iterator().next()).isNull();
}
static class SampleClass implements Serializable {
@@ -99,8 +116,7 @@
return e;
}
- public void remove() {
- }
+ public void remove() {}
};
}
}
diff --git a/src/test/java/org/mockitousage/serialization/ParallelSerializationTest.java b/src/test/java/org/mockitousage/serialization/ParallelSerializationTest.java
index 92faeed..e2caf7c 100644
--- a/src/test/java/org/mockitousage/serialization/ParallelSerializationTest.java
+++ b/src/test/java/org/mockitousage/serialization/ParallelSerializationTest.java
@@ -2,12 +2,10 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.serialization;
-import org.junit.Test;
-import org.mockitousage.IMethods;
-import org.mockitoutil.SimpleSerializationUtil;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.withSettings;
import java.nio.charset.CharacterCodingException;
import java.util.ArrayList;
@@ -15,46 +13,55 @@
import java.util.Random;
import java.util.concurrent.*;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.withSettings;
+import org.junit.Test;
+import org.mockitousage.IMethods;
+import org.mockitoutil.SimpleSerializationUtil;
public class ParallelSerializationTest {
@Test
- public void single_mock_being_serialized_in_different_classloaders_by_multiple_threads() throws ExecutionException, InterruptedException {
+ public void single_mock_being_serialized_in_different_classloaders_by_multiple_threads()
+ throws ExecutionException, InterruptedException {
// given
int iterations = 2;
int threadingFactor = 200;
final ExecutorService executorService = Executors.newFixedThreadPool(threadingFactor);
- final IMethods iMethods_that_store_invocations = mock(IMethods.class, withSettings().serializable());
+ final IMethods iMethods_that_store_invocations =
+ mock(IMethods.class, withSettings().serializable());
// when
for (int i = 0; i <= iterations; i++) {
List<Future<?>> futures = new ArrayList<Future<?>>(threadingFactor);
- final CyclicBarrier barrier_that_will_wait_until_threads_are_ready = new CyclicBarrier(threadingFactor);
+ final CyclicBarrier barrier_that_will_wait_until_threads_are_ready =
+ new CyclicBarrier(threadingFactor);
// prepare all threads by submitting a callable
// - that will serialize the mock a 'threadingFactor' times
// - that will use the mock a 'threadingFactor' times
for (int j = 0; j < threadingFactor; j++) {
// submit a callable that will serialize the mock 'iMethods'
- futures.add(executorService.submit(new Callable<Object>() {
- public Object call() throws Exception {
- barrier_that_will_wait_until_threads_are_ready.await();
+ futures.add(
+ executorService.submit(
+ new Callable<Object>() {
+ public Object call() throws Exception {
+ barrier_that_will_wait_until_threads_are_ready.await();
- randomCallOn(iMethods_that_store_invocations);
+ randomCallOn(iMethods_that_store_invocations);
- return SimpleSerializationUtil.serializeMock(iMethods_that_store_invocations).toByteArray();
- }
- }));
+ return SimpleSerializationUtil.serializeMock(
+ iMethods_that_store_invocations)
+ .toByteArray();
+ }
+ }));
// submit a callable that will only use the mock 'iMethods'
- executorService.submit(new Callable<Object>() {
- public Object call() throws Exception {
- barrier_that_will_wait_until_threads_are_ready.await();
- return iMethods_that_store_invocations.longObjectReturningMethod();
- }
- });
+ executorService.submit(
+ new Callable<Object>() {
+ public Object call() throws Exception {
+ barrier_that_will_wait_until_threads_are_ready.await();
+ return iMethods_that_store_invocations.longObjectReturningMethod();
+ }
+ });
}
// ensure we are getting the futures
@@ -67,16 +74,36 @@
private void randomCallOn(IMethods iMethods) throws CharacterCodingException {
int random = new Random().nextInt(10);
switch (random) {
- case 0 : iMethods.arrayReturningMethod(); break;
- case 1 : iMethods.longObjectReturningMethod(); break;
- case 2 : iMethods.linkedListReturningMethod(); break;
- case 3 : iMethods.iMethodsReturningMethod(); break;
- case 4 : iMethods.canThrowException(); break;
- case 5 : iMethods.differentMethod(); break;
- case 6 : iMethods.voidMethod(); break;
- case 7 : iMethods.varargsString(1, ""); break;
- case 8 : iMethods.forMap(null); break;
- case 9 : iMethods.throwsNothing(false); break;
+ case 0:
+ iMethods.arrayReturningMethod();
+ break;
+ case 1:
+ iMethods.longObjectReturningMethod();
+ break;
+ case 2:
+ iMethods.linkedListReturningMethod();
+ break;
+ case 3:
+ iMethods.iMethodsReturningMethod();
+ break;
+ case 4:
+ iMethods.canThrowException();
+ break;
+ case 5:
+ iMethods.differentMethod();
+ break;
+ case 6:
+ iMethods.voidMethod();
+ break;
+ case 7:
+ iMethods.varargsString(1, "");
+ break;
+ case 8:
+ iMethods.forMap(null);
+ break;
+ case 9:
+ iMethods.throwsNothing(false);
+ break;
default:
}
}
diff --git a/src/test/java/org/mockitousage/serialization/StrictStubsSerializableTest.java b/src/test/java/org/mockitousage/serialization/StrictStubsSerializableTest.java
new file mode 100644
index 0000000..456cde2
--- /dev/null
+++ b/src/test/java/org/mockitousage/serialization/StrictStubsSerializableTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.serialization;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.*;
+import static org.mockitoutil.SimpleSerializationUtil.serializeAndBack;
+
+import java.io.Serializable;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
+public class StrictStubsSerializableTest {
+
+ @Mock(serializable = true)
+ private SampleClass sampleClass;
+
+ @Test
+ public void should_serialize_and_deserialize_mock_created_with_serializable_and_strict_stubs()
+ throws Exception {
+ // given
+ when(sampleClass.isFalse()).thenReturn(true);
+
+ // when
+ SampleClass deserializedSample = serializeAndBack(sampleClass);
+ // to satisfy strict stubbing
+ deserializedSample.isFalse();
+ verify(deserializedSample).isFalse();
+ verify(sampleClass, never()).isFalse();
+
+ // then
+ assertThat(deserializedSample.isFalse()).isEqualTo(true);
+ assertThat(sampleClass.isFalse()).isEqualTo(true);
+ }
+
+ static class SampleClass implements Serializable {
+
+ boolean isFalse() {
+ return false;
+ }
+ }
+}
diff --git a/src/test/java/org/mockitousage/session/MockitoSessionTest.java b/src/test/java/org/mockitousage/session/MockitoSessionTest.java
index 5271f92..958e569 100644
--- a/src/test/java/org/mockitousage/session/MockitoSessionTest.java
+++ b/src/test/java/org/mockitousage/session/MockitoSessionTest.java
@@ -4,6 +4,14 @@
*/
package org.mockitousage.session;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -20,110 +28,115 @@
import org.mockitoutil.JUnitResultAssert;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mockingDetails;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
public class MockitoSessionTest extends TestBase {
private JUnitCore junit = new JUnitCore();
- @Test public void session_without_any_configuration() {
- //when
+ @Test
+ public void session_without_any_configuration() {
+ // when
Result result = junit.run(MockitoSessionTest.SessionWithoutAnyConfiguration.class);
- //expect
+ // expect
JUnitResultAssert.assertThat(result).succeeds(1);
}
- @Test public void session_without_init_mocks_configured() {
- //when
+ @Test
+ public void session_without_init_mocks_configured() {
+ // when
Result result = junit.run(MockitoSessionTest.SessionWithoutInitMocksConfigured.class);
- //expect
+ // expect
JUnitResultAssert.assertThat(result).succeeds(1);
}
- @Test public void session_without_strictness_configured() {
- //when
+ @Test
+ public void session_without_strictness_configured() {
+ // when
Result result = junit.run(MockitoSessionTest.SessionWithoutStrictnessConfigured.class);
- //expect
+ // expect
JUnitResultAssert.assertThat(result).succeeds(1);
}
- @Test public void session_with_incorrect_mockito_usage() {
- //when
+ @Test
+ public void session_with_incorrect_mockito_usage() {
+ // when
Result result = junit.run(MockitoSessionTest.SessionWithIncorrectMockitoUsage.class);
- //expect
+ // expect
JUnitResultAssert.assertThat(result).fails(1, UnfinishedStubbingException.class);
}
- @Test public void reports_other_failure_and_incorrect_mockito_usage() {
- //when
- Result result = junit.run(MockitoSessionTest.SessionWithTestFailureAndIncorrectMockitoUsage.class);
+ @Test
+ public void reports_other_failure_and_incorrect_mockito_usage() {
+ // when
+ Result result =
+ junit.run(MockitoSessionTest.SessionWithTestFailureAndIncorrectMockitoUsage.class);
- //expect
+ // expect
JUnitResultAssert.assertThat(result)
.failsExactly(AssertionError.class, UnfinishedStubbingException.class);
}
- @Test public void allows_initializing_mocks_manually() {
- //when
+ @Test
+ public void allows_initializing_mocks_manually() {
+ // when
Result result = junit.run(MockitoSessionTest.SessionWithManuallyInitializedMock.class);
- //expect
+ // expect
JUnitResultAssert.assertThat(result).succeeds(1);
}
- @Test public void allows_updating_strictness() {
- //when
+ @Test
+ public void allows_updating_strictness() {
+ // when
Result result = junit.run(MockitoSessionTest.SessionWithUpdatedStrictness.class);
- //expect
+ // expect
JUnitResultAssert.assertThat(result).succeeds(1);
}
- @Test public void allows_overriding_failure() {
- //when
+ @Test
+ public void allows_overriding_failure() {
+ // when
Result result = junit.run(MockitoSessionTest.SessionWithOverriddenFailure.class);
- //expect
+ // expect
JUnitResultAssert.assertThat(result).isSuccessful();
- //in order to demonstrate feature, we intentionally misuse Mockito and need to clean up state
+ // in order to demonstrate feature, we intentionally misuse Mockito and need to clean up
+ // state
resetState();
}
- @Test public void cleans_up_state_when_init_fails() {
- //when
+ @Test
+ public void cleans_up_state_when_init_fails() {
+ // when
Result result = junit.run(MockitoSessionTest.SessionWithInitMocksFailure.class);
- //expect that both failures are the same, indicating correct listener cleanup
- //incorrect cleanup causes 1 failure to be InjectMocksException
- // but the next test method would have failed with unuseful error that session was not cleaned up
- JUnitResultAssert.assertThat(result)
- .fails(2, InjectMocksException.class);
+ // expect that both failures are the same, indicating correct listener cleanup
+ // incorrect cleanup causes 1 failure to be InjectMocksException
+ // but the next test method would have failed with unuseful error that session was not
+ // cleaned up
+ JUnitResultAssert.assertThat(result).fails(2, InjectMocksException.class);
}
public static class SessionWithoutAnyConfiguration {
@Mock IMethods mock;
- //session without initMocks is not currently supported
+ // session without initMocks is not currently supported
MockitoSession mockito = Mockito.mockitoSession().startMocking();
- @After public void after() {
+ @After
+ public void after() {
mockito.finishMocking();
}
- @Test public void some_test() {
- assertNull(mock); //initMocks() was not used when configuring session
+ @Test
+ public void some_test() {
+ assertNull(mock); // initMocks() was not used when configuring session
}
}
@@ -131,14 +144,17 @@
@Mock IMethods mock;
- MockitoSession mockito = Mockito.mockitoSession().strictness(Strictness.LENIENT).startMocking();
+ MockitoSession mockito =
+ Mockito.mockitoSession().strictness(Strictness.LENIENT).startMocking();
- @After public void after() {
+ @After
+ public void after() {
mockito.finishMocking();
}
- @Test public void some_test() {
- assertNull(mock); //initMocks() was not used when configuring session
+ @Test
+ public void some_test() {
+ assertNull(mock); // initMocks() was not used when configuring session
}
}
@@ -147,11 +163,13 @@
MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
- @After public void after() {
+ @After
+ public void after() {
mockito.finishMocking();
}
- @Test public void some_test() {
+ @Test
+ public void some_test() {
assertNotNull(mock);
}
}
@@ -161,12 +179,14 @@
MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
- @After public void after() {
+ @After
+ public void after() {
mockito.finishMocking();
}
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
- @Test public void unfinished_stubbing() {
+ @Test
+ public void unfinished_stubbing() {
when(mock.simpleMethod());
}
}
@@ -176,12 +196,14 @@
MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
- @After public void after() {
+ @After
+ public void after() {
mockito.finishMocking();
}
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
- @Test public void unfinished_stubbing_with_other_failure() {
+ @Test
+ public void unfinished_stubbing_with_other_failure() {
when(mock.simpleMethod());
assertTrue(false);
}
@@ -193,31 +215,43 @@
MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
- @After public void after() {
+ @After
+ public void after() {
mockito.finishMocking();
}
- @Test public void manual_mock_preserves_its_settings() {
- assertEquals("mock", mockingDetails(mock).getMockCreationSettings().getMockName().toString());
- assertEquals("manual mock", mockingDetails(mock2).getMockCreationSettings().getMockName().toString());
+ @Test
+ public void manual_mock_preserves_its_settings() {
+ assertEquals(
+ "mock",
+ mockingDetails(mock).getMockCreationSettings().getMockName().toString());
+ assertEquals(
+ "manual mock",
+ mockingDetails(mock2).getMockCreationSettings().getMockName().toString());
}
}
public static class SessionWithUpdatedStrictness {
@Mock IMethods mock;
- MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
+ MockitoSession mockito =
+ Mockito.mockitoSession()
+ .initMocks(this)
+ .strictness(Strictness.STRICT_STUBS)
+ .startMocking();
- @After public void after() {
+ @After
+ public void after() {
mockito.finishMocking();
}
- @Test public void manual_mock_preserves_its_settings() {
+ @Test
+ public void manual_mock_preserves_its_settings() {
when(mock.simpleMethod(1)).thenReturn("foo");
- //when
+ // when
mockito.setStrictness(Strictness.LENIENT);
- //then no exception is thrown, even though the arg is different
+ // then no exception is thrown, even though the arg is different
mock.simpleMethod(2);
}
}
@@ -226,12 +260,14 @@
@Mock IMethods mock;
MockitoSession mockito = Mockito.mockitoSession().initMocks(this).startMocking();
- @After public void after() {
+ @After
+ public void after() {
mockito.finishMocking(new RuntimeException("Boo!"));
}
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
- @Test public void invalid_mockito_usage() {
+ @Test
+ public void invalid_mockito_usage() {
verify(mock);
}
}
@@ -245,20 +281,23 @@
mockito = Mockito.mockitoSession().initMocks(this).startMocking();
}
- @After public void after() {
+ @After
+ public void after() {
if (mockito != null) {
- //so that we reduce amount of exceptions for easier assertions
- //otherwise we would get an NPE here
+ // so that we reduce amount of exceptions for easier assertions
+ // otherwise we would get an NPE here
mockito.finishMocking();
}
}
- @Test public void test1() {
- //should fail the same way
+ @Test
+ public void test1() {
+ // should fail the same way
}
- @Test public void test2() {
- //should fail the same way
+ @Test
+ public void test2() {
+ // should fail the same way
}
static class ConstructorFail {
diff --git a/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java b/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java
index b5ea754..bf616f8 100644
--- a/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java
+++ b/src/test/java/org/mockitousage/spies/PartialMockingWithSpiesTest.java
@@ -2,14 +2,8 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.spies;
-import org.assertj.core.api.Assertions;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
-
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.doThrow;
@@ -18,6 +12,11 @@
import static org.mockito.Mockito.when;
import static org.mockitoutil.Conditions.methodsInStackTrace;
+import org.assertj.core.api.Assertions;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
@SuppressWarnings("unchecked")
public class PartialMockingWithSpiesTest extends TestBase {
@@ -28,6 +27,7 @@
class InheritMe {
private String inherited = "100$";
+
protected String getInherited() {
return inherited;
}
@@ -90,13 +90,14 @@
public void shouldAllowStubbingWithThrowablesMethodsThatDelegateToOtherMethods() {
// when
doThrow(new RuntimeException("appetite for destruction"))
- .when(spy).getNameButDelegateToMethodThatThrows();
+ .when(spy)
+ .getNameButDelegateToMethodThatThrows();
// then
try {
spy.getNameButDelegateToMethodThatThrows();
fail();
- } catch(Exception e) {
+ } catch (Exception e) {
assertEquals("appetite for destruction", e.getMessage());
}
}
@@ -109,15 +110,16 @@
fail();
} catch (Throwable t) {
// then
- Assertions.assertThat(t).has(methodsInStackTrace(
- "throwSomeException",
- "getNameButDelegateToMethodThatThrows",
- "shouldStackTraceGetFilteredOnUserExceptions"
- ));
+ Assertions.assertThat(t)
+ .has(
+ methodsInStackTrace(
+ "throwSomeException",
+ "getNameButDelegateToMethodThatThrows",
+ "shouldStackTraceGetFilteredOnUserExceptions"));
}
}
-// @Test //manual verification
+ // @Test //manual verification
public void verifyTheStackTrace() {
spy.getNameButDelegateToMethodThatThrows();
}
diff --git a/src/test/java/org/mockitousage/spies/SpiesWithRealEqualsAndInOrderTest.java b/src/test/java/org/mockitousage/spies/SpiesWithRealEqualsAndInOrderTest.java
new file mode 100644
index 0000000..e2dabe9
--- /dev/null
+++ b/src/test/java/org/mockitousage/spies/SpiesWithRealEqualsAndInOrderTest.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2021 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.spies;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.inOrder;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+
+// https://github.com/mockito/mockito/issues/2394
+public class SpiesWithRealEqualsAndInOrderTest {
+
+ @Test
+ public void should_be_able_to_handle_in_order_on_spies_with_equals() {
+ ToBeSpied mock1 = spy(new ToBeSpied());
+ ToBeSpied mock2 = spy(new ToBeSpied());
+ mock1.someMethod();
+ InOrder order = inOrder(mock1, mock2);
+ order.verify(mock1).someMethod();
+ order.verifyNoMoreInteractions();
+ }
+
+ static class ToBeSpied {
+ void someMethod() {}
+ }
+}
diff --git a/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java b/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java
index 6bebbdf..b6fe514 100644
--- a/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java
+++ b/src/test/java/org/mockitousage/spies/SpyingOnInterfacesTest.java
@@ -2,9 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.spies;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+
import net.bytebuddy.ByteBuddy;
import net.bytebuddy.ClassFileVersion;
import net.bytebuddy.description.modifier.Visibility;
@@ -17,15 +25,6 @@
import org.mockito.stubbing.Answer;
import org.mockitoutil.TestBase;
-import java.util.List;
-
-import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@SuppressWarnings({"unchecked"})
public class SpyingOnInterfacesTest extends TestBase {
@@ -33,9 +32,9 @@
public void shouldFailFastWhenCallingRealMethodOnInterface() throws Exception {
List<?> list = mock(List.class);
try {
- //when
+ // when
when(list.get(0)).thenCallRealMethod();
- //then
+ // then
fail();
} catch (MockitoException e) {
}
@@ -43,19 +42,19 @@
@Test
public void shouldFailInRuntimeWhenCallingRealMethodOnInterface() throws Exception {
- //given
+ // given
List<Object> list = mock(List.class);
- when(list.get(0)).thenAnswer(
- new Answer<Object>() {
- public Object answer(InvocationOnMock invocation) throws Throwable {
- return invocation.callRealMethod();
- }
- }
- );
+ when(list.get(0))
+ .thenAnswer(
+ new Answer<Object>() {
+ public Object answer(InvocationOnMock invocation) throws Throwable {
+ return invocation.callRealMethod();
+ }
+ });
try {
- //when
+ // when
list.get(0);
- //then
+ // then
fail();
} catch (MockitoException e) {
}
@@ -63,48 +62,55 @@
@Test
public void shouldAllowDelegatingToDefaultMethod() throws Exception {
- assumeTrue("Test can only be executed on Java 8 capable VMs", ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V8));
+ assumeTrue(
+ "Test can only be executed on Java 8 capable VMs",
+ ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V8));
- Class<?> type = new ByteBuddy()
- .makeInterface()
- .defineMethod("foo", String.class, Visibility.PUBLIC)
- .intercept(FixedValue.value("bar"))
- .make()
- .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
- .getLoaded();
+ Class<?> type =
+ new ByteBuddy()
+ .makeInterface()
+ .defineMethod("foo", String.class, Visibility.PUBLIC)
+ .intercept(FixedValue.value("bar"))
+ .make()
+ .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
+ .getLoaded();
Object object = mock(type);
- //when
+ // when
when(type.getMethod("foo").invoke(object)).thenCallRealMethod();
- //then
+ // then
Assertions.assertThat(type.getMethod("foo").invoke(object)).isEqualTo((Object) "bar");
type.getMethod("foo").invoke(verify(object));
}
@Test
public void shouldAllowSpyingOnDefaultMethod() throws Exception {
- assumeTrue("Test can only be executed on Java 8 capable VMs", ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V8));
+ assumeTrue(
+ "Test can only be executed on Java 8 capable VMs",
+ ClassFileVersion.ofThisVm().isAtLeast(ClassFileVersion.JAVA_V8));
- Class<?> iFace = new ByteBuddy()
- .makeInterface()
- .defineMethod("foo", String.class, Visibility.PUBLIC)
- .intercept(FixedValue.value("bar"))
- .make()
- .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
- .getLoaded();
+ Class<?> iFace =
+ new ByteBuddy()
+ .makeInterface()
+ .defineMethod("foo", String.class, Visibility.PUBLIC)
+ .intercept(FixedValue.value("bar"))
+ .make()
+ .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
+ .getLoaded();
- Class<?> impl = new ByteBuddy()
- .subclass(iFace)
- .make()
- .load(iFace.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
- .getLoaded();
+ Class<?> impl =
+ new ByteBuddy()
+ .subclass(iFace)
+ .make()
+ .load(iFace.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
+ .getLoaded();
- Object object = spy(impl.newInstance());
+ Object object = spy(impl.getConstructor().newInstance());
- //when
+ // when
Assertions.assertThat(impl.getMethod("foo").invoke(object)).isEqualTo((Object) "bar");
- //then
+ // then
impl.getMethod("foo").invoke(verify(object));
}
}
diff --git a/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java b/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java
index 8603ca0..30d3784 100644
--- a/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java
+++ b/src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java
@@ -2,27 +2,26 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.spies;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.Mockito.*;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
import org.junit.Test;
import org.mockito.InOrder;
import org.mockito.Mockito;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.exceptions.verification.NoInteractionsWanted;
-import org.mockito.exceptions.verification.TooLittleActualInvocations;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
import org.mockito.exceptions.verification.VerificationInOrderFailure;
import org.mockitoutil.TestBase;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
-import static org.junit.Assert.*;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assume.assumeTrue;
-import static org.mockito.Mockito.*;
-
public class SpyingOnRealObjectsTest extends TestBase {
List<String> list = new LinkedList<String>();
@@ -49,9 +48,7 @@
@Test
public void shouldStub() {
spy.add("one");
- when(spy.get(0))
- .thenReturn("1")
- .thenReturn("1 again");
+ when(spy.get(0)).thenReturn("1").thenReturn("1 again");
assertEquals("1", spy.get(0));
assertEquals("1 again", spy.get(0));
@@ -62,7 +59,7 @@
@Test
public void shouldAllowOverridingStubs() {
- when(spy.contains(anyObject())).thenReturn(true);
+ when(spy.contains(any())).thenReturn(true);
when(spy.contains("foo")).thenReturn(false);
assertTrue(spy.contains("bar"));
@@ -71,26 +68,22 @@
@Test
public void shouldStubVoid() {
- doNothing()
- .doThrow(new RuntimeException())
- .when(spy)
- .clear();
+ doNothing().doThrow(new RuntimeException()).when(spy).clear();
spy.add("one");
spy.clear();
try {
spy.clear();
fail();
- } catch (RuntimeException e) {}
+ } catch (RuntimeException e) {
+ }
assertEquals(1, spy.size());
}
@Test
public void shouldStubWithDoReturnAndVerify() {
- doReturn("foo")
- .doReturn("bar")
- .when(spy).get(0);
+ doReturn("foo").doReturn("bar").when(spy).get(0);
assertEquals("foo", spy.get(0));
assertEquals("bar", spy.get(0));
@@ -121,7 +114,8 @@
try {
inOrder.verify(spy).add("one");
fail();
- } catch (VerificationInOrderFailure f) {}
+ } catch (VerificationInOrderFailure f) {
+ }
}
@Test
@@ -141,7 +135,8 @@
try {
verify(spy, times(3)).add("one");
fail();
- } catch (TooLittleActualInvocations e) {}
+ } catch (TooFewActualInvocations e) {
+ }
}
@Test
@@ -153,13 +148,14 @@
try {
verifyNoMoreInteractions(spy);
fail();
- } catch (NoInteractionsWanted e) {}
+ } catch (NoInteractionsWanted e) {
+ }
}
@Test
public void shouldToString() {
spy.add("foo");
- assertEquals("[foo]" , spy.toString());
+ assertEquals("[foo]", spy.toString());
}
interface Foo {
@@ -168,14 +164,16 @@
@Test
public void shouldAllowSpyingAnonymousClasses() {
- //when
- Foo spy = spy(new Foo() {
- public String print() {
- return "foo";
- }
- });
+ // when
+ Foo spy =
+ spy(
+ new Foo() {
+ public String print() {
+ return "foo";
+ }
+ });
- //then
+ // then
assertEquals("foo", spy.print());
}
@@ -184,10 +182,14 @@
List<String> real = Arrays.asList("first", "second");
try {
List<String> spy = spy(real);
- assumeTrue("Using inline mocks, it is possible to spy on private types", spy.getClass() != real.getClass());
+ assumeTrue(
+ "Using inline mocks, it is possible to spy on private types",
+ spy.getClass() != real.getClass());
fail();
} catch (MockitoException e) {
- assertThat(e).hasMessageContaining("Most likely it is due to mocking a private class that is not visible to Mockito");
+ assertThat(e)
+ .hasMessageContaining(
+ "Most likely it is due to mocking a private class that is not visible to Mockito");
}
}
}
diff --git a/src/test/java/org/mockitousage/spies/StubbingSpiesDoesNotYieldNPETest.java b/src/test/java/org/mockitousage/spies/StubbingSpiesDoesNotYieldNPETest.java
index 12d3a41..89bdd66 100644
--- a/src/test/java/org/mockitousage/spies/StubbingSpiesDoesNotYieldNPETest.java
+++ b/src/test/java/org/mockitousage/spies/StubbingSpiesDoesNotYieldNPETest.java
@@ -4,14 +4,14 @@
*/
package org.mockitousage.spies;
-import org.junit.Test;
-import org.mockitoutil.TestBase;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.spy;
import java.util.Collection;
import java.util.Map;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.spy;
+import org.junit.Test;
+import org.mockitoutil.TestBase;
public class StubbingSpiesDoesNotYieldNPETest extends TestBase {
diff --git a/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesTest.java b/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesTest.java
index 92e1e85..e204784 100644
--- a/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesTest.java
+++ b/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesTest.java
@@ -2,20 +2,19 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stacktrace;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
import org.junit.Test;
import org.mockito.Mock;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
public class ClickableStackTracesTest extends TestBase {
@Mock private IMethods mock;
@@ -35,7 +34,9 @@
verifyTheMock(1, "not foo");
fail();
} catch (ArgumentsAreDifferent e) {
- assertThat(e).hasMessageContaining("callMethodOnMock(").hasMessageContaining("verifyTheMock(");
+ assertThat(e)
+ .hasMessageContaining("callMethodOnMock(")
+ .hasMessageContaining("verifyTheMock(");
}
}
}
diff --git a/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java b/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java
index e9a98c1..2bd7e0c 100644
--- a/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java
+++ b/src/test/java/org/mockitousage/stacktrace/ClickableStackTracesWhenFrameworkMisusedTest.java
@@ -2,9 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stacktrace;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
import org.junit.After;
import org.junit.Test;
import org.mockito.Mock;
@@ -14,10 +17,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
-
public class ClickableStackTracesWhenFrameworkMisusedTest extends TestBase {
@Mock private IMethods mock;
@@ -28,7 +27,7 @@
}
private void misplacedArgumentMatcherHere() {
- anyString();
+ String ignored = anyString();
}
@Test
@@ -39,8 +38,8 @@
fail();
} catch (InvalidUseOfMatchersException e) {
assertThat(e)
- .hasMessageContaining("-> at ")
- .hasMessageContaining("misplacedArgumentMatcherHere(");
+ .hasMessageContaining("-> at ")
+ .hasMessageContaining("misplacedArgumentMatcherHere(");
}
}
@@ -58,8 +57,8 @@
fail();
} catch (UnfinishedStubbingException e) {
assertThat(e)
- .hasMessageContaining("-> at ")
- .hasMessageContaining("unfinishedStubbingHere(");
+ .hasMessageContaining("-> at ")
+ .hasMessageContaining("unfinishedStubbingHere(");
}
}
diff --git a/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java b/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java
index e1bd9af..ba6aed4 100644
--- a/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java
+++ b/src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java
@@ -2,9 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stacktrace;
+import static org.mockito.Mockito.*;
+
+import java.util.LinkedList;
+import java.util.List;
+
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
@@ -16,11 +20,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.util.LinkedList;
-import java.util.List;
-
-import static org.mockito.Mockito.*;
-
@Ignore
@RunWith(MockitoJUnitRunner.class)
public class ModellingDescriptiveMessagesTest extends TestBase {
@@ -35,7 +34,7 @@
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
@Test
public void makeSureStateIsValidatedInTheVeryFirstTestThanksToTheRunner() {
- //mess up the state:
+ // mess up the state:
verify(mock);
}
@@ -59,7 +58,7 @@
}
@Test
- public void shouldSayTooLittleInvocations() {
+ public void shouldSayTooFewInvocations() {
mock.simpleMethod();
verify(mock, times(2)).simpleMethod();
}
@@ -81,7 +80,7 @@
}
@Test
- public void shouldSayTooLittleInvocationsInOrder() {
+ public void shouldSayTooFewInvocationsInOrder() {
mock.simpleMethod();
mock.otherMethod();
mock.otherMethod();
@@ -108,7 +107,7 @@
}
@Test
- public void shouldSayTooLittleInvocationsInAtLeastModeInOrder() {
+ public void shouldSayTooFewInvocationsInAtLeastModeInOrder() {
mock.simpleMethod();
InOrder inOrder = inOrder(mock);
@@ -116,7 +115,7 @@
}
@Test
- public void shouldSayTooLittleInvocationsInAtLeastMode() {
+ public void shouldSayTooFewInvocationsInAtLeastMode() {
mock.simpleMethod();
verify(mock, atLeast(2)).simpleMethod();
@@ -165,8 +164,8 @@
@Test
public void shouldShowExampleOfCorrectArgumentCapturing() {
ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);
- argument.capture();
- argument.getValue();
+ Object ignored = argument.capture();
+ String ignoredValue = argument.getValue();
}
@SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
diff --git a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationChunkInOrderTest.java b/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationChunkInOrderTest.java
index cbb8334..4a2b7b7 100644
--- a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationChunkInOrderTest.java
+++ b/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationChunkInOrderTest.java
@@ -2,9 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stacktrace;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -15,10 +18,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
-
@RunWith(MockitoJUnitRunner.class)
public class PointingStackTraceToActualInvocationChunkInOrderTest extends TestBase {
@@ -40,14 +39,17 @@
mock.simpleMethod(1);
mock.simpleMethod(1);
}
+
private void secondChunk() {
mockTwo.simpleMethod(2);
mockTwo.simpleMethod(2);
}
+
private void thirdChunk() {
mock.simpleMethod(3);
mock.simpleMethod(3);
}
+
private void fourthChunk() {
mockTwo.simpleMethod(4);
mockTwo.simpleMethod(4);
@@ -79,7 +81,7 @@
}
@Test
- public void shouldPointToThirdChunkWhenTooLittleActualInvocations() {
+ public void shouldPointToThirdChunkWhenTooFewActualInvocations() {
inOrder.verify(mock, times(2)).simpleMethod(anyInt());
inOrder.verify(mockTwo, times(2)).simpleMethod(anyInt());
inOrder.verify(mock, atLeastOnce()).simpleMethod(anyInt());
diff --git a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationInOrderTest.java b/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationInOrderTest.java
index 6e05111..a85252d 100644
--- a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationInOrderTest.java
+++ b/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationInOrderTest.java
@@ -2,9 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stacktrace;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -15,11 +18,7 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
-
-//This is required to make sure stack trace is well filtered when runner is ON
+// This is required to make sure stack trace is well filtered when runner is ON
@RunWith(MockitoJUnitRunner.class)
public class PointingStackTraceToActualInvocationInOrderTest extends TestBase {
@@ -40,12 +39,15 @@
private void first() {
mock.simpleMethod(1);
}
+
private void second() {
mockTwo.simpleMethod(2);
}
+
private void third() {
mock.simpleMethod(3);
}
+
private void fourth() {
mockTwo.simpleMethod(4);
}
@@ -111,7 +113,7 @@
}
@Test
- public void shouldPointToFourthMethodBecauseOfTooLittleActualInvocations() {
+ public void shouldPointToFourthMethodBecauseOfTooFewActualInvocations() {
inOrder.verify(mock).simpleMethod(anyInt());
inOrder.verify(mockTwo).simpleMethod(anyInt());
inOrder.verify(mock).simpleMethod(anyInt());
diff --git a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java b/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java
index 34f3e15..41c2f04 100644
--- a/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java
+++ b/src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationTest.java
@@ -2,9 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stacktrace;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -14,12 +18,7 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-//This is required to make sure stack trace is well filtered when runner is ON
+// This is required to make sure stack trace is well filtered when runner is ON
@RunWith(MockitoJUnitRunner.class)
public class PointingStackTraceToActualInvocationTest extends TestBase {
@@ -37,12 +36,15 @@
private void first() {
mock.simpleMethod(1);
}
+
private void second() {
mockTwo.simpleMethod(2);
}
+
private void third() {
mock.simpleMethod(3);
}
+
private void fourth() {
mockTwo.simpleMethod(4);
}
diff --git a/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java b/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
index 6186130..ec3a733 100644
--- a/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
+++ b/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
@@ -2,9 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stacktrace;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+import static org.mockitoutil.Conditions.firstMethodInStackTrace;
+
import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Before;
@@ -18,14 +26,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
-import static org.mockito.Mockito.when;
-import static org.mockitoutil.Conditions.firstMethodInStackTrace;
-
public class StackTraceFilteringTest extends TestBase {
@Mock private IMethods mock;
@@ -57,7 +57,10 @@
verifyNoMoreInteractions(mock);
fail();
} catch (NoInteractionsWanted e) {
- Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyNoMoreInteractions"));
+ Assertions.assertThat(e)
+ .has(
+ firstMethodInStackTrace(
+ "shouldFilterStackTraceOnVerifyNoMoreInteractions"));
}
}
@@ -68,7 +71,20 @@
verifyZeroInteractions(mock);
fail();
} catch (NoInteractionsWanted e) {
- Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyZeroInteractions"));
+ Assertions.assertThat(e)
+ .has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyZeroInteractions"));
+ }
+ }
+
+ @Test
+ public void shouldFilterStackTraceOnVerifyNoInteractions() {
+ mock.oneArg(true);
+ try {
+ verifyNoInteractions(mock);
+ fail();
+ } catch (NoInteractionsWanted e) {
+ Assertions.assertThat(e)
+ .has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyNoInteractions"));
}
}
@@ -80,7 +96,8 @@
verify(mock).oneArg(true);
fail();
} catch (MockitoException expected) {
- Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStacktraceOnMockitoException"));
+ Assertions.assertThat(expected)
+ .has(firstMethodInStackTrace("shouldFilterStacktraceOnMockitoException"));
}
}
@@ -95,7 +112,8 @@
inOrder.verify(mock).oneArg(true);
fail();
} catch (VerificationInOrderFailure e) {
- Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStacktraceWhenVerifyingInOrder"));
+ Assertions.assertThat(e)
+ .has(firstMethodInStackTrace("shouldFilterStacktraceWhenVerifyingInOrder"));
}
}
@@ -105,7 +123,10 @@
inOrder();
fail();
} catch (MockitoException expected) {
- Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStacktraceWhenInOrderThrowsMockitoException"));
+ Assertions.assertThat(expected)
+ .has(
+ firstMethodInStackTrace(
+ "shouldFilterStacktraceWhenInOrderThrowsMockitoException"));
}
}
@@ -116,7 +137,8 @@
inOrder.verify(null);
fail();
} catch (MockitoException expected) {
- Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStacktraceWhenInOrderVerifies"));
+ Assertions.assertThat(expected)
+ .has(firstMethodInStackTrace("shouldFilterStacktraceWhenInOrderVerifies"));
}
}
@@ -126,7 +148,10 @@
when(mock.oneArg(true)).thenThrow(new Exception());
fail();
} catch (MockitoException expected) {
- Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStackTraceWhenThrowingExceptionFromMockHandler"));
+ Assertions.assertThat(expected)
+ .has(
+ firstMethodInStackTrace(
+ "shouldFilterStackTraceWhenThrowingExceptionFromMockHandler"));
}
}
@@ -138,7 +163,8 @@
mock.simpleMethod();
fail();
} catch (RuntimeException e) {
- Assertions.assertThat(e).has(firstMethodInStackTrace("shouldShowProperExceptionStackTrace"));
+ Assertions.assertThat(e)
+ .has(firstMethodInStackTrace("shouldShowProperExceptionStackTrace"));
}
}
}
diff --git a/src/test/java/org/mockitousage/strictness/LenientMockAnnotationTest.java b/src/test/java/org/mockitousage/strictness/LenientMockAnnotationTest.java
new file mode 100644
index 0000000..e2f4b7e
--- /dev/null
+++ b/src/test/java/org/mockitousage/strictness/LenientMockAnnotationTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.strictness;
+
+import static org.mockito.Mockito.when;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+
+public class LenientMockAnnotationTest {
+
+ public @Rule MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
+
+ @Mock(lenient = true)
+ IMethods lenientMock;
+
+ @Mock IMethods regularMock;
+
+ @Test
+ public void mock_is_lenient() {
+ when(lenientMock.simpleMethod("1")).thenReturn("1");
+ when(regularMock.simpleMethod("2")).thenReturn("2");
+
+ // then lenient mock does not throw:
+ ProductionCode.simpleMethod(lenientMock, "3");
+
+ // but regular mock throws:
+ Assertions.assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ ProductionCode.simpleMethod(regularMock, "4");
+ }
+ })
+ .isInstanceOf(PotentialStubbingProblem.class);
+ }
+}
diff --git a/src/test/java/org/mockitousage/strictness/PotentialStubbingSensitivityTest.java b/src/test/java/org/mockitousage/strictness/PotentialStubbingSensitivityTest.java
new file mode 100644
index 0000000..9b468ff
--- /dev/null
+++ b/src/test/java/org/mockitousage/strictness/PotentialStubbingSensitivityTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.strictness;
+
+import static org.mockito.Mockito.when;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.exceptions.misusing.PotentialStubbingProblem;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.quality.Strictness;
+import org.mockitousage.IMethods;
+
+public class PotentialStubbingSensitivityTest {
+
+ @Rule public MockitoRule mockito = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
+ @Mock IMethods mock;
+
+ @Before
+ public void setup() {
+ when(mock.simpleMethod("1")).thenReturn("1");
+ }
+
+ @Test
+ public void allows_stubbing_with_different_arg_in_test_code() {
+ // although we are calling 'simpleMethod' with different argument
+ // Mockito understands that this is stubbing in the test code and does not trigger
+ // PotentialStubbingProblem
+ when(mock.simpleMethod("2")).thenReturn("2");
+
+ // methods in anonymous inner classes are ok, too
+ new Runnable() {
+ public void run() {
+ when(mock.simpleMethod("3")).thenReturn("3");
+ }
+ }.run();
+
+ // avoiding unnecessary stubbing failures:
+ mock.simpleMethod("1");
+ mock.simpleMethod("2");
+ mock.simpleMethod("3");
+ }
+
+ @Test
+ public void reports_potential_stubbing_problem_in_production_code() {
+ // when
+ Assertions.assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() throws Throwable {
+ ProductionCode.simpleMethod(mock, "2");
+ }
+ })
+ .isInstanceOf(PotentialStubbingProblem.class);
+ }
+}
diff --git a/src/test/java/org/mockitousage/strictness/ProductionCode.java b/src/test/java/org/mockitousage/strictness/ProductionCode.java
new file mode 100644
index 0000000..8e76702
--- /dev/null
+++ b/src/test/java/org/mockitousage/strictness/ProductionCode.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.strictness;
+
+import org.mockitousage.IMethods;
+
+/**
+ * Test utility class that simulates invocation of mock in production code.
+ * In certain tests, the production code needs to be invoked in a different class/source file than the test.
+ */
+public class ProductionCode {
+
+ public static void simpleMethod(IMethods mock, String argument) {
+ mock.simpleMethod(argument);
+ }
+
+ public static void simpleMethod(IMethods mock, int argument) {
+ mock.simpleMethod(argument);
+ }
+}
diff --git a/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java b/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java
index 2dce3e0..fd1c053 100644
--- a/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java
+++ b/src/test/java/org/mockitousage/strictness/StrictnessPerMockTest.java
@@ -2,9 +2,17 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.strictness;
+import static junit.framework.TestCase.assertFalse;
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.assertNull;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.withSettings;
+
import org.assertj.core.api.Assertions;
import org.assertj.core.api.ThrowableAssert;
import org.junit.After;
@@ -20,16 +28,7 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static junit.framework.TestCase.assertFalse;
-import static junit.framework.TestCase.assertTrue;
-import static org.junit.Assert.assertNull;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockingDetails;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.withSettings;
-
-//TODO 792 also move other Strictness tests to this package (unless they already have good package)
+// TODO 792 also move other Strictness tests to this package (unless they already have good package)
public class StrictnessPerMockTest {
MockitoSession mockito;
@@ -38,7 +37,11 @@
@Before
public void before() {
- mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
+ mockito =
+ Mockito.mockitoSession()
+ .initMocks(this)
+ .strictness(Strictness.STRICT_STUBS)
+ .startMocking();
assertNull(lenientMock);
lenientMock = mock(IMethods.class, withSettings().lenient());
}
@@ -51,63 +54,73 @@
@Test
public void potential_stubbing_problem() {
- //when
+ // when
given(lenientMock.simpleMethod(100)).willReturn("100");
given(strictStubsMock.simpleMethod(100)).willReturn("100");
- //then on lenient mock (created by hand), we can call the stubbed method with different arg:
+ // then on lenient mock (created by hand), we can call the stubbed method with different
+ // arg:
lenientMock.simpleMethod(200);
- //and on strict stub mock (created by session), we cannot call stubbed method with different arg:
- Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() throws Throwable {
- strictStubsMock.simpleMethod(200);
- }
- }).isInstanceOf(PotentialStubbingProblem.class);
+ // and on strict stub mock (created by session), we cannot call stubbed method with
+ // different arg:
+ Assertions.assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() throws Throwable {
+ ProductionCode.simpleMethod(strictStubsMock, 200);
+ }
+ })
+ .isInstanceOf(PotentialStubbingProblem.class);
}
@Test
public void unnecessary_stubbing() {
- //when
+ // when
given(lenientMock.simpleMethod(100)).willReturn("100");
given(strictStubsMock.simpleMethod(100)).willReturn("100");
- //then unnecessary stubbing flags method only on the strict stub mock:
- Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() throws Throwable {
- mockito.finishMocking();
- }
- }).isInstanceOf(UnnecessaryStubbingException.class)
- .hasMessageContaining("1. -> ")
- //good enough to prove that we're flagging just one unnecessary stubbing:
- //TODO 792: let's make UnnecessaryStubbingException exception contain the Invocation instance
- //so that we can write clean assertion rather than depending on string
- .isNot(TestBase.hasMessageContaining("2. ->"));
+ // then unnecessary stubbing flags method only on the strict stub mock:
+ Assertions.assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ @Override
+ public void call() throws Throwable {
+ mockito.finishMocking();
+ }
+ })
+ .isInstanceOf(UnnecessaryStubbingException.class)
+ .hasMessageContaining("1. -> ")
+ // good enough to prove that we're flagging just one unnecessary stubbing:
+ // TODO 792: let's make UnnecessaryStubbingException exception contain the
+ // Invocation instance
+ // so that we can write clean assertion rather than depending on string
+ .isNot(TestBase.hasMessageContaining("2. ->"));
}
@Test
public void verify_no_more_invocations() {
- //when
+ // when
given(lenientMock.simpleMethod(100)).willReturn("100");
given(strictStubsMock.simpleMethod(100)).willReturn("100");
- //and:
+ // and:
strictStubsMock.simpleMethod(100);
lenientMock.simpleMethod(100);
- //then 'verifyNoMoreInteractions' ignores strict stub (implicitly verified) but flags the lenient mock
- Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() throws Throwable {
- verifyNoMoreInteractions(strictStubsMock, lenientMock);
- }
- }).isInstanceOf(NoInteractionsWanted.class)
- .hasMessageContaining("But found this interaction on mock 'iMethods'")
- //TODO 792: let's make NoInteractionsWanted exception contain the Invocation instances
- //so that we can write clean assertion rather than depending on string
- .hasMessageContaining("Actually, above is the only interaction with this mock");
+ // then 'verifyNoMoreInteractions' ignores strict stub (implicitly verified) but flags the
+ // lenient mock
+ Assertions.assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ @Override
+ public void call() throws Throwable {
+ verifyNoMoreInteractions(strictStubsMock, lenientMock);
+ }
+ })
+ .isInstanceOf(NoInteractionsWanted.class)
+ .hasMessageContaining("But found this interaction on mock 'iMethods'")
+ // TODO 792: let's make NoInteractionsWanted exception contain the Invocation
+ // instances
+ // so that we can write clean assertion rather than depending on string
+ .hasMessageContaining("Actually, above is the only interaction with this mock");
}
@After
diff --git a/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingTest.java b/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingTest.java
index 3838bee..cc78e2a 100644
--- a/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingTest.java
+++ b/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingTest.java
@@ -2,9 +2,16 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.strictness;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
import org.assertj.core.api.ThrowableAssert;
import org.junit.After;
import org.junit.Before;
@@ -20,14 +27,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
public class StrictnessPerStubbingTest {
MockitoSession mockito;
@@ -35,135 +34,155 @@
@Before
public void before() {
- mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
+ mockito =
+ Mockito.mockitoSession()
+ .initMocks(this)
+ .strictness(Strictness.STRICT_STUBS)
+ .startMocking();
}
@Test
public void potential_stubbing_problem() {
- //when
+ // when
when(mock.simpleMethod("1")).thenReturn("1");
lenient().when(mock.differentMethod("2")).thenReturn("2");
- //then on lenient stubbing, we can call it with different argument:
+ // then on lenient stubbing, we can call it with different argument:
mock.differentMethod("200");
- //but on strict stubbing, we cannot:
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() throws Throwable {
- mock.simpleMethod("100");
- }
- }).isInstanceOf(PotentialStubbingProblem.class);
+ // but on strict stubbing, we cannot:
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ @Override
+ public void call() throws Throwable {
+ ProductionCode.simpleMethod(mock, "100");
+ }
+ })
+ .isInstanceOf(PotentialStubbingProblem.class);
}
@Test
public void doReturn_syntax() {
- //when
- lenient().doReturn("2").doReturn("3")
- .when(mock).simpleMethod(1);
+ // when
+ lenient().doReturn("2").doReturn("3").when(mock).simpleMethod(1);
- //then on lenient stubbing, we can call it with different argument:
+ // then on lenient stubbing, we can call it with different argument:
mock.simpleMethod(200);
- //and stubbing works, too:
+ // and stubbing works, too:
assertEquals("2", mock.simpleMethod(1));
assertEquals("3", mock.simpleMethod(1));
}
@Test
public void doReturn_varargs_syntax() {
- //when
- lenient().doReturn("2", "3")
- .when(mock).simpleMethod(1);
+ // when
+ lenient().doReturn("2", "3").when(mock).simpleMethod(1);
- //then on lenient stubbing, we can call it with different argument with no exception:
+ // then on lenient stubbing, we can call it with different argument with no exception:
mock.simpleMethod(200);
- //and stubbing works, too:
+ // and stubbing works, too:
assertEquals("2", mock.simpleMethod(1));
assertEquals("3", mock.simpleMethod(1));
}
@Test
public void doThrow_syntax() {
- //when
+ // when
lenient()
- .doThrow(IllegalArgumentException.class)
- .doThrow(IllegalStateException.class)
- .when(mock).simpleMethod(1);
+ .doThrow(IllegalArgumentException.class)
+ .doThrow(IllegalStateException.class)
+ .when(mock)
+ .simpleMethod(1);
- //then on lenient stubbing, we can call it with different argument with no exception:
+ // then on lenient stubbing, we can call it with different argument with no exception:
mock.simpleMethod(200);
- //and stubbing works, too:
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- public void call() throws Throwable {
- mock.simpleMethod(1);
- }
- }).isInstanceOf(IllegalArgumentException.class);
+ // and stubbing works, too:
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() throws Throwable {
+ mock.simpleMethod(1);
+ }
+ })
+ .isInstanceOf(IllegalArgumentException.class);
- //testing consecutive call:
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- public void call() throws Throwable {
- mock.simpleMethod(1);
- }
- }).isInstanceOf(IllegalStateException.class);
+ // testing consecutive call:
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() throws Throwable {
+ mock.simpleMethod(1);
+ }
+ })
+ .isInstanceOf(IllegalStateException.class);
}
@Test
public void doThrow_vararg_syntax() {
- //when
+ // when
lenient()
- .doThrow(IllegalArgumentException.class, IllegalStateException.class)
- .when(mock).simpleMethod(1);
+ .doThrow(IllegalArgumentException.class, IllegalStateException.class)
+ .when(mock)
+ .simpleMethod(1);
- //then on lenient stubbing, we can call it with different argument with no exception:
+ // then on lenient stubbing, we can call it with different argument with no exception:
mock.simpleMethod(200);
- //and stubbing works, too:
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- public void call() throws Throwable {
- mock.simpleMethod(1);
- }
- }).isInstanceOf(IllegalArgumentException.class);
+ // and stubbing works, too:
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() throws Throwable {
+ mock.simpleMethod(1);
+ }
+ })
+ .isInstanceOf(IllegalArgumentException.class);
- //testing consecutive call:
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- public void call() throws Throwable {
- mock.simpleMethod(1);
- }
- }).isInstanceOf(IllegalStateException.class);
+ // testing consecutive call:
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() throws Throwable {
+ mock.simpleMethod(1);
+ }
+ })
+ .isInstanceOf(IllegalStateException.class);
}
@Test
public void doThrow_instance_vararg_syntax() {
- //when
+ // when
lenient()
- .doThrow(new IllegalArgumentException(), new IllegalStateException())
- .when(mock).simpleMethod(1);
+ .doThrow(new IllegalArgumentException(), new IllegalStateException())
+ .when(mock)
+ .simpleMethod(1);
- //then on lenient stubbing, we can call it with different argument with no exception:
+ // then on lenient stubbing, we can call it with different argument with no exception:
mock.simpleMethod(200);
- //and stubbing works, too:
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- public void call() throws Throwable {
- mock.simpleMethod(1);
- }
- }).isInstanceOf(IllegalArgumentException.class);
+ // and stubbing works, too:
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() throws Throwable {
+ mock.simpleMethod(1);
+ }
+ })
+ .isInstanceOf(IllegalArgumentException.class);
- //testing consecutive call:
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- public void call() throws Throwable {
- mock.simpleMethod(1);
- }
- }).isInstanceOf(IllegalStateException.class);
+ // testing consecutive call:
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() throws Throwable {
+ mock.simpleMethod(1);
+ }
+ })
+ .isInstanceOf(IllegalStateException.class);
}
static class Counter {
int increment(int x) {
return x + 1;
}
+
void scream(String message) {
throw new RuntimeException(message);
}
@@ -171,97 +190,104 @@
@Test
public void doCallRealMethod_syntax() {
- //when
+ // when
Counter mock = mock(Counter.class);
lenient().doCallRealMethod().when(mock).increment(1);
- //then no exception and default return value if we call it with different arg:
+ // then no exception and default return value if we call it with different arg:
assertEquals(0, mock.increment(0));
- //and real method is called when using correct arg:
+ // and real method is called when using correct arg:
assertEquals(2, mock.increment(1));
}
@Test
public void doNothing_syntax() {
- //when
+ // when
final Counter spy = spy(Counter.class);
lenient().doNothing().when(spy).scream("1");
- //then no stubbing exception and real method is called if we call stubbed method with different arg:
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() throws Throwable {
- spy.scream("2");
- }
- }).hasMessage("2");
+ // then no stubbing exception and real method is called if we call stubbed method with
+ // different arg:
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ @Override
+ public void call() throws Throwable {
+ spy.scream("2");
+ }
+ })
+ .hasMessage("2");
- //and we do nothing when stubbing called with correct arg:
+ // and we do nothing when stubbing called with correct arg:
spy.scream("1");
}
@Test
public void doAnswer_syntax() {
- //when
+ // when
lenient().doAnswer(AdditionalAnswers.returnsFirstArg()).when(mock).simpleMethod("1");
- //then on lenient stubbing, we can call it with different argument:
+ // then on lenient stubbing, we can call it with different argument:
mock.simpleMethod("200");
- //and stubbing works, too:
+ // and stubbing works, too:
assertEquals("1", mock.simpleMethod("1"));
}
@Test
public void unnecessary_stubbing() {
- //when
+ // when
when(mock.simpleMethod("1")).thenReturn("1");
lenient().when(mock.differentMethod("2")).thenReturn("2");
- //then unnecessary stubbing flags method only on the strict stubbing:
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() throws Throwable {
- mockito.finishMocking();
- }
- }).isInstanceOf(UnnecessaryStubbingException.class)
- .hasMessageContaining("1. -> ")
- //good enough to prove that we're flagging just one unnecessary stubbing:
- //TODO 792: this assertion is duplicated with StrictnessPerMockTest
- .isNot(TestBase.hasMessageContaining("2. ->"));
+ // then unnecessary stubbing flags method only on the strict stubbing:
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ @Override
+ public void call() throws Throwable {
+ mockito.finishMocking();
+ }
+ })
+ .isInstanceOf(UnnecessaryStubbingException.class)
+ .hasMessageContaining("1. -> ")
+ // good enough to prove that we're flagging just one unnecessary stubbing:
+ // TODO 792: this assertion is duplicated with StrictnessPerMockTest
+ .isNot(TestBase.hasMessageContaining("2. ->"));
}
@Test
public void unnecessary_stubbing_with_doReturn() {
- //when
+ // when
lenient().doReturn("2").when(mock).differentMethod("2");
- //then no exception is thrown:
+ // then no exception is thrown:
mockito.finishMocking();
}
@Test
public void verify_no_more_invocations() {
- //when
+ // when
when(mock.simpleMethod("1")).thenReturn("1");
lenient().when(mock.differentMethod("2")).thenReturn("2");
- //and:
+ // and:
mock.simpleMethod("1");
mock.differentMethod("200"); // <- different arg
- //then 'verifyNoMoreInteractions' flags the lenient stubbing (called with different arg)
- //and reports it with [?] in the exception message
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() throws Throwable {
- verifyNoMoreInteractions(mock);
- }
- }).isInstanceOf(NoInteractionsWanted.class)
- .hasMessageContaining("1. ->")
- .hasMessageContaining("2. [?]->");
- //TODO 792: assertion duplicated with StrictnessPerMockTest
- // and we should use assertions based on content of the exception rather than the string
+ // then 'verifyNoMoreInteractions' flags the lenient stubbing (called with different arg)
+ // and reports it with [?] in the exception message
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ @Override
+ public void call() throws Throwable {
+ verifyNoMoreInteractions(mock);
+ }
+ })
+ .isInstanceOf(NoInteractionsWanted.class)
+ .hasMessageContaining("1. ->")
+ .hasMessageContaining("2. [?]->");
+ // TODO 792: assertion duplicated with StrictnessPerMockTest
+ // and we should use assertions based on content of the exception rather than the string
}
@After
diff --git a/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingWithRunnerTest.java b/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingWithRunnerTest.java
index e42d340..b8a5dc4 100644
--- a/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingWithRunnerTest.java
+++ b/src/test/java/org/mockitousage/strictness/StrictnessPerStubbingWithRunnerTest.java
@@ -2,9 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.strictness;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
+
import org.assertj.core.api.ThrowableAssert;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -13,10 +16,6 @@
import org.mockito.junit.MockitoJUnitRunner;
import org.mockitousage.IMethods;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.when;
-
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class StrictnessPerStubbingWithRunnerTest {
@@ -24,28 +23,29 @@
@Test
public void potential_stubbing_problem() {
- //when
+ // when
when(mock.simpleMethod("1")).thenReturn("1");
lenient().when(mock.differentMethod("2")).thenReturn("2");
- //then on lenient stubbing, we can call it with different argument:
+ // then on lenient stubbing, we can call it with different argument:
mock.differentMethod("200");
- //but on strict stubbing, we cannot:
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() throws Throwable {
- mock.simpleMethod("100");
- }
- }).isInstanceOf(PotentialStubbingProblem.class);
+ // but on strict stubbing, we cannot:
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ ProductionCode.simpleMethod(mock, "100");
+ }
+ })
+ .isInstanceOf(PotentialStubbingProblem.class);
- //let's use the strict stubbing so that it is not reported as failure by the runner:
+ // let's use the strict stubbing so that it is not reported as failure by the runner:
mock.simpleMethod("1");
}
@Test
public void unnecessary_stubbing() {
- //this unnecessary stubbing is not flagged by the runner:
+ // this unnecessary stubbing is not flagged by the runner:
lenient().when(mock.differentMethod("2")).thenReturn("2");
}
}
diff --git a/src/test/java/org/mockitousage/strictness/StrictnessWhenRuleStrictnessIsUpdatedTest.java b/src/test/java/org/mockitousage/strictness/StrictnessWhenRuleStrictnessIsUpdatedTest.java
index 592cca9..c108127 100644
--- a/src/test/java/org/mockitousage/strictness/StrictnessWhenRuleStrictnessIsUpdatedTest.java
+++ b/src/test/java/org/mockitousage/strictness/StrictnessWhenRuleStrictnessIsUpdatedTest.java
@@ -2,9 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.strictness;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.withSettings;
+
import org.assertj.core.api.ThrowableAssert;
import org.junit.Rule;
import org.junit.Test;
@@ -15,12 +20,6 @@
import org.mockito.quality.Strictness;
import org.mockitousage.IMethods;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.withSettings;
-
public class StrictnessWhenRuleStrictnessIsUpdatedTest {
@Mock IMethods mock;
@@ -28,19 +27,20 @@
@Test
public void strictness_per_mock() {
- //when
+ // when
rule.strictness(Strictness.STRICT_STUBS);
- //then previous mock is strict:
+ // then previous mock is strict:
when(mock.simpleMethod(1)).thenReturn("1");
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() throws Throwable {
- mock.simpleMethod(2);
- }
- }).isInstanceOf(PotentialStubbingProblem.class);
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ ProductionCode.simpleMethod(mock, 2);
+ }
+ })
+ .isInstanceOf(PotentialStubbingProblem.class);
- //but the new mock is lenient, even though the rule is not:
+ // but the new mock is lenient, even though the rule is not:
final IMethods lenientMock = mock(IMethods.class, withSettings().lenient());
when(lenientMock.simpleMethod(1)).thenReturn("1");
lenientMock.simpleMethod(100);
@@ -48,19 +48,20 @@
@Test
public void strictness_per_stubbing() {
- //when
+ // when
rule.strictness(Strictness.STRICT_STUBS);
- //then previous mock is strict:
+ // then previous mock is strict:
when(mock.simpleMethod(1)).thenReturn("1");
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() throws Throwable {
- mock.simpleMethod(2);
- }
- }).isInstanceOf(PotentialStubbingProblem.class);
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ ProductionCode.simpleMethod(mock, 2);
+ }
+ })
+ .isInstanceOf(PotentialStubbingProblem.class);
- //but the new mock is lenient, even though the rule is not:
+ // but the new mock is lenient, even though the rule is not:
lenient().when(mock.simpleMethod(1)).thenReturn("1");
mock.simpleMethod(100);
}
diff --git a/src/test/java/org/mockitousage/strictness/StrictnessWithRulesTest.java b/src/test/java/org/mockitousage/strictness/StrictnessWithRulesTest.java
index 3a323fb..1bc9574 100644
--- a/src/test/java/org/mockitousage/strictness/StrictnessWithRulesTest.java
+++ b/src/test/java/org/mockitousage/strictness/StrictnessWithRulesTest.java
@@ -2,9 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.strictness;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
+
import org.assertj.core.api.ThrowableAssert;
import org.junit.Rule;
import org.junit.Test;
@@ -15,10 +18,6 @@
import org.mockito.quality.Strictness;
import org.mockitousage.IMethods;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.when;
-
public class StrictnessWithRulesTest {
@Mock IMethods mock;
@@ -26,28 +25,29 @@
@Test
public void potential_stubbing_problem() {
- //when
+ // when
when(mock.simpleMethod("1")).thenReturn("1");
lenient().when(mock.differentMethod("2")).thenReturn("2");
- //then on lenient stubbing, we can call it with different argument:
+ // then on lenient stubbing, we can call it with different argument:
mock.differentMethod("200");
- //but on strict stubbing, we cannot:
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() throws Throwable {
- mock.simpleMethod("100");
- }
- }).isInstanceOf(PotentialStubbingProblem.class);
+ // but on strict stubbing, we cannot:
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ ProductionCode.simpleMethod(mock, "100");
+ }
+ })
+ .isInstanceOf(PotentialStubbingProblem.class);
- //let's use the strict stubbing so that it is not reported as failure by the rule:
+ // let's use the strict stubbing so that it is not reported as failure by the rule:
mock.simpleMethod("1");
}
@Test
public void unnecessary_stubbing() {
- //this unnecessary stubbing is not flagged by the rule:
+ // this unnecessary stubbing is not flagged by the rule:
lenient().when(mock.differentMethod("2")).thenReturn("2");
}
}
diff --git a/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java b/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
index c63cb6d..375a204 100644
--- a/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
+++ b/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
@@ -2,9 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stubbing;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.exceptions.misusing.CannotVerifyStubOnlyMock;
@@ -13,11 +17,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
-
public class BasicStubbingTest extends TestBase {
private IMethods mock;
@@ -34,7 +33,8 @@
assertEquals(200, mock.objectReturningMethod(200));
assertEquals(100, mock.objectReturningMethod(666));
- assertEquals("default behavior should return null", null, mock.objectReturningMethod("blah"));
+ assertEquals(
+ "default behavior should return null", null, mock.objectReturningMethod("blah"));
}
@Test
@@ -46,7 +46,8 @@
try {
verifyNoMoreInteractions(mock);
fail();
- } catch (NoInteractionsWanted e) {}
+ } catch (NoInteractionsWanted e) {
+ }
}
@Test
@@ -67,18 +68,40 @@
}
@Test
+ public void should_stubbing_not_be_treated_as_interaction_verify_no_interactions() {
+ when(mock.simpleMethod("one")).thenThrow(new RuntimeException());
+ doThrow(new RuntimeException()).when(mock).simpleMethod("two");
+
+ verifyNoInteractions(mock);
+ }
+
+ @Test
public void unfinished_stubbing_cleans_up_the_state() {
reset(mock);
try {
when("").thenReturn("");
fail();
- } catch (MissingMethodInvocationException e) {}
+ } catch (MissingMethodInvocationException e) {
+ }
- //anything that can cause state validation
+ // anything that can cause state validation
verifyZeroInteractions(mock);
}
@Test
+ public void unfinished_stubbing_cleans_up_the_state_verify_no_interactions() {
+ reset(mock);
+ try {
+ when("").thenReturn("");
+ fail();
+ } catch (MissingMethodInvocationException e) {
+ }
+
+ // anything that can cause state validation
+ verifyNoInteractions(mock);
+ }
+
+ @Test
public void should_to_string_mock_name() {
IMethods mock = mock(IMethods.class, "mockie");
IMethods mockTwo = mock(IMethods.class);
@@ -108,12 +131,16 @@
assertEquals(200, localMock.objectReturningMethod(200));
assertEquals(100, localMock.objectReturningMethod(666));
- assertEquals("default behavior should return null", null, localMock.objectReturningMethod("blah"));
+ assertEquals(
+ "default behavior should return null",
+ null,
+ localMock.objectReturningMethod("blah"));
try {
verify(localMock, atLeastOnce()).objectReturningMethod(eq(200));
fail();
- } catch (CannotVerifyStubOnlyMock e) {}
+ } catch (CannotVerifyStubOnlyMock e) {
+ }
}
@SuppressWarnings("MockitoUsage")
@@ -124,6 +151,34 @@
try {
verify(localMock); // throws exception before method invocation
fail();
- } catch (CannotVerifyStubOnlyMock e) {}
+ } catch (CannotVerifyStubOnlyMock e) {
+ assertEquals(
+ "\n"
+ + "Argument \"iMethods\" passed to verify is a stubOnly() mock which cannot be verified.\n"
+ + "If you intend to verify invocations on this mock, don't use stubOnly() in its MockSettings.",
+ e.getMessage());
+ }
+ }
+
+ @Test
+ public void test_stub_only_not_verifiable_verify_no_more_interactions() {
+ IMethods localMock = mock(IMethods.class, withSettings().stubOnly());
+
+ try {
+ verifyNoMoreInteractions(localMock);
+ fail();
+ } catch (CannotVerifyStubOnlyMock e) {
+ }
+ }
+
+ @Test
+ public void test_stub_only_not_verifiable_in_order() {
+ IMethods localMock = mock(IMethods.class, withSettings().stubOnly());
+
+ try {
+ inOrder(localMock);
+ fail();
+ } catch (CannotVerifyStubOnlyMock e) {
+ }
}
}
diff --git a/src/test/java/org/mockitousage/stubbing/CallingRealMethodTest.java b/src/test/java/org/mockitousage/stubbing/CallingRealMethodTest.java
index 9fcf6e0..333661d 100644
--- a/src/test/java/org/mockitousage/stubbing/CallingRealMethodTest.java
+++ b/src/test/java/org/mockitousage/stubbing/CallingRealMethodTest.java
@@ -4,17 +4,16 @@
*/
package org.mockitousage.stubbing;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.*;
-
public class CallingRealMethodTest extends TestBase {
- @Mock
- TestedObject mock;
+ @Mock TestedObject mock;
static class TestedObject {
diff --git a/src/test/java/org/mockitousage/stubbing/CloningParameterTest.java b/src/test/java/org/mockitousage/stubbing/CloningParameterTest.java
index 3da0cdc..000f766 100644
--- a/src/test/java/org/mockitousage/stubbing/CloningParameterTest.java
+++ b/src/test/java/org/mockitousage/stubbing/CloningParameterTest.java
@@ -2,18 +2,18 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stubbing;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
import org.junit.Test;
import org.mockito.internal.stubbing.answers.ClonesArguments;
import org.mockitoutil.TestBase;
-import java.util.List;
-
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.*;
-
public class CloningParameterTest extends TestBase {
@Test
@@ -49,6 +49,34 @@
assertNotNull(emails);
}
+ @Test
+ public void shouldCloneArrays() throws Exception {
+
+ EmailSender emailSender = mock(EmailSender.class, new ClonesArguments());
+
+ // 1. Pass an array into a mock that "ClonesArguments"
+ Person[] ccList = new Person[] {new Person("Wes")};
+ emailSender.sendGroupEmail(1, ccList);
+
+ // 2. Mutate the array
+ ccList[0] = new Person("Joe");
+
+ // 3. Verify that the mock made a copy of the array
+ verify(emailSender).sendGroupEmail(1, new Person[] {new Person("Wes")});
+ }
+
+ @Test
+ public void shouldNotThrowNPEWhenCloningNulls() throws Exception {
+
+ EmailSender emailSender = mock(EmailSender.class, new ClonesArguments());
+
+ // 1. Pass a null into a mock that "ClonesArguments"
+ emailSender.sendEmail(1, (Person) null);
+
+ // 2. Verify that the null argument was captured
+ verify(emailSender).sendEmail(eq(1), (Person) isNull());
+ }
+
public class Person {
private final String name;
@@ -74,36 +102,29 @@
@Override
public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
+ if (this == obj) return true;
+ if (obj == null) return false;
+ if (getClass() != obj.getClass()) return false;
Person other = (Person) obj;
- if (!getOuterType().equals(other.getOuterType()))
- return false;
- if (emailSent != other.emailSent)
- return false;
+ if (!getOuterType().equals(other.getOuterType())) return false;
+ if (emailSent != other.emailSent) return false;
if (name == null) {
- if (other.name != null)
- return false;
- } else if (!name.equals(other.name))
- return false;
+ if (other.name != null) return false;
+ } else if (!name.equals(other.name)) return false;
return true;
}
private CloningParameterTest getOuterType() {
return CloningParameterTest.this;
}
-
}
public interface EmailSender {
void sendEmail(int i, Person person);
- List<?> getAllEmails(Person person);
+ void sendGroupEmail(int i, Person[] persons);
+ List<?> getAllEmails(Person person);
}
}
diff --git a/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java b/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java
index 5622b54..5e39714 100644
--- a/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java
+++ b/src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java
@@ -4,23 +4,28 @@
*/
package org.mockitousage.stubbing;
-import org.assertj.core.api.Assertions;
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.exceptions.verification.TooManyActualInvocations;
-import org.mockitoutil.TestBase;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.*;
-import javax.net.SocketFactory;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.List;
import java.util.Locale;
-import static org.junit.Assert.*;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.*;
+import javax.net.SocketFactory;
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.MockSettings;
+import org.mockito.exceptions.verification.TooManyActualInvocations;
+import org.mockitoutil.TestBase;
public class DeepStubbingTest extends TestBase {
@@ -74,6 +79,20 @@
interface Second extends List<String> {}
+ class BaseClassGenerics<A, B> {}
+
+ class ReversedGenerics<A, B> extends BaseClassGenerics<A, B> {
+ ReversedGenerics<B, A> reverse() {
+ return null;
+ }
+
+ A finalMethod() {
+ return null;
+ }
+ }
+
+ class SuperOfReversedGenerics extends ReversedGenerics<String, Long> {}
+
@Test
public void myTest() throws Exception {
SocketFactory sf = mock(SocketFactory.class, RETURNS_DEEP_STUBS);
@@ -147,7 +166,7 @@
public void withAnyPatternArguments() throws Exception {
OutputStream out = new ByteArrayOutputStream();
- //TODO: should not use javax in case it changes
+ // TODO: should not use javax in case it changes
SocketFactory sf = mock(SocketFactory.class, RETURNS_DEEP_STUBS);
when(sf.createSocket(anyString(), anyInt()).getOutputStream()).thenReturn(out);
@@ -204,56 +223,80 @@
assertEquals(a, sf.createSocket("stackoverflow.com", 80).getPort());
}
+ @Test
+ public void unnamed_to_string() {
+ SocketFactory sf = mock(SocketFactory.class, RETURNS_DEEP_STUBS);
+ assertNotNull(sf.toString());
+ }
+
+ @Test
+ public void named_to_string() {
+ MockSettings settings =
+ withSettings().name("name of mock").defaultAnswer(RETURNS_DEEP_STUBS);
+ SocketFactory sf = mock(SocketFactory.class, settings);
+ assertEquals("name of mock", sf.toString());
+ }
+
Person person = mock(Person.class, RETURNS_DEEP_STUBS);
@Test
- public void shouldStubbingBasicallyWorkFine() throws Exception {
- //given
+ public void shouldStubbingBasicallyWorkFine() {
+ // given
given(person.getAddress().getStreet().getName()).willReturn("Norymberska");
- //when
+ // when
String street = person.getAddress().getStreet().getName();
- //then
+ // then
assertEquals("Norymberska", street);
}
@Test
- public void shouldVerificationBasicallyWorkFine() throws Exception {
- //given
+ public void shouldVerificationBasicallyWorkFine() {
+ // given
person.getAddress().getStreet().getName();
- //then
+ // then
verify(person.getAddress().getStreet()).getName();
}
@Test
- public void verification_work_with_argument_Matchers_in_nested_calls() throws Exception {
- //given
+ public void verification_work_with_argument_Matchers_in_nested_calls() {
+ // given
person.getAddress("111 Mock Lane").getStreet();
person.getAddress("111 Mock Lane").getStreet(Locale.ITALIAN).getName();
- //then
+ // then
verify(person.getAddress(anyString())).getStreet();
verify(person.getAddress(anyString()).getStreet(Locale.CHINESE), never()).getName();
verify(person.getAddress(anyString()).getStreet(eq(Locale.ITALIAN))).getName();
}
@Test
- public void deep_stub_return_same_mock_instance_if_invocation_matchers_matches() throws Exception {
+ public void deep_stub_return_same_mock_instance_if_invocation_matchers_matches() {
when(person.getAddress(anyString()).getStreet().getName()).thenReturn("deep");
person.getAddress("the docks").getStreet().getName();
- assertSame(person.getAddress("the docks").getStreet(), person.getAddress(anyString()).getStreet());
- assertSame(person.getAddress(anyString()).getStreet(), person.getAddress(anyString()).getStreet());
- assertSame(person.getAddress("the docks").getStreet(), person.getAddress("the docks").getStreet());
- assertSame(person.getAddress(anyString()).getStreet(), person.getAddress("the docks").getStreet());
- assertSame(person.getAddress("111 Mock Lane").getStreet(), person.getAddress("the docks").getStreet());
+ assertSame(
+ person.getAddress("the docks").getStreet(),
+ person.getAddress(anyString()).getStreet());
+ assertSame(
+ person.getAddress(anyString()).getStreet(),
+ person.getAddress(anyString()).getStreet());
+ assertSame(
+ person.getAddress("the docks").getStreet(),
+ person.getAddress("the docks").getStreet());
+ assertSame(
+ person.getAddress(anyString()).getStreet(),
+ person.getAddress("the docks").getStreet());
+ assertSame(
+ person.getAddress("111 Mock Lane").getStreet(),
+ person.getAddress("the docks").getStreet());
}
@Test
- public void times_never_atLeast_atMost_verificationModes_should_work() throws Exception {
+ public void times_never_atLeast_atMost_verificationModes_should_work() {
when(person.getAddress(anyString()).getStreet().getName()).thenReturn("deep");
person.getAddress("the docks").getStreet().getName();
@@ -263,12 +306,11 @@
verify(person.getAddress("the docks").getStreet(), times(3)).getName();
verify(person.getAddress("the docks").getStreet(Locale.CHINESE), never()).getName();
- verify(person.getAddress("the docks").getStreet(Locale.ITALIAN), atMost(1)).getName();
+ verify(person.getAddress("the docks").getStreet(Locale.ITALIAN), atMostOnce()).getName();
}
-
@Test
- public void inOrder_only_work_on_the_very_last_mock_but_it_works() throws Exception {
+ public void inOrder_only_work_on_the_very_last_mock_but_it_works() {
when(person.getAddress(anyString()).getStreet().getName()).thenReturn("deep");
when(person.getAddress(anyString()).getStreet(Locale.ITALIAN).getName()).thenReturn("deep");
when(person.getAddress(anyString()).getStreet(Locale.CHINESE).getName()).thenReturn("deep");
@@ -278,19 +320,20 @@
person.getAddress("the docks").getStreet(Locale.ITALIAN).getName();
person.getAddress("the docks").getStreet(Locale.CHINESE).getName();
- InOrder inOrder = inOrder(
- person.getAddress("the docks").getStreet(),
- person.getAddress("the docks").getStreet(Locale.CHINESE),
- person.getAddress("the docks").getStreet(Locale.ITALIAN)
- );
+ InOrder inOrder =
+ inOrder(
+ person.getAddress("the docks").getStreet(),
+ person.getAddress("the docks").getStreet(Locale.CHINESE),
+ person.getAddress("the docks").getStreet(Locale.ITALIAN));
inOrder.verify(person.getAddress("the docks").getStreet(), times(1)).getName();
inOrder.verify(person.getAddress("the docks").getStreet()).getLongName();
- inOrder.verify(person.getAddress("the docks").getStreet(Locale.ITALIAN), atLeast(1)).getName();
+ inOrder.verify(person.getAddress("the docks").getStreet(Locale.ITALIAN), atLeast(1))
+ .getName();
inOrder.verify(person.getAddress("the docks").getStreet(Locale.CHINESE)).getName();
}
@Test
- public void verificationMode_only_work_on_the_last_returned_mock() throws Exception {
+ public void verificationMode_only_work_on_the_last_returned_mock() {
// 1st invocation on Address mock (stubbing)
when(person.getAddress("the docks").getStreet().getName()).thenReturn("deep");
@@ -304,19 +347,17 @@
verify(person.getAddress("the docks"), times(1)).getStreet();
fail();
} catch (TooManyActualInvocations e) {
- Assertions.assertThat(e.getMessage())
- .contains("Wanted 1 time")
- .contains("But was 3 times");
+ assertThat(e.getMessage()).contains("Wanted 1 time").contains("But was 3 times");
}
}
@Test
- public void shouldFailGracefullyWhenClassIsFinal() throws Exception {
- //when
+ public void shouldFailGracefullyWhenClassIsFinal() {
+ // when
FinalClass value = new FinalClass();
given(person.getFinalClass()).willReturn(value);
- //then
+ // then
assertEquals(value, person.getFinalClass());
}
@@ -326,4 +367,13 @@
assertNull(first.getString());
assertNull(first.getSecond().get(0));
}
+
+ @Test
+ public void deep_stub_does_not_stack_overflow_on_reversed_generics() {
+ SuperOfReversedGenerics mock = mock(SuperOfReversedGenerics.class, RETURNS_DEEP_STUBS);
+
+ when((Object) mock.reverse().finalMethod()).thenReturn(5L);
+
+ assertThat(mock.reverse().finalMethod()).isEqualTo(5L);
+ }
}
diff --git a/src/test/java/org/mockitousage/stubbing/MisusingStubbingTest.java b/src/test/java/org/mockitousage/stubbing/MisusingStubbingTest.java
new file mode 100644
index 0000000..556bc56
--- /dev/null
+++ b/src/test/java/org/mockitousage/stubbing/MisusingStubbingTest.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.validateMockitoUsage;
+
+import org.junit.Test;
+import org.mockitoutil.TestBase;
+
+public class MisusingStubbingTest extends TestBase {
+
+ @Test
+ public void clean_state_after_not_a_mock() {
+ // when
+ assertThatThrownBy(() -> doReturn(100).when("not a mock"));
+
+ // then
+ validateMockitoUsage();
+ }
+
+ @Test
+ public void clean_state_after_null_passed() {
+ // when
+ assertThatThrownBy(() -> doReturn(100).when(null));
+
+ // then
+ validateMockitoUsage();
+ }
+}
diff --git a/src/test/java/org/mockitousage/stubbing/ReturningDefaultValuesTest.java b/src/test/java/org/mockitousage/stubbing/ReturningDefaultValuesTest.java
index 5629898..fb2592c 100644
--- a/src/test/java/org/mockitousage/stubbing/ReturningDefaultValuesTest.java
+++ b/src/test/java/org/mockitousage/stubbing/ReturningDefaultValuesTest.java
@@ -2,22 +2,21 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stubbing;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockitousage.IMethods;
-import org.mockitoutil.TestBase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
@SuppressWarnings("unchecked")
public class ReturningDefaultValuesTest extends TestBase {
diff --git a/src/test/java/org/mockitousage/stubbing/SmartNullsGenericBugTest.java b/src/test/java/org/mockitousage/stubbing/SmartNullsGenericBugTest.java
new file mode 100644
index 0000000..38f5ff6
--- /dev/null
+++ b/src/test/java/org/mockitousage/stubbing/SmartNullsGenericBugTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.withSettings;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.Answers;
+
+// Reproduces issue #1551
+public class SmartNullsGenericBugTest {
+
+ @Test
+ public void smart_nulls_generic_bug_generic_T() {
+ ConcreteDao concreteDao =
+ mock(ConcreteDao.class, withSettings().defaultAnswer(Answers.RETURNS_SMART_NULLS));
+
+ final Entity result = concreteDao.findById();
+
+ Assertions.assertThat(result).as("#1551").isNotNull();
+ }
+
+ @Test
+ public void smart_nulls_generic_bug_generic_M() {
+ ConcreteDao concreteDao =
+ mock(ConcreteDao.class, withSettings().defaultAnswer(Answers.RETURNS_SMART_NULLS));
+
+ final String other = concreteDao.find();
+
+ Assertions.assertThat(other).as("#1551 - CCannot resolve type").isNull();
+ }
+
+ @Test
+ public void smart_nulls_generic_bug_generic_M_provided_in_args() {
+ ConcreteDao concreteDao =
+ mock(ConcreteDao.class, withSettings().defaultAnswer(Answers.RETURNS_SMART_NULLS));
+
+ final String other = concreteDao.findArgs(1, "plop");
+
+ Assertions.assertThat(other).as("#1551").isEqualTo("");
+ }
+
+ @Test
+ public void smart_nulls_generic_bug_generic_M_provided_as_varargs() {
+ ConcreteDao concreteDao =
+ mock(ConcreteDao.class, withSettings().defaultAnswer(Answers.RETURNS_SMART_NULLS));
+
+ final String other = concreteDao.findVarargs(42, "plip", "plop");
+
+ Assertions.assertThat(other).as("#1551").isEqualTo("");
+ }
+
+ static class AbstractDao<T> {
+ T findById() {
+ return null;
+ }
+
+ <M> M find() {
+ return null;
+ }
+
+ <M> M findArgs(int idx, M arg) {
+ return null;
+ }
+
+ <M> M findVarargs(int idx, M... args) {
+ return null;
+ }
+ }
+
+ static class Entity {}
+
+ static class ConcreteDao extends AbstractDao<Entity> {}
+}
diff --git a/src/test/java/org/mockitousage/stubbing/SmartNullsStubbingTest.java b/src/test/java/org/mockitousage/stubbing/SmartNullsStubbingTest.java
index 9b3dc86..cd98a0d 100644
--- a/src/test/java/org/mockitousage/stubbing/SmartNullsStubbingTest.java
+++ b/src/test/java/org/mockitousage/stubbing/SmartNullsStubbingTest.java
@@ -2,9 +2,13 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stubbing;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
@@ -13,11 +17,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
-
public class SmartNullsStubbingTest extends TestBase {
private IMethods mock;
@@ -42,6 +41,15 @@
}
}
+ @Test
+ public void should_not_throw_NPE_when_verifying_with_returns_smart_nulls() {
+ Foo mock = mock(Foo.class, RETURNS_SMART_NULLS);
+
+ when(mock.returnsFromArg(null)).thenReturn("Does not fail.");
+
+ assertThat((Object) mock.returnsFromArg(null)).isEqualTo("Does not fail.");
+ }
+
interface Bar {
void boo();
}
@@ -59,6 +67,10 @@
return null;
}
+ <T> T returnsFromArg(T arg) {
+ return arg;
+ }
+
void boo() {}
}
@@ -69,7 +81,8 @@
try {
foo.boo();
fail();
- } catch (SmartNullPointerException e) {}
+ } catch (SmartNullPointerException e) {
+ }
}
@Test
@@ -79,10 +92,10 @@
try {
bar.boo();
fail();
- } catch (SmartNullPointerException e) {}
+ } catch (SmartNullPointerException e) {
+ }
}
-
@Test
public void shouldReturnOrdinaryEmptyValuesForOrdinaryTypes() throws Exception {
IMethods mock = mock(IMethods.class, RETURNS_SMART_NULLS);
@@ -99,13 +112,14 @@
try {
verify(mock).simpleMethod(smartNull);
fail();
- } catch (WantedButNotInvoked e) {}
+ } catch (WantedButNotInvoked e) {
+ }
}
@Test
public void shouldNotThrowSmartNullPointerOnObjectMethods() {
Object smartNull = mock.objectReturningMethod();
- smartNull.toString();
+ String ignored = smartNull.toString();
}
@Test
@@ -124,7 +138,8 @@
@Test
public void shouldShowParametersWhenParamsAreHuge() {
Foo foo = mock(Foo.class, RETURNS_SMART_NULLS);
- String longStr = "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.";
+ String longStr =
+ "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.";
Bar smartNull = foo.getBarWithParams(10, longStr);
try {
diff --git a/src/test/java/org/mockitousage/stubbing/StrictStubbingEndToEndTest.java b/src/test/java/org/mockitousage/stubbing/StrictStubbingEndToEndTest.java
index 724239e..71ae857 100644
--- a/src/test/java/org/mockitousage/stubbing/StrictStubbingEndToEndTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StrictStubbingEndToEndTest.java
@@ -4,6 +4,13 @@
*/
package org.mockitousage.stubbing;
+import static org.mockito.BDDMockito.given;
+import static org.mockitoutil.ConcurrentTesting.concurrently;
+import static org.mockitoutil.JUnitResultAssert.assertThat;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
import org.junit.After;
import org.junit.Test;
import org.junit.runner.JUnitCore;
@@ -17,62 +24,71 @@
import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
import org.mockito.quality.Strictness;
import org.mockitousage.IMethods;
-
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-import static org.mockito.BDDMockito.given;
-import static org.mockitoutil.ConcurrentTesting.concurrently;
-import static org.mockitoutil.JUnitResultAssert.assertThat;
+import org.mockitousage.strictness.ProductionCode;
public class StrictStubbingEndToEndTest {
JUnitCore junit = new JUnitCore();
- @After public void after() {
+ @After
+ public void after() {
new StateMaster().clearMockitoListeners();
}
- @Test public void finish_mocking_exception_does_not_hide_the_exception_from_test() {
+ @Test
+ public void finish_mocking_exception_does_not_hide_the_exception_from_test() {
Result result = junit.run(UnnecessaryStubbing.class);
assertThat(result)
- //both exceptions are reported to JUnit:
+ // both exceptions are reported to JUnit:
.fails("unnecessary_stubbing", IllegalStateException.class)
.fails("unnecessary_stubbing", UnnecessaryStubbingException.class);
}
- @Test public void does_not_report_unused_stubbing_if_mismatch_reported() {
+ @Test
+ public void does_not_report_unused_stubbing_if_mismatch_reported() {
Result result = junit.run(ReportMismatchButNotUnusedStubbing.class);
assertThat(result).fails(1, PotentialStubbingProblem.class);
}
- @Test public void strict_stubbing_does_not_leak_to_other_tests() {
- Result result = junit.run(LenientStrictness1.class, StrictStubsPassing.class, LenientStrictness2.class);
- //all tests pass, lenient test cases contain incorrect stubbing
+ @Test
+ public void strict_stubbing_does_not_leak_to_other_tests() {
+ Result result =
+ junit.run(
+ LenientStrictness1.class,
+ StrictStubsPassing.class,
+ LenientStrictness2.class);
+ // all tests pass, lenient test cases contain incorrect stubbing
assertThat(result).succeeds(5);
}
- @Test public void detects_unfinished_session() {
+ @Test
+ public void detects_unfinished_session() {
Result result = junit.run(UnfinishedMocking.class);
assertThat(result)
- .fails(UnfinishedMockingSessionException.class, "\n" +
- "Unfinished mocking session detected.\n" +
- "Previous MockitoSession was not concluded with 'finishMocking()'.\n" +
- "For examples of correct usage see javadoc for MockitoSession class.");
+ .fails(
+ UnfinishedMockingSessionException.class,
+ "\n"
+ + "Unfinished mocking session detected.\n"
+ + "Previous MockitoSession was not concluded with 'finishMocking()'.\n"
+ + "For examples of correct usage see javadoc for MockitoSession class.");
}
- @Test public void concurrent_sessions_in_different_threads() throws Exception {
+ @Test
+ public void concurrent_sessions_in_different_threads() throws Exception {
final Map<Class, Result> results = new ConcurrentHashMap<Class, Result>();
- concurrently(new Runnable() {
- public void run() {
- results.put(StrictStubsPassing.class, junit.run(StrictStubsPassing.class));
- }
- }, new Runnable() {
- public void run() {
- results.put(ReportMismatchButNotUnusedStubbing.class, junit.run(ReportMismatchButNotUnusedStubbing.class));
- }
- }
- );
+ concurrently(
+ new Runnable() {
+ public void run() {
+ results.put(StrictStubsPassing.class, junit.run(StrictStubsPassing.class));
+ }
+ },
+ new Runnable() {
+ public void run() {
+ results.put(
+ ReportMismatchButNotUnusedStubbing.class,
+ junit.run(ReportMismatchButNotUnusedStubbing.class));
+ }
+ });
assertThat(results.get(StrictStubsPassing.class)).succeeds(1);
assertThat(results.get(ReportMismatchButNotUnusedStubbing.class)).fails(1);
@@ -80,13 +96,19 @@
public static class UnnecessaryStubbing {
@Mock IMethods mock;
- MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
+ MockitoSession mockito =
+ Mockito.mockitoSession()
+ .initMocks(this)
+ .strictness(Strictness.STRICT_STUBS)
+ .startMocking();
- @After public void after() {
+ @After
+ public void after() {
mockito.finishMocking();
}
- @Test public void unnecessary_stubbing() {
+ @Test
+ public void unnecessary_stubbing() {
given(mock.simpleMethod("1")).willReturn("one");
throw new IllegalStateException();
}
@@ -94,27 +116,39 @@
public static class ReportMismatchButNotUnusedStubbing {
@Mock IMethods mock;
- MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
+ MockitoSession mockito =
+ Mockito.mockitoSession()
+ .initMocks(this)
+ .strictness(Strictness.STRICT_STUBS)
+ .startMocking();
- @After public void after() {
+ @After
+ public void after() {
mockito.finishMocking();
}
- @Test public void mismatch() {
+ @Test
+ public void mismatch() {
given(mock.simpleMethod(1)).willReturn("");
- mock.simpleMethod(2);
+ ProductionCode.simpleMethod(mock, 2);
}
}
public static class StrictStubsPassing {
@Mock IMethods mock;
- MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
+ MockitoSession mockito =
+ Mockito.mockitoSession()
+ .initMocks(this)
+ .strictness(Strictness.STRICT_STUBS)
+ .startMocking();
- @After public void after() {
+ @After
+ public void after() {
mockito.finishMocking();
}
- @Test public void used() {
+ @Test
+ public void used() {
given(mock.simpleMethod(1)).willReturn("");
mock.simpleMethod(1);
}
@@ -123,11 +157,13 @@
public static class LenientStrictness1 {
@Mock IMethods mock = Mockito.mock(IMethods.class);
- @Test public void unused() {
+ @Test
+ public void unused() {
given(mock.simpleMethod(1)).willReturn("");
}
- @Test public void mismatch() {
+ @Test
+ public void mismatch() {
given(mock.simpleMethod(2)).willReturn("");
mock.simpleMethod(3);
}
@@ -136,11 +172,13 @@
public static class LenientStrictness2 {
@Mock IMethods mock = Mockito.mock(IMethods.class);
- @Test public void unused() {
+ @Test
+ public void unused() {
given(mock.simpleMethod(1)).willReturn("");
}
- @Test public void mismatch() {
+ @Test
+ public void mismatch() {
given(mock.simpleMethod(2)).willReturn("");
mock.simpleMethod(3);
}
@@ -148,13 +186,19 @@
public static class UnfinishedMocking {
@Mock IMethods mock;
- MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
+ MockitoSession mockito =
+ Mockito.mockitoSession()
+ .initMocks(this)
+ .strictness(Strictness.STRICT_STUBS)
+ .startMocking();
- @Test public void unused() {
+ @Test
+ public void unused() {
given(mock.simpleMethod("1")).willReturn("one");
}
- @Test public void unused2() {
+ @Test
+ public void unused2() {
given(mock.simpleMethod("1")).willReturn("one");
}
}
diff --git a/src/test/java/org/mockitousage/stubbing/StrictStubbingTest.java b/src/test/java/org/mockitousage/stubbing/StrictStubbingTest.java
index 2f40a2d..dfc0323 100644
--- a/src/test/java/org/mockitousage/stubbing/StrictStubbingTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StrictStubbingTest.java
@@ -4,6 +4,11 @@
*/
package org.mockitousage.stubbing;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockitoutil.ThrowableAssert.assertThat;
+
import org.junit.After;
import org.junit.Test;
import org.mockito.Mock;
@@ -14,88 +19,102 @@
import org.mockito.exceptions.verification.NoInteractionsWanted;
import org.mockito.quality.Strictness;
import org.mockitousage.IMethods;
-
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockitoutil.ThrowableAssert.assertThat;
+import org.mockitousage.strictness.ProductionCode;
public class StrictStubbingTest {
@Mock IMethods mock;
- MockitoSession mockito = Mockito.mockitoSession().initMocks(this).strictness(Strictness.STRICT_STUBS).startMocking();
+ MockitoSession mockito =
+ Mockito.mockitoSession()
+ .initMocks(this)
+ .strictness(Strictness.STRICT_STUBS)
+ .startMocking();
- @After public void after() {
- //Some tests already invoke below but that's ok
+ @After
+ public void after() {
+ // Some tests already invoke below but that's ok
mockito.finishMocking();
}
- @Test public void no_interactions() throws Throwable {
- //expect no exception
+ @Test
+ public void no_interactions() throws Throwable {
+ // expect no exception
mockito.finishMocking();
}
- @Test public void few_interactions() throws Throwable {
+ @Test
+ public void few_interactions() throws Throwable {
mock.simpleMethod(100);
mock.otherMethod();
}
- @Test public void few_verified_interactions() throws Throwable {
- //when
+ @Test
+ public void few_verified_interactions() throws Throwable {
+ // when
mock.simpleMethod(100);
mock.otherMethod();
- //and
+ // and
verify(mock).simpleMethod(100);
verify(mock).otherMethod();
verifyNoMoreInteractions(mock);
}
- @Test public void stubbed_method_is_implicitly_verified() throws Throwable {
- //when
+ @Test
+ public void stubbed_method_is_implicitly_verified() throws Throwable {
+ // when
given(mock.simpleMethod(100)).willReturn("100");
mock.simpleMethod(100);
- //no exceptions:
+ // no exceptions:
verifyNoMoreInteractions(mock);
}
- @Test public void unused_stubbed_is_not_implicitly_verified() throws Throwable {
- //when
+ @Test
+ public void unused_stubbed_is_not_implicitly_verified() throws Throwable {
+ // when
given(mock.simpleMethod(100)).willReturn("100");
mock.simpleMethod(100); // <- implicitly verified
mock.simpleMethod(200); // <- unverified
- //expect
- assertThat(new Runnable() {
- public void run() {
- verifyNoMoreInteractions(mock);
- }
- }).throwsException(NoInteractionsWanted.class);
+ // expect
+ assertThat(
+ new Runnable() {
+ public void run() {
+ verifyNoMoreInteractions(mock);
+ }
+ })
+ .throwsException(NoInteractionsWanted.class);
}
- @Test public void stubbing_argument_mismatch() throws Throwable {
- //when
+ @Test
+ public void stubbing_argument_mismatch() throws Throwable {
+ // when
given(mock.simpleMethod(100)).willReturn("100");
- //stubbing argument mismatch is detected
- assertThat(new Runnable() {
- public void run() {
- mock.simpleMethod(200);
- }
- }).throwsException(PotentialStubbingProblem.class);
+ // stubbing argument mismatch is detected
+ assertThat(
+ new Runnable() {
+ public void run() {
+ ProductionCode.simpleMethod(mock, 200);
+ }
+ })
+ .throwsException(PotentialStubbingProblem.class);
}
- @Test public void unused_stubbing() throws Throwable {
- //when
+ @Test
+ public void unused_stubbing() throws Throwable {
+ // when
given(mock.simpleMethod(100)).willReturn("100");
- //unused stubbing is reported
- assertThat(new Runnable() {
- public void run() {
- mockito.finishMocking();
- }
- }).throwsException(UnnecessaryStubbingException.class);
+ // unused stubbing is reported
+ assertThat(
+ new Runnable() {
+ public void run() {
+ mockito.finishMocking();
+ }
+ })
+ .throwsException(UnnecessaryStubbingException.class);
}
}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java b/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java
index 47c2172..6098805 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java
@@ -2,29 +2,24 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stubbing;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.exceptions.base.MockitoException;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-
public class StubbingConsecutiveAnswersTest extends TestBase {
- @Mock
- private IMethods mock;
+ @Mock private IMethods mock;
@Test
public void should_return_consecutive_values() throws Exception {
- when(mock.simpleMethod())
- .thenReturn("one")
- .thenReturn("two")
- .thenReturn("three");
+ when(mock.simpleMethod()).thenReturn("one").thenReturn("two").thenReturn("three");
assertEquals("one", mock.simpleMethod());
assertEquals("two", mock.simpleMethod());
@@ -70,7 +65,8 @@
}
@Test
- public void should_return_consecutive_values_set_by_shorten_then_return_method() throws Exception {
+ public void should_return_consecutive_values_set_by_shorten_then_return_method()
+ throws Exception {
when(mock.simpleMethod()).thenReturn("one", "two", "three");
assertEquals("one", mock.simpleMethod());
@@ -81,12 +77,14 @@
}
@Test
- public void should_return_consecutive_value_and_throw_exceptions_set_by_shorten_return_methods() {
- when(mock.simpleMethod()).thenReturn("zero")
- .thenReturn("one", "two")
- .thenThrow(new NullPointerException(), new RuntimeException())
- .thenReturn("three")
- .thenThrow(new IllegalArgumentException());
+ public void
+ should_return_consecutive_value_and_throw_exceptions_set_by_shorten_return_methods() {
+ when(mock.simpleMethod())
+ .thenReturn("zero")
+ .thenReturn("one", "two")
+ .thenThrow(new NullPointerException(), new RuntimeException())
+ .thenReturn("three")
+ .thenThrow(new IllegalArgumentException());
assertEquals("zero", mock.simpleMethod());
assertEquals("one", mock.simpleMethod());
@@ -94,70 +92,84 @@
try {
mock.simpleMethod();
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
try {
mock.simpleMethod();
fail();
- } catch (RuntimeException expected) { }
+ } catch (RuntimeException expected) {
+ }
assertEquals("three", mock.simpleMethod());
try {
mock.simpleMethod();
fail();
- } catch (IllegalArgumentException expected) { }
+ } catch (IllegalArgumentException expected) {
+ }
}
@Test
public void should_throw_consecutively() throws Exception {
- when(mock.simpleMethod()).thenThrow(new RuntimeException())
- .thenThrow(new IllegalArgumentException())
- .thenThrow(new NullPointerException());
+ when(mock.simpleMethod())
+ .thenThrow(new RuntimeException())
+ .thenThrow(new IllegalArgumentException())
+ .thenThrow(new NullPointerException());
try {
mock.simpleMethod();
fail();
- } catch (RuntimeException expected) { }
+ } catch (RuntimeException expected) {
+ }
try {
mock.simpleMethod();
fail();
- } catch (IllegalArgumentException expected) { }
+ } catch (IllegalArgumentException expected) {
+ }
try {
mock.simpleMethod();
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
try {
mock.simpleMethod();
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
}
@Test
public void should_throw_consecutively_set_by_shorten_then_throw_method() throws Exception {
- when(mock.simpleMethod()).thenThrow(new RuntimeException(),
- new IllegalArgumentException(),
- new NullPointerException());
+ when(mock.simpleMethod())
+ .thenThrow(
+ new RuntimeException(),
+ new IllegalArgumentException(),
+ new NullPointerException());
try {
mock.simpleMethod();
fail();
- } catch (RuntimeException expected) { }
+ } catch (RuntimeException expected) {
+ }
try {
mock.simpleMethod();
fail();
- } catch (IllegalArgumentException expected) { }
+ } catch (IllegalArgumentException expected) {
+ }
try {
mock.simpleMethod();
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
try {
mock.simpleMethod();
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
}
@Test
@@ -168,41 +180,50 @@
try {
mock.simpleMethod();
fail();
- } catch (IllegalArgumentException expected) { }
+ } catch (IllegalArgumentException expected) {
+ }
try {
mock.simpleMethod();
fail();
- } catch (IllegalArgumentException expected) { }
+ } catch (IllegalArgumentException expected) {
+ }
}
@Test
@SuppressWarnings("unchecked")
- public void should_throw_consecutively_classes_set_by_shorten_then_throw_method() throws Exception {
+ public void should_throw_consecutively_classes_set_by_shorten_then_throw_method()
+ throws Exception {
// Unavoidable JDK7+ 'unchecked generic array creation' warning
- when(mock.simpleMethod()).thenThrow(RuntimeException.class,
- IllegalArgumentException.class,
- NullPointerException.class);
+ when(mock.simpleMethod())
+ .thenThrow(
+ RuntimeException.class,
+ IllegalArgumentException.class,
+ NullPointerException.class);
try {
mock.simpleMethod();
fail();
- } catch (RuntimeException expected) { }
+ } catch (RuntimeException expected) {
+ }
try {
mock.simpleMethod();
fail();
- } catch (IllegalArgumentException expected) { }
+ } catch (IllegalArgumentException expected) {
+ }
try {
mock.simpleMethod();
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
try {
mock.simpleMethod();
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
}
@Test
@@ -216,14 +237,16 @@
try {
mock.simpleMethod();
fail();
- } catch (IllegalArgumentException expected) { }
+ } catch (IllegalArgumentException expected) {
+ }
assertEquals("one", mock.simpleMethod());
try {
mock.simpleMethod();
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
assertEquals(null, mock.simpleMethod());
assertEquals(null, mock.simpleMethod());
@@ -231,50 +254,49 @@
@Test(expected = MockitoException.class)
public void should_validate_consecutive_exception() throws Exception {
- when(mock.simpleMethod())
- .thenReturn("one")
- .thenThrow(new Exception());
+ when(mock.simpleMethod()).thenReturn("one").thenThrow(new Exception());
}
@Test
public void should_stub_void_method_and_continue_throwing() throws Exception {
doThrow(new IllegalArgumentException())
- .doNothing()
- .doThrow(new NullPointerException())
- .when(mock).voidMethod();
+ .doNothing()
+ .doThrow(new NullPointerException())
+ .when(mock)
+ .voidMethod();
try {
mock.voidMethod();
fail();
- } catch (IllegalArgumentException expected) { }
+ } catch (IllegalArgumentException expected) {
+ }
mock.voidMethod();
try {
mock.voidMethod();
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
try {
mock.voidMethod();
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
}
@Test
public void should_stub_void_method() throws Exception {
- doNothing()
- .doThrow(new NullPointerException())
- .doNothing()
- .when(mock)
- .voidMethod();
+ doNothing().doThrow(new NullPointerException()).doNothing().when(mock).voidMethod();
mock.voidMethod();
try {
mock.voidMethod();
fail();
- } catch (NullPointerException expected) { }
+ } catch (NullPointerException expected) {
+ }
mock.voidMethod();
mock.voidMethod();
@@ -282,9 +304,6 @@
@Test(expected = MockitoException.class)
public void should_validate_consecutive_exception_for_void_method() throws Exception {
- doNothing()
- .doThrow(new Exception())
- .when(mock)
- .voidMethod();
+ doNothing().doThrow(new Exception()).when(mock).voidMethod();
}
}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingReturnsSelfTest.java b/src/test/java/org/mockitousage/stubbing/StubbingReturnsSelfTest.java
index 5362fa8..4e75dfb 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingReturnsSelfTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingReturnsSelfTest.java
@@ -4,13 +4,13 @@
*/
package org.mockitousage.stubbing;
-import org.junit.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.*;
import java.util.ArrayList;
import java.util.List;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import org.junit.Test;
public class StubbingReturnsSelfTest {
@@ -150,6 +150,5 @@
public String request() {
return uri + headers.toString();
}
-
}
}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingUsingDoReturnTest.java b/src/test/java/org/mockitousage/stubbing/StubbingUsingDoReturnTest.java
index f8169b0..e9776f4 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingUsingDoReturnTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingUsingDoReturnTest.java
@@ -2,9 +2,14 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stubbing;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
+import java.io.IOException;
+
import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Test;
@@ -17,18 +22,13 @@
import org.mockitousage.MethodsImpl;
import org.mockitoutil.TestBase;
-import java.io.IOException;
-
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
-
@SuppressWarnings("serial")
public class StubbingUsingDoReturnTest extends TestBase {
@Mock private IMethods mock;
- @After public void reset_state() {
+ @After
+ public void reset_state() {
super.resetState();
}
@@ -58,7 +58,8 @@
try {
mock.voidMethod();
fail();
- } catch (FooRuntimeException e) {}
+ } catch (FooRuntimeException e) {
+ }
}
@Test
@@ -68,7 +69,8 @@
try {
mock.throwsIOException(0);
fail();
- } catch (IOException e) {}
+ } catch (IOException e) {
+ }
}
class FooCheckedException extends Exception {}
@@ -89,9 +91,7 @@
doReturn("foo").when(mock).voidMethod();
fail();
} catch (MockitoException e) {
- assertThat(e)
- .hasMessageContaining("void method")
- .hasMessageContaining("cannot");
+ assertThat(e).hasMessageContaining("void method").hasMessageContaining("cannot");
}
}
@@ -117,16 +117,14 @@
@Test
public void should_allow_chained_stubbing() {
- doReturn("foo")
- .doThrow(new RuntimeException())
- .doReturn("bar")
- .when(mock).simpleMethod();
+ doReturn("foo").doThrow(new RuntimeException()).doReturn("bar").when(mock).simpleMethod();
Assertions.assertThat(mock.simpleMethod()).isEqualTo("foo");
try {
mock.simpleMethod();
fail();
- } catch (RuntimeException expected) { }
+ } catch (RuntimeException expected) {
+ }
Assertions.assertThat(mock.simpleMethod()).isEqualTo("bar");
Assertions.assertThat(mock.simpleMethod()).isEqualTo("bar");
@@ -137,14 +135,16 @@
doReturn("foo", "bar")
.doThrow(new RuntimeException())
.doReturn(430L, new byte[0], "qix")
- .when(mock).objectReturningMethodNoArgs();
+ .when(mock)
+ .objectReturningMethodNoArgs();
Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("foo");
Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo("bar");
try {
mock.objectReturningMethodNoArgs();
fail("exception not raised");
- } catch (RuntimeException expected) { }
+ } catch (RuntimeException expected) {
+ }
Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo(430L);
Assertions.assertThat(mock.objectReturningMethodNoArgs()).isEqualTo(new byte[0]);
@@ -155,8 +155,7 @@
@Test
public void should_allow_do_call_real_method_in_chained_stubbing() throws Exception {
MethodsImpl methods = mock(MethodsImpl.class);
- doReturn("A").doCallRealMethod()
- .when(methods).simpleMethod();
+ doReturn("A").doCallRealMethod().when(methods).simpleMethod();
Assertions.assertThat(methods.simpleMethod()).isEqualTo("A");
Assertions.assertThat(methods.simpleMethod()).isEqualTo(null);
@@ -172,31 +171,32 @@
@Test
public void should_allow_chained_stubbing_on_void_methods() {
- doNothing()
- .doNothing()
- .doThrow(new RuntimeException())
- .when(mock).voidMethod();
+ doNothing().doNothing().doThrow(new RuntimeException()).when(mock).voidMethod();
mock.voidMethod();
mock.voidMethod();
try {
mock.voidMethod();
fail();
- } catch (RuntimeException e) {}
+ } catch (RuntimeException e) {
+ }
try {
mock.voidMethod();
fail();
- } catch (RuntimeException e) {}
+ } catch (RuntimeException e) {
+ }
}
@Test
public void should_stub_with_generic_answer() {
- doAnswer(new Answer<Object>() {
- public Object answer(InvocationOnMock invocation) throws Throwable {
- return "foo";
- }
- })
- .when(mock).simpleMethod();
+ doAnswer(
+ new Answer<Object>() {
+ public Object answer(InvocationOnMock invocation) throws Throwable {
+ return "foo";
+ }
+ })
+ .when(mock)
+ .simpleMethod();
Assertions.assertThat(mock.simpleMethod()).isEqualTo("foo");
}
@@ -218,7 +218,8 @@
try {
verifyNoMoreInteractions(mock);
fail();
- } catch (NoInteractionsWanted e) {}
+ } catch (NoInteractionsWanted e) {
+ }
}
@Test
@@ -243,9 +244,11 @@
doReturn("foo").when(mock).booleanObjectReturningMethod();
fail();
} catch (Exception e) {
- assertThat(e).hasMessageContaining("String cannot be returned by booleanObjectReturningMethod()" +
- "\n" +
- "booleanObjectReturningMethod() should return Boolean");
+ assertThat(e)
+ .hasMessageContaining(
+ "String cannot be returned by booleanObjectReturningMethod()"
+ + "\n"
+ + "booleanObjectReturningMethod() should return Boolean");
}
}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
index 6bf2041..b959e99 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWarningsTest.java
@@ -4,6 +4,13 @@
*/
package org.mockitousage.stubbing;
+import static java.util.Collections.singletonList;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.verify;
+import static org.mockitoutil.TestBase.filterLineNo;
+
import org.junit.After;
import org.junit.Test;
import org.mockito.Mock;
@@ -15,12 +22,6 @@
import org.mockito.quality.Strictness;
import org.mockitousage.IMethods;
-import static java.util.Collections.singletonList;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.verify;
-import static org.mockitoutil.TestBase.filterLineNo;
-
public class StubbingWarningsTest {
private static final String TEST_NAME = "test.name";
@@ -28,85 +29,102 @@
@Mock IMethods mock;
SimpleMockitoLogger logger = new SimpleMockitoLogger();
- MockitoSession mockito = new DefaultMockitoSession(singletonList((Object) this), TEST_NAME, Strictness.WARN, logger);
+ MockitoSession mockito =
+ new DefaultMockitoSession(
+ singletonList((Object) this), TEST_NAME, Strictness.WARN, logger);
- @After public void after() {
+ @After
+ public void after() {
StateMaster stateMaster = new StateMaster();
stateMaster.reset();
stateMaster.clearMockitoListeners();
}
- @Test public void few_interactions() throws Throwable {
- //when
+ @Test
+ public void few_interactions() throws Throwable {
+ // when
mock.simpleMethod(100);
mock.otherMethod();
- //expect no exception
+ // expect no exception
mockito.finishMocking();
logger.assertEmpty();
}
- @Test public void stubbing_used() throws Throwable {
- //when
+ @Test
+ public void stubbing_used() throws Throwable {
+ // when
given(mock.simpleMethod(100)).willReturn("100");
mock.simpleMethod(100);
- //then
+ // then
mockito.finishMocking();
logger.assertEmpty();
}
- @Test public void unused_stubbed_is_not_implicitly_verified() throws Throwable {
- //when
+ @Test
+ public void unused_stubbed_is_not_implicitly_verified() throws Throwable {
+ // when
given(mock.simpleMethod(100)).willReturn("100");
mock.simpleMethod(100); // <- stubbing is used
mock.simpleMethod(200); // <- other method should not generate arg mismatch
- //then
+ // then
mockito.finishMocking();
logger.assertEmpty();
}
- @Test public void stubbing_argument_mismatch() throws Throwable {
- //when
+ @Test
+ public void stubbing_argument_mismatch() throws Throwable {
+ // when
given(mock.simpleMethod(100)).willReturn("100");
mock.simpleMethod(200);
mockito.finishMocking();
- //TODO - currently we warn about "Unused" instead of "Arg mismatch" below
- //because it was simpler to implement. This can be improved given we put priority to improve the warnings.
- //then
- assertEquals(filterLineNo(
- "[MockitoHint] " + TEST_NAME + " (see javadoc for MockitoHint):\n" +
- "[MockitoHint] 1. Unused -> at org.mockitousage.stubbing.StubbingWarningsTest.stubbing_argument_mismatch(StubbingWarningsTest.java:0)\n"),
+ // TODO - currently we warn about "Unused" instead of "Arg mismatch" below
+ // because it was simpler to implement. This can be improved given we put priority to
+ // improve the warnings.
+ // then
+ assertEquals(
+ filterLineNo(
+ "[MockitoHint] "
+ + TEST_NAME
+ + " (see javadoc for MockitoHint):\n"
+ + "[MockitoHint] 1. Unused -> at org.mockitousage.stubbing.StubbingWarningsTest.stubbing_argument_mismatch(StubbingWarningsTest.java:0)\n"),
filterLineNo(logger.getLoggedInfo()));
}
- @Test public void unused_stubbing() throws Throwable {
- //when
+ @Test
+ public void unused_stubbing() throws Throwable {
+ // when
given(mock.simpleMethod(100)).willReturn("100");
mockito.finishMocking();
- //then
- assertEquals(filterLineNo(
- "[MockitoHint] " + TEST_NAME + " (see javadoc for MockitoHint):\n" +
- "[MockitoHint] 1. Unused -> at org.mockitousage.stubbing.StubbingWarningsTest.unused_stubbing(StubbingWarningsTest.java:0)\n"),
+ // then
+ assertEquals(
+ filterLineNo(
+ "[MockitoHint] "
+ + TEST_NAME
+ + " (see javadoc for MockitoHint):\n"
+ + "[MockitoHint] 1. Unused -> at org.mockitousage.stubbing.StubbingWarningsTest.unused_stubbing(StubbingWarningsTest.java:0)\n"),
filterLineNo(logger.getLoggedInfo()));
}
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
- @Test(expected = MockitoException.class) public void unfinished_verification_without_throwable() throws Throwable {
- //when
+ @Test(expected = MockitoException.class)
+ public void unfinished_verification_without_throwable() throws Throwable {
+ // when
verify(mock);
mockito.finishMocking();
}
@SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
- @Test public void unfinished_verification_with_throwable() throws Throwable {
- //when
+ @Test
+ public void unfinished_verification_with_throwable() throws Throwable {
+ // when
verify(mock);
mockito.finishMocking(new AssertionError());
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithAdditionalAnswersTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithAdditionalAnswersTest.java
index 417d998..7dfed44 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithAdditionalAnswersTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWithAdditionalAnswersTest.java
@@ -8,11 +8,11 @@
import static org.assertj.core.api.Assertions.within;
import static org.mockito.AdditionalAnswers.answer;
import static org.mockito.AdditionalAnswers.answerVoid;
+import static org.mockito.AdditionalAnswers.answersWithDelay;
import static org.mockito.AdditionalAnswers.returnsArgAt;
import static org.mockito.AdditionalAnswers.returnsFirstArg;
import static org.mockito.AdditionalAnswers.returnsLastArg;
import static org.mockito.AdditionalAnswers.returnsSecondArg;
-import static org.mockito.AdditionalAnswers.answersWithDelay;
import static org.mockito.BDDMockito.any;
import static org.mockito.BDDMockito.anyInt;
import static org.mockito.BDDMockito.anyString;
@@ -21,6 +21,9 @@
import static org.mockito.BDDMockito.mock;
import static org.mockito.BDDMockito.times;
import static org.mockito.BDDMockito.verify;
+
+import java.util.Date;
+
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
@@ -30,15 +33,15 @@
import org.mockito.stubbing.Answer3;
import org.mockito.stubbing.Answer4;
import org.mockito.stubbing.Answer5;
+import org.mockito.stubbing.Answer6;
import org.mockito.stubbing.VoidAnswer1;
import org.mockito.stubbing.VoidAnswer2;
import org.mockito.stubbing.VoidAnswer3;
import org.mockito.stubbing.VoidAnswer4;
import org.mockito.stubbing.VoidAnswer5;
+import org.mockito.stubbing.VoidAnswer6;
import org.mockitousage.IMethods;
-import java.util.Date;
-
@RunWith(MockitoJUnitRunner.class)
public class StubbingWithAdditionalAnswersTest {
@@ -59,7 +62,8 @@
public void can_return_after_delay() throws Exception {
final long sleepyTime = 500L;
- given(iMethods.objectArgMethod(any())).will(answersWithDelay(sleepyTime, returnsFirstArg()));
+ given(iMethods.objectArgMethod(any()))
+ .will(answersWithDelay(sleepyTime, returnsFirstArg()));
final Date before = new Date();
assertThat(iMethods.objectArgMethod("first")).isEqualTo("first");
@@ -73,7 +77,8 @@
public void can_return_expanded_arguments_of_invocation() throws Exception {
given(iMethods.varargsObject(eq(1), any())).will(returnsArgAt(3));
- assertThat(iMethods.varargsObject(1, "bob", "alexander", "alice", "carl")).isEqualTo("alice");
+ assertThat(iMethods.varargsObject(1, "bob", "alexander", "alice", "carl"))
+ .isEqualTo("alice");
}
@Test
@@ -88,25 +93,30 @@
@Test
public void can_return_based_on_strongly_types_one_parameter_function() throws Exception {
given(iMethods.simpleMethod(anyString()))
- .will(answer(new Answer1<String, String>() {
- public String answer(String s) {
- return s;
- }
- }));
+ .will(
+ answer(
+ new Answer1<String, String>() {
+ public String answer(String s) {
+ return s;
+ }
+ }));
assertThat(iMethods.simpleMethod("string")).isEqualTo("string");
}
@Test
- public void will_execute_a_void_based_on_strongly_typed_one_parameter_function() throws Exception {
+ public void will_execute_a_void_based_on_strongly_typed_one_parameter_function()
+ throws Exception {
final IMethods target = mock(IMethods.class);
given(iMethods.simpleMethod(anyString()))
- .will(answerVoid(new VoidAnswer1<String>() {
- public void answer(String s) {
- target.simpleMethod(s);
- }
- }));
+ .will(
+ answerVoid(
+ new VoidAnswer1<String>() {
+ public void answer(String s) {
+ target.simpleMethod(s);
+ }
+ }));
// invoke on iMethods
iMethods.simpleMethod("string");
@@ -118,28 +128,33 @@
@Test
public void can_return_based_on_strongly_typed_two_parameter_function() throws Exception {
given(iMethods.simpleMethod(anyString(), anyInt()))
- .will(answer(new Answer2<String, String, Integer>() {
- public String answer(String s, Integer i) {
- return s + "-" + i;
- }
- }));
+ .will(
+ answer(
+ new Answer2<String, String, Integer>() {
+ public String answer(String s, Integer i) {
+ return s + "-" + i;
+ }
+ }));
- assertThat(iMethods.simpleMethod("string",1)).isEqualTo("string-1");
+ assertThat(iMethods.simpleMethod("string", 1)).isEqualTo("string-1");
}
@Test
- public void will_execute_a_void_based_on_strongly_typed_two_parameter_function() throws Exception {
+ public void will_execute_a_void_based_on_strongly_typed_two_parameter_function()
+ throws Exception {
final IMethods target = mock(IMethods.class);
given(iMethods.simpleMethod(anyString(), anyInt()))
- .will(answerVoid(new VoidAnswer2<String, Integer>() {
- public void answer(String s, Integer i) {
- target.simpleMethod(s, i);
- }
- }));
+ .will(
+ answerVoid(
+ new VoidAnswer2<String, Integer>() {
+ public void answer(String s, Integer i) {
+ target.simpleMethod(s, i);
+ }
+ }));
// invoke on iMethods
- iMethods.simpleMethod("string",1);
+ iMethods.simpleMethod("string", 1);
// expect the answer to write correctly to "target"
verify(target, times(1)).simpleMethod("string", 1);
@@ -149,27 +164,33 @@
public void can_return_based_on_strongly_typed_three_parameter_function() throws Exception {
final IMethods target = mock(IMethods.class);
given(iMethods.threeArgumentMethodWithStrings(anyInt(), anyString(), anyString()))
- .will(answer(new Answer3<String, Integer, String, String>() {
- public String answer(Integer i, String s1, String s2) {
- target.threeArgumentMethodWithStrings(i, s1, s2);
- return "answered";
- }
- }));
+ .will(
+ answer(
+ new Answer3<String, Integer, String, String>() {
+ public String answer(Integer i, String s1, String s2) {
+ target.threeArgumentMethodWithStrings(i, s1, s2);
+ return "answered";
+ }
+ }));
- assertThat(iMethods.threeArgumentMethodWithStrings(1, "string1", "string2")).isEqualTo("answered");
+ assertThat(iMethods.threeArgumentMethodWithStrings(1, "string1", "string2"))
+ .isEqualTo("answered");
verify(target, times(1)).threeArgumentMethodWithStrings(1, "string1", "string2");
}
@Test
- public void will_execute_a_void_based_on_strongly_typed_three_parameter_function() throws Exception {
+ public void will_execute_a_void_based_on_strongly_typed_three_parameter_function()
+ throws Exception {
final IMethods target = mock(IMethods.class);
given(iMethods.threeArgumentMethodWithStrings(anyInt(), anyString(), anyString()))
- .will(answerVoid(new VoidAnswer3<Integer, String, String>() {
- public void answer(Integer i, String s1, String s2) {
- target.threeArgumentMethodWithStrings(i, s1, s2);
- }
- }));
+ .will(
+ answerVoid(
+ new VoidAnswer3<Integer, String, String>() {
+ public void answer(Integer i, String s1, String s2) {
+ target.threeArgumentMethodWithStrings(i, s1, s2);
+ }
+ }));
// invoke on iMethods
iMethods.threeArgumentMethodWithStrings(1, "string1", "string2");
@@ -182,31 +203,39 @@
public void can_return_based_on_strongly_typed_four_parameter_function() throws Exception {
final IMethods target = mock(IMethods.class);
given(iMethods.fourArgumentMethod(anyInt(), anyString(), anyString(), any(boolean[].class)))
- .will(answer(new Answer4<String, Integer, String, String, boolean[]>() {
- public String answer(Integer i, String s1, String s2, boolean[] a) {
- target.fourArgumentMethod(i, s1, s2, a);
- return "answered";
- }
- }));
+ .will(
+ answer(
+ new Answer4<String, Integer, String, String, boolean[]>() {
+ public String answer(
+ Integer i, String s1, String s2, boolean[] a) {
+ target.fourArgumentMethod(i, s1, s2, a);
+ return "answered";
+ }
+ }));
- boolean[] booleanArray = { true, false };
- assertThat(iMethods.fourArgumentMethod(1, "string1", "string2", booleanArray)).isEqualTo("answered");
+ boolean[] booleanArray = {true, false};
+ assertThat(iMethods.fourArgumentMethod(1, "string1", "string2", booleanArray))
+ .isEqualTo("answered");
verify(target, times(1)).fourArgumentMethod(1, "string1", "string2", booleanArray);
}
@Test
- public void will_execute_a_void_based_on_strongly_typed_four_parameter_function() throws Exception {
+ public void will_execute_a_void_based_on_strongly_typed_four_parameter_function()
+ throws Exception {
final IMethods target = mock(IMethods.class);
given(iMethods.fourArgumentMethod(anyInt(), anyString(), anyString(), any(boolean[].class)))
- .will(answerVoid(new VoidAnswer4<Integer, String, String, boolean[]>() {
- public void answer(Integer i, String s1, String s2, boolean[] a) {
- target.fourArgumentMethod(i, s1, s2, a);
- }
- }));
+ .will(
+ answerVoid(
+ new VoidAnswer4<Integer, String, String, boolean[]>() {
+ public void answer(
+ Integer i, String s1, String s2, boolean[] a) {
+ target.fourArgumentMethod(i, s1, s2, a);
+ }
+ }));
// invoke on iMethods
- boolean[] booleanArray = { true, false };
+ boolean[] booleanArray = {true, false};
iMethods.fourArgumentMethod(1, "string1", "string2", booleanArray);
// expect the answer to write correctly to "target"
@@ -217,27 +246,42 @@
public void can_return_based_on_strongly_typed_five_parameter_function() throws Exception {
final IMethods target = mock(IMethods.class);
given(iMethods.simpleMethod(anyString(), anyInt(), anyInt(), anyInt(), anyInt()))
- .will(answer(new Answer5<String, String, Integer, Integer, Integer, Integer>() {
- public String answer(String s1, Integer i1, Integer i2, Integer i3, Integer i4) {
- target.simpleMethod(s1, i1, i2, i3, i4);
- return "answered";
- }
- }));
+ .will(
+ answer(
+ new Answer5<String, String, Integer, Integer, Integer, Integer>() {
+ public String answer(
+ String s1,
+ Integer i1,
+ Integer i2,
+ Integer i3,
+ Integer i4) {
+ target.simpleMethod(s1, i1, i2, i3, i4);
+ return "answered";
+ }
+ }));
assertThat(iMethods.simpleMethod("hello", 1, 2, 3, 4)).isEqualTo("answered");
verify(target, times(1)).simpleMethod("hello", 1, 2, 3, 4);
}
@Test
- public void will_execute_a_void_based_on_strongly_typed_five_parameter_function() throws Exception {
+ public void will_execute_a_void_based_on_strongly_typed_five_parameter_function()
+ throws Exception {
final IMethods target = mock(IMethods.class);
given(iMethods.simpleMethod(anyString(), anyInt(), anyInt(), anyInt(), anyInt()))
- .will(answerVoid(new VoidAnswer5<String, Integer, Integer, Integer, Integer>() {
- public void answer(String s1, Integer i1, Integer i2, Integer i3, Integer i4) {
- target.simpleMethod(s1, i1, i2, i3, i4);
- }
- }));
+ .will(
+ answerVoid(
+ new VoidAnswer5<String, Integer, Integer, Integer, Integer>() {
+ public void answer(
+ String s1,
+ Integer i1,
+ Integer i2,
+ Integer i3,
+ Integer i4) {
+ target.simpleMethod(s1, i1, i2, i3, i4);
+ }
+ }));
// invoke on iMethods
iMethods.simpleMethod("hello", 1, 2, 3, 4);
@@ -246,4 +290,61 @@
verify(target, times(1)).simpleMethod("hello", 1, 2, 3, 4);
}
+ @Test
+ public void can_return_based_on_strongly_typed_six_parameter_function() throws Exception {
+ final IMethods target = mock(IMethods.class);
+ given(iMethods.simpleMethod(anyString(), anyInt(), anyInt(), anyInt(), anyInt(), anyInt()))
+ .will(
+ answer(
+ new Answer6<
+ String,
+ String,
+ Integer,
+ Integer,
+ Integer,
+ Integer,
+ Integer>() {
+ public String answer(
+ String s1,
+ Integer i1,
+ Integer i2,
+ Integer i3,
+ Integer i4,
+ Integer i5) {
+ target.simpleMethod(s1, i1, i2, i3, i4, i5);
+ return "answered";
+ }
+ }));
+
+ assertThat(iMethods.simpleMethod("hello", 1, 2, 3, 4, 5)).isEqualTo("answered");
+ verify(target, times(1)).simpleMethod("hello", 1, 2, 3, 4, 5);
+ }
+
+ @Test
+ public void will_execute_a_void_returning_strongly_typed_six_parameter_function()
+ throws Exception {
+ final IMethods target = mock(IMethods.class);
+
+ given(iMethods.simpleMethod(anyString(), anyInt(), anyInt(), anyInt(), anyInt(), anyInt()))
+ .will(
+ answerVoid(
+ new VoidAnswer6<
+ String, Integer, Integer, Integer, Integer, Integer>() {
+ public void answer(
+ String s1,
+ Integer i1,
+ Integer i2,
+ Integer i3,
+ Integer i4,
+ Integer i5) {
+ target.simpleMethod(s1, i1, i2, i3, i4, i5);
+ }
+ }));
+
+ // invoke on iMethods
+ iMethods.simpleMethod("hello", 1, 2, 3, 4, 5);
+
+ // expect the answer to write correctly to "target"
+ verify(target, times(1)).simpleMethod("hello", 1, 2, 3, 4, 5);
+ }
}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithBadThrowablesTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithBadThrowablesTest.java
new file mode 100644
index 0000000..43824bf
--- /dev/null
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWithBadThrowablesTest.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockitousage.stubbing;
+
+import static org.mockito.Mockito.doThrow;
+
+import java.util.List;
+
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockitoutil.TestBase;
+
+// issue 1514
+@SuppressWarnings({"serial", "unchecked", "rawtypes"})
+public class StubbingWithBadThrowablesTest extends TestBase {
+
+ @Mock List mock;
+
+ @Test
+ public void handles_bad_exception() {
+ Assertions.assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ doThrow(UninstantiableException.class).when(mock).clear();
+ }
+ })
+ .isInstanceOf(
+ InstantiationError.class); // because the exception cannot be instantiated
+
+ // ensure that the state is cleaned
+ Mockito.validateMockitoUsage();
+ }
+
+ abstract static class UninstantiableException extends RuntimeException {}
+}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java
index 6d59b6c..5591bc4 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWithCustomAnswerTest.java
@@ -4,6 +4,12 @@
*/
package org.mockitousage.stubbing;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import java.lang.reflect.Method;
+import java.util.Set;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.invocation.InvocationOnMock;
@@ -11,25 +17,20 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.lang.reflect.Method;
-import java.util.Set;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-
public class StubbingWithCustomAnswerTest extends TestBase {
- @Mock
- private IMethods mock;
+ @Mock private IMethods mock;
@Test
public void shouldAnswer() throws Exception {
- when(mock.simpleMethod(anyString())).thenAnswer(new Answer<String>() {
- public String answer(InvocationOnMock invocation) throws Throwable {
- String arg = invocation.getArgument(0);
+ when(mock.simpleMethod(anyString()))
+ .thenAnswer(
+ new Answer<String>() {
+ public String answer(InvocationOnMock invocation) throws Throwable {
+ String arg = invocation.getArgument(0);
- return invocation.getMethod().getName() + "-" + arg;
- }
- });
+ return invocation.getMethod().getName() + "-" + arg;
+ }
+ });
assertEquals("simpleMethod-test", mock.simpleMethod("test"));
}
@@ -39,7 +40,7 @@
RecordCall recordCall = new RecordCall();
Set<?> mockedSet = (Set<?>) when(mock(Set.class).isEmpty()).then(recordCall).getMock();
- mockedSet.isEmpty();
+ boolean unused = mockedSet.isEmpty();
assertTrue(recordCall.isCalled());
}
@@ -47,17 +48,19 @@
@Test
public void shouldAnswerConsecutively() throws Exception {
when(mock.simpleMethod())
- .thenAnswer(new Answer<String>() {
- public String answer(InvocationOnMock invocation) throws Throwable {
- return invocation.getMethod().getName();
- }
- })
+ .thenAnswer(
+ new Answer<String>() {
+ public String answer(InvocationOnMock invocation) throws Throwable {
+ return invocation.getMethod().getName();
+ }
+ })
.thenReturn("Hello")
- .thenAnswer(new Answer<String>() {
- public String answer(InvocationOnMock invocation) throws Throwable {
- return invocation.getMethod().getName() + "-1";
- }
- });
+ .thenAnswer(
+ new Answer<String>() {
+ public String answer(InvocationOnMock invocation) throws Throwable {
+ return invocation.getMethod().getName() + "-1";
+ }
+ });
assertEquals("simpleMethod", mock.simpleMethod());
assertEquals("Hello", mock.simpleMethod());
@@ -81,9 +84,10 @@
RecordCall call2 = new RecordCall();
doAnswer(call1)
- .doThrow(new UnsupportedOperationException())
- .doAnswer(call2)
- .when(mock).voidMethod();
+ .doThrow(new UnsupportedOperationException())
+ .doAnswer(call2)
+ .when(mock)
+ .voidMethod();
mock.voidMethod();
assertTrue(call1.isCalled());
@@ -101,14 +105,16 @@
@Test
public void shouldMakeSureTheInterfaceDoesNotChange() throws Exception {
- when(mock.simpleMethod(anyString())).thenAnswer(new Answer<String>() {
- public String answer(InvocationOnMock invocation) throws Throwable {
- assertTrue(invocation.getArguments().getClass().isArray());
- assertEquals(Method.class, invocation.getMethod().getClass());
+ when(mock.simpleMethod(anyString()))
+ .thenAnswer(
+ new Answer<String>() {
+ public String answer(InvocationOnMock invocation) throws Throwable {
+ assertTrue(invocation.getArguments().getClass().isArray());
+ assertEquals(Method.class, invocation.getMethod().getClass());
- return "assertions passed";
- }
- });
+ return "assertions passed";
+ }
+ });
assertEquals("assertions passed", mock.simpleMethod("test"));
}
@@ -125,5 +131,4 @@
return null;
}
}
-
}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java
index 24c4854..245fa78 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateTest.java
@@ -4,22 +4,24 @@
*/
package org.mockitousage.stubbing;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.exceptions.base.MockitoException;
-import org.mockitousage.IMethods;
-import org.mockitousage.MethodsImpl;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
-import static org.junit.Assert.assertEquals;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
+import org.junit.Test;
+import org.mockito.AdditionalAnswers;
+import org.mockito.Mockito;
+import org.mockito.exceptions.base.MockitoException;
+import org.mockitousage.IMethods;
+import org.mockitousage.MethodsImpl;
@SuppressWarnings("unchecked")
public class StubbingWithDelegateTest {
@@ -95,15 +97,10 @@
}
@Test
- public void null_wrapper_dont_throw_exception_from_org_mockito_package() throws Exception {
+ public void null_wrapper_dont_throw_exception_from_org_mockito_package() {
IMethods methods = mock(IMethods.class, delegatesTo(new MethodsImpl()));
- try {
- byte b = methods.byteObjectReturningMethod(); // real method returns null
- fail();
- } catch (Exception e) {
- assertThat(e.toString()).doesNotContain("org.mockito");
- }
+ assertThat(methods.byteObjectReturningMethod()).isNull();
}
@Test
@@ -142,7 +139,9 @@
mock.size();
fail();
} catch (MockitoException e) {
- assertThat(e.toString()).contains("Methods called on delegated instance must have compatible return type");
+ assertThat(e.toString())
+ .contains(
+ "Methods called on delegated instance must have compatible return type");
}
}
@@ -154,19 +153,25 @@
mock.subList(0, 0);
fail();
} catch (MockitoException e) {
- assertThat(e.toString()).contains("Methods called on delegated instance must have compatible return type");
+ assertThat(e.toString())
+ .contains(
+ "Methods called on delegated instance must have compatible return type");
}
}
@Test
public void exception_should_be_propagated_from_delegate() throws Exception {
final RuntimeException failure = new RuntimeException("angry-method");
- IMethods methods = mock(IMethods.class, delegatesTo(new MethodsImpl() {
- @Override
- public String simpleMethod() {
- throw failure;
- }
- }));
+ IMethods methods =
+ mock(
+ IMethods.class,
+ delegatesTo(
+ new MethodsImpl() {
+ @Override
+ public String simpleMethod() {
+ throw failure;
+ }
+ }));
try {
methods.simpleMethod(); // delegate throws an exception
@@ -175,4 +180,26 @@
assertThat(e).isEqualTo(failure);
}
}
+
+ interface Foo {
+ int bar();
+ }
+
+ @Test
+ public void should_call_anonymous_class_method() throws Throwable {
+ Foo foo =
+ new Foo() {
+ public int bar() {
+ return 0;
+ }
+ };
+
+ Foo mock = mock(Foo.class);
+ when(mock.bar()).thenAnswer(AdditionalAnswers.delegatesTo(foo));
+
+ // when
+ mock.bar();
+
+ // then no exception is thrown
+ }
}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java
index d1c3828..5bd3f33 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWithDelegateVarArgsTest.java
@@ -4,13 +4,13 @@
*/
package org.mockitousage.stubbing;
-import org.junit.Test;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.AdditionalAnswers.delegatesTo;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.withSettings;
+import org.junit.Test;
+
public class StubbingWithDelegateVarArgsTest {
public interface Foo {
@@ -23,28 +23,24 @@
public int bar(String baz, Object... args) {
return args != null ? args.length : -1; // simple return argument count
}
-
}
@Test
public void should_not_fail_when_calling_varargs_method() {
- Foo foo = mock(Foo.class, withSettings()
- .defaultAnswer(delegatesTo(new FooImpl())));
+ Foo foo = mock(Foo.class, withSettings().defaultAnswer(delegatesTo(new FooImpl())));
assertThat(foo.bar("baz", 12, "45", 67.8)).isEqualTo(3);
}
@Test
public void should_not_fail_when_calling_varargs_method_without_arguments() {
- Foo foo = mock(Foo.class, withSettings()
- .defaultAnswer(delegatesTo(new FooImpl())));
+ Foo foo = mock(Foo.class, withSettings().defaultAnswer(delegatesTo(new FooImpl())));
assertThat(foo.bar("baz")).isEqualTo(0);
assertThat(foo.bar("baz", new Object[0])).isEqualTo(0);
}
@Test
public void should_not_fail_when_calling_varargs_method_with_null_argument() {
- Foo foo = mock(Foo.class, withSettings()
- .defaultAnswer(delegatesTo(new FooImpl())));
+ Foo foo = mock(Foo.class, withSettings().defaultAnswer(delegatesTo(new FooImpl())));
assertThat(foo.bar("baz", (Object[]) null)).isEqualTo(-1);
}
}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java
index a2cc3d1..b7f1cec 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWithExtraAnswersTest.java
@@ -2,9 +2,16 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stubbing;
+import static java.util.Arrays.asList;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+
import org.junit.Test;
import org.mockito.AdditionalAnswers;
import org.mockito.Mock;
@@ -12,39 +19,34 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.util.List;
-
-import static java.util.Arrays.asList;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.when;
-
public class StubbingWithExtraAnswersTest extends TestBase {
@Mock private IMethods mock;
@Test
public void shouldWorkAsStandardMockito() throws Exception {
- //when
+ // when
List<Integer> list = asList(1, 2, 3);
- when(mock.objectReturningMethodNoArgs()).thenAnswer(AdditionalAnswers.returnsElementsOf(list));
+ when(mock.objectReturningMethodNoArgs())
+ .thenAnswer(AdditionalAnswers.returnsElementsOf(list));
- //then
+ // then
assertEquals(1, mock.objectReturningMethodNoArgs());
assertEquals(2, mock.objectReturningMethodNoArgs());
assertEquals(3, mock.objectReturningMethodNoArgs());
- //last element is returned continuously
+ // last element is returned continuously
assertEquals(3, mock.objectReturningMethodNoArgs());
assertEquals(3, mock.objectReturningMethodNoArgs());
}
@Test
public void shouldReturnNullIfNecessary() throws Exception {
- //when
+ // when
List<Integer> list = asList(1, null);
- when(mock.objectReturningMethodNoArgs()).thenAnswer(AdditionalAnswers.returnsElementsOf(list));
+ when(mock.objectReturningMethodNoArgs())
+ .thenAnswer(AdditionalAnswers.returnsElementsOf(list));
- //then
+ // then
assertEquals(1, mock.objectReturningMethodNoArgs());
assertEquals(null, mock.objectReturningMethodNoArgs());
assertEquals(null, mock.objectReturningMethodNoArgs());
@@ -53,10 +55,11 @@
@Test
public void shouldScreamWhenNullPassed() throws Exception {
try {
- //when
+ // when
AdditionalAnswers.returnsElementsOf(null);
- //then
+ // then
fail();
- } catch (MockitoException e) {}
+ } catch (MockitoException e) {
+ }
}
}
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
index 9353724..625961c 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
@@ -2,19 +2,19 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.stubbing;
+import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.hamcrest.CoreMatchers.sameInstance;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
import java.io.IOException;
@@ -35,15 +35,14 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-@SuppressWarnings({ "serial", "unchecked", "rawtypes" })
+@SuppressWarnings({"serial", "unchecked", "rawtypes"})
public class StubbingWithThrowablesTest extends TestBase {
private LinkedList mock;
private Map mockTwo;
- @Rule
- public ExpectedException exception = ExpectedException.none();
+ @Rule public ExpectedException exception = ExpectedException.none();
@Before
public void setup() {
@@ -55,42 +54,74 @@
public void throws_same_exception_consecutively() {
when(mock.add("")).thenThrow(new ExceptionOne());
- //1st invocation
- Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- public void call() {
- mock.add("");
- }
- }).isInstanceOf(ExceptionOne.class);
+ // 1st invocation
+ Assertions.assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mock.add("");
+ }
+ })
+ .isInstanceOf(ExceptionOne.class);
mock.add("1");
- //2nd invocation
- Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- public void call() {
- mock.add("");
- }
- }).isInstanceOf(ExceptionOne.class);
+ // 2nd invocation
+ Assertions.assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mock.add("");
+ }
+ })
+ .isInstanceOf(ExceptionOne.class);
}
@Test
public void throws_same_exception_consecutively_with_doThrow() {
doThrow(new ExceptionOne()).when(mock).clear();
- //1st invocation
- Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- public void call() {
- mock.clear();
- }
- }).isInstanceOf(ExceptionOne.class);
+ // 1st invocation
+ Assertions.assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mock.clear();
+ }
+ })
+ .isInstanceOf(ExceptionOne.class);
mock.add("1");
- //2nd invocation
- Assertions.assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- public void call() {
- mock.clear();
- }
- }).isInstanceOf(ExceptionOne.class);
+ // 2nd invocation
+ Assertions.assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ public void call() {
+ mock.clear();
+ }
+ })
+ .isInstanceOf(ExceptionOne.class);
+ }
+
+ @Test
+ public void throws_new_exception_consecutively_from_class() {
+ when(mock.add(null)).thenThrow(NaughtyException.class);
+
+ NaughtyException first =
+ Assertions.catchThrowableOfType(() -> mock.add(null), NaughtyException.class);
+ NaughtyException second =
+ Assertions.catchThrowableOfType(() -> mock.add(null), NaughtyException.class);
+
+ assertNotSame(first, second);
+ }
+
+ @Test
+ public void throws_new_exception_consecutively_from_class_with_doThrow() {
+ doThrow(NaughtyException.class).when(mock).add(null);
+
+ NaughtyException first =
+ Assertions.catchThrowableOfType(() -> mock.add(null), NaughtyException.class);
+ NaughtyException second =
+ Assertions.catchThrowableOfType(() -> mock.add(null), NaughtyException.class);
+
+ assertNotSame(first, second);
}
@Test
@@ -111,7 +142,6 @@
exception.expect(sameInstance(expected));
mock.clear();
-
}
@Test
@@ -125,7 +155,8 @@
}
@Test
- public void shouldFailStubbingThrowableOnTheSameInvocationDueToAcceptableLimitation() throws Exception {
+ public void shouldFailStubbingThrowableOnTheSameInvocationDueToAcceptableLimitation()
+ throws Exception {
when(mock.size()).thenThrow(new ExceptionOne());
exception.expect(ExceptionOne.class);
@@ -263,7 +294,7 @@
}
@Test
- public void shouldNotAllowDifferntCheckedException() throws Exception {
+ public void shouldNotAllowDifferentCheckedException() throws Exception {
IMethods mock = mock(IMethods.class);
exception.expect(MockitoException.class);
@@ -357,7 +388,7 @@
when(mock.size()).thenThrow(new RuntimeException());
doThrow(new RuntimeException()).when(mock).clone();
- verifyZeroInteractions(mock);
+ verifyNoInteractions(mock);
mock.add("test");
@@ -380,20 +411,15 @@
}
}
- private class ExceptionOne extends RuntimeException {
- }
+ private class ExceptionOne extends RuntimeException {}
- private class ExceptionTwo extends RuntimeException {
- }
+ private class ExceptionTwo extends RuntimeException {}
- private class ExceptionThree extends RuntimeException {
- }
+ private class ExceptionThree extends RuntimeException {}
- private class ExceptionFour extends RuntimeException {
- }
+ private class ExceptionFour extends RuntimeException {}
- private class CheckedException extends Exception {
- }
+ private class CheckedException extends Exception {}
public class NaughtyException extends RuntimeException {
public NaughtyException() {
diff --git a/src/test/java/org/mockitousage/verification/AtLeastXVerificationTest.java b/src/test/java/org/mockitousage/verification/AtLeastXVerificationTest.java
index c766498..8a3f6b1 100644
--- a/src/test/java/org/mockitousage/verification/AtLeastXVerificationTest.java
+++ b/src/test/java/org/mockitousage/verification/AtLeastXVerificationTest.java
@@ -2,31 +2,30 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.verification;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.exceptions.base.MockitoAssertionError;
import org.mockitoutil.TestBase;
-import java.util.List;
-
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
public class AtLeastXVerificationTest extends TestBase {
@Mock private List<String> mock;
@Test
public void shouldVerifyAtLeastXTimes() throws Exception {
- //when
+ // when
mock.clear();
mock.clear();
mock.clear();
- //then
+ // then
verify(mock, atLeast(2)).clear();
}
@@ -38,16 +37,18 @@
try {
verify(mock, atLeast(2)).add(anyString());
fail();
- } catch (MockitoAssertionError e) {}
+ } catch (MockitoAssertionError e) {
+ }
}
@Test
- public void shouldAllowAtLeastZeroForTheSakeOfVerifyNoMoreInteractionsSometimes() throws Exception {
- //when
+ public void shouldAllowAtLeastZeroForTheSakeOfVerifyNoMoreInteractionsSometimes()
+ throws Exception {
+ // when
mock.add("one");
mock.clear();
- //then
+ // then
verify(mock, atLeast(0)).add("one");
verify(mock, atLeast(0)).clear();
diff --git a/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java b/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java
index 2756ef8..47c78f7 100644
--- a/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java
+++ b/src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java
@@ -2,9 +2,20 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.verification;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.atMost;
+import static org.mockito.Mockito.atMostOnce;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import java.util.List;
+
import org.junit.Test;
import org.mockito.InOrder;
import org.mockito.Mock;
@@ -13,17 +24,6 @@
import org.mockito.exceptions.verification.NoInteractionsWanted;
import org.mockitoutil.TestBase;
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.anyString;
-import static org.mockito.Mockito.atMost;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-
public class AtMostXVerificationTest extends TestBase {
@Mock private List<String> mock;
@@ -37,9 +37,10 @@
verify(mock, atMost(3)).clear();
try {
- verify(mock, atMost(1)).clear();
+ verify(mock, atMostOnce()).clear();
fail();
- } catch (MoreThanAllowedActualInvocations e) {}
+ } catch (MoreThanAllowedActualInvocations e) {
+ }
}
@Test
@@ -50,7 +51,8 @@
try {
verify(mock, atMost(0)).add(anyString());
fail();
- } catch (MoreThanAllowedActualInvocations e) {}
+ } catch (MoreThanAllowedActualInvocations e) {
+ }
}
@Test
@@ -69,7 +71,7 @@
mock.clear();
try {
- verify(mock, atMost(1)).clear();
+ verify(mock, atMostOnce()).clear();
fail();
} catch (MoreThanAllowedActualInvocations e) {
assertEquals("\nWanted at most 1 time but was 2", e.getMessage());
@@ -82,7 +84,7 @@
InOrder inOrder = inOrder(mock);
try {
- inOrder.verify(mock, atMost(1)).clear();
+ inOrder.verify(mock, atMostOnce()).clear();
fail();
} catch (MockitoException e) {
assertEquals("AtMost is not implemented to work with InOrder", e.getMessage());
@@ -108,7 +110,7 @@
try {
verifyNoMoreInteractions(mock);
fail();
- } catch(NoInteractionsWanted e) {
+ } catch (NoInteractionsWanted e) {
assertThat(e).hasMessageContaining("undesiredInteraction(");
}
}
diff --git a/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java b/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
index b0e3179..f424fab 100644
--- a/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
+++ b/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
@@ -2,23 +2,25 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.verification;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
import org.mockito.exceptions.base.MockitoException;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.exceptions.misusing.NullInsteadOfMockException;
import org.mockito.exceptions.verification.NoInteractionsWanted;
import org.mockito.exceptions.verification.VerificationInOrderFailure;
import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
public class BasicVerificationInOrderTest extends TestBase {
private IMethods mockOne;
@@ -264,9 +266,39 @@
verifyZeroInteractions(mockOne);
}
+ @Test(expected = NoInteractionsWanted.class)
+ public void shouldFailOnVerifyNoInteractions() {
+ verifyNoInteractions(mockOne);
+ }
+
@SuppressWarnings({"all", "CheckReturnValue", "MockitoUsage"})
@Test(expected = MockitoException.class)
public void shouldScreamWhenNullPassed() {
- inOrder((Object[])null);
+ inOrder((Object[]) null);
+ }
+
+ @Test
+ public void shouldThrowNullPassedToVerifyException() {
+ try {
+ inOrder.verify(null);
+ fail();
+ } catch (NullInsteadOfMockException e) {
+ assertThat(e)
+ .hasMessageContaining(
+ "Argument passed to verify() should be a mock but is null!");
+ }
+ }
+
+ @Test
+ public void shouldThrowNotAMockPassedToVerifyException() {
+ Object object = new Object();
+ try {
+ inOrder.verify(object);
+ fail();
+ } catch (NotAMockException e) {
+ assertThat(e)
+ .hasMessageContaining(
+ "Argument passed to verify() is of type Object and is not a mock!");
+ }
}
}
diff --git a/src/test/java/org/mockitousage/verification/BasicVerificationTest.java b/src/test/java/org/mockitousage/verification/BasicVerificationTest.java
index d9a74ff..2f2f6b3 100644
--- a/src/test/java/org/mockitousage/verification/BasicVerificationTest.java
+++ b/src/test/java/org/mockitousage/verification/BasicVerificationTest.java
@@ -2,25 +2,24 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.verification;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
import org.assertj.core.api.ThrowableAssert;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.exceptions.verification.NoInteractionsWanted;
import org.mockito.exceptions.verification.TooManyActualInvocations;
import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
-
public class BasicVerificationTest extends TestBase {
@Mock private List<String> mock;
@@ -37,7 +36,7 @@
verifyNoMoreInteractions(mock);
}
- @Test(expected=WantedButNotInvoked.class)
+ @Test(expected = WantedButNotInvoked.class)
public void shouldFailVerification() throws Exception {
verify(mock).clear();
}
@@ -49,12 +48,14 @@
verify(mock).clear();
- assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
- @Override
- public void call() {
- verify(mock).add("bar");
- }
- }).isInstanceOf(ArgumentsAreDifferent.class);
+ assertThatThrownBy(
+ new ThrowableAssert.ThrowingCallable() {
+ @Override
+ public void call() {
+ verify(mock).add("bar");
+ }
+ })
+ .isInstanceOf(ArgumentsAreDifferent.class);
}
@Test
@@ -69,7 +70,8 @@
try {
verify(mockTwo, atLeastOnce()).add("foo");
fail();
- } catch (WantedButNotInvoked e) {}
+ } catch (WantedButNotInvoked e) {
+ }
}
@Test
@@ -84,7 +86,8 @@
try {
verifyNoMoreInteractions(mock);
fail();
- } catch (NoInteractionsWanted e) {}
+ } catch (NoInteractionsWanted e) {
+ }
}
@Test
@@ -98,7 +101,8 @@
try {
verify(mock).clear();
fail();
- } catch (TooManyActualInvocations e) {}
+ } catch (TooManyActualInvocations e) {
+ }
}
@Test
@@ -110,7 +114,6 @@
verify(mock).add("test");
}
-
@Test
public void shouldDetectWhenOverloadedMethodCalled() throws Exception {
IMethods mockThree = mock(IMethods.class);
@@ -119,6 +122,7 @@
try {
verify(mockThree).varargs((String[]) new String[] {});
fail();
- } catch(WantedButNotInvoked e) {}
+ } catch (WantedButNotInvoked e) {
+ }
}
}
diff --git a/src/test/java/org/mockitousage/verification/CustomVerificationTest.java b/src/test/java/org/mockitousage/verification/CustomVerificationTest.java
index e38df06..766bb1d 100644
--- a/src/test/java/org/mockitousage/verification/CustomVerificationTest.java
+++ b/src/test/java/org/mockitousage/verification/CustomVerificationTest.java
@@ -4,6 +4,9 @@
*/
package org.mockitousage.verification;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.verify;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.exceptions.base.MockitoAssertionError;
@@ -14,49 +17,55 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.verify;
-
public class CustomVerificationTest extends TestBase {
@Mock IMethods mock;
@Test
public void custom_verification_with_old_api() {
- //given:
+ // given:
mock.simpleMethod("a", 10);
- //expect:
+ // expect:
verify(mock, ignoreParametersUsingOldApi()).simpleMethod();
try {
verify(mock, ignoreParametersUsingOldApi()).otherMethod();
fail();
- } catch (MockitoAssertionError e) {}
+ } catch (MockitoAssertionError e) {
+ }
}
- //Old api still supported, see https://github.com/mockito/mockito/issues/730
+ // Old api still supported, see https://github.com/mockito/mockito/issues/730
private VerificationMode ignoreParametersUsingOldApi() {
return new VerificationMode() {
public void verify(VerificationData data) {
- //use old api
+ // use old api
InvocationMatcher target = data.getWanted();
- //sanity check the new api
+ // sanity check the new api
if (data.getTarget() != target) {
throw new RuntimeException("Sanity check");
}
- //look for the relevant invocation and exit if found
+ // look for the relevant invocation and exit if found
for (Invocation invocation : data.getAllInvocations()) {
- if (target.getInvocation().getMethod().getName().equals(invocation.getMethod().getName())) {
+ if (target.getInvocation()
+ .getMethod()
+ .getName()
+ .equals(invocation.getMethod().getName())) {
return;
}
}
- //verification failed!
- throw new MockitoAssertionError("Expected method with name: " + target + " not found in:\n" + data.getAllInvocations());
+ // verification failed!
+ throw new MockitoAssertionError(
+ "Expected method with name: "
+ + target
+ + " not found in:\n"
+ + data.getAllInvocations());
}
+
public VerificationMode description(String description) {
return this;
}
diff --git a/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java b/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java
index 8e1bf06..9e5ffeb 100644
--- a/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java
+++ b/src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java
@@ -2,9 +2,12 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.verification;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
@@ -14,10 +17,6 @@
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
-
public class DescriptiveMessagesOnVerificationInOrderErrorsTest extends TestBase {
private IMethods one;
@@ -50,24 +49,24 @@
fail();
} catch (VerificationInOrderFailure e) {
String expected =
- "\n" +
- "Verification in order failure" +
- "\n" +
- "Wanted but not invoked:" +
- "\n" +
- "iMethods.simpleMethod(11);" +
- "\n" +
- "-> at ";
+ "\n"
+ + "Verification in order failure"
+ + "\n"
+ + "Wanted but not invoked:"
+ + "\n"
+ + "iMethods.simpleMethod(11);"
+ + "\n"
+ + "-> at ";
assertThat(e).hasMessageContaining(expected);
String expectedCause =
- "\n" +
- "Wanted anywhere AFTER following interaction:" +
- "\n" +
- "iMethods.simpleMethod(2);" +
- "\n" +
- "-> at ";
+ "\n"
+ + "Wanted anywhere AFTER following interaction:"
+ + "\n"
+ + "iMethods.simpleMethod(2);"
+ + "\n"
+ + "-> at ";
assertThat(e).hasMessageContaining(expectedCause);
}
@@ -80,12 +79,12 @@
fail();
} catch (WantedButNotInvoked e) {
String expected =
- "\n" +
- "Wanted but not invoked:" +
- "\n" +
- "iMethods.differentMethod();" +
- "\n" +
- "-> at";
+ "\n"
+ + "Wanted but not invoked:"
+ + "\n"
+ + "iMethods.differentMethod();"
+ + "\n"
+ + "-> at";
assertThat(e).hasMessageContaining(expected);
}
@@ -96,14 +95,15 @@
try {
inOrder.verify(one).simpleMethod(999);
fail();
- } catch (org.mockito.exceptions.verification.junit.ArgumentsAreDifferent e) {
- assertThat(e).hasMessageContaining("has different arguments");
+ } catch (org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent e) {
+ assertThat(e).hasMessageContaining("have different arguments");
}
}
@Test
public void shouldNotSayArgumentsAreDifferent() {
- //this is the last invocation so any next verification in order should simply say wanted but not invoked
+ // this is the last invocation so any next verification in order should simply say wanted
+ // but not invoked
inOrder.verify(three).simpleMethod(3);
try {
inOrder.verify(one).simpleMethod(999);
@@ -124,12 +124,12 @@
fail();
} catch (VerificationInOrderFailure e) {
String expectedMessage =
- "\n" +
- "Verification in order failure" +
- "\n" +
- "Wanted but not invoked:" +
- "\n" +
- "iMethods.simpleMethod(999);";
+ "\n"
+ + "Verification in order failure"
+ + "\n"
+ + "Wanted but not invoked:"
+ + "\n"
+ + "iMethods.simpleMethod(999);";
assertThat(e).hasMessageContaining(expectedMessage);
}
}
@@ -143,27 +143,23 @@
fail();
} catch (VerificationInOrderFailure e) {
String expectedMessage =
- "\n" +
- "Verification in order failure:" +
- "\n" +
- "iMethods.simpleMethod(2);" +
- "\n" +
- "Wanted 1 time:" +
- "\n" +
- "-> at";
+ "\n"
+ + "Verification in order failure:"
+ + "\n"
+ + "iMethods.simpleMethod(2);"
+ + "\n"
+ + "Wanted 1 time:"
+ + "\n"
+ + "-> at";
assertThat(e).hasMessageContaining(expectedMessage);
- String expectedCause =
- "\n" +
- "But was 2 times:" +
- "\n" +
- "-> at";
+ String expectedCause = "\n" + "But was 2 times:" + "\n" + "-> at";
assertThat(e).hasMessageContaining(expectedCause);
}
}
@Test
- public void shouldPrintTooLittleInvocations() {
+ public void shouldPrintTooFewInvocations() {
two.simpleMethod(2);
inOrder.verify(one, atLeastOnce()).simpleMethod(anyInt());
@@ -175,21 +171,17 @@
fail();
} catch (VerificationInOrderFailure e) {
String expectedMessage =
- "\n" +
- "Verification in order failure:" +
- "\n" +
- "iMethods.simpleMethod(2);" +
- "\n" +
- "Wanted 2 times:" +
- "\n" +
- "-> at";
+ "\n"
+ + "Verification in order failure:"
+ + "\n"
+ + "iMethods.simpleMethod(2);"
+ + "\n"
+ + "Wanted 2 times:"
+ + "\n"
+ + "-> at";
assertThat(e).hasMessageContaining(expectedMessage);
- String expectedCause =
- "\n" +
- "But was 1 time:" +
- "\n" +
- "-> at";
+ String expectedCause = "\n" + "But was 1 time:" + "\n" + "-> at";
assertThat(e).hasMessageContaining(expectedCause);
}
diff --git a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenTimesXVerificationFailsTest.java b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenTimesXVerificationFailsTest.java
index 1d5bed0..7ad4627 100644
--- a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenTimesXVerificationFailsTest.java
+++ b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenTimesXVerificationFailsTest.java
@@ -2,22 +2,21 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.verification;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.times;
+
+import java.util.LinkedList;
+
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.exceptions.verification.TooLittleActualInvocations;
+import org.mockito.exceptions.verification.TooFewActualInvocations;
import org.mockito.exceptions.verification.TooManyActualInvocations;
import org.mockitoutil.TestBase;
-import java.util.LinkedList;
-
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.times;
-
@SuppressWarnings("unchecked")
public class DescriptiveMessagesWhenTimesXVerificationFailsTest extends TestBase {
@@ -33,11 +32,11 @@
try {
Mockito.verify(mock, times(100)).clear();
fail();
- } catch (TooLittleActualInvocations e) {
+ } catch (TooFewActualInvocations e) {
assertThat(e)
- .hasMessageContaining("mock.clear();")
- .hasMessageContaining("Wanted 100 times")
- .hasMessageContaining("was 3");
+ .hasMessageContaining("mock.clear();")
+ .hasMessageContaining("Wanted 100 times")
+ .hasMessageContaining("was 3");
}
}
@@ -54,9 +53,9 @@
fail();
} catch (TooManyActualInvocations e) {
assertThat(e)
- .hasMessageContaining("mock.clear();")
- .hasMessageContaining("Wanted 1 time")
- .hasMessageContaining("was 4");
+ .hasMessageContaining("mock.clear();")
+ .hasMessageContaining("Wanted 1 time")
+ .hasMessageContaining("was 4");
}
}
}
diff --git a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java
index 43729f3..94f6602 100644
--- a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java
+++ b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java
@@ -2,9 +2,15 @@
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
-
package org.mockitousage.verification;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
+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;
@@ -13,15 +19,10 @@
import org.mockito.exceptions.verification.NeverWantedButInvoked;
import org.mockito.exceptions.verification.NoInteractionsWanted;
import org.mockito.exceptions.verification.WantedButNotInvoked;
-import org.mockito.exceptions.verification.junit.ArgumentsAreDifferent;
+import org.mockito.exceptions.verification.opentest4j.ArgumentsAreDifferent;
import org.mockitousage.IMethods;
import org.mockitoutil.TestBase;
-import static org.junit.Assert.fail;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.AdditionalMatchers.aryEq;
-import static org.mockito.Mockito.*;
-
public class DescriptiveMessagesWhenVerificationFailsTest extends TestBase {
private IMethods mock;
@@ -38,12 +39,12 @@
fail();
} catch (WantedButNotInvoked e) {
String expectedMessage =
- "\n" +
- "Wanted but not invoked:" +
- "\n" +
- "iMethods.simpleMethod();" +
- "\n" +
- "-> at";
+ "\n"
+ + "Wanted but not invoked:"
+ + "\n"
+ + "iMethods.simpleMethod();"
+ + "\n"
+ + "-> at";
assertThat(e).hasMessageContaining(expectedMessage);
}
}
@@ -73,18 +74,18 @@
fail();
} catch (ArgumentsAreDifferent e) {
String wanted =
- "\n" +
- "Argument(s) are different! Wanted:" +
- "\n" +
- "iMethods.varargs(1, 1000);";
+ "\n"
+ + "Argument(s) are different! Wanted:"
+ + "\n"
+ + "iMethods.varargs(1, 1000);";
assertThat(e).hasMessageContaining(wanted);
String actual =
- "\n" +
- "Actual invocation has different arguments:" +
- "\n" +
- "iMethods.varargs(1, 2);";
+ "\n"
+ + "Actual invocations have different arguments:"
+ + "\n"
+ + "iMethods.varargs(1, 2);";
assertThat(e).hasMessageContaining(actual);
}
@@ -99,46 +100,49 @@
fail();
} catch (ArgumentsAreDifferent e) {
String wanted =
- "\n" +
- "Argument(s) are different! Wanted:" +
- "\n" +
- "iMethods.varargs(" +
- "\n" +
- " \"x\"," +
- "\n" +
- " \"y\"," +
- "\n" +
- " \"z\"" +
- "\n" +
- ");";
+ "\n"
+ + "Argument(s) are different! Wanted:"
+ + "\n"
+ + "iMethods.varargs("
+ + "\n"
+ + " \"x\","
+ + "\n"
+ + " \"y\","
+ + "\n"
+ + " \"z\""
+ + "\n"
+ + ");";
assertThat(e).hasMessageContaining(wanted);
String actual =
- "\n" +
- "Actual invocation has different arguments:" +
- "\n" +
- "iMethods.varargs(" +
- "\n" +
- " \"this is very long string\"," +
- "\n" +
- " \"this is another very long string\"" +
- "\n" +
- ");";
+ "\n"
+ + "Actual invocations have different arguments:"
+ + "\n"
+ + "iMethods.varargs("
+ + "\n"
+ + " \"this is very long string\","
+ + "\n"
+ + " \"this is another very long string\""
+ + "\n"
+ + ");";
assertThat(e).hasMessageContaining(actual);
}
}
@Test
- public void should_print_actual_and_wanted_when_actual_method_name_and_wanted_method_name_are_the_same() {
+ public void
+ should_print_actual_and_wanted_when_actual_method_name_and_wanted_method_name_are_the_same() {
mock.simpleMethod();
try {
verify(mock).simpleMethod(10);
fail();
} catch (ArgumentsAreDifferent e) {
- assertThat(e).hasMessageContaining("simpleMethod(10)").hasMessageContaining("simpleMethod()");
+ assertThat(e)
+ .hasMessageContaining("simpleMethod(10)")
+ .hasMessageContaining("simpleMethod()");
}
}
@@ -167,18 +171,11 @@
verifyNoMoreInteractions(mock);
fail();
} catch (NoInteractionsWanted e) {
- String expectedMessage =
- "\n" +
- "No interactions wanted here:" +
- "\n" +
- "-> at";
+ String expectedMessage = "\n" + "No interactions wanted here:" + "\n" + "-> at";
assertThat(e).hasMessageContaining(expectedMessage);
String expectedCause =
- "\n" +
- "But found this interaction on mock '" + mock + "':" +
- "\n" +
- "-> at";
+ "\n" + "But found this interaction on mock '" + mock + "':" + "\n" + "-> at";
assertThat(e).hasMessageContaining(expectedCause);
}
}
@@ -192,19 +189,32 @@
verifyZeroInteractions(mock);
fail();
} catch (NoInteractionsWanted e) {
- String expected =
- "\n" +
- "No interactions wanted here:" +
- "\n" +
- "-> at";
+ String expected = "\n" + "No interactions wanted here:" + "\n" + "-> at";
assertThat(e).hasMessageContaining(expected);
String expectedCause =
- "\n" +
- "But found this interaction on mock '" + mock + "':" +
- "\n" +
- "-> at";
+ "\n" + "But found this interaction on mock '" + mock + "':" + "\n" + "-> at";
+
+ assertThat(e).hasMessageContaining(expectedCause);
+ }
+ }
+
+ @Test
+ public void should_print_first_unexpected_invocation_when_verifying_no_interactions() {
+ mock.twoArgumentMethod(1, 2);
+ mock.threeArgumentMethod(1, "2", "3");
+
+ try {
+ verifyNoInteractions(mock);
+ fail();
+ } catch (NoInteractionsWanted e) {
+ String expected = "\n" + "No interactions wanted here:" + "\n" + "-> at";
+
+ assertThat(e).hasMessageContaining(expected);
+
+ String expectedCause =
+ "\n" + "But found these interactions on mock '" + mock + "':" + "\n" + "-> at";
assertThat(e).hasMessageContaining(expectedCause);
}
@@ -227,28 +237,28 @@
fail();
} catch (WantedButNotInvoked e) {
String expectedMessage =
- "\n" +
- "Wanted but not invoked:" +
- "\n" +
- "iMethods.twoArgumentMethod(\n" +
- " <any integer>,\n" +
- " 100\n" +
- ");";
+ "\n"
+ + "Wanted but not invoked:"
+ + "\n"
+ + "iMethods.twoArgumentMethod(\n"
+ + " <any integer>,\n"
+ + " 100\n"
+ + ");";
assertThat(e).hasMessageContaining(expectedMessage);
}
}
@Test
public void should_print_method_when_missing_invocation_with_array_matcher() {
- mock.oneArray(new boolean[] { true, false, false });
+ mock.oneArray(new boolean[] {true, false, false});
try {
- 