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