How to use matches method of org.mockito.ArgumentMatcher class

Best Mockito code snippet using org.mockito.ArgumentMatcher.matches

Source:ExtendedMatchers.java

...16 *17 */18public interface ExtendedMatchers extends MatchersMixin {19	/**20	 * A matcher call which matches if an argument contains all the given text21	 * 22	 * @param expectedParts23	 * @return true if all the expected parts match24	 */25	default String containsAllOf(final CharSequence... expectedParts) {26		return argThat(new ArgumentMatcher<String>() {27			/*28			 * (non-Javadoc)29			 * 30			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)31			 */32			@Override33			public boolean matches(String argument) {34				return StringUtil.containsAll(argument, expectedParts);35			}36			/*37			 * (non-Javadoc)38			 * 39			 * @see java.lang.Object#toString()40			 */41			@Override42			public String toString() {43				return "{String containing all of: " + StringUtil.charSequenceArrayToString(expectedParts) + "}";44			}45		});46	}47	/**48	 * A matcher call which matches if an argument's toString() result contains49	 * all of the given text50	 * 51	 * @param expectedParts52	 * @return true if all of the expected parts match, false if one does not53	 *         match54	 */55	default <T> T toStringContainsAllOf(final CharSequence... expectedParts) {56		return argThat(new ArgumentMatcher<T>() {57			/*58			 * (non-Javadoc)59			 * 60			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)61			 */62			@Override63			public boolean matches(T argument) {64				return StringUtil.containsAll(argument, expectedParts);65			}66			/*67			 * (non-Javadoc)68			 * 69			 * @see java.lang.Object#toString()70			 */71			@Override72			public String toString() {73				return "{Object with toString() containing all of: "74						+ StringUtil.charSequenceArrayToString(expectedParts) + "}";75			}76		});77	}78	/**79	 * A matcher call which matches if an argument contains at least one of the80	 * given text parts81	 * 82	 * @param expectedParts83	 * @return true if any of the expected parts match, false if none match84	 */85	default String containsOneOrMoreOf(final CharSequence... expectedParts) {86		return argThat(new ArgumentMatcher<String>() {87			/*88			 * (non-Javadoc)89			 * 90			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)91			 */92			@Override93			public boolean matches(String argument) {94				return StringUtil.containsOneOrMoreOf(argument, expectedParts);95			}96			/*97			 * (non-Javadoc)98			 * 99			 * @see java.lang.Object#toString()100			 */101			@Override102			public String toString() {103				return "{String containing one or more of: " + StringUtil.charSequenceArrayToString(expectedParts)104						+ "}";105			}106		});107	}108	/**109	 * A matcher call which matches if an argument's toString() result contains110	 * at least one of the given text111	 * 112	 * @param expectedParts113	 * @return true if any of the expected parts match, false if none match114	 */115	default <T> T toStringContainsOneOrMoreOf(final CharSequence... expectedParts) {116		return argThat(new ArgumentMatcher<T>() {117			/*118			 * (non-Javadoc)119			 * 120			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)121			 */122			@Override123			public boolean matches(T argument) {124				return StringUtil.containsOneOrMoreOf(argument, expectedParts);125			}126			/*127			 * (non-Javadoc)128			 * 129			 * @see java.lang.Object#toString()130			 */131			@Override132			public String toString() {133				return "{Object with toString() containing one or more of: "134						+ StringUtil.charSequenceArrayToString(expectedParts) + "}";135			}136		});137	}138	/**139	 * A predicate-based matcher for list arguments - all items must match140	 * 141	 * @param predicate142	 * @return null143	 */144	default <T extends Object> List<T> allListItemsMatch(Predicate<T> predicate) {145		return argThat(new ListMatcher<T>() {146			@Override147			protected boolean evaluateStream(Stream<T> stream) {148				return stream.allMatch(predicate);149			}150			/*151			 * (non-Javadoc)152			 * 153			 * @see java.lang.Object#toString()154			 */155			@Override156			public String toString() {157				return "[All items matching the given Predicate]";158			}159		});160	}161	/**162	 * A predicate-based matcher for list arguments - at least one item must163	 * match164	 * 165	 * @param predicate166	 *            A lambda to evaluate a method argument167	 * @return null168	 */169	default <T extends Object> List<T> oneOrMoreListItemsMatch(Predicate<T> predicate) {170		return argThat(new ListMatcher<T>() {171			@Override172			protected boolean evaluateStream(Stream<T> stream) {173				return stream.anyMatch(predicate);174			}175			/*176			 * (non-Javadoc)177			 * 178			 * @see java.lang.Object#toString()179			 */180			@Override181			public String toString() {182				return "[One or more items matching the given Predicate]";183			}184		});185	}186	/**187	 * Lenient-order list matcher For a match, the list argument encountered by188	 * the mock must contain exactly the items provided (no more, no fewer), but189	 * any order is acceptable190	 * 191	 * @param items192	 *            List of exact items expected (in any order)193	 * @return null194	 */195	default <T extends Object> List<T> listContainsExactlyInAnyOrder(T... items) {196		return argThat(new LenientOrderListMatcher<>(items));197	}198	/**199	 * Matcher for a map argument200	 * 201	 * @param predicate202	 *            lambda for assessing the map argument203	 * @return null204	 */205	default <K, V> Map<K, V> mapThat(Predicate<Map<K, V>> predicate) {206		// return argThat(map -> predicate.test((Map<K, V>) map));207		return argThat(new ArgumentMatcher<Map<K, V>>() {208			@Override209			public boolean matches(Map<K, V> argument) {210				return predicate.test(argument);211			}212			/*213			 * (non-Javadoc)214			 * 215			 * @see java.lang.Object#toString()216			 */217			@Override218			public String toString() {219				return "[Map matching the given Predicate]";220			}221		});222	}223	/**224	 * Matcher for a map argument225	 * 226	 * @param predicate227	 *            lambda for assessing the map argument228	 * @param description229	 *            Description of expected argument - will appear in verify()230	 *            failures231	 * @return null232	 */233	default <K, V> Map<K, V> mapThat(Predicate<Map<K, V>> predicate, final String description) {234		// return argThat(map -> predicate.test((Map<K, V>) map));235		return argThat(new ArgumentMatcher<Map<K, V>>() {236			@Override237			public boolean matches(Map<K, V> argument) {238				return predicate.test(argument);239			}240			/*241			 * (non-Javadoc)242			 * 243			 * @see java.lang.Object#toString()244			 */245			@Override246			public String toString() {247				return description;248			}249		});250	}251	/**252	 * A predicate-based matcher for set arguments - all items must match253	 * 254	 * @param predicate255	 * @return null256	 */257	default <T extends Object> Set<T> allSetItemsMatch(Predicate<T> predicate) {258		return argThat(new ArgumentMatcher<Set<T>>() {259			@Override260			public boolean matches(Set<T> argument) {261				return argument.stream().allMatch(predicate);262			}263			/*264			 * (non-Javadoc)265			 * 266			 * @see java.lang.Object#toString()267			 */268			@Override269			public String toString() {270				return "[All items matching the given Predicate]";271			}272		});273	}274	/**275	 * A predicate-based matcher for set arguments - at least one of the items276	 * must match277	 * 278	 * @param predicate279	 * @return null280	 */281	default <T extends Object> Set<T> oneOrMoreSetItemsMatch(Predicate<T> predicate) {282		return argThat(new ArgumentMatcher<Set<T>>() {283			@Override284			public boolean matches(Set<T> argument) {285				return argument.stream().anyMatch(predicate);286			}287			/*288			 * (non-Javadoc)289			 * 290			 * @see java.lang.Object#toString()291			 */292			@Override293			public String toString() {294				return "[One or more items matching the given Predicate]";295			}296		});297	}298	/**299	 * A predicate-based matcher for object arguments300	 * 301	 * Effectively, it's equivalent to argThat(), but objectMatches can accept a302	 * Predicate instance which can be reused in a variable outside of Mockito,303	 * whereas argThat can accept as its argument a lambda, but not a Predicate.304	 * 305	 * DO NOT USE THIS FOR PRIMITIVE ARGUMENTS such as int, double, etc.306	 * 307	 * Use intMatches, doubleMatches, etc. instead, because Mockito doesn't308	 * always handle autoboxing well309	 * 310	 * @param predicate311	 *            A lambda to evaluate a method argument312	 * @return null313	 */314	default <T> T objectMatches(Predicate<T> predicate) {315		return objectMatches(predicate, "{object matching the given predicate}");//argThat((argument) -> predicate.test((T) argument));316	}317	/**318	 * A predicate-based matcher for object arguments319	 * 320	 * Effectively, it's equivalent to argThat(), but objectMatches can accept a321	 * Predicate instance which can be reused in a variable outside of Mockito,322	 * whereas argThat can accept as its argument a lambda, but not a Predicate.323	 * 324	 * DO NOT USE THIS FOR PRIMITIVE ARGUMENTS such as int, double, etc.325	 * 326	 * Use intMatches, doubleMatches, etc. instead, because Mockito doesn't327	 * always handle autoboxing well328	 * 329	 * @param predicate330	 *            A lambda to evaluate a method argument331	 * @param description332	 *            Will appear in verify() failure messages333	 * @return null334	 */335	default <T> T objectMatches(Predicate<T> predicate, String description) {336		return argThat(new ArgumentMatcher<T>() {337			/*338			 * (non-Javadoc)339			 * 340			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)341			 */342			@Override343			public boolean matches(Object argument) {344				return predicate.test((T) argument);345			}346			/*347			 * (non-Javadoc)348			 * 349			 * @see java.lang.Object#toString()350			 */351			@Override352			public String toString() {353				return description;354			}355		});356	}357	/**358	 * A predicate-based matcher for primitive int arguments359	 * 360	 * @param predicate361	 *            A lambda to evaluate a method argument362	 * @return 0363	 */364	default int intMatches(Predicate<Integer> predicate) {365		return intMatches(predicate, "<int matching the given predicate>");366	}367	/**368	 * A predicate-based matcher for primitive int arguments369	 * 370	 * @param predicate371	 *            A lambda to evaluate a method argument372	 * @param description373	 *            Description of expected argument - will appear in verify()374	 *            failures375	 * @return 0376	 */377	default int intMatches(Predicate<Integer> predicate, final String description) {378		return intThat(new ArgumentMatcher<Integer>() {379			/*380			 * (non-Javadoc)381			 * 382			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)383			 */384			@Override385			public boolean matches(Integer argument) {386				return null != argument && predicate.test(argument.intValue());387			}388			/*389			 * (non-Javadoc)390			 * 391			 * @see java.lang.Object#toString()392			 */393			@Override394			public String toString() {395				return description;396			}397		});398	}399	/**400	 * A predicate-based matcher for primitive double arguments401	 * 402	 * @param predicate403	 *            A lambda to evaluate a method argument404	 * @return 0405	 */406	default double doubleMatches(Predicate<Double> predicate) {407		return doubleMatches(predicate, "<double matching the given predicate>");408	}409	/**410	 * A predicate-based matcher for primitive double arguments411	 * 412	 * @param predicate413	 *            A lambda to evaluate a method argument414	 * @param description415	 *            Description of expected argument - will appear in verify()416	 *            failures417	 * @return 0418	 */419	default double doubleMatches(Predicate<Double> predicate, final String description) {420		return doubleThat(new ArgumentMatcher<Double>() {421			/*422			 * (non-Javadoc)423			 * 424			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)425			 */426			@Override427			public boolean matches(Double argument) {428				return null != argument && predicate.test(argument.doubleValue());429			}430			/*431			 * (non-Javadoc)432			 * 433			 * @see java.lang.Object#toString()434			 */435			@Override436			public String toString() {437				return description;438			}439		});440	}441	/**442	 * A predicate-based matcher for primitive float arguments443	 * 444	 * @param predicate445	 *            A lambda to evaluate a method argument446	 * @return 0447	 */448	default float floatMatches(Predicate<Float> predicate) {449		return floatMatches(predicate, "<float matching the given predicate>");450	}451	/**452	 * A predicate-based matcher for primitive float arguments453	 * 454	 * @param predicate455	 *            A lambda to evaluate a method argument456	 * @param description457	 *            Description of expected argument - will appear in verify()458	 *            failures459	 * @return 0460	 */461	default float floatMatches(Predicate<Float> predicate, final String description) {462		return floatThat(new ArgumentMatcher<Float>() {463			/*464			 * (non-Javadoc)465			 * 466			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)467			 */468			@Override469			public boolean matches(Float argument) {470				return null != argument && predicate.test(argument.floatValue());471			}472			/*473			 * (non-Javadoc)474			 * 475			 * @see java.lang.Object#toString()476			 */477			@Override478			public String toString() {479				return description;480			}481		});482	}483	/**484	 * A predicate-based matcher for primitive short arguments485	 * 486	 * @param predicate487	 *            A lambda to evaluate a method argument488	 * @return 0489	 */490	default short shortMatches(Predicate<Short> predicate) {491		return shortMatches(predicate, "<short matching the given predicate>");492	}493	/**494	 * A predicate-based matcher for primitive short arguments495	 * 496	 * @param predicate497	 *            A lambda to evaluate a method argument498	 * @param description499	 *            Description of expected argument - will appear in verify()500	 *            failures501	 * @return 0502	 */503	default short shortMatches(Predicate<Short> predicate, final String description) {504		return shortThat(new ArgumentMatcher<Short>() {505			/*506			 * (non-Javadoc)507			 * 508			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)509			 */510			@Override511			public boolean matches(Short argument) {512				return null != argument && predicate.test(argument.shortValue());513			}514			/*515			 * (non-Javadoc)516			 * 517			 * @see java.lang.Object#toString()518			 */519			@Override520			public String toString() {521				return description;522			}523		});524	}525	/**526	 * A predicate-based matcher for primitive long arguments527	 * 528	 * @param predicate529	 *            A lambda to evaluate a method argument530	 * @return 0531	 */532	default long longMatches(Predicate<Long> predicate) {533		return longMatches(predicate, "<long matching the given predicate>");534	}535	/**536	 * A predicate-based matcher for primitive long arguments537	 * 538	 * @param predicate539	 *            A lambda to evaluate a method argument540	 * @param description541	 *            Description of expected argument - will appear in verify()542	 *            failures543	 * @return 0544	 */545	default long longMatches(Predicate<Long> predicate, final String description) {546		return longThat(new ArgumentMatcher<Long>() {547			/*548			 * (non-Javadoc)549			 * 550			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)551			 */552			@Override553			public boolean matches(Long argument) {554				return null != argument && predicate.test(argument.longValue());555			}556			/*557			 * (non-Javadoc)558			 * 559			 * @see java.lang.Object#toString()560			 */561			@Override562			public String toString() {563				return description;564			}565		});566	}567	/**568	 * A predicate-based matcher for primitive byte arguments569	 * 570	 * @param predicate571	 *            A lambda to evaluate a method argument572	 * @return 0573	 */574	default byte byteMatches(Predicate<Byte> predicate) {575		return byteMatches(predicate, "<byte matching the given predicate>");576	}577	/**578	 * A predicate-based matcher for primitive byte arguments579	 * 580	 * @param predicate581	 *            A lambda to evaluate a method argument582	 * @param description583	 *            Description of expected argument - will appear in verify()584	 *            failures585	 * @return 0586	 */587	default byte byteMatches(Predicate<Byte> predicate, final String description) {588		return byteThat(new ArgumentMatcher<Byte>() {589			/*590			 * (non-Javadoc)591			 * 592			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)593			 */594			@Override595			public boolean matches(Byte argument) {596				return null != argument && predicate.test(argument.byteValue());597			}598			/*599			 * (non-Javadoc)600			 * 601			 * @see java.lang.Object#toString()602			 */603			@Override604			public String toString() {605				return description;606			}607		});608	}609	/**610	 * A predicate-based matcher for primitive char arguments611	 * 612	 * @param predicate613	 *            A lambda to evaluate a method argument614	 * @return 0615	 */616	default char charMatches(Predicate<Character> predicate) {617		return charMatches(predicate, "<char matching the given predicate>");618	}619	620	/**621	 * A predicate-based matcher for primitive char arguments622	 * 623	 * @param predicate624	 *            A lambda to evaluate a method argument625	 * @param description626	 *            Description of expected argument - will appear in verify()627	 *            failures628	 * @return 0629	 */630	default char charMatches(Predicate<Character> predicate, final String description) {631		return charThat(new ArgumentMatcher<Character>() {632			/* (non-Javadoc)633			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)634			 */635			@Override636			public boolean matches(Character argument) {637				return null != argument && predicate.test(argument);638			}639			/* (non-Javadoc)640			 * @see java.lang.Object#toString()641			 */642			@Override643			public String toString() {644				return description;645			}646		});647	}648	/**649	 * Match based on exact toString() of the argument650	 * 651	 * @param expectedToString652	 * @return null653	 */654	default <T> T hasToString(String expectedToString) {655		// return argThat((argument) -> null != argument &&656		// argument.toString().equals(expectedToString));657		return argThat(new ArgumentMatcher<T>() {658			/*659			 * (non-Javadoc)660			 * 661			 * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)662			 */663			@Override664			public boolean matches(T argument) {665				return null != argument && argument.toString().equals(expectedToString);666			}667			/*668			 * (non-Javadoc)669			 * 670			 * @see java.lang.Object#toString()671			 */672			@Override673			public String toString() {674				return "{" + expectedToString + "}";675			}676		});677	}678}...

Source:MatchersMixin.java

...280    default long longThat(ArgumentMatcher<Long> matcher) {281        return ArgumentMatchers.longThat(matcher);282    }283    /**284     * Delegate call to public static java.lang.String org.mockito.ArgumentMatchers.matches(java.util.regex.Pattern)285     * {@link org.mockito.ArgumentMatchers#matches(java.util.regex.Pattern)}286     */287    default String matches(Pattern pattern) {288        return ArgumentMatchers.matches(pattern);289    }290    /**291     * Delegate call to public static java.lang.String org.mockito.ArgumentMatchers.matches(java.lang.String)292     * {@link org.mockito.ArgumentMatchers#matches(java.lang.String)}293     */294    default String matches(String regex) {295        return ArgumentMatchers.matches(regex);296    }297    /**298     * Delegate call to public static <T> T org.mockito.ArgumentMatchers.notNull()299     * {@link org.mockito.ArgumentMatchers#notNull()}300     */301    default <T> T notNull() {302        return ArgumentMatchers.notNull();303    }304    /**305     * Delegate call to public static <T> T org.mockito.ArgumentMatchers.nullable(java.lang.Class<T>)306     * {@link org.mockito.ArgumentMatchers#nullable(java.lang.Class)}307     */308    default <T> T nullable(Class<T> clazz) {309        return ArgumentMatchers.nullable(clazz);...

Source:MockitoMatchersTest.java

...101	}102	@Test103	public void testContainsCaseInsensitive() {104		ArgumentMatcher<String> matcher = MockitoMatchers.containsCaseInsensitive("tst");105		assertFalse(matcher.matches(null));106		assertFalse(matcher.matches(""));107		assertFalse(matcher.matches("?"));108		assertFalse(matcher.matches("t"));109		assertFalse(matcher.matches("s"));110		assertTrue(matcher.matches("teststring"));111		assertTrue(matcher.matches("tst"));112		assertTrue(matcher.matches("teststring".toUpperCase()));113		assertTrue(matcher.matches("eTstRIng"));114		assertTrue(matcher.matches("TestStr"));115		matcher = MockitoMatchers.containsCaseInsensitive("TST");116		assertFalse(matcher.matches("t"));117		assertFalse(matcher.matches("s"));118		assertTrue(matcher.matches("teststring"));119		assertTrue(matcher.matches("tst"));120		assertTrue(matcher.matches("teststring".toUpperCase()));121		assertTrue(matcher.matches("eTstRIng"));122		assertTrue(matcher.matches("TestStr"));123	}124	@Test125	public void testEqCaseInsensitive() {126		assertFalse(MockitoMatchers.eqCaseInsensitive("teststring").matches("teststr"));127		assertFalse(MockitoMatchers.eqCaseInsensitive("teststring").matches("eststring"));128		assertFalse(MockitoMatchers.eqCaseInsensitive("teststring").matches(" teststring"));129		assertTrue(MockitoMatchers.eqCaseInsensitive("teststring").matches("teststring"));130		assertTrue(MockitoMatchers.eqCaseInsensitive("teststring").matches("teststring".toUpperCase()));131		assertTrue(MockitoMatchers.eqCaseInsensitive("teststring".toUpperCase()).matches("teststring"));132		assertTrue(MockitoMatchers.eqCaseInsensitive("teststring").matches("tesTString"));133		assertTrue(MockitoMatchers.eqCaseInsensitive("tesTString").matches("teststring"));134	}135	@Test136	public void testNullValueArrayWorking() {137		ObjectArrayMethod method = Mockito.mock(ObjectArrayMethod.class);138		Mockito.when(method.call(ArgumentMatchers.<Object>any())).thenReturn(15);139		Object[] arg = new Object[] { null, null };140		int actual = method.call(arg);141		assertEquals(15, actual);142	}143	@Test144	public void testNullValueArrayEq() {145		ObjectArrayMethod method = Mockito.mock(ObjectArrayMethod.class);146		Object[] arg = { "", 1 };147		Mockito.when(method.call(ArgumentMatchers.<Object>any())).thenReturn(15);148		int actual = method.call(arg);149		assertEquals(15, actual);150	}151	@Test152	public void testVerifyNullValueArrayEq() {153		ObjectArrayMethod method = Mockito.mock(ObjectArrayMethod.class);154		Object[] arg = { "", "" };155		method.call(arg);156		verify(method).call(ArgumentMatchers.<String>any());157		verify(method).call(ArgumentMatchers.<Object>any());158	}159	@Test160	public void testObjectArrayMockitoMatchers() {161		ObjectArrayMethod method = Mockito.mock(ObjectArrayMethod.class);162		Object[] arg = new Object[] { "", "" };163		Mockito.when(method.call(ArgumentMatchers.<Object>any())).thenReturn(10);164		int actual = method.call(arg);165		verify(method).call(arg);166		assertEquals(10, actual);167		arg = new Object[] { "", 1 };168		Mockito.when(method.call(ArgumentMatchers.<Object>any())).thenReturn(12);169		actual = method.call(arg);170		verify(method).call(arg);171		assertEquals(12, actual);172		Mockito.when(method.call(ArgumentMatchers.<Object>any())).thenReturn(15);173		arg = new Object[] { "", Long.valueOf(2), new Date() };174		actual = method.call(arg);175		verify(method).call(arg);176		assertEquals(15, actual);177	}178	@Test179	public void testObjectArray() {180		ArgumentMatcher<Object[]> allObjectArraysMatcher = MockitoMatchers.objectArray((Object[]) null);181		assertTrue("null Array", allObjectArraysMatcher.matches(null));182		assertTrue("Empty Array", allObjectArraysMatcher.matches(new Object[0]));183		assertTrue("Two Objects Array null values", allObjectArraysMatcher.matches(new Object[2]));184		assertTrue("Two Objects Array String and int values", allObjectArraysMatcher.matches(new Object[] { "1", 1 }));185	}186	static class ObjectArrayMethod {187		public int call(Object... objects) {188			return 0;189		}190	}191	public interface StringArg {192		String exec(String arg);193	}194}...

matches

Using AI Code Generation

1import org.mockito.ArgumentMatcher;2import org.mockito.Mockito;3import org.mockito.invocation.InvocationOnMock;4import org.mockito.stubbing.Answer;5import org.mockito.stubbing.OngoingStubbing;6import org.mockito.stubbing.Stubber;7import org.mockito.verification.VerificationMode;8import org.mockito.verification.VerificationWithTimeout;9import org.mockito.verification.VerificationWithoutOrder;10import org.mockito.verification.VerificationWrapper;11import java.util.List;12import static org.mockito.Mockito.*;13public class MockitoTest {14    public static void main(String[] args) {15        List mockedList = mock(List.class);16        mockedList.add("one");17        mockedList.clear();18        verify(mockedList).add("one");19        verify(mockedList, times(1)).add("one");20        verify(mockedList, never()).add("two");21        verify(mockedList, atLeastOnce()).add("one");22        verify(mockedList, atLeastOnce()).add("two");23        verify(mockedList, atLeastOnce()).add("three");24        verify(mockedList, atLeast(2)).add("one");25        verify(mockedList, atMost(5)).add("one");26        when(mockedList.get(anyInt())).thenReturn("element");27        when(mockedList.contains(argThat(isValid()))).thenReturn(true);28        System.out.println(mockedList.get(999));29        verify(mockedList).get(anyInt());30        verify(mockedList).add(argThat(someString -> someString.length() > 5));31        when(mockedList.get(0)).thenReturn("one", "two");32        System.out.println(mockedList.get(0));33        System.out.println(mockedList.get(0));

matches

Using AI Code Generation

1import org.mockito.ArgumentMatcher;2import org.mockito.Mock;3import org.mockito.MockitoAnnotations;4import org.mockito.Spy;5import org.mockito.internal.matchers.Equals;6import org.mockito.invocation.InvocationOnMock;7import org.mockito.stubbing.Answer;8import org.mockito.stubbing.Stubber;9import org.testng.annotations.BeforeMethod;10import org.testng.annotations.Test;11import static org.mockito.Matchers.any;12import static org.mockito.Matchers.argThat;13import static org.mockito.Mockito.doAnswer;14import static org.mockito.Mockito.doCallRealMethod;15import static org.mockito.Mockito.doNothing;16import static org.mockito.Mockito.doReturn;17import static org.mockito.Mockito.doThrow;18import static org.mockito.Mockito.spy;19import static org.mockito.Mockito.when;20import static org.testng.Assert.assertEquals;21import static org.testng.Assert.assertTrue;22public class Test1 {23    private Class1 class1;24    private Class1 class1Spy;25    public void setUp() {26        MockitoAnnotations.initMocks(this);27    }28    public void test1() {29        when(class1.method1(any(String.class))).thenReturn("test");30        String result = class1.method1("test");31        assertEquals(result, "test");32    }33    public void test2() {34        when(class1.method1(argThat(new ArgumentMatcher<String>() {35            public boolean matches(Object argument) {36                return "test".equals(argument);37            }38        }))).thenReturn("test");39        String result = class1.method1("test");40        assertEquals(result, "test");41    }42    public void test3() {43        doReturn("test").when(class1Spy).method1(any(String.class));44        String result = class1Spy.method1("test");45        assertEquals(result, "test");46    }47    public void test4() {48        doReturn("test").when(class1Spy).method1(argThat(new ArgumentMatcher<String>() {49            public boolean matches(Object argument) {50                return "test".equals(argument);51            }52        }));53        String result = class1Spy.method1("test");54        assertEquals(result, "test");55    }56    public void test5() {57        when(class1.method1(any(String.class))).thenAnswer(new Answer<String>() {58            public String answer(InvocationOnMock invocation) throws Throwable {59                return "test";

matches

Using AI Code Generation

1import org.mockito.ArgumentMatcher;2public class MyMatcher implements ArgumentMatcher<String> {3    public boolean matches(String s) {4        return s.matches("Hello");5    }6}7import static org.mockito.ArgumentMatchers.any;8public class MyMatcher implements ArgumentMatcher<String> {9    public boolean matches(String s) {10        return any(String.class).matches("Hello");11    }12}13import static org.mockito.ArgumentMatchers.anyString;14public class MyMatcher implements ArgumentMatcher<String> {15    public boolean matches(String s) {16        return anyString().matches("Hello");17    }18}19import static org.mockito.ArgumentMatchers.eq;20public class MyMatcher implements ArgumentMatcher<String> {21    public boolean matches(String s) {22        return eq("Hello").matches("Hello");23    }24}25import static org.mockito.ArgumentMatchers.startsWith;26public class MyMatcher implements ArgumentMatcher<String> {27    public boolean matches(String s) {28        return startsWith("Hello").matches("Hello");29    }30}31import static org.mockito.ArgumentMatchers.endsWith;32public class MyMatcher implements ArgumentMatcher<String> {33    public boolean matches(String s) {34        return endsWith("Hello").matches("Hello");35    }36}37import static org.mockito.ArgumentMatchers.contains;38public class MyMatcher implements ArgumentMatcher<String> {39    public boolean matches(String s) {40        return contains("Hello").matches("Hello");41    }42}43import static org.mockito.ArgumentMatchers.matches;44public class MyMatcher implements ArgumentMatcher<String> {45    public boolean matches(String s) {46        return matches("Hello").matches("Hello");47    }48}

matches

Using AI Code Generation

1import org.mockito.ArgumentMatcher;2import org.mockito.Mockito;3import org.mockito.ArgumentCaptor;4import java.util.List;5import java.util.ArrayList;6import java.util.Arrays;7public class 1 {8    public static void main(String[] args) {9        List<String> mockedList = Mockito.mock(List.class);10        mockedList.add("one");11        mockedList.add("two");12        mockedList.add("three");13        mockedList.add("four");14        mockedList.add("five");15        ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);16        Mockito.verify(mockedList, Mockito.times(5)).add(argument.capture());17        List<String> capturedArguments = argument.getAllValues();18        System.out.println(capturedArguments);19    }20}

matches

Using AI Code Generation

1import org.mockito.ArgumentMatcher;2import org.mockito.Mockito;3import static org.mockito.Mockito.when;4public class 1 {5    public static void main(String[] args) {6        List mockedList = Mockito.mock(List.class);7        when(mockedList.get(Mockito.anyInt())).thenReturn("element");8        when(mockedList.contains(Mockito.argThat(new IsValid()))).thenReturn(true);9        System.out.println(mockedList.get(999));10        Mockito.verify(mockedList).get(Mockito.anyInt());11        when(mockedList.contains(Mockito.argThat(s -> s.length() > 5))).thenReturn(true);12    }13}14class IsValid extends ArgumentMatcher<List> {15    public boolean matches(Object list) {16        return list.size() > 10;17    }18}19import org.mockito.ArgumentMatcher;20import org.mockito.Mockito;21import static org.mockito.Mockito.when;22public class 2 {23    public static void main(String[] args) {24        List mockedList = Mockito.mock(List.class);25        when(mockedList.get(Mockito.anyInt())).thenReturn("element");26        when(mockedList.contains(Mockito.argThat(new IsValid()))).thenReturn(true);27        System.out.println(mockedList.get(999));28        Mockito.verify(mockedList).get(Mockito.anyInt());29        when(mockedList.contains(Mockito.argThat(s -> s.length() > 5))).thenReturn(true);30    }31}32class IsValid extends ArgumentMatcher<List> {33    public boolean matches(Object list) {34        return list.size() > 10;35    }36}

matches

Using AI Code Generation

1import org.mockito.ArgumentMatcher;2public class MyMatcher implements ArgumentMatcher {3    public boolean matches(Object o) {4        return o instanceof String && ((String) o).matches(".*\\d.*");5    }6}7import org.junit.Test;8import org.junit.runner.RunWith;9import org.mockito.ArgumentMatcher;10import org.mockito.Mock;11import org.mockito.runners.MockitoJUnitRunner;12import java.util.List;13import static org.mockito.Matchers.argThat;14import static org.mockito.Mockito.verify;15@RunWith(MockitoJUnitRunner.class)16public class ArgumentMatcherTest {17    private List mockedList;18    public void shouldCheckIfArgumentMatches() {19        mockedList.add("one");20        verify(mockedList).add(argThat(new MyMatcher()));21        mockedList.clear();22        verify(mockedList).clear();23    }24}25org.mockito.exceptions.verification.junit.ArgumentsAreDifferent: Argument(s) are different! Wanted:26mockedList.add(27);28-> at ArgumentMatcherTest.shouldCheckIfArgumentMatches(ArgumentMatcherTest.java:19)29mockedList.add(30);31-> at ArgumentMatcherTest.shouldCheckIfArgumentMatches(ArgumentMatcherTest.java:19)32org.mockito.exceptions.verification.junit.ArgumentsAreDifferent: Argument(s) are different! Wanted:33mockedList.clear();34-> at ArgumentMatcherTest.shouldCheckIfArgumentMatches(ArgumentMatcherTest.java:23)35mockedList.clear();36-> at ArgumentMatcherTest.shouldCheckIfArgumentMatches(ArgumentMatcherTest.java:23)37ArgumentCaptor.capture()38ArgumentMatcher.matches()39ArgumentMatchers.any()40ArgumentMatchers.anyBoolean()41ArgumentMatchers.anyByte()42ArgumentMatchers.anyCollection()43ArgumentMatchers.anyDouble()44ArgumentMatchers.anyFloat()45ArgumentMatchers.anyInt()46ArgumentMatchers.anyList()47ArgumentMatchers.anyLong()48ArgumentMatchers.anyMap()49ArgumentMatchers.anySet()50ArgumentMatchers.anyShort()51ArgumentMatchers.anyString()52ArgumentMatchers.anyVararg()53ArgumentMatchers.argThat()54ArgumentMatchers.contains()55ArgumentMatchers.endsWith()56ArgumentMatchers.eq()57ArgumentMatchers.isA()58ArgumentMatchers.isNull()59ArgumentMatchers.isNotNull()60ArgumentMatchers.matches()61ArgumentMatchers.notNull()62ArgumentMatchers.refEq()63ArgumentMatchers.startsWith()64ArgumentMatchers.same()65ArgumentMatchers.varargThat()66ArgumentMatchers.varargThat()67ArgumentMatchers.varargThat()68ArgumentMatchers.varargThat()

matches

Using AI Code Generation

1package org.mockito;2import org.mockito.ArgumentMatcher;3import org.mockito.Matchers;4public class ArgumentMatcherExample {5    public static void main(String[] args) {6        ArgumentMatcher<String> matcher = new ArgumentMatcher<String>() {7            public boolean matches(Object argument) {8                return argument != null && argument.toString().startsWith("ab");9            }10        };11        System.out.println(matcher.matches("abc"));12        System.out.println(matcher.matches("bcd"));13    }14}

matches

Using AI Code Generation

1package com.automationrhapsody.junit;2import static org.mockito.Matchers.*;3import static org.mockito.Mockito.*;4import org.junit.Test;5import org.mockito.ArgumentMatcher;6import org.mockito.Mockito;7public class MockitoMatchesMethod {8   public void testMatchesMethod() {9      MyInterface myInterface = Mockito.mock(MyInterface.class);10      when(myInterface.doSomething(anyString(), anyInt())).thenReturn("Hello");11      myInterface.doSomething("Hello", 123);12      verify(myInterface).doSomething(matches("Hello"), anyInt());13   }14}15package com.automationrhapsody.junit;16public interface MyInterface {17   public String doSomething(String str, int i);18}19package com.automationrhapsody.junit;20import static org.mockito.Matchers.*;21import static org.mockito.Mockito.*;22import org.junit.Test;23import org.mockito.ArgumentMatcher;24import org.mockito.Mockito;25public class MockitoMatchesMethod {26   public void testMatchesMethod() {27      MyInterface myInterface = Mockito.mock(MyInterface.class);28      when(myInterface.doSomething(anyString(), anyInt())).thenReturn("Hello");29      myInterface.doSomething("Hello", 123);30      verify(myInterface).doSomething(matches("Hello"), anyInt());31   }32}33package com.automationrhapsody.junit;34public class MyArgumentMatcher extends ArgumentMatcher<String> {35   public boolean matches(Object obj) {36      return obj.equals("Hello");37   }38}39package com.automationrhapsody.junit;40import static org.mockito.Matchers.*;41import static org.mockito.Mockito.*;42import org.junit.Test;43import org.mockito.ArgumentMatcher;

matches

Using AI Code Generation

1public class MyArgumentMatcher implements ArgumentMatcher {2    public boolean matches(Object o) {3        return o instanceof Integer && (Integer)o == 3;4    }5}6public class MyArgumentMatcher implements ArgumentMatcher {7    public boolean matches(Object o) {8        return o instanceof Integer && (Integer)o == 3;9    }10}11public class MyArgumentMatcher implements ArgumentMatcher {12    public boolean matches(Object o) {13        return o instanceof Integer && (Integer)o == 3;14    }15}16package com.journaldev.mockito;17import static org.mockito.Mockito.*;18import org.mockito.ArgumentMatcher;19import org.junit.Test;20public class MockitoArgumentMatcherTest {21    public void testArgumentMatcher() {22        MyArgumentMatcher myMatcher = new MyArgumentMatcher();23        List mockedList = mock(List.class);24        when(mockedList.get(myMatcher)).thenReturn("3");25        System.out.println(mockedList.get(3));26    }27}

matches

Using AI Code Generation

1import org.mockito.ArgumentMatcher;2public class MyMatcher extends ArgumentMatcher {3    public boolean matches(Object obj) {4        return obj.equals("Hello");5    }6}7import static org.mockito.Mockito.*;8import org.mockito.ArgumentMatcher;9public class Test {10    public static void main(String[] args) {11        Foo foo = mock(Foo.class);12        when(foo.doSomething(argThat(new MyMatcher()))).thenReturn("Hello");13        System.out.println(foo.doSomething("Hello"));14    }15}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.