@Factory @Deprecated /** * Please avoid using as the hamcrest way of reporting error wraps a multi-line * text into a single line and makes hard to understand the problem. * Instead, please try to use the spock/groovy assert and {@link #containsLine(String, String)} */ public static Matcher<String> containsLine(final String line) { return new BaseMatcher<String>() { public boolean matches(Object o) { return containsLine(equalTo(line)).matches(o); } public void describeTo(Description description) { description.appendText("a String that contains line ").appendValue(line); } }; }
@Factory public static Matcher<Object> isSerializable() { return new BaseMatcher<Object>() { public boolean matches(Object o) { try { new ObjectOutputStream(new ByteArrayOutputStream()).writeObject(o); } catch (IOException e) { throw new RuntimeException(e); } return true; } public void describeTo(Description description) { description.appendText("is serializable"); } }; }
/** * Matches the set of entries against the given set of values. The full combinatorial of values passed in is expected in the output set. * * @param rows * Rows to check for. * @param colFs * Column families to check for. * @param colQs * Column qualifiers to check for. * @param colVs * Column visibilities to check for. * @param values * Values to check for. * @return Hamcrest matcher. */ @Factory @SuppressWarnings("unchecked") public static Matcher<Iterable<Entry<Key,Value>>> hasData(Collection<String> rows, Collection<String> colFs, Collection<String> colQs, Collection<String> colVs, Collection<String> values) { int size = rows.size() * colFs.size() * colQs.size() * colVs.size() * values.size(); ArrayList<Matcher<? super Iterable<Entry<Key,Value>>>> matchers = new ArrayList<>(size + 1); matchers.add(IsIterableWithSize.iterableWithSize(size)); for (String row : rows) { for (String colF : colFs) { for (String colQ : colQs) { for (String colV : colVs) { for (String value : values) { matchers.add(hasItems(equalToRow(row, colF, colQ, colV, value))); } } } } } return allOf(matchers); }
/** * @param v The expected vertex. * @return A matcher that compares an actual vertex with the expected * vertex. Two vertices are considered equal if all their fields are equal. */ @Factory public static Matcher equalsVertex(Vertex v) { return new TypeSafeMatcher<Vertex>() { @Override protected boolean matchesSafely(Vertex w) { return v.label.equals(w.label) && Double.doubleToLongBits(v.radius) == Double.doubleToLongBits(w.radius) && v.fillColor.equals(w.fillColor) && v.strokeWidth == w.strokeWidth && v.textHeight == w.textHeight && v.strokeColor.equals(w.strokeColor) && v.coordinates.equals(w.coordinates); } @Override public void describeTo(Description d) { d.appendText("Vertex equality"); } }; }
@Factory public static <T> Matcher<Node> cellWithValue(final Matcher<T> contentsMatcher) { return new TypeSafeMatcher<Node>(Cell.class) { @Override protected boolean matchesSafely(Node item) { return contentsMatcher.matches(((Cell) item).getItem()); } @Override public void describeTo(Description description) { description.appendText(Cell.class.getSimpleName()) .appendText(" ") .appendText("with value") .appendDescriptionOf(contentsMatcher); } }; }
/** * A reimplementation of hamcrest's isA() but without the broken generics. */ @Factory public static Matcher<Object> isA(final Class<?> type) { return new BaseMatcher<Object>() { public boolean matches(Object item) { return type.isInstance(item); } public void describeTo(Description description) { description.appendText("instanceof ").appendValue(type); } }; }
@Factory public static <T extends CharSequence> Matcher<T> matchesRegexp(final String pattern) { return new BaseMatcher<T>() { public boolean matches(Object o) { return Pattern.compile(pattern, Pattern.DOTALL).matcher((CharSequence) o).matches(); } public void describeTo(Description description) { description.appendText("a CharSequence that matches regexp ").appendValue(pattern); } }; }
@Factory public static <T extends CharSequence> Matcher<T> matchesRegexp(final Pattern pattern) { return new BaseMatcher<T>() { public boolean matches(Object o) { return pattern.matcher((CharSequence) o).matches(); } public void describeTo(Description description) { description.appendText("a CharSequence that matches regexp ").appendValue(pattern); } }; }
@Factory public static <T extends CharSequence> Matcher<T> containsText(final String pattern) { return new BaseMatcher<T>() { public boolean matches(Object o) { return ((String) o).contains(pattern); } public void describeTo(Description description) { description.appendText("a CharSequence that contains text ").appendValue(pattern); } }; }
@Factory public static <T> Matcher<T> strictlyEqual(final T other) { return new BaseMatcher<T>() { public boolean matches(Object o) { return strictlyEquals(o, other); } public void describeTo(Description description) { description.appendText("an Object that strictly equals ").appendValue(other); } }; }
@Factory public static Matcher<String> containsLine(final Matcher<? super String> matcher) { return new BaseMatcher<String>() { public boolean matches(Object o) { String str = (String) o; return containsLine(str, matcher); } public void describeTo(Description description) { description.appendText("a String that contains line that is ").appendDescriptionOf(matcher); } }; }
@Factory public static Matcher<Iterable<?>> isEmpty() { return new BaseMatcher<Iterable<?>>() { public boolean matches(Object o) { Iterable<?> iterable = (Iterable<?>) o; return iterable != null && !iterable.iterator().hasNext(); } public void describeTo(Description description) { description.appendText("an empty Iterable"); } }; }
@Factory public static Matcher<Map<?, ?>> isEmptyMap() { return new BaseMatcher<Map<?, ?>>() { public boolean matches(Object o) { Map<?, ?> map = (Map<?, ?>) o; return map != null && map.isEmpty(); } public void describeTo(Description description) { description.appendText("an empty map"); } }; }
@Factory public static Matcher<Throwable> hasMessage(final Matcher<String> matcher) { return new BaseMatcher<Throwable>() { public boolean matches(Object o) { Throwable t = (Throwable) o; return matcher.matches(t.getMessage()); } public void describeTo(Description description) { description.appendText("an exception with message that is ").appendDescriptionOf(matcher); } }; }
@Factory public static Matcher<String> normalizedLineSeparators(final Matcher<String> matcher) { return new BaseMatcher<String>() { public boolean matches(Object o) { String string = (String) o; return matcher.matches(string.replace(SystemProperties.getInstance().getLineSeparator(), "\n")); } public void describeTo(Description description) { matcher.describeTo(description); description.appendText(" (normalize line separators)"); } }; }
@Factory private static DiagnosingMatcher<Object> translateTo(HttpStatus status) { return new DiagnosingMatcher<Object>() { private static final String EXCEPTION = "EXCEPTION"; @Override public void describeTo(final Description description) { description.appendText("does not translate to ").appendText(status.toString()); } @SuppressWarnings("unchecked") protected boolean matches(final Object item, final Description mismatch) { if (item instanceof Class) { if (((Class) item).getClass().isInstance(Throwable.class)) { Class<? extends Throwable> type = (Class<? extends Throwable>) item; try { Throwable exception = type.getConstructor(String.class).newInstance(EXCEPTION); Mono.just(exception).transform(ThrowableTranslator::translate).subscribe(translator -> { assertThat(translator.getMessage(), is(EXCEPTION)); assertThat(translator.getHttpStatus(), is(status)); }); } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException cause) { throw new AssertionError("This exception class has not constructor with a String", cause); } return true; } } mismatch.appendText(item.toString()); return false; } }; }
@Factory public static Matcher<Predicate> absentBackReferences(int noOfPredicateArguments) { Matcher[] matchers = new Matcher[noOfPredicateArguments]; Arrays.fill(matchers, isAbsent()); return new ArgumentBackReferences(Absent.<TransactionContext>absent(), matchers); }
@Factory public static Matcher<Predicate> absentBackReferences(TransactionContext tc, int noOfPredicateArguments) { Matcher[] matchers = new Matcher[noOfPredicateArguments]; Arrays.fill(matchers, isAbsent()); return new ArgumentBackReferences(new Present<>(tc), matchers); }
@Factory public static RingBufferEventMatcher ringBufferWithEvents(final Object... values) { Matcher<?>[] valueMatchers = new Matcher[values.length]; for (int i = 0; i < values.length; i++) { final Object value = values[i]; valueMatchers[i] = is(value); } return new RingBufferEventMatcher(valueMatchers); }
@Factory public static Matcher<BattleModel> monsterIsAlive() { return new FeatureMatcher<BattleModel, Boolean>( is( true ), "monster alive", "monster alive" ) { @Override protected Boolean featureValueOf(BattleModel actual) { return actual.monsterAlive(); } }; }
@Factory public static Matcher<HtmlElement> hasAttributes(String... nameValues) { if (nameValues.length % 2 != 0) throw new RuntimeException("The last attr was missing a value"); List<Attribute> expectedAttrs = new ArrayList<Attribute>(); for (int i = 0; i < nameValues.length; i += 2) { expectedAttrs.add(new Attribute(nameValues[i], nameValues[i + 1])); } return new HasAttribute(expectedAttrs); }
@Factory public static <T extends CharSequence> Matcher<T> containsText(final String pattern) { return new BaseMatcher<T>() { public boolean matches(Object o) { return Pattern.compile(pattern).matcher((CharSequence) o).find(); } public void describeTo(Description description) { description.appendText("a CharSequence that contains text ").appendValue(pattern); } }; }
@Factory public static Matcher<String> normalizedLineSeparators(final Matcher<String> matcher) { return new BaseMatcher<String>() { public boolean matches(Object o) { String string = (String) o; return matcher.matches(string.replace(SystemProperties.getLineSeparator(), "\n")); } public void describeTo(Description description) { matcher.describeTo(description); description.appendText(" (normalize line separators)"); } }; }
@Factory public static Collection<Matcher<? super Asset>> assetsWithIds(Asset... assets) { ArrayList<Matcher<? super Asset>> matchers = new ArrayList<>(); for (Asset asset : assets) { matchers.add(hasId(asset)); } return matchers; }
@Factory public static <T> Matcher<T> reflectionEquals(T equalsTo) { return new ReflectionEqualsMatcher<T>(equalsTo); }
@Factory public static Matcher<AspectRatio> closeTo(AspectRatio ratio) { return new AspectRatioIsCloseTo(ratio); }
@Factory public static Matcher<AspectRatio> closeToOrInverse(AspectRatio ratio) { return either(closeTo(ratio)).or(closeTo(ratio.inverse())); }
/** * Gets a hamcrest matcher that tests whether two Ini objects are equal. * * @param expectedValue * The expected value to core against. * @return Method safe matcher that will core field equality. */ @Factory public static TypeSafeMatcher<Ini> equalTo(final Ini expectedValue) { return new TypeSafeMatcher<Ini>() { @Override protected boolean matchesSafely(Ini actualValue) { if (expectedValue.size() != actualValue.size()) { return false; } for (Section expectedSection : expectedValue.values()) { Section actualSection = actualValue.get(expectedSection.getName()); if (actualSection == null) { return false; } if (expectedSection.size() != actualSection.size()) { return false; } for (Entry<String,String> expectedEntry : expectedSection.entrySet()) { if (!actualSection.containsKey(expectedEntry.getKey())) { return false; } String actual = actualSection.get(expectedEntry.getKey()); String expected = expectedEntry.getValue(); if ((actual == null && expected != null) || (actual != null && !actual.equals(expected))) { return false; } } } return true; } @Override public void describeTo(Description description) { description.appendValue(expectedValue); } }; }