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 }