    001    package org.junit.matchers;
    002
    003    import org.hamcrest.CoreMatchers;
    004    import org.hamcrest.Matcher;
    005    import org.hamcrest.core.CombinableMatcher.CombinableBothMatcher;
    006    import org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher;
    007    import org.junit.internal.matchers.StacktracePrintingMatcher;
    008
    009    /**
    010     * Convenience import class: these are useful matchers for use with the assertThat method, but they are
    011     * not currently included in the basic CoreMatchers class from hamcrest.
    012     *
    013     * @since 4.4
    014     */
    015    public class JUnitMatchers {
    016        /**
    017         * @return A matcher matching any collection containing element
    018         * @deprecated Please use {@link CoreMatchers#hasItem(Object)} instead.
    019         */
    020        @Deprecated
    021        public static <T> Matcher<Iterable<? super T>> hasItem(T element) {
    022            return CoreMatchers.hasItem(element);
    023        }
    024
    025        /**
    026         * @return A matcher matching any collection containing an element matching elementMatcher
    027         * @deprecated Please use {@link CoreMatchers#hasItem(Matcher)} instead.
    028         */
    029        @Deprecated
    030        public static <T> Matcher<Iterable<? super T>> hasItem(Matcher<? super T> elementMatcher) {
    031            return CoreMatchers.<T>hasItem(elementMatcher);
    032        }
    033
    034        /**
    035         * @return A matcher matching any collection containing every element in elements
    036         * @deprecated Please use {@link CoreMatchers#hasItems(Object...)} instead.
    037         */
    038        @Deprecated
    039        public static <T> Matcher<Iterable<T>> hasItems(T... elements) {
    040            return CoreMatchers.hasItems(elements);
    041        }
    042
    043        /**
    044         * @return A matcher matching any collection containing at least one element that matches
    045         *         each matcher in elementMatcher (this may be one element matching all matchers,
    046         *         or different elements matching each matcher)
    047         * @deprecated Please use {@link CoreMatchers#hasItems(Matcher...)} instead.
    048         */
    049        @Deprecated
    050        public static <T> Matcher<Iterable<T>> hasItems(Matcher<? super T>... elementMatchers) {
    051            return CoreMatchers.hasItems(elementMatchers);
    052        }
    053
    054        /**
    055         * @return A matcher matching any collection in which every element matches elementMatcher
    056         * @deprecated Please use {@link CoreMatchers#everyItem(Matcher)} instead.
    057         */
    058        @Deprecated
    059        public static <T> Matcher<Iterable<T>> everyItem(final Matcher<T> elementMatcher) {
    060            return CoreMatchers.everyItem(elementMatcher);
    061        }
    062
    063        /**
    064         * @return a matcher matching any string that contains substring
    065         * @deprecated Please use {@link CoreMatchers#containsString(String)} instead.
    066         */
    067        @Deprecated
    068        public static Matcher<java.lang.String> containsString(java.lang.String substring) {
    069            return CoreMatchers.containsString(substring);
    070        }
    071
    072        /**
    073         * This is useful for fluently combining matchers that must both pass.  For example:
    074         * <pre>
    075         *   assertThat(string, both(containsString("a")).and(containsString("b")));
    076         * </pre>
    077         *
    078         * @deprecated Please use {@link CoreMatchers#both(Matcher)} instead.
    079         */
    080        @Deprecated
    081        public static <T> CombinableBothMatcher<T> both(Matcher<? super T> matcher) {
    082            return CoreMatchers.both(matcher);
    083        }
    084
    085        /**
    086         * This is useful for fluently combining matchers where either may pass, for example:
    087         * <pre>
    088         *   assertThat(string, either(containsString("a")).or(containsString("b")));
    089         * </pre>
    090         *
    091         * @deprecated Please use {@link CoreMatchers#either(Matcher)} instead.
    092         */
    093        @Deprecated
    094        public static <T> CombinableEitherMatcher<T> either(Matcher<? super T> matcher) {
    095            return CoreMatchers.either(matcher);
    096        }
    097
    098        /**
    099         * @return A matcher that delegates to throwableMatcher and in addition
    100         *         appends the stacktrace of the actual Throwable in case of a mismatch.
    101         */
    102        public static <T extends Throwable> Matcher<T> isThrowable(Matcher<T> throwableMatcher) {
    103            return StacktracePrintingMatcher.isThrowable(throwableMatcher);
    104        }
    105
    106        /**
    107         * @return A matcher that delegates to exceptionMatcher and in addition
    108         *         appends the stacktrace of the actual Exception in case of a mismatch.
    109         */
    110        public static <T extends Exception> Matcher<T> isException(Matcher<T> exceptionMatcher) {
    111            return StacktracePrintingMatcher.isException(exceptionMatcher);
    112        }
    113    }