001// Generated source.
002package org.hamcrest;
003
004public 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}