org.cthul.matchers.hamcrest.MatcherAccepts Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of cthul-matchers Show documentation
Provides hamcrest.org matchers for strings and exceptions, allows matching code blocks, and provides several utilities for combining matchers.
The newest version!
package org.cthul.matchers.hamcrest;

import org.cthul.matchers.diagnose.result.AbstractMatchResult;
import org.cthul.matchers.diagnose.result.MatchResult;
import org.cthul.matchers.diagnose.safe.TypesafeNestedResultMatcher;
import org.hamcrest.Description;
import org.hamcrest.Factory;
import org.hamcrest.Matcher;

/**
 *
 */
public class MatcherAccepts extends TypesafeNestedResultMatcher> {
    
    @Factory
    public static  Matcher> accepts(T value) {
        return new MatcherAccepts<>(value);
    }
    
    @Factory
    public static  Matcher> rejects(T value) {
        return new MatcherAccepts<>(false, value);
    }

    @Factory
    public static  Matcher> accepts(T value, Matcher> resultMatcher) {
        return new MatcherAccepts<>(value, resultMatcher);
    }
    
    @Factory
    public static  Matcher> rejects(T value, Matcher> resultMatcher) {
        return new MatcherAccepts<>(false, value, resultMatcher);
    }

    @Factory
    public static  Matcher> acceptsWithMessage(T value, Matcher messageMatcher) {
        return new MatcherAccepts<>(value, HasDescription.message(messageMatcher));
    }
    
    @Factory
    public static  Matcher> rejectsWithMessage(T value, Matcher messageMatcher) {
        return new MatcherAccepts<>(false, value, HasDescription.message(messageMatcher));
    }

    @Factory
    public static  Matcher> rejectsWithExpectedMessage(T value, Matcher messageMatcher) {
        return new MatcherAccepts<>(false, value, MatchResultExpected.expectedMessage(messageMatcher));
    }

    @Factory
    public static  Matcher> acceptsWithMessage(T value, String messageMatcher) {
        return new MatcherAccepts<>(value, HasDescription.message(messageMatcher));
    }
    
    @Factory
    public static  Matcher> rejectsWithMessage(T value, String messageMatcher) {
        return new MatcherAccepts<>(false, value, HasDescription.message(messageMatcher));
    }

    @Factory
    public static  Matcher> rejectsWithExpectedMessage(T value, String messageMatcher) {
        return new MatcherAccepts<>(false, value, MatchResultExpected.expectedMessage(messageMatcher));
    }

    @Factory
    public static  Matcher> accepts(T value, String messageMatcher) {
        return acceptsWithMessage(value, messageMatcher);
    }
    
    @Factory
    public static  Matcher> rejects(T value, String messageMatcher) {
        return rejectsWithMessage(value, messageMatcher);
    }

    @Factory
    public static  Matcher> expects(T value, String messageMatcher) {
        return rejectsWithExpectedMessage(value, messageMatcher);
    }

    private final boolean match;
    private final T value;
    private final Matcher> resultMatcher;

    public MatcherAccepts(T value) {
        super(Matcher.class);
        this.match = true;
        this.value = value;
        this.resultMatcher = null;
    }

    public MatcherAccepts(T value, Matcher> resultMatcher) {
        super(Matcher.class);
        this.match = true;
        this.value = value;
        this.resultMatcher = resultMatcher;
    }

    public MatcherAccepts(boolean match, T value) {
        super(Matcher.class);
        this.match = match;
        this.value = value;
        this.resultMatcher = null;
    }

    public MatcherAccepts(boolean match, T value, Matcher> resultMatcher) {
        super(Matcher.class);
        this.match = match;
        this.value = value;
        this.resultMatcher = resultMatcher;
    }

    @Override
    public void describeTo(Description description) {
        description.appendText("a matcher ")
                .appendText(match ? "accepting " : "rejecting ")
                .appendValue(value);
        if (resultMatcher != null) {
            description
                    .appendText(" and ")
                    .appendText(match ? "match " : "mismatch ");
            nestedDescribeTo(resultMatcher, description);
        }
    }

    @Override
    public int getDescriptionPrecedence() {
        return resultMatcher == null ? P_ATOMIC : P_UNARY;
    }
    
    @Override
    protected boolean matchesSafely(Matcher item) {
        if (item.matches(value) != match) {
            return false;
        }
        if (resultMatcher == null) {
            return true;
        }
        return resultMatcher.matches(quickMatchResult(item, value));
    }

    @Override
    protected > MatchResult matchResultSafely(I item) {
        MatchResult valueResult = quickMatchResult(item, value);
        if (resultMatcher == null || valueResult.matched() != match) {
            return valueResult(item, valueResult);
        }
        MatchResult> msgResult = quickMatchResult(resultMatcher, valueResult);
        return messageResult(item, msgResult);
    }

    private > MatchResult valueResult(I item, final MatchResult mr) {
        return new AbstractMatchResult>(item, this, mr.matched() == match) {
            @Override
            public void describeMatch(Description d) {
                d.appendValue(getValue())
                        .appendText(match ? " accepted " : " rejected ")
                        .appendValue(value)
                        .appendText(": '")
                        .appendValue(mr)
                        .appendText("'");
            }
            @Override
            public void describeMismatch(Description d) {
                d.appendValue(getValue())
                        .appendText(match ? " rejected " : " accepted ")
                        .appendValue(value)
                        .appendText(": '")
                        .appendValue(mr)
                        .appendText("'");
            }
        };
    }

    private > MatchResult messageResult(I item, final MatchResult> mr) {
        return new NestedResult>(item, this, mr.matched()) {
            @Override
            public void describeMatch(Description d) {
                d.appendValue(getValue());
                d.appendText(match ? " match " : " mismatch ");
                nestedDescribeTo(getMatchPrecedence(), mr, d);
            }
            @Override
            public void describeMismatch(Description d) {
                d.appendValue(getValue());
                d.appendText(match ? " match " : " mismatch ");
                nestedDescribeTo(getMismatchPrecedence(), mr, d);
            }
        };
    }
}