Matchers.java revision c1dbb44e71e47410ad5685aba3ef3fccb095a2b4
1f5e9a2415ec42c425c2bb17db46f2a9649992d80Brett Chabotpackage org.hamcrest; 2f5e9a2415ec42c425c2bb17db46f2a9649992d80Brett Chabot 3f5e9a2415ec42c425c2bb17db46f2a9649992d80Brett Chabotpublic class Matchers { 4f5e9a2415ec42c425c2bb17db46f2a9649992d80Brett Chabot 5c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 6c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers. 7c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 8c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre> 9c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 10c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> allOf(java.lang.Iterable<org.hamcrest.Matcher<? super T>> matchers) { 11c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AllOf.<T>allOf(matchers); 12c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 13c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 14c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 15c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers. 16c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 17c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre> 18c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 19c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T>... matchers) { 20c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AllOf.<T>allOf(matchers); 21c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 22c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 23c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 24c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers. 25c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 26c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre> 27c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 28c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second) { 29c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AllOf.<T>allOf(first, second); 30c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 31c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 32c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 33c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers. 34c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 35c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre> 36c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 37c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third) { 38c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AllOf.<T>allOf(first, second, third); 39c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 40c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 41c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 42c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers. 43c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 44c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre> 45c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 46c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth) { 47c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AllOf.<T>allOf(first, second, third, fourth); 48c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 49c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 50c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 51c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers. 52c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 53c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre> 54c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 55c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth, org.hamcrest.Matcher<? super T> fifth) { 56c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AllOf.<T>allOf(first, second, third, fourth, fifth); 57c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 58c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 59c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 60c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers. 61c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 62c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre> 63c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 64c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth, org.hamcrest.Matcher<? super T> fifth, org.hamcrest.Matcher<? super T> sixth) { 65c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AllOf.<T>allOf(first, second, third, fourth, fifth, sixth); 66c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 67c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 68c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 69c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers. 70c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 71c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre> 72c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 73c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.core.AnyOf<T> anyOf(java.lang.Iterable<org.hamcrest.Matcher<? super T>> matchers) { 74c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AnyOf.<T>anyOf(matchers); 75c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 76c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 77c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 78c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers. 79c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 80c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre> 81c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 82c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<? super T>... matchers) { 83c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AnyOf.<T>anyOf(matchers); 84c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 85c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 86c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 87c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers. 88c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 89c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre> 90c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 91c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second) { 92c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AnyOf.<T>anyOf(first, second); 93c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 94c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 95c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 96c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers. 97c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 98c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre> 99c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 100c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third) { 101c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AnyOf.<T>anyOf(first, second, third); 102c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 103c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 104c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 105c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers. 106c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 107c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre> 108c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 109c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth) { 110c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AnyOf.<T>anyOf(first, second, third, fourth); 111c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 112c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 113c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 114c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers. 115c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 116c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre> 117c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 118c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth, org.hamcrest.Matcher<? super T> fifth) { 119c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AnyOf.<T>anyOf(first, second, third, fourth, fifth); 120c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 121c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 122c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 123c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers. 124c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 125c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre> 126c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 127c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth, org.hamcrest.Matcher<? super T> fifth, org.hamcrest.Matcher<? super T> sixth) { 128c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.AnyOf.<T>anyOf(first, second, third, fourth, fifth, sixth); 129c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 130c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 131c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 132c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when both of the specified matchers match the examined object. 133c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 134c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("fab", both(containsString("a")).and(containsString("b")))</pre> 135c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 136c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <LHS> org.hamcrest.core.CombinableMatcher.CombinableBothMatcher<LHS> both(org.hamcrest.Matcher<? super LHS> matcher) { 137c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.CombinableMatcher.<LHS>both(matcher); 138c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 139c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 140c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 141c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when either of the specified matchers match the examined object. 142c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 143c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("fan", either(containsString("a")).or(containsString("b")))</pre> 144c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 145c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <LHS> org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher<LHS> either(org.hamcrest.Matcher<? super LHS> matcher) { 146c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.CombinableMatcher.<LHS>either(matcher); 147c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 148c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 149c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 150c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Wraps an existing matcher, overriding its description with that specified. All other functions are 151c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * delegated to the decorated matcher, including its mismatch description. 152c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 153c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())</pre> 154c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 155c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param description 156c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the new description for the wrapped matcher 157c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param matcher 158c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matcher to wrap 159c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param values 160c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * optional values to insert into the tokenised description 161c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 162c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> describedAs(java.lang.String description, org.hamcrest.Matcher<T> matcher, java.lang.Object... values) { 163c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.DescribedAs.<T>describedAs(description, matcher, values); 164c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 165c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 166c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 167c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that only matches when a single pass over the 168c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yields items that are all matched by the specified 169c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <code>itemMatcher</code>. 170c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 171c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre> 172c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 173c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatcher 174c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matcher to apply to every item provided by the examined {@link Iterable} 175c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 176c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <U> org.hamcrest.Matcher<java.lang.Iterable<? extends U>> everyItem(org.hamcrest.Matcher<U> itemMatcher) { 177c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.Every.<U>everyItem(itemMatcher); 178c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 179c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 180c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 181c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Decorates another Matcher, retaining its behaviour, but allowing tests 182c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * to be slightly more expressive. 183c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 184c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(equalTo(smelly)))</pre> 185c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * instead of: 186c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, equalTo(smelly))</pre> 187c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 188c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> is(org.hamcrest.Matcher<T> matcher) { 189c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.Is.<T>is(matcher); 190c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 191c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 192c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 193c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * A shortcut to the frequently used <code>is(equalTo(x))</code>. 194c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 195c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(smelly))</pre> 196c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * instead of: 197c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(equalTo(smelly)))</pre> 198c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 199c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> is(T value) { 200c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.Is.<T>is(value); 201c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 202c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 203c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 204c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * A shortcut to the frequently used <code>is(instanceOf(SomeClass.class))</code>. 205c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 206c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, isA(Cheddar.class))</pre> 207c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * instead of: 208c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(instanceOf(Cheddar.class)))</pre> 209c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 210c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> isA(java.lang.Class<T> type) { 211c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.Is.<T>isA(type); 212c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 213c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 214c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 215c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that always matches, regardless of the examined object. 216c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 217c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.Object> anything() { 218c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsAnything.anything(); 219c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 220c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 221c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 222c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that always matches, regardless of the examined object, but describes 223c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * itself with the specified {@link String}. 224c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 225c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param description 226c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a meaningful {@link String} used when describing itself 227c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 228c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.Object> anything(java.lang.String description) { 229c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsAnything.anything(description); 230c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 231c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 232c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 233c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that only matches when a single pass over the 234c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yields at least one item that is matched by the specified 235c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <code>itemMatcher</code>. Whilst matching, the traversal of the examined {@link Iterable} 236c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * will stop as soon as a matching item is found. 237c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 238c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))</pre> 239c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 240c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatcher 241c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matcher to apply to items provided by the examined {@link Iterable} 242c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 243c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<java.lang.Iterable<? super T>> hasItem(org.hamcrest.Matcher<? super T> itemMatcher) { 244c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsCollectionContaining.<T>hasItem(itemMatcher); 245c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 246c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 247c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 248c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that only matches when a single pass over the 249c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yields at least one item that is equal to the specified 250c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <code>item</code>. Whilst matching, the traversal of the examined {@link Iterable} 251c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * will stop as soon as a matching item is found. 252c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 253c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))</pre> 254c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 255c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param item 256c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the item to compare against the items provided by the examined {@link Iterable} 257c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 258c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<java.lang.Iterable<? super T>> hasItem(T item) { 259c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsCollectionContaining.<T>hasItem(item); 260c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 261c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 262c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 263c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that matches when consecutive passes over the 264c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yield at least one item that is matched by the corresponding 265c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * matcher from the specified <code>itemMatchers</code>. Whilst matching, each traversal of 266c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the examined {@link Iterable} will stop as soon as a matching item is found. 267c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 268c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))</pre> 269c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 270c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatchers 271c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matchers to apply to items provided by the examined {@link Iterable} 272c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 273c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(org.hamcrest.Matcher<? super T>... itemMatchers) { 274c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsCollectionContaining.<T>hasItems(itemMatchers); 275c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 276c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 277c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 278c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that matches when consecutive passes over the 279c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yield at least one item that is equal to the corresponding 280c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * item from the specified <code>items</code>. Whilst matching, each traversal of the 281c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} will stop as soon as a matching item is found. 282c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 283c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))</pre> 284c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 285c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param items 286c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the items to compare against the items provided by the examined {@link Iterable} 287c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 288c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(T... items) { 289c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsCollectionContaining.<T>hasItems(items); 290c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 291c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 292c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 293c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when the examined object is logically equal to the specified 294c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <code>operand</code>, as determined by calling the {@link java.lang.Object#equals} method on 295c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the <b>examined</b> object. 296c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 297c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p>If the specified operand is <code>null</code> then the created matcher will only match if 298c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the examined object's <code>equals</code> method returns <code>true</code> when passed a 299c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <code>null</code> (which would be a violation of the <code>equals</code> contract), unless the 300c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined object itself is <code>null</code>, in which case the matcher will return a positive 301c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * match.</p> 302c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 303c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p>The created matcher provides a special behaviour when examining <code>Array</code>s, whereby 304c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * it will match if both the operand and the examined object are arrays of the same length and 305c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * contain items that are equal to each other (according to the above rules) <b>in the same 306c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * indexes</b>.</p> 307c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 308c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre> 309c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * assertThat("foo", equalTo("foo")); 310c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"})); 311c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </pre> 312c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 313c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> equalTo(T operand) { 314c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsEqual.<T>equalTo(operand); 315c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 316c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 317c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 318c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates an {@link org.hamcrest.core.IsEqual} matcher that does not enforce the values being 319c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * compared to be of the same static type. 320c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 321c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.Object> equalToObject(java.lang.Object operand) { 322c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsEqual.equalToObject(operand); 323c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 324c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 325c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 326c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when the examined object is an instance of the specified <code>type</code>, 327c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * as determined by calling the {@link java.lang.Class#isInstance(Object)} method on that type, passing the 328c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the examined object. 329c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 330c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p>The created matcher forces a relationship between specified type and the examined object, and should be 331c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * used when it is necessary to make generics conform, for example in the JMock clause 332c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <code>with(any(Thing.class))</code></p> 333c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 334c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new Canoe(), instanceOf(Canoe.class));</pre> 335c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 336c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> any(java.lang.Class<T> type) { 337c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsInstanceOf.<T>any(type); 338c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 339c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 340c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 341c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when the examined object is an instance of the specified <code>type</code>, 342c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * as determined by calling the {@link java.lang.Class#isInstance(Object)} method on that type, passing the 343c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the examined object. 344c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 345c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p>The created matcher assumes no relationship between specified type and the examined object.</p> 346c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 347c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new Canoe(), instanceOf(Paddlable.class));</pre> 348c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 349c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> instanceOf(java.lang.Class<?> type) { 350c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsInstanceOf.<T>instanceOf(type); 351c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 352c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 353c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 354c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that wraps an existing matcher, but inverts the logic by which 355c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * it will match. 356c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 357c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> 358c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 359c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param matcher 360c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matcher whose sense should be inverted 361c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 362c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> not(org.hamcrest.Matcher<T> matcher) { 363c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsNot.<T>not(matcher); 364c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 365c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 366c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 367c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * A shortcut to the frequently used <code>not(equalTo(x))</code>. 368c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 369c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(not(smelly)))</pre> 370c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * instead of: 371c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> 372c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 373c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param value 374c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the value that any examined object should <b>not</b> equal 375c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 376c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> not(T value) { 377c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsNot.<T>not(value); 378c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 379c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 380c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 381c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * A shortcut to the frequently used <code>not(nullValue())</code>. 382c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 383c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(notNullValue()))</pre> 384c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * instead of: 385c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(not(nullValue())))</pre> 386c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 387c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.Object> notNullValue() { 388c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsNull.notNullValue(); 389c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 390c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 391c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 392c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * A shortcut to the frequently used <code>not(nullValue(X.class)). Accepts a 393c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * single dummy argument to facilitate type inference.</code>. 394c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 395c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(notNullValue(X.class)))</pre> 396c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * instead of: 397c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(not(nullValue(X.class))))</pre> 398c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 399c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param type 400c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * dummy parameter used to infer the generic type of the returned matcher 401c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 402c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> notNullValue(java.lang.Class<T> type) { 403c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsNull.<T>notNullValue(type); 404c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 405c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 406c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 407c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if examined object is <code>null</code>. 408c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 409c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(nullValue())</pre> 410c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 411c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.Object> nullValue() { 412c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsNull.nullValue(); 413c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 414c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 415c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 416c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if examined object is <code>null</code>. Accepts a 417c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * single dummy argument to facilitate type inference. 418c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 419c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(cheese, is(nullValue(Cheese.class))</pre> 420c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 421c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param type 422c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * dummy parameter used to infer the generic type of the returned matcher 423c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 424c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> nullValue(java.lang.Class<T> type) { 425c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsNull.<T>nullValue(type); 426c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 427c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 428c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 429c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches only when the examined object is the same instance as 430c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the specified target object. 431c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 432c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param target 433c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the target instance against which others should be assessed 434c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 435c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> sameInstance(T target) { 436c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsSame.<T>sameInstance(target); 437c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 438c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 439c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 440c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches only when the examined object is the same instance as 441c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the specified target object. 442c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 443c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param target 444c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the target instance against which others should be assessed 445c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 446c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> theInstance(T target) { 447c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.IsSame.<T>theInstance(target); 448c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 449c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 450c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 451c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined {@link String} contains the specified 452c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * {@link String} anywhere. 453c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 454c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myStringOfNote", containsString("ring"))</pre> 455c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 456c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param substring 457c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the substring that the returned matcher will expect to find within any examined string 458c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 459c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> containsString(java.lang.String substring) { 460c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.StringContains.containsString(substring); 461c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 462c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 463c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 464c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined {@link String} contains the specified 465c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * {@link String} anywhere, ignoring case. 466c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 467c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myStringOfNote", containsString("ring"))</pre> 468c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 469c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param substring 470c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the substring that the returned matcher will expect to find within any examined string 471c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 472c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> containsStringIgnoringCase(java.lang.String substring) { 473c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.StringContains.containsStringIgnoringCase(substring); 474c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 475c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 476c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 477c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 478c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined {@link String} starts with the specified 479c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * {@link String}. 480c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 481c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 482c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myStringOfNote", startsWith("my"))</pre> 483c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 484c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param prefix 485c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the substring that the returned matcher will expect at the start of any examined string 486c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 487c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> startsWith(java.lang.String prefix) { 488c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.StringStartsWith.startsWith(prefix); 489c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 490c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 491c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 492c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 493c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined {@link String} starts with the specified 494c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * {@link String}, ignoring case 495c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 496c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 497c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myStringOfNote", startsWith("my"))</pre> 498c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 499c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param prefix 500c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the substring that the returned matcher will expect at the start of any examined string 501c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 502c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> startsWithIgnoringCase(java.lang.String prefix) { 503c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.StringStartsWith.startsWithIgnoringCase(prefix); 504c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 505c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 506c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 507c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined {@link String} ends with the specified 508c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * {@link String}. 509c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 510c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myStringOfNote", endsWith("Note"))</pre> 511c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 512c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param suffix 513c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the substring that the returned matcher will expect at the end of any examined string 514c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 515c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> endsWith(java.lang.String suffix) { 516c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.StringEndsWith.endsWith(suffix); 517c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 518c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 519c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 520c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches if the examined {@link String} ends with the specified 521c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * {@link String}, ignoring case. 522c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 523c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myStringOfNote", endsWith("Note"))</pre> 524c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 525c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param suffix 526c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the substring that the returned matcher will expect at the end of any examined string 527c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 528c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> endsWithIgnoringCase(java.lang.String suffix) { 529c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.core.StringEndsWith.endsWithIgnoringCase(suffix); 530c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 531c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 532c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 533c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches arrays whose elements are satisfied by the specified matchers. Matches 534c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * positively only if the number of matchers specified is equal to the length of the examined array and 535c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * each matcher[i] is satisfied by array[i]. 536c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 537c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new Integer[]{1,2,3}, is(array(equalTo(1), equalTo(2), equalTo(3))))</pre> 538c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 539c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param elementMatchers 540c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matchers that the elements of examined arrays should satisfy 541c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 542c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.collection.IsArray<T> array(org.hamcrest.Matcher<? super T>... elementMatchers) { 543c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsArray.<T>array(elementMatchers); 544c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 545c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 546c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 547c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for arrays that matches when the examined array contains at least one item 548c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * that is matched by the specified <code>elementMatcher</code>. Whilst matching, the traversal 549c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * of the examined array will stop as soon as a matching element is found. 550c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 551c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new String[] {"foo", "bar"}, hasItemInArray(startsWith("ba")))</pre> 552c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 553c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param elementMatcher 554c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matcher to apply to elements in examined arrays 555c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 556c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T[]> hasItemInArray(org.hamcrest.Matcher<? super T> elementMatcher) { 557c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsArrayContaining.<T>hasItemInArray(elementMatcher); 558c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 559c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 560c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 561c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * A shortcut to the frequently used <code>hasItemInArray(equalTo(x))</code>. 562c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 563c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(hasItemInArray(x))</pre> 564c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * instead of: 565c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(hasItemInArray(equalTo(x)))</pre> 566c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 567c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param element 568c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the element that should be present in examined arrays 569c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 570c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T[]> hasItemInArray(T element) { 571c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsArrayContaining.<T>hasItemInArray(element); 572c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 573c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 574c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 575c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for arrays that matches when each item in the examined array is 576c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * logically equal to the corresponding item in the specified items. For a positive match, 577c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the examined array must be of the same length as the number of specified items. 578c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 579c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new String[]{"foo", "bar"}, contains("foo", "bar"))</pre> 580c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 581c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param items 582c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the items that must equal the items within an examined array 583c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 584c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<E[]> arrayContaining(E... items) { 585c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsArrayContainingInOrder.<E>arrayContaining(items); 586c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 587c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 588c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 589c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for arrays that matches when each item in the examined array satisfies the 590c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * corresponding matcher in the specified matchers. For a positive match, the examined array 591c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * must be of the same length as the number of specified matchers. 592c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 593c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new String[]{"foo", "bar"}, contains(equalTo("foo"), equalTo("bar")))</pre> 594c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 595c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatchers 596c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matchers that must be satisfied by the items in the examined array 597c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 598c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<E[]> arrayContaining(org.hamcrest.Matcher<? super E>... itemMatchers) { 599c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsArrayContainingInOrder.<E>arrayContaining(itemMatchers); 600c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 601c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 602c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 603c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for arrays that matches when each item in the examined array satisfies the 604c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * corresponding matcher in the specified list of matchers. For a positive match, the examined array 605c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * must be of the same length as the specified list of matchers. 606c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 607c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new String[]{"foo", "bar"}, contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))</pre> 608c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 609c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatchers 610c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a list of matchers, each of which must be satisfied by the corresponding item in an examined array 611c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 612c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<E[]> arrayContaining(java.util.List<org.hamcrest.Matcher<? super E>> itemMatchers) { 613c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsArrayContainingInOrder.<E>arrayContaining(itemMatchers); 614c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 615c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 616c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 617c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 618c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates an order agnostic matcher for arrays that matches when each item in the 619c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined array satisfies one matcher anywhere in the specified matchers. 620c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For a positive match, the examined array must be of the same length as the number of 621c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * specified matchers. 622c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 623c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 624c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * N.B. each of the specified matchers will only be used once during a given examination, so be 625c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * careful when specifying matchers that may be satisfied by more than one entry in an examined 626c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * array. 627c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 628c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 629c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 630c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 631c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(equalTo("bar"), equalTo("foo")))</pre> 632c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 633c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatchers 634c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a list of matchers, each of which must be satisfied by an entry in an examined array 635c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 636c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(org.hamcrest.Matcher<? super E>... itemMatchers) { 637c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsArrayContainingInAnyOrder.<E>arrayContainingInAnyOrder(itemMatchers); 638c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 639c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 640c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 641c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 642c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates an order agnostic matcher for arrays that matches when each item in the 643c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined array satisfies one matcher anywhere in the specified collection of matchers. 644c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For a positive match, the examined array must be of the same length as the specified collection 645c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * of matchers. 646c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 647c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 648c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * N.B. each matcher in the specified collection will only be used once during a given 649c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examination, so be careful when specifying matchers that may be satisfied by more than 650c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * one entry in an examined array. 651c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 652c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 653c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 654c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 655c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new String[]{"foo", "bar"}, arrayContainingInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))</pre> 656c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 657c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatchers 658c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a list of matchers, each of which must be satisfied by an item provided by an examined array 659c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 660c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(java.util.Collection<org.hamcrest.Matcher<? super E>> itemMatchers) { 661c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsArrayContainingInAnyOrder.<E>arrayContainingInAnyOrder(itemMatchers); 662c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 663c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 664c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 665c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p>Creates an order agnostic matcher for arrays that matches when each item in the 666c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined array is logically equal to one item anywhere in the specified items. 667c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For a positive match, the examined array must be of the same length as the number of 668c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * specified items. 669c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 670c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p>N.B. each of the specified items will only be used once during a given examination, so be 671c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * careful when specifying items that may be equal to more than one entry in an examined 672c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * array. 673c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 674c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 675c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 676c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 677c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new String[]{"foo", "bar"}, containsInAnyOrder("bar", "foo"))</pre> 678c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 679c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param items 680c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the items that must equal the entries of an examined array, in any order 681c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 682c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<E[]> arrayContainingInAnyOrder(E... items) { 683c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsArrayContainingInAnyOrder.<E>arrayContainingInAnyOrder(items); 684c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 685c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 686c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 687c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for arrays that matches when the <code>length</code> of the array 688c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * satisfies the specified matcher. 689c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 690c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new String[]{"foo", "bar"}, arrayWithSize(equalTo(2)))</pre> 691c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 692c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param sizeMatcher 693c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a matcher for the length of an examined array 694c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 695c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<E[]> arrayWithSize(org.hamcrest.Matcher<? super java.lang.Integer> sizeMatcher) { 696c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsArrayWithSize.<E>arrayWithSize(sizeMatcher); 697c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 698c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 699c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 700c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for arrays that matches when the <code>length</code> of the array 701c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * equals the specified <code>size</code>. 702c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 703c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new String[]{"foo", "bar"}, arrayWithSize(2))</pre> 704c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 705c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param size 706c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the length that an examined array must have for a positive match 707c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 708c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<E[]> arrayWithSize(int size) { 709c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsArrayWithSize.<E>arrayWithSize(size); 710c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 711c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 712c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 713c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for arrays that matches when the <code>length</code> of the array 714c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * is zero. 715c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 716c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new String[0], emptyArray())</pre> 717c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 718c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<E[]> emptyArray() { 719c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsArrayWithSize.<E>emptyArray(); 720c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 721c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 722c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 723c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Map}s that matches when the <code>size()</code> method returns 724c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a value that satisfies the specified matcher. 725c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 726c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myMap, is(aMapWithSize(equalTo(2))))</pre> 727c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 728c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param sizeMatcher 729c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a matcher for the size of an examined {@link java.util.Map} 730c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 731c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <K, V> org.hamcrest.Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(org.hamcrest.Matcher<? super java.lang.Integer> sizeMatcher) { 732c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsMapWithSize.<K,V>aMapWithSize(sizeMatcher); 733c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 734c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 735c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 736c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Map}s that matches when the <code>size()</code> method returns 737c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a value equal to the specified <code>size</code>. 738c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 739c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myMap, is(aMapWithSize(2)))</pre> 740c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 741c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param size 742c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the expected size of an examined {@link java.util.Map} 743c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 744c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <K, V> org.hamcrest.Matcher<java.util.Map<? extends K,? extends V>> aMapWithSize(int size) { 745c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsMapWithSize.<K,V>aMapWithSize(size); 746c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 747c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 748c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 749c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Map}s that matches when the <code>size()</code> method returns 750c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * zero. 751c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 752c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myMap, is(anEmptyMap()))</pre> 753c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 754c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <K, V> org.hamcrest.Matcher<java.util.Map<? extends K,? extends V>> anEmptyMap() { 755c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsMapWithSize.<K,V>anEmptyMap(); 756c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 757c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 758c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 759c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Collection}s that matches when the <code>size()</code> method returns 760c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a value that satisfies the specified matcher. 761c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 762c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar"), hasSize(equalTo(2)))</pre> 763c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 764c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param sizeMatcher 765c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a matcher for the size of an examined {@link java.util.Collection} 766c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 767c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.util.Collection<? extends E>> hasSize(org.hamcrest.Matcher<? super java.lang.Integer> sizeMatcher) { 768c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsCollectionWithSize.<E>hasSize(sizeMatcher); 769c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 770c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 771c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 772c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Collection}s that matches when the <code>size()</code> method returns 773c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a value equal to the specified <code>size</code>. 774c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 775c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar"), hasSize(2))</pre> 776c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 777c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param size 778c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the expected size of an examined {@link java.util.Collection} 779c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 780c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.util.Collection<? extends E>> hasSize(int size) { 781c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsCollectionWithSize.<E>hasSize(size); 782c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 783c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 784c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 785c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Collection}s matching examined collections whose <code>isEmpty</code> 786c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * method returns <code>true</code>. 787c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 788c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new ArrayList<String>(), is(empty()))</pre> 789c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 790c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.util.Collection<? extends E>> empty() { 791c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsEmptyCollection.<E>empty(); 792c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 793c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 794c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 795c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Collection}s matching examined collections whose <code>isEmpty</code> 796c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * method returns <code>true</code>. 797c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 798c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new ArrayList<String>(), is(emptyCollectionOf(String.class)))</pre> 799c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 800c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param unusedToForceReturnType 801c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the type of the collection's content 802c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 803c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.util.Collection<E>> emptyCollectionOf(java.lang.Class<E> unusedToForceReturnType) { 804c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsEmptyCollection.<E>emptyCollectionOf(unusedToForceReturnType); 805c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 806c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 807c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 808c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s matching examined iterables that yield no items. 809c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 810c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new ArrayList<String>(), is(emptyIterable()))</pre> 811c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 812c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> emptyIterable() { 813c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsEmptyIterable.<E>emptyIterable(); 814c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 815c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 816c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 817c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s matching examined iterables that yield no items. 818c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 819c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new ArrayList<String>(), is(emptyIterableOf(String.class)))</pre> 820c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 821c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param unusedToForceReturnType 822c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the type of the iterable's content 823c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 824c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.lang.Iterable<E>> emptyIterableOf(java.lang.Class<E> unusedToForceReturnType) { 825c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsEmptyIterable.<E>emptyIterableOf(unusedToForceReturnType); 826c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 827c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 828c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 829c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that matches when a single pass over the 830c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yields a series of items, each logically equal to the 831c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * corresponding item in the specified items. For a positive match, the examined iterable 832c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * must be of the same length as the number of specified items. 833c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 834c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar"), contains("foo", "bar"))</pre> 835c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 836c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param items 837c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the items that must equal the items provided by an examined {@link Iterable} 838c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 839c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains(E... items) { 840c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIterableContainingInOrder.<E>contains(items); 841c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 842c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 843c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 844c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that matches when a single pass over the 845c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yields a single item that satisfies the specified matcher. 846c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For a positive match, the examined iterable must only yield one item. 847c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 848c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo"), contains(equalTo("foo")))</pre> 849c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 850c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatcher 851c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matcher that must be satisfied by the single item provided by an 852c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} 853c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 854c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains(org.hamcrest.Matcher<? super E> itemMatcher) { 855c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIterableContainingInOrder.<E>contains(itemMatcher); 856c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 857c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 858c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 859c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that matches when a single pass over the 860c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yields a series of items, each satisfying the corresponding 861c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * matcher in the specified matchers. For a positive match, the examined iterable 862c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * must be of the same length as the number of specified matchers. 863c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 864c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar"), contains(equalTo("foo"), equalTo("bar")))</pre> 865c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 866c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatchers 867c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matchers that must be satisfied by the items provided by an examined {@link Iterable} 868c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 869c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains(org.hamcrest.Matcher<? super E>... itemMatchers) { 870c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIterableContainingInOrder.<E>contains(itemMatchers); 871c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 872c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 873c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 874c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that matches when a single pass over the 875c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yields a series of items, each satisfying the corresponding 876c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * matcher in the specified list of matchers. For a positive match, the examined iterable 877c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * must be of the same length as the specified list of matchers. 878c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 879c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar"), contains(Arrays.asList(equalTo("foo"), equalTo("bar"))))</pre> 880c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 881c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatchers 882c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a list of matchers, each of which must be satisfied by the corresponding item provided by 883c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * an examined {@link Iterable} 884c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 885c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> contains(java.util.List<org.hamcrest.Matcher<? super E>> itemMatchers) { 886c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIterableContainingInOrder.<E>contains(itemMatchers); 887c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 888c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 889c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 890c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 891c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates an order agnostic matcher for {@link Iterable}s that matches when a single pass over 892c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the examined {@link Iterable} yields a series of items, each satisfying one matcher anywhere 893c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * in the specified matchers. For a positive match, the examined iterable must be of the same 894c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * length as the number of specified matchers. 895c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 896c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 897c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * N.B. each of the specified matchers will only be used once during a given examination, so be 898c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * careful when specifying matchers that may be satisfied by more than one entry in an examined 899c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * iterable. 900c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 901c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 902c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 903c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 904c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(equalTo("bar"), equalTo("foo")))</pre> 905c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 906c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatchers 907c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a list of matchers, each of which must be satisfied by an item provided by an examined {@link Iterable} 908c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 909c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(org.hamcrest.Matcher<? super T>... itemMatchers) { 910c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIterableContainingInAnyOrder.<T>containsInAnyOrder(itemMatchers); 911c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 912c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 913c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 914c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 915c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates an order agnostic matcher for {@link Iterable}s that matches when a single pass over 916c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the examined {@link Iterable} yields a series of items, each logically equal to one item 917c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * anywhere in the specified items. For a positive match, the examined iterable 918c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * must be of the same length as the number of specified items. 919c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 920c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 921c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * N.B. each of the specified items will only be used once during a given examination, so be 922c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * careful when specifying items that may be equal to more than one entry in an examined 923c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * iterable. 924c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 925c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 926c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 927c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 928c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder("bar", "foo"))</pre> 929c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 930c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param items 931c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the items that must equal the items provided by an examined {@link Iterable} in any order 932c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 933c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(T... items) { 934c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIterableContainingInAnyOrder.<T>containsInAnyOrder(items); 935c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 936c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 937c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 938c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 939c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates an order agnostic matcher for {@link Iterable}s that matches when a single pass over 940c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the examined {@link Iterable} yields a series of items, each satisfying one matcher anywhere 941c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * in the specified collection of matchers. For a positive match, the examined iterable 942c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * must be of the same length as the specified collection of matchers. 943c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 944c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p> 945c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * N.B. each matcher in the specified collection will only be used once during a given 946c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examination, so be careful when specifying matchers that may be satisfied by more than 947c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * one entry in an examined iterable. 948c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </p> 949c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <p>For example:</p> 950c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar"), containsInAnyOrder(Arrays.asList(equalTo("bar"), equalTo("foo"))))</pre> 951c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 952c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatchers 953c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a list of matchers, each of which must be satisfied by an item provided by an examined {@link Iterable} 954c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 955c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(java.util.Collection<org.hamcrest.Matcher<? super T>> itemMatchers) { 956c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIterableContainingInAnyOrder.<T>containsInAnyOrder(itemMatchers); 957c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 958c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 959c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 960c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that matches when a single pass over the 961c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yields a series of items, that contains items logically equal to the 962c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * corresponding item in the specified items, in the same relative order 963c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 964c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder("b", "d"))</pre> 965c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 966c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param items 967c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the items that must be contained within items provided by an examined {@link Iterable} in the same relative order 968c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 969c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(E... items) { 970c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIterableContainingInRelativeOrder.<E>containsInRelativeOrder(items); 971c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 972c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 973c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 974c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that matches when a single pass over the 975c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yields a series of items, that each satisfying the corresponding 976c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * matcher in the specified matchers, in the same relative order. 977c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 978c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("a", "b", "c", "d", "e"), containsInRelativeOrder(equalTo("b"), equalTo("d")))</pre> 979c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 980c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatchers 981c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matchers that must be satisfied by the items provided by an examined {@link Iterable} in the same relative order 982c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 983c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(org.hamcrest.Matcher<? super E>... itemMatchers) { 984c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIterableContainingInRelativeOrder.<E>containsInRelativeOrder(itemMatchers); 985c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 986c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 987c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 988c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that matches when a single pass over the 989c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yields a series of items, that contains items satisfying the corresponding 990c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * matcher in the specified list of matchers, in the same relative order. 991c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 992c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("a", "b", "c", "d", "e"), contains(Arrays.asList(equalTo("b"), equalTo("d"))))</pre> 993c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 994c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param itemMatchers 995c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a list of matchers, each of which must be satisfied by the items provided by 996c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * an examined {@link Iterable} in the same relative order 997c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 998c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.lang.Iterable<? extends E>> containsInRelativeOrder(java.util.List<org.hamcrest.Matcher<? super E>> itemMatchers) { 999c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIterableContainingInRelativeOrder.<E>containsInRelativeOrder(itemMatchers); 1000c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1001c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1002c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1003c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that matches when a single pass over the 1004c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yields an item count that satisfies the specified 1005c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * matcher. 1006c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1007c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar"), iterableWithSize(equalTo(2)))</pre> 1008c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1009c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param sizeMatcher 1010c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a matcher for the number of items that should be yielded by an examined {@link Iterable} 1011c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1012c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.lang.Iterable<E>> iterableWithSize(org.hamcrest.Matcher<? super java.lang.Integer> sizeMatcher) { 1013c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIterableWithSize.<E>iterableWithSize(sizeMatcher); 1014c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1015c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1016c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1017c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link Iterable}s that matches when a single pass over the 1018c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * examined {@link Iterable} yields an item count that is equal to the specified 1019c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <code>size</code> argument. 1020c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1021c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Arrays.asList("foo", "bar"), iterableWithSize(2))</pre> 1022c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1023c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param size 1024c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the number of items that should be yielded by an examined {@link Iterable} 1025c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1026c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <E> org.hamcrest.Matcher<java.lang.Iterable<E>> iterableWithSize(int size) { 1027c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIterableWithSize.<E>iterableWithSize(size); 1028c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1029c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1030c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1031c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Map}s matching when the examined {@link java.util.Map} contains 1032c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * at least one entry whose key satisfies the specified <code>keyMatcher</code> <b>and</b> whose 1033c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * value satisfies the specified <code>valueMatcher</code>. 1034c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1035c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myMap, hasEntry(equalTo("bar"), equalTo("foo")))</pre> 1036c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1037c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param keyMatcher 1038c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the key matcher that, in combination with the valueMatcher, must be satisfied by at least one entry 1039c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param valueMatcher 1040c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the value matcher that, in combination with the keyMatcher, must be satisfied by at least one entry 1041c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1042c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <K, V> org.hamcrest.Matcher<java.util.Map<? extends K,? extends V>> hasEntry(org.hamcrest.Matcher<? super K> keyMatcher, org.hamcrest.Matcher<? super V> valueMatcher) { 1043c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsMapContaining.<K,V>hasEntry(keyMatcher, valueMatcher); 1044c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1045c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1046c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1047c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Map}s matching when the examined {@link java.util.Map} contains 1048c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * at least one entry whose key equals the specified <code>key</code> <b>and</b> whose value equals the 1049c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * specified <code>value</code>. 1050c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1051c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myMap, hasEntry("bar", "foo"))</pre> 1052c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1053c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param key 1054c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the key that, in combination with the value, must be describe at least one entry 1055c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param value 1056c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the value that, in combination with the key, must be describe at least one entry 1057c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1058c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <K, V> org.hamcrest.Matcher<java.util.Map<? extends K,? extends V>> hasEntry(K key, V value) { 1059c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsMapContaining.<K,V>hasEntry(key, value); 1060c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1061c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1062c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1063c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Map}s matching when the examined {@link java.util.Map} contains 1064c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * at least one key that satisfies the specified matcher. 1065c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1066c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myMap, hasKey(equalTo("bar")))</pre> 1067c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1068c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param keyMatcher 1069c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matcher that must be satisfied by at least one key 1070c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1071c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <K> org.hamcrest.Matcher<java.util.Map<? extends K,?>> hasKey(org.hamcrest.Matcher<? super K> keyMatcher) { 1072c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsMapContaining.<K>hasKey(keyMatcher); 1073c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1074c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1075c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1076c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Map}s matching when the examined {@link java.util.Map} contains 1077c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * at least one key that is equal to the specified key. 1078c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1079c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myMap, hasKey("bar"))</pre> 1080c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1081c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param key 1082c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the key that satisfying maps must contain 1083c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1084c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <K> org.hamcrest.Matcher<java.util.Map<? extends K,?>> hasKey(K key) { 1085c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsMapContaining.<K>hasKey(key); 1086c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1087c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1088c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1089c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Map}s matching when the examined {@link java.util.Map} contains 1090c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * at least one value that satisfies the specified valueMatcher. 1091c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1092c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myMap, hasValue(equalTo("foo")))</pre> 1093c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1094c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param valueMatcher 1095c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matcher that must be satisfied by at least one value 1096c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1097c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <V> org.hamcrest.Matcher<java.util.Map<?,? extends V>> hasValue(org.hamcrest.Matcher<? super V> valueMatcher) { 1098c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsMapContaining.<V>hasValue(valueMatcher); 1099c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1100c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1101c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1102c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher for {@link java.util.Map}s matching when the examined {@link java.util.Map} contains 1103c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * at least one value that is equal to the specified value. 1104c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1105c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myMap, hasValue("foo"))</pre> 1106c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1107c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param value 1108c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the value that satisfying maps must contain 1109c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1110c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <V> org.hamcrest.Matcher<java.util.Map<?,? extends V>> hasValue(V value) { 1111c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsMapContaining.<V>hasValue(value); 1112c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1113c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1114c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1115c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when the examined object is found within the 1116c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * specified collection. 1117c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1118c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("foo", is(in(Arrays.asList("bar", "foo"))))</pre> 1119c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1120c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param collection 1121c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the collection in which matching items must be found 1122c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1123c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> in(java.util.Collection<T> collection) { 1124c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIn.<T>in(collection); 1125c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1126c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1127c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1128c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when the examined object is found within the 1129c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * specified array. 1130c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1131c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("foo", is(in(new String[]{"bar", "foo"})))</pre> 1132c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1133c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param elements 1134c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the array in which matching items must be found 1135c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1136c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> in(T[] elements) { 1137c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIn.<T>in(elements); 1138c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1139c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1140c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1141c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when the examined object is found within the 1142c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * specified collection. 1143c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1144c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("foo", isIn(Arrays.asList("bar", "foo")))</pre> 1145c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1146c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @deprecated use is(in(...)) instead 1147c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param collection 1148c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the collection in which matching items must be found 1149c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1150c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> isIn(java.util.Collection<T> collection) { 1151c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIn.<T>isIn(collection); 1152c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1153c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1154c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1155c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when the examined object is found within the 1156c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * specified array. 1157c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1158c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("foo", isIn(new String[]{"bar", "foo"}))</pre> 1159c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1160c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @deprecated use is(in(...)) instead 1161c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param elements 1162c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the array in which matching items must be found 1163c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1164c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> isIn(T[] elements) { 1165c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIn.<T>isIn(elements); 1166c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1167c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1168c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1169c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when the examined object is equal to one of the 1170c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * specified elements. 1171c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1172c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("foo", isOneOf("bar", "foo"))</pre> 1173c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1174c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @deprecated use is(oneOf(...)) instead 1175c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param elements 1176c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the elements amongst which matching items will be found 1177c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1178c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> isOneOf(T... elements) { 1179c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIn.<T>isOneOf(elements); 1180c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1181c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1182c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1183c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when the examined object is equal to one of the 1184c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * specified elements. 1185c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1186c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("foo", is(oneOf("bar", "foo")))</pre> 1187c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1188c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param elements 1189c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the elements amongst which matching items will be found 1190c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1191c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> oneOf(T... elements) { 1192c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.collection.IsIn.<T>oneOf(elements); 1193c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1194c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1195c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1196c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link Double}s that matches when an examined double is equal 1197c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * to the specified <code>operand</code>, within a range of +/- <code>error</code>. 1198c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1199c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(1.03, is(closeTo(1.0, 0.03)))</pre> 1200c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1201c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param operand 1202c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the expected value of matching doubles 1203c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param error 1204c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the delta (+/-) within which matches will be allowed 1205c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1206c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.Double> closeTo(double operand, double error) { 1207c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.number.IsCloseTo.closeTo(operand, error); 1208c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1209c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1210c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1211c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link Double}s that matches when an examined double is not a number. 1212c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1213c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Double.NaN, is(notANumber()))</pre> 1214c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1215c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.Double> notANumber() { 1216c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.number.IsNaN.notANumber(); 1217c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1218c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1219c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1220c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link java.math.BigDecimal}s that matches when an examined BigDecimal is equal 1221c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * to the specified <code>operand</code>, within a range of +/- <code>error</code>. The comparison for equality 1222c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * is done by BigDecimals {@link java.math.BigDecimal#compareTo(java.math.BigDecimal)} method. 1223c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1224c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(new BigDecimal("1.03"), is(closeTo(new BigDecimal("1.0"), new BigDecimal("0.03"))))</pre> 1225c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1226c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param operand 1227c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the expected value of matching BigDecimals 1228c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param error 1229c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the delta (+/-) within which matches will be allowed 1230c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1231c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.math.BigDecimal> closeTo(java.math.BigDecimal operand, java.math.BigDecimal error) { 1232c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.number.BigDecimalCloseTo.closeTo(operand, error); 1233c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1234c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1235c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1236c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link Comparable} object that matches when the examined object is 1237c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * equal to the specified value, as reported by the <code>compareTo</code> method of the 1238c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <b>examined</b> object. 1239c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1240c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(1, comparesEqualTo(1))</pre> 1241c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1242c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param value the value which, when passed to the compareTo method of the examined object, should return zero 1243c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1244c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T extends java.lang.Comparable<T>> org.hamcrest.Matcher<T> comparesEqualTo(T value) { 1245c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.number.OrderingComparison.<T>comparesEqualTo(value); 1246c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1247c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1248c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1249c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link Comparable} object that matches when the examined object is 1250c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * greater than the specified value, as reported by the <code>compareTo</code> method of the 1251c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <b>examined</b> object. 1252c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1253c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(2, greaterThan(1))</pre> 1254c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1255c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param value the value which, when passed to the compareTo method of the examined object, should return greater 1256c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * than zero 1257c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1258c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T extends java.lang.Comparable<T>> org.hamcrest.Matcher<T> greaterThan(T value) { 1259c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.number.OrderingComparison.<T>greaterThan(value); 1260c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1261c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1262c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1263c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link Comparable} object that matches when the examined object is 1264c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * greater than or equal to the specified value, as reported by the <code>compareTo</code> method 1265c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * of the <b>examined</b> object. 1266c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1267c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(1, greaterThanOrEqualTo(1))</pre> 1268c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1269c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param value the value which, when passed to the compareTo method of the examined object, should return greater 1270c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * than or equal to zero 1271c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1272c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T extends java.lang.Comparable<T>> org.hamcrest.Matcher<T> greaterThanOrEqualTo(T value) { 1273c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.number.OrderingComparison.<T>greaterThanOrEqualTo(value); 1274c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1275c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1276c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1277c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link Comparable} object that matches when the examined object is 1278c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * less than the specified value, as reported by the <code>compareTo</code> method of the 1279c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <b>examined</b> object. 1280c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1281c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(1, lessThan(2))</pre> 1282c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1283c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param value the value which, when passed to the compareTo method of the examined object, should return less 1284c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * than zero 1285c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1286c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T extends java.lang.Comparable<T>> org.hamcrest.Matcher<T> lessThan(T value) { 1287c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.number.OrderingComparison.<T>lessThan(value); 1288c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1289c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1290c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1291c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link Comparable} object that matches when the examined object is 1292c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * less than or equal to the specified value, as reported by the <code>compareTo</code> method 1293c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * of the <b>examined</b> object. 1294c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1295c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(1, lessThanOrEqualTo(1))</pre> 1296c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1297c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param value the value which, when passed to the compareTo method of the examined object, should return less 1298c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * than or equal to zero 1299c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1300c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T extends java.lang.Comparable<T>> org.hamcrest.Matcher<T> lessThanOrEqualTo(T value) { 1301c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.number.OrderingComparison.<T>lessThanOrEqualTo(value); 1302c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1303c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1304c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1305c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link String} that matches when the examined string is equal to 1306c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the specified expectedString, ignoring case. 1307c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1308c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("Foo", equalToIgnoringCase("FOO"))</pre> 1309c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1310c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param expectedString 1311c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the expected value of matched strings 1312c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1313c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> equalToIgnoringCase(java.lang.String expectedString) { 1314c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.text.IsEqualIgnoringCase.equalToIgnoringCase(expectedString); 1315c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1316c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1317c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1318c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link String} that matches when the examined string is equal to 1319c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the specified expectedString, when whitespace differences are (mostly) ignored. To be 1320c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * exact, the following whitespace rules are applied: 1321c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <ul> 1322c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <li>all leading and trailing whitespace of both the expectedString and the examined string are ignored</li> 1323c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <li>any remaining whitespace, appearing within either string, is collapsed to a single space before comparison</li> 1324c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * </ul> 1325c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1326c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(" my\tfoo bar ", equalToIgnoringWhiteSpace(" my foo bar"))</pre> 1327c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1328c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param expectedString 1329c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the expected value of matched strings 1330c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1331c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> equalToIgnoringWhiteSpace(java.lang.String expectedString) { 1332c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.text.IsEqualIgnoringWhiteSpace.equalToIgnoringWhiteSpace(expectedString); 1333c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1334c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1335c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1336c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link String} that matches when the examined string is <code>null</code>, or 1337c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * has zero length. 1338c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1339c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(((String)null), is(emptyOrNullString()))</pre> 1340c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1341c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> emptyOrNullString() { 1342c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.text.IsEmptyString.emptyOrNullString(); 1343c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1344c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1345c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1346c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link String} that matches when the examined string has zero length. 1347c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1348c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("", is(emptyString()))</pre> 1349c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1350c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> emptyString() { 1351c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.text.IsEmptyString.emptyString(); 1352c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1353c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1354c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1355c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link String} that matches when the examined string is <code>null</code>, or 1356c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * has zero length. 1357c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1358c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(((String)null), isEmptyOrNullString())</pre> 1359c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1360c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @deprecated use is(emptyOrNullString()) instead 1361c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1362c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> isEmptyOrNullString() { 1363c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.text.IsEmptyString.isEmptyOrNullString(); 1364c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1365c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1366c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1367c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link String} that matches when the examined string has zero length. 1368c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1369c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("", isEmptyString())</pre> 1370c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1371c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @deprecated use is(emptyString()) instead 1372c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1373c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> isEmptyString() { 1374c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.text.IsEmptyString.isEmptyString(); 1375c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1376c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1377c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1378c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link String} that matches when the examined string is <code>null</code>, or 1379c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * contains zero or more whitespace characters and nothing else. 1380c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1381c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(((String)null), is(blankOrNullString()))</pre> 1382c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1383c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> blankOrNullString() { 1384c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.text.IsBlankString.blankOrNullString(); 1385c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1386c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1387c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1388c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link String} that matches when the examined string contains 1389c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * zero or more whitespace characters and nothing else. 1390c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1391c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(" ", is(blankString()))</pre> 1392c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1393c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> blankString() { 1394c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.text.IsBlankString.blankString(); 1395c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1396c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1397c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1398c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link java.lang.String} that matches when the examined string 1399c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * exactly matches the given {@link java.util.regex.Pattern}. 1400c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1401c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> matchesPattern(java.util.regex.Pattern pattern) { 1402c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.text.MatchesPattern.matchesPattern(pattern); 1403c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1404c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1405c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1406c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link java.lang.String} that matches when the examined string 1407c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * exactly matches the given regular expression, treated as a {@link java.util.regex.Pattern}. 1408c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1409c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> matchesPattern(java.lang.String regex) { 1410c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.text.MatchesPattern.matchesPattern(regex); 1411c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1412c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1413c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1414c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link String} that matches when the examined string contains all of 1415c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the specified substrings, considering the order of their appearance. 1416c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1417c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myfoobarbaz", stringContainsInOrder(Arrays.asList("bar", "foo")))</pre> 1418c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * fails as "foo" occurs before "bar" in the string "myfoobarbaz" 1419c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1420c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param substrings 1421c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the substrings that must be contained within matching strings 1422c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1423c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> stringContainsInOrder(java.lang.Iterable<java.lang.String> substrings) { 1424c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.text.StringContainsInOrder.stringContainsInOrder(substrings); 1425c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1426c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1427c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1428c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link String} that matches when the examined string contains all of 1429c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the specified substrings, considering the order of their appearance. 1430c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1431c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat("myfoobarbaz", stringContainsInOrder("bar", "foo"))</pre> 1432c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * fails as "foo" occurs before "bar" in the string "myfoobarbaz" 1433c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1434c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param substrings 1435c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the substrings that must be contained within matching strings 1436c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1437c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.lang.String> stringContainsInOrder(java.lang.String... substrings) { 1438c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.text.StringContainsInOrder.stringContainsInOrder(substrings); 1439c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1440c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1441c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1442c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches any examined object whose <code>toString</code> method 1443c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * returns a value that satisfies the specified matcher. 1444c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1445c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(true, hasToString(equalTo("TRUE")))</pre> 1446c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1447c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param toStringMatcher 1448c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the matcher used to verify the toString result 1449c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1450c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> hasToString(org.hamcrest.Matcher<? super java.lang.String> toStringMatcher) { 1451c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.object.HasToString.<T>hasToString(toStringMatcher); 1452c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1453c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1454c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1455c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches any examined object whose <code>toString</code> method 1456c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * returns a value equalTo the specified string. 1457c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1458c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(true, hasToString("TRUE"))</pre> 1459c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1460c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param expectedToString 1461c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the expected toString result 1462c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1463c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> hasToString(java.lang.String expectedToString) { 1464c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.object.HasToString.<T>hasToString(expectedToString); 1465c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1466c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1467c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1468c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link Class} that matches when the specified baseType is 1469c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * assignable from the examined class. 1470c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1471c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(Integer.class, typeCompatibleWith(Number.class))</pre> 1472c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1473c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param baseType 1474c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the base class to examine classes against 1475c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1476c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<java.lang.Class<?>> typeCompatibleWith(java.lang.Class<T> baseType) { 1477c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.object.IsCompatibleType.<T>typeCompatibleWith(baseType); 1478c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1479c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1480c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1481c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link java.util.EventObject} that matches any object 1482c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * derived from <var>eventClass</var> announced by <var>source</var>. 1483c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1484c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myEvent, is(eventFrom(PropertyChangeEvent.class, myBean)))</pre> 1485c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1486c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param eventClass 1487c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the class of the event to match on 1488c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param source 1489c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the source of the event 1490c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1491c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.util.EventObject> eventFrom(java.lang.Class<? extends java.util.EventObject> eventClass, java.lang.Object source) { 1492c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.object.IsEventFrom.eventFrom(eventClass, source); 1493c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1494c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1495c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1496c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link java.util.EventObject} that matches any EventObject 1497c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * announced by <var>source</var>. 1498c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1499c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myEvent, is(eventFrom(myBean)))</pre> 1500c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1501c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param source 1502c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the source of the event 1503c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1504c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<java.util.EventObject> eventFrom(java.lang.Object source) { 1505c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.object.IsEventFrom.eventFrom(source); 1506c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1507c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1508c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1509c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when the examined object has a JavaBean property 1510c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * with the specified name. 1511c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1512c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myBean, hasProperty("foo"))</pre> 1513c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1514c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param propertyName 1515c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the name of the JavaBean property that examined beans should possess 1516c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1517f5e9a2415ec42c425c2bb17db46f2a9649992d80Brett Chabot public static <T> org.hamcrest.Matcher<T> hasProperty(java.lang.String propertyName) { 1518c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.beans.HasProperty.<T>hasProperty(propertyName); 1519c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1520c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1521c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1522c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when the examined object has a JavaBean property 1523c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * with the specified name whose value satisfies the specified matcher. 1524c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1525c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myBean, hasProperty("foo", equalTo("bar"))</pre> 1526c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1527c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param propertyName 1528c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the name of the JavaBean property that examined beans should possess 1529c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param valueMatcher 1530c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * a matcher for the value of the specified property of the examined bean 1531c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1532c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> hasProperty(java.lang.String propertyName, org.hamcrest.Matcher<?> valueMatcher) { 1533c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.beans.HasPropertyWithValue.<T>hasProperty(propertyName, valueMatcher); 1534c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1535c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1536c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1537c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher that matches when the examined object has values for all of 1538c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * its JavaBean properties that are equal to the corresponding values of the 1539c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * specified bean. 1540c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1541c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(myBean, samePropertyValuesAs(myExpectedBean))</pre> 1542c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1543c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param expectedBean 1544c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the bean against which examined beans are compared 1545c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1546c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static <T> org.hamcrest.Matcher<T> samePropertyValuesAs(T expectedBean) { 1547c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.beans.SamePropertyValuesAs.<T>samePropertyValuesAs(expectedBean); 1548f5e9a2415ec42c425c2bb17db46f2a9649992d80Brett Chabot } 1549f5e9a2415ec42c425c2bb17db46f2a9649992d80Brett Chabot 1550c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1551c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link org.w3c.dom.Node}s that matches when the examined node has a value at the 1552c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * specified <code>xPath</code> that satisfies the specified <code>valueMatcher</code>. 1553c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1554c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(xml, hasXPath("/root/something[2]/cheese", equalTo("Cheddar")))</pre> 1555c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1556c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param xPath 1557c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the target xpath 1558c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param valueMatcher 1559c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * matcher for the value at the specified xpath 1560c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1561c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath, org.hamcrest.Matcher<java.lang.String> valueMatcher) { 1562c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.xml.HasXPath.hasXPath(xPath, valueMatcher); 1563f5e9a2415ec42c425c2bb17db46f2a9649992d80Brett Chabot } 1564f5e9a2415ec42c425c2bb17db46f2a9649992d80Brett Chabot 1565c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1566c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link org.w3c.dom.Node}s that matches when the examined node has a value at the 1567c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * specified <code>xPath</code>, within the specified <code>namespaceContext</code>, that satisfies 1568c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the specified <code>valueMatcher</code>. 1569c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1570c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(xml, hasXPath("/root/something[2]/cheese", myNs, equalTo("Cheddar")))</pre> 1571c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1572c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param xPath 1573c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the target xpath 1574c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param namespaceContext 1575c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the namespace for matching nodes 1576c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param valueMatcher 1577c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * matcher for the value at the specified xpath 1578c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1579c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath, javax.xml.namespace.NamespaceContext namespaceContext, org.hamcrest.Matcher<java.lang.String> valueMatcher) { 1580c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.xml.HasXPath.hasXPath(xPath, namespaceContext, valueMatcher); 1581c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1582f5e9a2415ec42c425c2bb17db46f2a9649992d80Brett Chabot 1583c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1584c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link org.w3c.dom.Node}s that matches when the examined node contains a node 1585c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * at the specified <code>xPath</code>, with any content. 1586c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1587c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(xml, hasXPath("/root/something[2]/cheese"))</pre> 1588c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1589c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param xPath 1590c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the target xpath 1591c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1592c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath) { 1593c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.xml.HasXPath.hasXPath(xPath); 1594c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1595c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin 1596c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin /** 1597c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * Creates a matcher of {@link org.w3c.dom.Node}s that matches when the examined node contains a node 1598c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * at the specified <code>xPath</code> within the specified namespace context, with any content. 1599c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * For example: 1600c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * <pre>assertThat(xml, hasXPath("/root/something[2]/cheese", myNs))</pre> 1601c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * 1602c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param xPath 1603c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the target xpath 1604c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * @param namespaceContext 1605c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin * the namespace for matching nodes 1606c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin */ 1607c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin public static org.hamcrest.Matcher<org.w3c.dom.Node> hasXPath(java.lang.String xPath, javax.xml.namespace.NamespaceContext namespaceContext) { 1608c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin return org.hamcrest.xml.HasXPath.hasXPath(xPath, namespaceContext); 1609c1dbb44e71e47410ad5685aba3ef3fccb095a2b4Paul Duffin } 1610f5e9a2415ec42c425c2bb17db46f2a9649992d80Brett Chabot 1611f5e9a2415ec42c425c2bb17db46f2a9649992d80Brett Chabot} 1612