com.github.aro_tech.extended_mockito.ExtendedMatchers Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of extended-mockito Show documentation
Jar with Mockito as a mixin interface, plus extra features
There is a newer version: 4.4.0.1
/**
 * 
 */
package com.github.aro_tech.extended_mockito;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Stream;

import com.github.aro_tech.extended_mockito.util.StringUtil;

/**
 * @author aro_tech
 *
 */
public interface ExtendedMatchers extends MatchersMixin {

	/**
	 * A matcher call which matches if an argument contains all the given text
	 * 
	 * @param expectedParts
	 * @return true if all the expected parts match
	 */
	default String containsAllOf(final CharSequence... expectedParts) {
		return argThat((argument) -> StringUtil.containsAll(argument, expectedParts));
	}

	/**
	 * A matcher call which matches if an argument's toString() result contains
	 * all of the given text
	 * 
	 * @param expectedParts
	 * @return true if all of the expected parts match, false if one does not
	 *         match
	 */
	default  T toStringContainsAllOf(final CharSequence... expectedParts) {
		return argThat((argument) -> StringUtil.containsAll(argument, expectedParts));
	}

	/**
	 * A matcher call which matches if an argument contains at least one of the
	 * given text parts
	 * 
	 * @param expectedParts
	 * @return true if any of the expected parts match, false if none match
	 */
	default String containsOneOrMoreOf(final CharSequence... expectedParts) {
		return argThat((argument) -> StringUtil.containsOneOrMoreOf(argument, expectedParts));
	}

	/**
	 * A matcher call which matches if an argument's toString() result contains
	 * at least one of the given text
	 * 
	 * @param expectedParts
	 * @return true if any of the expected parts match, false if none match
	 */
	default  T toStringContainsOneOrMoreOf(final CharSequence... expectedParts) {
		return argThat((argument) -> StringUtil.containsOneOrMoreOf(argument, expectedParts));
	}

	/**
	 * A predicate-based matcher for list arguments - all items must match
	 * 
	 * @param predicate
	 * @return null
	 */
	default  List allListItemsMatch(Predicate predicate) {
		return argThat(new ListMatcher() {
			@Override
			protected boolean evaluateStream(Stream stream) {
				return stream.allMatch(predicate);
			}
		});
	}

	/**
	 * A predicate-based matcher for list arguments - at least one item must
	 * match
	 * 
	 * @param predicate
	 *            A lambda to evaluate a method argument
	 * @return null
	 */
	default  List oneOrMoreListItemsMatch(Predicate predicate) {
		return argThat(new ListMatcher() {
			@Override
			protected boolean evaluateStream(Stream stream) {
				return stream.anyMatch(predicate);
			}
		});
	}
	

	/**
	 * Lenient-order list matcher For a match, the list argument encountered by
	 * the mock must contain exactly the items provided (no more, no fewer), but
	 * any order is acceptable
	 * 
	 * @param items
	 *            List of exact items expected (in any order)
	 * @return null
	 */
	default  List listContainsExactlyInAnyOrder(T... items) {
		return argThat(new LenientOrderListMatcher<>(items));
	}

	/**
	 * Matcher for a map argument
	 * 
	 * @param predicate
	 *            lambda for assessing the map argument
	 * @return null
	 */
	default  Map mapThat(Predicate> predicate) {
		return argThat(map -> predicate.test((Map) map));
	}

	/**
	 * A predicate-based matcher for set arguments - all items must match
	 * 
	 * @param predicate
	 * @return null
	 */
	default  Set allSetItemsMatch(Predicate predicate) {
		return argThat(arg -> ((Set) arg).stream().allMatch(predicate));
	}

	/**
	 * A predicate-based matcher for set arguments - at least one of the items
	 * must match
	 * 
	 * @param predicate
	 * @return null
	 */
	default  Set oneOrMoreSetItemsMatch(Predicate predicate) {
		return argThat(arg -> ((Set) arg).stream().anyMatch(predicate));
	}

	/**
	 * A predicate-based matcher for object arguments
	 * 
	 * Effectively, it's equivalent to argThat(), but objectMatches can accept a
	 * Predicate instance which can be reused in a variable outside of Mockito,
	 * whereas argThat can accept as its argument a lambda, but not a Predicate.
	 * 
	 * DO NOT USE THIS FOR PRIMITIVE ARGUMENTS such as int, double, etc.
	 * 
	 * Use intMatches, doubleMatches, etc. instead, because Mockito doesn't
	 * always handle autoboxing well
	 * 
	 * @param predicate
	 *            A lambda to evaluate a method argument
	 * @return null
	 */
	default  T objectMatches(Predicate predicate) {
		return argThat((argument) -> predicate.test((T) argument));
	}

	/**
	 * A predicate-based matcher for primitive int arguments
	 * 
	 * @param predicate
	 *            A lambda to evaluate a method argument
	 * @return 0
	 */
	default int intMatches(Predicate predicate) {
		return intThat((argument) -> predicate.test((int) argument));
	}

	/**
	 * A predicate-based matcher for primitive double arguments
	 * 
	 * @param predicate
	 *            A lambda to evaluate a method argument
	 * @return 0
	 */
	default double doubleMatches(Predicate predicate) {
		return doubleThat((argument) -> predicate.test((double) argument));
	}

	/**
	 * A predicate-based matcher for primitive float arguments
	 * 
	 * @param predicate
	 *            A lambda to evaluate a method argument
	 * @return 0
	 */
	default float floatMatches(Predicate predicate) {
		return floatThat((argument) -> predicate.test((float) argument));
	}

	/**
	 * A predicate-based matcher for primitive short arguments
	 * 
	 * @param predicate
	 *            A lambda to evaluate a method argument
	 * @return 0
	 */
	default short shortMatches(Predicate predicate) {
		return shortThat((argument) -> predicate.test((short) argument));
	}

	/**
	 * A predicate-based matcher for primitive long arguments
	 * 
	 * @param predicate
	 *            A lambda to evaluate a method argument
	 * @return 0
	 */
	default long longMatches(Predicate predicate) {
		return longThat((argument) -> predicate.test((long) argument));
	}

	/**
	 * A predicate-based matcher for primitive byte arguments
	 * 
	 * @param predicate
	 *            A lambda to evaluate a method argument
	 * @return 0
	 */
	default byte byteMatches(Predicate predicate) {
		return byteThat((argument) -> predicate.test((byte) argument));
	}

	/**
	 * A predicate-based matcher for primitive char arguments
	 * 
	 * @param predicate
	 *            A lambda to evaluate a method argument
	 * @return 0
	 */
	default char charMatches(Predicate predicate) {
		return charThat((argument) -> predicate.test((char) argument));
	}

	/**
	 * Match based on exact toString() of the argument
	 * 
	 * @param expectedToString
	 * @return null
	 */
	default  T hasToString(String expectedToString) {
		return argThat((argument) -> null != argument && argument.toString().equals(expectedToString));
	}

}