001    package org.hamcrest.core;
002    
003    import org.hamcrest.Description;
004    import org.hamcrest.DiagnosingMatcher;
005    import org.hamcrest.Factory;
006    import org.hamcrest.Matcher;
007    
008    import java.util.ArrayList;
009    import java.util.Arrays;
010    import java.util.List;
011    
012    /**
013     * Calculates the logical conjunction of multiple matchers. Evaluation is shortcut, so
014     * subsequent matchers are not called if an earlier matcher returns <code>false</code>.
015     */
016    public class AllOf<T> extends DiagnosingMatcher<T> {
017    
018        private final Iterable<Matcher<? super T>> matchers;
019    
020        public AllOf(Iterable<Matcher<? super T>> matchers) {
021            this.matchers = matchers;
022        }
023    
024        @Override
025        public boolean matches(Object o, Description mismatch) {
026            for (Matcher<? super T> matcher : matchers) {
027                if (!matcher.matches(o)) {
028                    mismatch.appendDescriptionOf(matcher).appendText(" ");
029                    matcher.describeMismatch(o, mismatch);
030                  return false;
031                }
032            }
033            return true;
034        }
035    
036        @Override
037        public void describeTo(Description description) {
038            description.appendList("(", " " + "and" + " ", ")", matchers);
039        }
040    
041        /**
042         * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
043         * <p/>
044         * For example:
045         * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
046         */
047        @Factory
048        public static <T> Matcher<T> allOf(Iterable<Matcher<? super T>> matchers) {
049            return new AllOf<T>(matchers);
050        }
051    
052        /**
053         * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
054         * <p/>
055         * For example:
056         * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
057         */
058        @Factory
059        public static <T> Matcher<T> allOf(Matcher<? super T>... matchers) {
060            return allOf(Arrays.asList(matchers));
061        }
062    
063        /**
064         * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
065         * <p/>
066         * For example:
067         * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
068         */
069        @Factory
070        public static <T> Matcher<T> allOf(Matcher<? super T> first, Matcher<? super T> second) {
071            List<Matcher<? super T>> matchers = new ArrayList<Matcher<? super T>>(2);
072            matchers.add(first);
073            matchers.add(second);
074            return allOf(matchers);
075        }
076    
077        /**
078         * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
079         * <p/>
080         * For example:
081         * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
082         */
083        @Factory
084        public static <T> Matcher<T> allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third) {
085            List<Matcher<? super T>> matchers = new ArrayList<Matcher<? super T>>(3);
086            matchers.add(first);
087            matchers.add(second);
088            matchers.add(third);
089            return allOf(matchers);
090        }
091    
092        /**
093         * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
094         * <p/>
095         * For example:
096         * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
097         */
098        @Factory
099        public static <T> Matcher<T> allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth) {
100            List<Matcher<? super T>> matchers = new ArrayList<Matcher<? super T>>(4);
101            matchers.add(first);
102            matchers.add(second);
103            matchers.add(third);
104            matchers.add(fourth);
105            return allOf(matchers);
106        }
107    
108        /**
109         * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
110         * <p/>
111         * For example:
112         * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
113         */
114        @Factory
115        public static <T> Matcher<T> allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth, Matcher<? super T> fifth) {
116            List<Matcher<? super T>> matchers = new ArrayList<Matcher<? super T>>(5);
117            matchers.add(first);
118            matchers.add(second);
119            matchers.add(third);
120            matchers.add(fourth);
121            matchers.add(fifth);
122            return allOf(matchers);
123        }
124    
125        /**
126         * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
127         * <p/>
128         * For example:
129         * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
130         */
131        @Factory
132        public static <T> Matcher<T> allOf(Matcher<? super T> first, Matcher<? super T> second, Matcher<? super T> third, Matcher<? super T> fourth, Matcher<? super T> fifth, Matcher<? super T> sixth) {
133            List<Matcher<? super T>> matchers = new ArrayList<Matcher<? super T>>(6);
134            matchers.add(first);
135            matchers.add(second);
136            matchers.add(third);
137            matchers.add(fourth);
138            matchers.add(fifth);
139            matchers.add(sixth);
140            return allOf(matchers);
141        }
142    }