org.mockito.Matchers Maven / Gradle / Ivy
Show all versions of mockito-all Show documentation
/*
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
package org.mockito;
import org.hamcrest.Matcher;
import org.mockito.internal.matchers.*;
import org.mockito.internal.matchers.apachecommons.ReflectionEquals;
import org.mockito.internal.progress.HandyReturnValues;
import org.mockito.internal.progress.MockingProgress;
import org.mockito.internal.progress.ThreadSafeMockingProgress;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Allow flexible verification or stubbing. See also {@link AdditionalMatchers}.
*
* {@link Mockito} extends Matchers so to get access to all matchers just import Mockito class statically.
*
* //stubbing using anyInt() argument matcher
* when(mockedList.get(anyInt())).thenReturn("element");
*
* //following prints "element"
* System.out.println(mockedList.get(999));
*
* //you can also verify using argument matcher
* verify(mockedList).get(anyInt());
*
* Scroll down to see all methods - full list of matchers.
*
* Warning:
*
* If you are using argument matchers, all arguments have to be provided by matchers.
*
* E.g: (example shows verification but the same applies to stubbing):
*
* verify(mock).someMethod(anyInt(), anyString(), eq("third argument"));
* //above is correct - eq() is also an argument matcher
*
* verify(mock).someMethod(anyInt(), anyString(), "third argument");
* //above is incorrect - exception will be thrown because third argument is given without argument matcher.
*
*
* Matcher methods like anyObject(), eq() do not return matchers.
* Internally, they record a matcher on a stack and return a dummy value (usually null).
* This implementation is due static type safety imposed by java compiler.
* The consequence is that you cannot use anyObject(), eq() methods outside of verified/stubbed method.
*
*
* Warning 2:
*
* The any family methods *don't do any type checks*, those are only here to avoid casting
* in your code. If you want to perform type checks use the {@link #isA(Class)} method.
* This might however change (type checks could be added) in a future major release.
*
*
Custom Argument Matchers
*
* Use {@link Matchers#argThat} method and pass an instance of hamcrest {@link Matcher}.
*
* Before you start implementing your own custom argument matcher, make sure you check out {@link ArgumentCaptor} api.
*
* So, how to implement your own argument matcher?
* First, you might want to subclass {@link ArgumentMatcher} which is an hamcrest matcher with predefined describeTo() method.
* Default description generated by describeTo() uses decamelized class name - to promote meaningful class names.
*
* Example:
*
*
* class IsListOfTwoElements extends ArgumentMatcher<List> {
* public boolean matches(Object list) {
* return ((List) list).size() == 2;
* }
* }
*
* List mock = mock(List.class);
*
* when(mock.addAll(argThat(new IsListOfTwoElements()))).thenReturn(true);
*
* mock.addAll(Arrays.asList("one", "two"));
*
* verify(mock).addAll(argThat(new IsListOfTwoElements()));
*
*
* To keep it readable you may want to extract method, e.g:
*
* verify(mock).addAll(argThat(new IsListOfTwoElements()));
* //becomes
* verify(mock).addAll(listOfTwoElements());
*
*
* Warning: Be reasonable with using complicated argument matching, especially custom argument matchers, as it can make the test less readable.
* Sometimes it's better to implement equals() for arguments that are passed to mocks
* (Mockito naturally uses equals() for argument matching).
* This can make the test cleaner.
*
* Also, sometimes {@link ArgumentCaptor} may be a better fit than custom matcher.
* For example, if custom argument matcher is not likely to be reused
* or you just need it to assert on argument values to complete verification of behavior.
*/
@SuppressWarnings("unchecked")
public class Matchers {
private static MockingProgress mockingProgress = new ThreadSafeMockingProgress();
/**
* Any boolean, Boolean or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return false.
*/
public static boolean anyBoolean() {
return reportMatcher(Any.ANY).returnFalse();
}
/**
* Any byte, Byte or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return 0.
*/
public static byte anyByte() {
return reportMatcher(Any.ANY).returnZero();
}
/**
* Any char, Character or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return 0.
*/
public static char anyChar() {
return reportMatcher(Any.ANY).returnChar();
}
/**
* Any int, Integer or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return 0.
*/
public static int anyInt() {
return reportMatcher(Any.ANY).returnZero();
}
/**
* Any long, Long or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return 0.
*/
public static long anyLong() {
return reportMatcher(Any.ANY).returnZero();
}
/**
* Any float, Float or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return 0.
*/
public static float anyFloat() {
return reportMatcher(Any.ANY).returnZero();
}
/**
* Any double, Double or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return 0.
*/
public static double anyDouble() {
return reportMatcher(Any.ANY).returnZero();
}
/**
* Any short, Short or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return 0.
*/
public static short anyShort() {
return reportMatcher(Any.ANY).returnZero();
}
/**
* Any Object or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* Has aliases: {@link #any()} and {@link #any(Class clazz)}
*
* See examples in javadoc for {@link Matchers} class
*
* @return null.
*/
public static T anyObject() {
return (T) reportMatcher(Any.ANY).returnNull();
}
//TODO: after 1.8 check out Jay Fields' idea on any() matcher
/**
* Any vararg, meaning any number and values of arguments.
*
* Example:
*
* //verification:
* mock.foo(1, 2);
* mock.foo(1, 2, 3, 4);
*
* verify(mock, times(2)).foo(anyVararg());
*
* //stubbing:
* when(mock.foo(anyVararg()).thenReturn(100);
*
* //prints 100
* System.out.println(mock.foo(1, 2));
* //also prints 100
* System.out.println(mock.foo(1, 2, 3, 4));
*
* See examples in javadoc for {@link Matchers} class
*
* @return null.
*/
public static T anyVararg() {
return (T) reportMatcher(AnyVararg.ANY_VARARG).returnNull();
}
/**
* Any kind object, not necessary of the given class.
* The class argument is provided only to avoid casting.
*
* Sometimes looks better than anyObject() - especially when explicit casting is required
*
* Alias to {@link Matchers#anyObject()}
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @param clazz The type to avoid casting
* @return null.
*/
public static T any(Class clazz) {
return (T) reportMatcher(Any.ANY).returnFor(clazz);
}
/**
* Any object or null.
*
* Shorter alias to {@link Matchers#anyObject()}
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return null.
*/
public static T any() {
return (T) anyObject();
}
/**
* Any String or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return empty String ("")
*/
public static String anyString() {
return reportMatcher(Any.ANY).returnString();
}
/**
* Any List or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return empty List.
*/
public static List anyList() {
return reportMatcher(Any.ANY).returnList();
}
/**
* Generic friendly alias to {@link Matchers#anyList()}.
* It's an alternative to @SuppressWarnings("unchecked") to keep code clean of compiler warnings.
*
* Any List or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @param clazz Type owned by the list to avoid casting
* @return empty List.
*/
public static List anyListOf(Class clazz) {
return (List) reportMatcher(Any.ANY).returnList();
}
/**
* Any Set or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return empty Set
*/
public static Set anySet() {
return reportMatcher(Any.ANY).returnSet();
}
/**
* Generic friendly alias to {@link Matchers#anySet()}.
* It's an alternative to @SuppressWarnings("unchecked") to keep code clean of compiler warnings.
*
* Any Set or null
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @param clazz Type owned by the Set to avoid casting
* @return empty Set
*/
public static Set anySetOf(Class clazz) {
return (Set) reportMatcher(Any.ANY).returnSet();
}
/**
* Any Map or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return empty Map.
*/
public static Map anyMap() {
return reportMatcher(Any.ANY).returnMap();
}
/**
* Generic friendly alias to {@link Matchers#anyMap()}.
* It's an alternative to @SuppressWarnings("unchecked") to keep code clean of compiler warnings.
*
* Any Map or null
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @param keyClazz Type of the map key to avoid casting
* @param valueClazz Type of the value to avoid casting
* @return empty Map.
*/
public static Map anyMapOf(Class keyClazz, Class valueClazz) {
return reportMatcher(Any.ANY).returnMap();
}
/**
* Any Collection or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @return empty Collection.
*/
public static Collection anyCollection() {
return reportMatcher(Any.ANY).returnList();
}
/**
* Generic friendly alias to {@link Matchers#anyCollection()}.
* It's an alternative to @SuppressWarnings("unchecked") to keep code clean of compiler warnings.
*
* Any Collection or null.
*
* This method *don't do any type checks*, it is only there to avoid casting
* in your code. This might however change (type checks could be added) in a
* future major release.
*
* See examples in javadoc for {@link Matchers} class
*
* @param clazz Type owned by the collection to avoid casting
* @return empty Collection.
*/
public static Collection anyCollectionOf(Class clazz) {
return (Collection) reportMatcher(Any.ANY).returnList();
}
/**
* Object argument that implements the given class.
*
* See examples in javadoc for {@link Matchers} class
*
* @param
* the accepted type.
* @param clazz
* the class of the accepted type.
* @return null.
*/
public static T isA(Class clazz) {
return reportMatcher(new InstanceOf(clazz)).returnFor(clazz);
}
/**
* boolean argument that is equal to the given value.
*
* See examples in javadoc for {@link Matchers} class
*
* @param value
* the given value.
* @return 0.
*/
public static boolean eq(boolean value) {
return reportMatcher(new Equals(value)).returnFalse();
}
/**
* byte argument that is equal to the given value.
*
* See examples in javadoc for {@link Matchers} class
*
* @param value
* the given value.
* @return 0.
*/
public static byte eq(byte value) {
return reportMatcher(new Equals(value)).returnZero();
}
/**
* char argument that is equal to the given value.
*
* See examples in javadoc for {@link Matchers} class
*
* @param value
* the given value.
* @return 0.
*/
public static char eq(char value) {
return reportMatcher(new Equals(value)).returnChar();
}
/**
* double argument that is equal to the given value.
*
* See examples in javadoc for {@link Matchers} class
*
* @param value
* the given value.
* @return 0.
*/
public static double eq(double value) {
return reportMatcher(new Equals(value)).returnZero();
}
/**
* float argument that is equal to the given value.
*
* See examples in javadoc for {@link Matchers} class
*
* @param value
* the given value.
* @return 0.
*/
public static float eq(float value) {
return reportMatcher(new Equals(value)).returnZero();
}
/**
* int argument that is equal to the given value.
*
* See examples in javadoc for {@link Matchers} class
*
* @param value
* the given value.
* @return 0.
*/
public static int eq(int value) {
return reportMatcher(new Equals(value)).returnZero();
}
/**
* long argument that is equal to the given value.
*
* See examples in javadoc for {@link Matchers} class
*
* @param value
* the given value.
* @return 0.
*/
public static long eq(long value) {
return reportMatcher(new Equals(value)).returnZero();
}
/**
* short argument that is equal to the given value.
*
* See examples in javadoc for {@link Matchers} class
*
* @param value
* the given value.
* @return 0.
*/
public static short eq(short value) {
return reportMatcher(new Equals(value)).returnZero();
}
/**
* Object argument that is equal to the given value.
*
* See examples in javadoc for {@link Matchers} class
*
* @param value
* the given value.
* @return null.
*/
public static T eq(T value) {
return (T) reportMatcher(new Equals(value)).returnFor(value);
}
/**
* Object argument that is reflection-equal to the given value with support for excluding
* selected fields from a class.
*
* This matcher can be used when equals() is not implemented on compared objects.
* Matcher uses java reflection API to compare fields of wanted and actual object.
*
* Works similarly to EqualsBuilder.reflectionEquals(this, other, exlucdeFields) from
* apache commons library.
*
* Warning The equality check is shallow!
*
* See examples in javadoc for {@link Matchers} class
*
* @param value
* the given value.
* @param excludeFields
* fields to exclude, if field does not exist it is ignored.
* @return null.
*/
public static T refEq(T value, String... excludeFields) {
return reportMatcher(new ReflectionEquals(value, excludeFields)).returnNull();
}
/**
* Object argument that is the same as the given value.
*
* See examples in javadoc for {@link Matchers} class
*
* @param
* the type of the object, it is passed through to prevent casts.
* @param value
* the given value.
* @return null.
*/
public static T same(T value) {
return (T) reportMatcher(new Same(value)).returnFor(value);
}
/**
* null argument.
*
* See examples in javadoc for {@link Matchers} class
*
* @return null.
*/
public static Object isNull() {
return reportMatcher(Null.NULL).returnNull();
}
/**
* null argument.
* The class argument is provided to avoid casting.
*
* See examples in javadoc for {@link Matchers} class
*
* @param clazz Type to avoid casting
* @return null.
*/
public static T isNull(Class clazz) {
return (T) reportMatcher(Null.NULL).returnNull();
}
/**
* Not null argument.
*
* alias to {@link Matchers#isNotNull()}
*
* See examples in javadoc for {@link Matchers} class
*
* @return null.
*/
public static Object notNull() {
return reportMatcher(NotNull.NOT_NULL).returnNull();
}
/**
* Not null argument, not necessary of the given class.
* The class argument is provided to avoid casting.
*
* alias to {@link Matchers#isNotNull(Class)}
*
* See examples in javadoc for {@link Matchers} class
*
* @param clazz Type to avoid casting
* @return null.
*/
public static T notNull(Class clazz) {
return (T) reportMatcher(NotNull.NOT_NULL).returnNull();
}
/**
* Not null argument.
*
* alias to {@link Matchers#notNull()}
*
* See examples in javadoc for {@link Matchers} class
*
* @return null.
*/
public static Object isNotNull() {
return notNull();
}
/**
* Not null argument, not necessary of the given class.
* The class argument is provided to avoid casting.
*
* alias to {@link Matchers#notNull(Class)}
*
* See examples in javadoc for {@link Matchers} class
*
* @param clazz Type to avoid casting
* @return null.
*/
public static T isNotNull(Class clazz) {
return notNull(clazz);
}
/**
* String argument that contains the given substring.
*
* See examples in javadoc for {@link Matchers} class
*
* @param substring
* the substring.
* @return empty String ("").
*/
public static String contains(String substring) {
return reportMatcher(new Contains(substring)).returnString();
}
/**
* String argument that matches the given regular expression.
*
* See examples in javadoc for {@link Matchers} class
*
* @param regex
* the regular expression.
* @return empty String ("").
*/
public static String matches(String regex) {
return reportMatcher(new Matches(regex)).returnString();
}
/**
* String argument that ends with the given suffix.
*
* See examples in javadoc for {@link Matchers} class
*
* @param suffix
* the suffix.
* @return empty String ("").
*/
public static String endsWith(String suffix) {
return reportMatcher(new EndsWith(suffix)).returnString();
}
/**
* String argument that starts with the given prefix.
*
* See examples in javadoc for {@link Matchers} class
*
* @param prefix
* the prefix.
* @return empty String ("").
*/
public static String startsWith(String prefix) {
return reportMatcher(new StartsWith(prefix)).returnString();
}
/**
* Allows creating custom argument matchers.
*
* In rare cases when the parameter is a primitive then you *must* use relevant intThat(), floatThat(), etc. method.
* This way you will avoid NullPointerException during auto-unboxing.
*
* See examples in javadoc for {@link ArgumentMatcher} class
*
* @param matcher decides whether argument matches
* @return null.
*/
public static T argThat(Matcher matcher) {
return reportMatcher(matcher).returnNull();
}
/**
* Allows creating custom Character argument matchers.
*
* See examples in javadoc for {@link Matchers} class
*
* @param matcher decides whether argument matches
* @return 0.
*/
public static char charThat(Matcher matcher) {
return reportMatcher(matcher).returnChar();
}
/**
* Allows creating custom Boolean argument matchers.
*
* See examples in javadoc for {@link Matchers} class
*
* @param matcher decides whether argument matches
* @return false.
*/
public static boolean booleanThat(Matcher matcher) {
return reportMatcher(matcher).returnFalse();
}
/**
* Allows creating custom Byte argument matchers.
*
* See examples in javadoc for {@link Matchers} class
*
* @param matcher decides whether argument matches
* @return 0.
*/
public static byte byteThat(Matcher matcher) {
return reportMatcher(matcher).returnZero();
}
/**
* Allows creating custom Short argument matchers.
*
* See examples in javadoc for {@link Matchers} class
*
* @param matcher decides whether argument matches
* @return 0.
*/
public static short shortThat(Matcher matcher) {
return reportMatcher(matcher).returnZero();
}
/**
* Allows creating custom Integer argument matchers.
*
* See examples in javadoc for {@link Matchers} class
*
* @param matcher decides whether argument matches
* @return 0.
*/
public static int intThat(Matcher matcher) {
return reportMatcher(matcher).returnZero();
}
/**
* Allows creating custom Long argument matchers.
*
* See examples in javadoc for {@link Matchers} class
*
* @param matcher decides whether argument matches
* @return 0.
*/
public static long longThat(Matcher matcher) {
return reportMatcher(matcher).returnZero();
}
/**
* Allows creating custom Float argument matchers.
*
* See examples in javadoc for {@link Matchers} class
*
* @param matcher decides whether argument matches
* @return 0.
*/
public static float floatThat(Matcher matcher) {
return reportMatcher(matcher).returnZero();
}
/**
* Allows creating custom Double argument matchers.
*
* See examples in javadoc for {@link Matchers} class
*
* @param matcher decides whether argument matches
* @return 0.
*/
public static double doubleThat(Matcher matcher) {
return reportMatcher(matcher).returnZero();
}
private static HandyReturnValues reportMatcher(Matcher matcher) {
return mockingProgress.getArgumentMatcherStorage().reportMatcher(matcher);
}
}