diff options
Diffstat (limited to 'src/main/java/org/junit/matchers')
| -rw-r--r-- | src/main/java/org/junit/matchers/JUnitMatchers.java | 166 |
1 files changed, 98 insertions, 68 deletions
diff --git a/src/main/java/org/junit/matchers/JUnitMatchers.java b/src/main/java/org/junit/matchers/JUnitMatchers.java index 837ed33..13407cc 100644 --- a/src/main/java/org/junit/matchers/JUnitMatchers.java +++ b/src/main/java/org/junit/matchers/JUnitMatchers.java @@ -1,83 +1,113 @@ package org.junit.matchers; +import org.hamcrest.CoreMatchers; import org.hamcrest.Matcher; -import org.junit.internal.matchers.CombinableMatcher; -import org.junit.internal.matchers.Each; -import org.junit.internal.matchers.IsCollectionContaining; -import org.junit.internal.matchers.StringContains; +import org.hamcrest.core.CombinableMatcher.CombinableBothMatcher; +import org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher; +import org.junit.internal.matchers.StacktracePrintingMatcher; /** * Convenience import class: these are useful matchers for use with the assertThat method, but they are * not currently included in the basic CoreMatchers class from hamcrest. + * + * @since 4.4 */ public class JUnitMatchers { - /** - * @param element - * @return A matcher matching any collection containing element - */ - public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItem(T element) { - return IsCollectionContaining.hasItem(element); - } + /** + * @return A matcher matching any collection containing element + * @deprecated Please use {@link CoreMatchers#hasItem(Object)} instead. + */ + @Deprecated + public static <T> Matcher<Iterable<? super T>> hasItem(T element) { + return CoreMatchers.hasItem(element); + } - /** - * @param elementMatcher - * @return A matcher matching any collection containing an element matching elementMatcher - */ - public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItem(org.hamcrest.Matcher<? extends T> elementMatcher) { - return IsCollectionContaining.<T>hasItem(elementMatcher); - } + /** + * @return A matcher matching any collection containing an element matching elementMatcher + * @deprecated Please use {@link CoreMatchers#hasItem(Matcher)} instead. + */ + @Deprecated + public static <T> Matcher<Iterable<? super T>> hasItem(Matcher<? super T> elementMatcher) { + return CoreMatchers.<T>hasItem(elementMatcher); + } - /** - * @param elements - * @return A matcher matching any collection containing every element in elements - */ - public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(T... elements) { - return IsCollectionContaining.hasItems(elements); - } + /** + * @return A matcher matching any collection containing every element in elements + * @deprecated Please use {@link CoreMatchers#hasItems(Object...)} instead. + */ + @Deprecated + public static <T> Matcher<Iterable<T>> hasItems(T... elements) { + return CoreMatchers.hasItems(elements); + } - /** - * @param elementMatchers - * @return A matcher matching any collection containing at least one element that matches - * each matcher in elementMatcher (this may be one element matching all matchers, - * or different elements matching each matcher) - */ - public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(org.hamcrest.Matcher<? extends T>... elementMatchers) { - return IsCollectionContaining.<T>hasItems(elementMatchers); - } + /** + * @return A matcher matching any collection containing at least one element that matches + * each matcher in elementMatcher (this may be one element matching all matchers, + * or different elements matching each matcher) + * @deprecated Please use {@link CoreMatchers#hasItems(Matcher...)} instead. + */ + @Deprecated + public static <T> Matcher<Iterable<T>> hasItems(Matcher<? super T>... elementMatchers) { + return CoreMatchers.hasItems(elementMatchers); + } - /** - * @param elementMatcher - * @return A matcher matching any collection in which every element matches elementMatcher - */ - public static <T> Matcher<Iterable<T>> everyItem(final Matcher<T> elementMatcher) { - return Each.each(elementMatcher); - } + /** + * @return A matcher matching any collection in which every element matches elementMatcher + * @deprecated Please use {@link CoreMatchers#everyItem(Matcher)} instead. + */ + @Deprecated + public static <T> Matcher<Iterable<T>> everyItem(final Matcher<T> elementMatcher) { + return CoreMatchers.everyItem(elementMatcher); + } - /** - * @param substring - * @return a matcher matching any string that contains substring - */ - public static org.hamcrest.Matcher<java.lang.String> containsString(java.lang.String substring) { - return StringContains.containsString(substring); - } - - /** - * This is useful for fluently combining matchers that must both pass. For example: - * <pre> - * assertThat(string, both(containsString("a")).and(containsString("b"))); - * </pre> - */ - public static <T> CombinableMatcher<T> both(Matcher<T> matcher) { - return new CombinableMatcher<T>(matcher); - } - - /** - * This is useful for fluently combining matchers where either may pass, for example: - * <pre> - * assertThat(string, either(containsString("a")).or(containsString("b"))); - * </pre> - */ - public static <T> CombinableMatcher<T> either(Matcher<T> matcher) { - return new CombinableMatcher<T>(matcher); - } + /** + * @return a matcher matching any string that contains substring + * @deprecated Please use {@link CoreMatchers#containsString(String)} instead. + */ + @Deprecated + public static Matcher<java.lang.String> containsString(java.lang.String substring) { + return CoreMatchers.containsString(substring); + } + + /** + * This is useful for fluently combining matchers that must both pass. For example: + * <pre> + * assertThat(string, both(containsString("a")).and(containsString("b"))); + * </pre> + * + * @deprecated Please use {@link CoreMatchers#both(Matcher)} instead. + */ + @Deprecated + public static <T> CombinableBothMatcher<T> both(Matcher<? super T> matcher) { + return CoreMatchers.both(matcher); + } + + /** + * This is useful for fluently combining matchers where either may pass, for example: + * <pre> + * assertThat(string, either(containsString("a")).or(containsString("b"))); + * </pre> + * + * @deprecated Please use {@link CoreMatchers#either(Matcher)} instead. + */ + @Deprecated + public static <T> CombinableEitherMatcher<T> either(Matcher<? super T> matcher) { + return CoreMatchers.either(matcher); + } + + /** + * @return A matcher that delegates to throwableMatcher and in addition + * appends the stacktrace of the actual Throwable in case of a mismatch. + */ + public static <T extends Throwable> Matcher<T> isThrowable(Matcher<T> throwableMatcher) { + return StacktracePrintingMatcher.isThrowable(throwableMatcher); + } + + /** + * @return A matcher that delegates to exceptionMatcher and in addition + * appends the stacktrace of the actual Exception in case of a mismatch. + */ + public static <T extends Exception> Matcher<T> isException(Matcher<T> exceptionMatcher) { + return StacktracePrintingMatcher.isException(exceptionMatcher); + } } |