001 // Generated source.
002 package org.hamcrest;
003
004 public class CoreMatchers {
005
006 /**
007 * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
008 * <p/>
009 * For example:
010 * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
011 */
012 public static <T> org.hamcrest.Matcher<T> allOf(java.lang.Iterable<org.hamcrest.Matcher<? super T>> matchers) {
013 return org.hamcrest.core.AllOf.<T>allOf(matchers);
014 }
015
016 /**
017 * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
018 * <p/>
019 * For example:
020 * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
021 */
022 public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T>... matchers) {
023 return org.hamcrest.core.AllOf.<T>allOf(matchers);
024 }
025
026 /**
027 * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
028 * <p/>
029 * For example:
030 * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
031 */
032 public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second) {
033 return org.hamcrest.core.AllOf.<T>allOf(first, second);
034 }
035
036 /**
037 * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
038 * <p/>
039 * For example:
040 * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
041 */
042 public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third) {
043 return org.hamcrest.core.AllOf.<T>allOf(first, second, third);
044 }
045
046 /**
047 * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
048 * <p/>
049 * For example:
050 * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
051 */
052 public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth) {
053 return org.hamcrest.core.AllOf.<T>allOf(first, second, third, fourth);
054 }
055
056 /**
057 * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
058 * <p/>
059 * For example:
060 * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
061 */
062 public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth, org.hamcrest.Matcher<? super T> fifth) {
063 return org.hamcrest.core.AllOf.<T>allOf(first, second, third, fourth, fifth);
064 }
065
066 /**
067 * Creates a matcher that matches if the examined object matches <b>ALL</b> of the specified matchers.
068 * <p/>
069 * For example:
070 * <pre>assertThat("myValue", allOf(startsWith("my"), containsString("Val")))</pre>
071 */
072 public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? super T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth, org.hamcrest.Matcher<? super T> fifth, org.hamcrest.Matcher<? super T> sixth) {
073 return org.hamcrest.core.AllOf.<T>allOf(first, second, third, fourth, fifth, sixth);
074 }
075
076 /**
077 * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers.
078 * <p/>
079 * For example:
080 * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre>
081 */
082 public static <T> org.hamcrest.core.AnyOf<T> anyOf(java.lang.Iterable<org.hamcrest.Matcher<? super T>> matchers) {
083 return org.hamcrest.core.AnyOf.<T>anyOf(matchers);
084 }
085
086 /**
087 * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers.
088 * <p/>
089 * For example:
090 * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre>
091 */
092 public static <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third) {
093 return org.hamcrest.core.AnyOf.<T>anyOf(first, second, third);
094 }
095
096 /**
097 * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers.
098 * <p/>
099 * For example:
100 * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre>
101 */
102 public static <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth) {
103 return org.hamcrest.core.AnyOf.<T>anyOf(first, second, third, fourth);
104 }
105
106 /**
107 * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers.
108 * <p/>
109 * For example:
110 * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre>
111 */
112 public static <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth, org.hamcrest.Matcher<? super T> fifth) {
113 return org.hamcrest.core.AnyOf.<T>anyOf(first, second, third, fourth, fifth);
114 }
115
116 /**
117 * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers.
118 * <p/>
119 * For example:
120 * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre>
121 */
122 public static <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second, org.hamcrest.Matcher<? super T> third, org.hamcrest.Matcher<? super T> fourth, org.hamcrest.Matcher<? super T> fifth, org.hamcrest.Matcher<? super T> sixth) {
123 return org.hamcrest.core.AnyOf.<T>anyOf(first, second, third, fourth, fifth, sixth);
124 }
125
126 /**
127 * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers.
128 * <p/>
129 * For example:
130 * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre>
131 */
132 public static <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<T> first, org.hamcrest.Matcher<? super T> second) {
133 return org.hamcrest.core.AnyOf.<T>anyOf(first, second);
134 }
135
136 /**
137 * Creates a matcher that matches if the examined object matches <b>ANY</b> of the specified matchers.
138 * <p/>
139 * For example:
140 * <pre>assertThat("myValue", anyOf(startsWith("foo"), containsString("Val")))</pre>
141 */
142 public static <T> org.hamcrest.core.AnyOf<T> anyOf(org.hamcrest.Matcher<? super T>... matchers) {
143 return org.hamcrest.core.AnyOf.<T>anyOf(matchers);
144 }
145
146 /**
147 * Creates a matcher that matches when both of the specified matchers match the examined object.
148 * <p/>
149 * For example:
150 * <pre>assertThat("fab", both(containsString("a")).and(containsString("b")))</pre>
151 */
152 public static <LHS> org.hamcrest.core.CombinableMatcher.CombinableBothMatcher<LHS> both(org.hamcrest.Matcher<? super LHS> matcher) {
153 return org.hamcrest.core.CombinableMatcher.<LHS>both(matcher);
154 }
155
156 /**
157 * Creates a matcher that matches when either of the specified matchers match the examined object.
158 * <p/>
159 * For example:
160 * <pre>assertThat("fan", either(containsString("a")).and(containsString("b")))</pre>
161 */
162 public static <LHS> org.hamcrest.core.CombinableMatcher.CombinableEitherMatcher<LHS> either(org.hamcrest.Matcher<? super LHS> matcher) {
163 return org.hamcrest.core.CombinableMatcher.<LHS>either(matcher);
164 }
165
166 /**
167 * Wraps an existing matcher, overriding its description with that specified. All other functions are
168 * delegated to the decorated matcher, including its mismatch description.
169 * <p/>
170 * For example:
171 * <pre>describedAs("a big decimal equal to %0", equalTo(myBigDecimal), myBigDecimal.toPlainString())</pre>
172 *
173 * @param description
174 * the new description for the wrapped matcher
175 * @param matcher
176 * the matcher to wrap
177 * @param values
178 * optional values to insert into the tokenised description
179 */
180 public static <T> org.hamcrest.Matcher<T> describedAs(java.lang.String description, org.hamcrest.Matcher<T> matcher, java.lang.Object... values) {
181 return org.hamcrest.core.DescribedAs.<T>describedAs(description, matcher, values);
182 }
183
184 /**
185 * Creates a matcher for {@link Iterable}s that only matches when a single pass over the
186 * examined {@link Iterable} yields items that are all matched by the specified
187 * <code>itemMatcher</code>.
188 * <p/>
189 * For example:
190 * <pre>assertThat(Arrays.asList("bar", "baz"), everyItem(startsWith("ba")))</pre>
191 *
192 * @param itemMatcher
193 * the matcher to apply to every item provided by the examined {@link Iterable}
194 */
195 public static <U> org.hamcrest.Matcher<java.lang.Iterable<U>> everyItem(org.hamcrest.Matcher<U> itemMatcher) {
196 return org.hamcrest.core.Every.<U>everyItem(itemMatcher);
197 }
198
199 /**
200 * A shortcut to the frequently used <code>is(equalTo(x))</code>.
201 * <p/>
202 * For example:
203 * <pre>assertThat(cheese, is(smelly))</pre>
204 * instead of:
205 * <pre>assertThat(cheese, is(equalTo(smelly)))</pre>
206 */
207 public static <T> org.hamcrest.Matcher<T> is(T value) {
208 return org.hamcrest.core.Is.<T>is(value);
209 }
210
211 /**
212 * Decorates another Matcher, retaining its behaviour, but allowing tests
213 * to be slightly more expressive.
214 * <p/>
215 * For example:
216 * <pre>assertThat(cheese, is(equalTo(smelly)))</pre>
217 * instead of:
218 * <pre>assertThat(cheese, equalTo(smelly))</pre>
219 */
220 public static <T> org.hamcrest.Matcher<T> is(org.hamcrest.Matcher<T> matcher) {
221 return org.hamcrest.core.Is.<T>is(matcher);
222 }
223
224 /**
225 * A shortcut to the frequently used <code>is(instanceOf(SomeClass.class))</code>.
226 * <p/>
227 * For example:
228 * <pre>assertThat(cheese, is(Cheddar.class))</pre>
229 * instead of:
230 * <pre>assertThat(cheese, is(instanceOf(Cheddar.class)))</pre>
231 *
232 * @deprecated use isA(Class<T> type) instead.
233 */
234 public static <T> org.hamcrest.Matcher<T> is(java.lang.Class<T> type) {
235 return org.hamcrest.core.Is.<T>is(type);
236 }
237
238 /**
239 * A shortcut to the frequently used <code>is(instanceOf(SomeClass.class))</code>.
240 * <p/>
241 * For example:
242 * <pre>assertThat(cheese, isA(Cheddar.class))</pre>
243 * instead of:
244 * <pre>assertThat(cheese, is(instanceOf(Cheddar.class)))</pre>
245 */
246 public static <T> org.hamcrest.Matcher<T> isA(java.lang.Class<T> type) {
247 return org.hamcrest.core.Is.<T>isA(type);
248 }
249
250 /**
251 * Creates a matcher that always matches, regardless of the examined object.
252 */
253 public static org.hamcrest.Matcher<java.lang.Object> anything() {
254 return org.hamcrest.core.IsAnything.anything();
255 }
256
257 /**
258 * Creates a matcher that always matches, regardless of the examined object, but describes
259 * itself with the specified {@link String}.
260 *
261 * @param description
262 * a meaningful {@link String} used when describing itself
263 */
264 public static org.hamcrest.Matcher<java.lang.Object> anything(java.lang.String description) {
265 return org.hamcrest.core.IsAnything.anything(description);
266 }
267
268 /**
269 * Creates a matcher for {@link Iterable}s that only matches when a single pass over the
270 * examined {@link Iterable} yields at least one item that is equal to the specified
271 * <code>item</code>. Whilst matching, the traversal of the examined {@link Iterable}
272 * will stop as soon as a matching item is found.
273 * <p/>
274 * For example:
275 * <pre>assertThat(Arrays.asList("foo", "bar"), hasItem("bar"))</pre>
276 *
277 * @param item
278 * the item to compare against the items provided by the examined {@link Iterable}
279 */
280 public static <T> org.hamcrest.Matcher<java.lang.Iterable<? super T>> hasItem(T item) {
281 return org.hamcrest.core.IsCollectionContaining.<T>hasItem(item);
282 }
283
284 /**
285 * Creates a matcher for {@link Iterable}s that only matches when a single pass over the
286 * examined {@link Iterable} yields at least one item that is matched by the specified
287 * <code>itemMatcher</code>. Whilst matching, the traversal of the examined {@link Iterable}
288 * will stop as soon as a matching item is found.
289 * <p/>
290 * For example:
291 * <pre>assertThat(Arrays.asList("foo", "bar"), hasItem(startsWith("ba")))</pre>
292 *
293 * @param itemMatcher
294 * the matcher to apply to items provided by the examined {@link Iterable}
295 */
296 public static <T> org.hamcrest.Matcher<java.lang.Iterable<? super T>> hasItem(org.hamcrest.Matcher<? super T> itemMatcher) {
297 return org.hamcrest.core.IsCollectionContaining.<T>hasItem(itemMatcher);
298 }
299
300 /**
301 * Creates a matcher for {@link Iterable}s that matches when consecutive passes over the
302 * examined {@link Iterable} yield at least one item that is equal to the corresponding
303 * item from the specified <code>items</code>. Whilst matching, each traversal of the
304 * examined {@link Iterable} will stop as soon as a matching item is found.
305 * <p/>
306 * For example:
307 * <pre>assertThat(Arrays.asList("foo", "bar", "baz"), hasItems("baz", "foo"))</pre>
308 *
309 * @param items
310 * the items to compare against the items provided by the examined {@link Iterable}
311 */
312 public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(T... items) {
313 return org.hamcrest.core.IsCollectionContaining.<T>hasItems(items);
314 }
315
316 /**
317 * Creates a matcher for {@link Iterable}s that matches when consecutive passes over the
318 * examined {@link Iterable} yield at least one item that is matched by the corresponding
319 * matcher from the specified <code>itemMatchers</code>. Whilst matching, each traversal of
320 * the examined {@link Iterable} will stop as soon as a matching item is found.
321 * <p/>
322 * For example:
323 * <pre>assertThat(Arrays.asList("foo", "bar", "baz"), hasItems(endsWith("z"), endsWith("o")))</pre>
324 *
325 * @param itemMatchers
326 * the matchers to apply to items provided by the examined {@link Iterable}
327 */
328 public static <T> org.hamcrest.Matcher<java.lang.Iterable<T>> hasItems(org.hamcrest.Matcher<? super T>... itemMatchers) {
329 return org.hamcrest.core.IsCollectionContaining.<T>hasItems(itemMatchers);
330 }
331
332 /**
333 * Creates a matcher that matches when the examined object is logically equal to the specified
334 * <code>operand</code>, as determined by calling the {@link java.lang.Object#equals} method on
335 * the <b>examined</b> object.
336 *
337 * <p>If the specified operand is <code>null</code> then the created matcher will only match if
338 * the examined object's <code>equals</code> method returns <code>true</code> when passed a
339 * <code>null</code> (which would be a violation of the <code>equals</code> contract), unless the
340 * examined object itself is <code>null</code>, in which case the matcher will return a positive
341 * match.</p>
342 *
343 * <p>The created matcher provides a special behaviour when examining <code>Array</code>s, whereby
344 * it will match if both the operand and the examined object are arrays of the same length and
345 * contain items that are equal to each other (according to the above rules) <b>in the same
346 * indexes</b>.</p>
347 * <p/>
348 * For example:
349 * <pre>
350 * assertThat("foo", equalTo("foo"));
351 * assertThat(new String[] {"foo", "bar"}, equalTo(new String[] {"foo", "bar"}));
352 * </pre>
353 */
354 public static <T> org.hamcrest.Matcher<T> equalTo(T operand) {
355 return org.hamcrest.core.IsEqual.<T>equalTo(operand);
356 }
357
358 /**
359 * Creates a matcher that matches when the examined object is an instance of the specified <code>type</code>,
360 * as determined by calling the {@link java.lang.Class#isInstance(Object)} method on that type, passing the
361 * the examined object.
362 *
363 * <p>The created matcher forces a relationship between specified type and the examined object, and should be
364 * used when it is necessary to make generics conform, for example in the JMock clause
365 * <code>with(any(Thing.class))</code></p>
366 * <p/>
367 * For example:
368 * <pre>assertThat(new Canoe(), instanceOf(Canoe.class));</pre>
369 */
370 public static <T> org.hamcrest.Matcher<T> any(java.lang.Class<T> type) {
371 return org.hamcrest.core.IsInstanceOf.<T>any(type);
372 }
373
374 /**
375 * Creates a matcher that matches when the examined object is an instance of the specified <code>type</code>,
376 * as determined by calling the {@link java.lang.Class#isInstance(Object)} method on that type, passing the
377 * the examined object.
378 *
379 * <p>The created matcher assumes no relationship between specified type and the examined object.</p>
380 * <p/>
381 * For example:
382 * <pre>assertThat(new Canoe(), instanceOf(Paddlable.class));</pre>
383 */
384 public static <T> org.hamcrest.Matcher<T> instanceOf(java.lang.Class<?> type) {
385 return org.hamcrest.core.IsInstanceOf.<T>instanceOf(type);
386 }
387
388 /**
389 * Creates a matcher that wraps an existing matcher, but inverts the logic by which
390 * it will match.
391 * <p/>
392 * For example:
393 * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre>
394 *
395 * @param matcher
396 * the matcher whose sense should be inverted
397 */
398 public static <T> org.hamcrest.Matcher<T> not(org.hamcrest.Matcher<T> matcher) {
399 return org.hamcrest.core.IsNot.<T>not(matcher);
400 }
401
402 /**
403 * A shortcut to the frequently used <code>not(equalTo(x))</code>.
404 * <p/>
405 * For example:
406 * <pre>assertThat(cheese, is(not(smelly)))</pre>
407 * instead of:
408 * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre>
409 *
410 * @param value
411 * the value that any examined object should <b>not</b> equal
412 */
413 public static <T> org.hamcrest.Matcher<T> not(T value) {
414 return org.hamcrest.core.IsNot.<T>not(value);
415 }
416
417 /**
418 * Creates a matcher that matches if examined object is <code>null</code>.
419 * <p/>
420 * For example:
421 * <pre>assertThat(cheese, is(nullValue())</pre>
422 */
423 public static org.hamcrest.Matcher<java.lang.Object> nullValue() {
424 return org.hamcrest.core.IsNull.nullValue();
425 }
426
427 /**
428 * Creates a matcher that matches if examined object is <code>null</code>. Accepts a
429 * single dummy argument to facilitate type inference.
430 * <p/>
431 * For example:
432 * <pre>assertThat(cheese, is(nullValue(Cheese.class))</pre>
433 *
434 * @param type
435 * dummy parameter used to infer the generic type of the returned matcher
436 */
437 public static <T> org.hamcrest.Matcher<T> nullValue(java.lang.Class<T> type) {
438 return org.hamcrest.core.IsNull.<T>nullValue(type);
439 }
440
441 /**
442 * A shortcut to the frequently used <code>not(nullValue())</code>.
443 * <p/>
444 * For example:
445 * <pre>assertThat(cheese, is(notNullValue()))</pre>
446 * instead of:
447 * <pre>assertThat(cheese, is(not(nullValue())))</pre>
448 */
449 public static org.hamcrest.Matcher<java.lang.Object> notNullValue() {
450 return org.hamcrest.core.IsNull.notNullValue();
451 }
452
453 /**
454 * A shortcut to the frequently used <code>not(nullValue(X.class)). Accepts a
455 * single dummy argument to facilitate type inference.</code>.
456 * <p/>
457 * For example:
458 * <pre>assertThat(cheese, is(notNullValue(X.class)))</pre>
459 * instead of:
460 * <pre>assertThat(cheese, is(not(nullValue(X.class))))</pre>
461 *
462 * @param type
463 * dummy parameter used to infer the generic type of the returned matcher
464 */
465 public static <T> org.hamcrest.Matcher<T> notNullValue(java.lang.Class<T> type) {
466 return org.hamcrest.core.IsNull.<T>notNullValue(type);
467 }
468
469 /**
470 * Creates a matcher that matches only when the examined object is the same instance as
471 * the specified target object.
472 *
473 * @param target
474 * the target instance against which others should be assessed
475 */
476 public static <T> org.hamcrest.Matcher<T> sameInstance(T target) {
477 return org.hamcrest.core.IsSame.<T>sameInstance(target);
478 }
479
480 /**
481 * Creates a matcher that matches only when the examined object is the same instance as
482 * the specified target object.
483 *
484 * @param target
485 * the target instance against which others should be assessed
486 */
487 public static <T> org.hamcrest.Matcher<T> theInstance(T target) {
488 return org.hamcrest.core.IsSame.<T>theInstance(target);
489 }
490
491 /**
492 * Creates a matcher that matches if the examined {@link String} contains the specified
493 * {@link String} anywhere.
494 * <p/>
495 * For example:
496 * <pre>assertThat("myStringOfNote", containsString("ring"))</pre>
497 *
498 * @param substring
499 * the substring that the returned matcher will expect to find within any examined string
500 */
501 public static org.hamcrest.Matcher<java.lang.String> containsString(java.lang.String substring) {
502 return org.hamcrest.core.StringContains.containsString(substring);
503 }
504
505 /**
506 * Creates a matcher that matches if the examined {@link String} starts with the specified
507 * {@link String}.
508 * <p/>
509 * For example:
510 * <pre>assertThat("myStringOfNote", startsWith("my"))</pre>
511 *
512 * @param prefix
513 * the substring that the returned matcher will expect at the start of any examined string
514 */
515 public static org.hamcrest.Matcher<java.lang.String> startsWith(java.lang.String prefix) {
516 return org.hamcrest.core.StringStartsWith.startsWith(prefix);
517 }
518
519 /**
520 * Creates a matcher that matches if the examined {@link String} ends with the specified
521 * {@link String}.
522 * <p/>
523 * For example:
524 * <pre>assertThat("myStringOfNote", endsWith("Note"))</pre>
525 *
526 * @param suffix
527 * the substring that the returned matcher will expect at the end of any examined string
528 */
529 public static org.hamcrest.Matcher<java.lang.String> endsWith(java.lang.String suffix) {
530 return org.hamcrest.core.StringEndsWith.endsWith(suffix);
531 }
532
533 }