diff options
author | Paul Duffin <paulduffin@google.com> | 2016-12-14 12:42:07 +0000 |
---|---|---|
committer | Paul Duffin <paulduffin@google.com> | 2016-12-20 15:52:52 +0000 |
commit | 86f323b2a73c9c250fbe25b828435aa936704ab3 (patch) | |
tree | 5e35bd76d6575654fdba8c7d6d64c11e55327755 /src/main/java/org/junit/matchers/JUnitMatchers.java | |
parent | 4156f43b51c6f2d42df6e45535e1967aa46514d3 (diff) | |
download | junit-86f323b2a73c9c250fbe25b828435aa936704ab3.tar.gz |
Revert matchers back to 4.10 to compile against Hamcrest 1.1
JUnit 4.12 is supposed to be built against Hamcrest 1.3 or above
but external/hamcrest is still at 1.1. This reverts affected
files back to their 4.10 version so that they will compile
against Hamcrest 1.1 for now.
Bug: 33613916
Test: make checkbuild
Change-Id: Ie3c15047aa5a942ed0987c31c345725bef4db3d4
Diffstat (limited to 'src/main/java/org/junit/matchers/JUnitMatchers.java')
-rw-r--r-- | src/main/java/org/junit/matchers/JUnitMatchers.java | 166 |
1 files changed, 68 insertions, 98 deletions
diff --git a/src/main/java/org/junit/matchers/JUnitMatchers.java b/src/main/java/org/junit/matchers/JUnitMatchers.java index 13407cc..01b8489 100644 --- a/src/main/java/org/junit/matchers/JUnitMatchers.java +++ b/src/main/java/org/junit/matchers/JUnitMatchers.java @@ -1,113 +1,83 @@ package org.junit.matchers; -import org.hamcrest.CoreMatchers; import org.hamcrest.Matcher; -import org.hamcrest.core.CombinableMatcher.CombinableBothMatcher; -import org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher; -import org.junit.internal.matchers.StacktracePrintingMatcher; +import org.junit.internal.matchers.CombinableMatcher; +import org.junit.internal.matchers.Each; +import org.junit.internal.matchers.IsCollectionContaining; +import org.junit.internal.matchers.StringContains; /** * 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 { - /** - * @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 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 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 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.hasItem(elementMatcher); + } - /** - * @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 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 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 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.hasItems(elementMatchers); + } - /** - * @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 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 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); - } + /** + * @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); + } } |