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 }