    001    package org.hamcrest.core;
    002
    003    import org.hamcrest.BaseMatcher;
    004    import org.hamcrest.Description;
    005    import org.hamcrest.Factory;
    006    import org.hamcrest.Matcher;
    007
    008    import static org.hamcrest.core.IsEqual.equalTo;
    009    import static org.hamcrest.core.IsInstanceOf.instanceOf;
    010
    011    /**
    012     * Decorates another Matcher, retaining the behaviour but allowing tests
    013     * to be slightly more expressive.
    014     *
    015     * For example:  assertThat(cheese, equalTo(smelly))
    016     *          vs.  assertThat(cheese, is(equalTo(smelly)))
    017     */
    018    public class Is<T> extends BaseMatcher<T> {
    019        private final Matcher<T> matcher;
    020
    021        public Is(Matcher<T> matcher) {
    022            this.matcher = matcher;
    023        }
    024
    025        @Override
    026        public boolean matches(Object arg) {
    027            return matcher.matches(arg);
    028        }
    029
    030        @Override
    031        public void describeTo(Description description) {
    032            description.appendText("is ").appendDescriptionOf(matcher);
    033        }
    034
    035        @Override
    036        public void describeMismatch(Object item, Description mismatchDescription) {
    037            matcher.describeMismatch(item, mismatchDescription);
    038        }
    039
    040        /**
    041         * Decorates another Matcher, retaining its behaviour, but allowing tests
    042         * to be slightly more expressive.
    043         * <p/>
    044         * For example:
    045         * <pre>assertThat(cheese, is(equalTo(smelly)))</pre>
    046         * instead of:
    047         * <pre>assertThat(cheese, equalTo(smelly))</pre>
    048         *
    049         */
    050        @Factory
    051        public static <T> Matcher<T> is(Matcher<T> matcher) {
    052            return new Is<T>(matcher);
    053        }
    054
    055        /**
    056         * A shortcut to the frequently used <code>is(equalTo(x))</code>.
    057         * <p/>
    058         * For example:
    059         * <pre>assertThat(cheese, is(smelly))</pre>
    060         * instead of:
    061         * <pre>assertThat(cheese, is(equalTo(smelly)))</pre>
    062         *
    063         */
    064        @Factory
    065        public static <T> Matcher<T> is(T value) {
    066            return is(equalTo(value));
    067        }
    068
    069        /**
    070         * A shortcut to the frequently used <code>is(instanceOf(SomeClass.class))</code>.
    071         * <p/>
    072         * For example:
    073         * <pre>assertThat(cheese, is(Cheddar.class))</pre>
    074         * instead of:
    075         * <pre>assertThat(cheese, is(instanceOf(Cheddar.class)))</pre>
    076         *
    077         * @deprecated use isA(Class<T> type) instead.
    078         */
    079        @Factory
    080        @Deprecated
    081        public static <T> Matcher<T> is(Class<T> type) {
    082            final Matcher<T> typeMatcher = instanceOf(type);
    083            return is(typeMatcher);
    084        }
    085
    086        /**
    087         * A shortcut to the frequently used <code>is(instanceOf(SomeClass.class))</code>.
    088         * <p/>
    089         * For example:
    090         * <pre>assertThat(cheese, isA(Cheddar.class))</pre>
    091         * instead of:
    092         * <pre>assertThat(cheese, is(instanceOf(Cheddar.class)))</pre>
    093         *
    094         */
    095        @Factory
    096        public static <T> Matcher<T> isA(Class<T> type) {
    097            final Matcher<T> typeMatcher = instanceOf(type);
    098            return is(typeMatcher);
    099        }
    100    }