/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Inverts the rule. */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Inverts the rule. */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }
/** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ @Factory public static <T> Matcher<T> not(Matcher<T> matcher) { return new IsNot<T>(matcher); }