1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
// Generated source.
package org.hamcrest;
public class CoreMatchers {
/**
* Decorates another Matcher, retaining the behavior but allowing tests
* to be slightly more expressive.
*
* eg. assertThat(cheese, equalTo(smelly))
* vs assertThat(cheese, is(equalTo(smelly)))
*/
public static <T> org.hamcrest.Matcher<T> is(org.hamcrest.Matcher<T> matcher) {
return org.hamcrest.core.Is.is(matcher);
}
/**
* This is a shortcut to the frequently used is(equalTo(x)).
*
* eg. assertThat(cheese, is(equalTo(smelly)))
* vs assertThat(cheese, is(smelly))
*/
public static <T> org.hamcrest.Matcher<T> is(T value) {
return org.hamcrest.core.Is.is(value);
}
/**
* Provided to cause compile time error when used in preference to a possible runtime error if
* this was not here.
*
* <p>This method was removed upstream between Hamcrest 1.1 and 1.3 in favour of the
* instanceOf(Class) method. Unfortunately, existing usages of it could still compile against the
* {@link #is(Object)} method instead. Although not every existing usage would compile
* successfully it is possible that some could and that would result in a change in the runtime
* behavior that could be difficult to detect and fix. This change aims to turn any significant
* usage of this method into a compile time error.
*
* @deprecated Use instanceOf(SomeClass.class) instead.
*/
public static void is(java.lang.Class<?> type) {
}
/**
* Inverts the rule.
*/
public static <T> org.hamcrest.Matcher<T> not(org.hamcrest.Matcher<T> matcher) {
return org.hamcrest.core.IsNot.not(matcher);
}
/**
* This is a shortcut to the frequently used not(equalTo(x)).
*
* eg. assertThat(cheese, is(not(equalTo(smelly))))
* vs assertThat(cheese, is(not(smelly)))
*/
public static <T> org.hamcrest.Matcher<T> not(T value) {
return org.hamcrest.core.IsNot.not(value);
}
/**
* Is the value equal to another value, as tested by the
* {@link java.lang.Object#equals} invokedMethod?
*/
public static <T> org.hamcrest.Matcher<T> equalTo(T operand) {
return org.hamcrest.core.IsEqual.equalTo(operand);
}
/**
* Is the value an instance of a particular type?
*/
public static org.hamcrest.Matcher<java.lang.Object> instanceOf(java.lang.Class<?> type) {
return org.hamcrest.core.IsInstanceOf.instanceOf(type);
}
/**
* Evaluates to true only if ALL of the passed in matchers evaluate to true.
*/
public static <T> org.hamcrest.Matcher<T> allOf(org.hamcrest.Matcher<? extends T>... matchers) {
return org.hamcrest.core.AllOf.<T>allOf(matchers);
}
/**
* Evaluates to true only if ALL of the passed in matchers evaluate to true.
*/
public static <T> org.hamcrest.Matcher<T> allOf(java.lang.Iterable<org.hamcrest.Matcher<? extends T>> matchers) {
return org.hamcrest.core.AllOf.allOf(matchers);
}
/**
* Evaluates to true if ANY of the passed in matchers evaluate to true.
*/
public static <T> org.hamcrest.Matcher<T> anyOf(org.hamcrest.Matcher<? extends T>... matchers) {
return org.hamcrest.core.AnyOf.<T>anyOf(matchers);
}
/**
* Evaluates to true if ANY of the passed in matchers evaluate to true.
*/
public static <T> org.hamcrest.Matcher<T> anyOf(java.lang.Iterable<org.hamcrest.Matcher<? extends T>> matchers) {
return org.hamcrest.core.AnyOf.anyOf(matchers);
}
/**
* Creates a new instance of IsSame
*
* @param object The predicate evaluates to true only when the argument is
* this object.
*/
public static <T> org.hamcrest.Matcher<T> sameInstance(T object) {
return org.hamcrest.core.IsSame.sameInstance(object);
}
/**
* This matcher always evaluates to true.
*/
public static <T> org.hamcrest.Matcher<T> anything() {
return org.hamcrest.core.IsAnything.anything();
}
/**
* This matcher always evaluates to true.
*
* @param description A meaningful string used when describing itself.
*/
public static <T> org.hamcrest.Matcher<T> anything(java.lang.String description) {
return org.hamcrest.core.IsAnything.anything(description);
}
/**
* This matcher always evaluates to true. With type inference.
*/
public static <T> org.hamcrest.Matcher<T> any(java.lang.Class<T> type) {
return org.hamcrest.core.IsAnything.any(type);
}
/**
* Matches if value is null.
*/
public static <T> org.hamcrest.Matcher<T> nullValue() {
return org.hamcrest.core.IsNull.nullValue();
}
/**
* Matches if value is null. With type inference.
*/
public static <T> org.hamcrest.Matcher<T> nullValue(java.lang.Class<T> type) {
return org.hamcrest.core.IsNull.nullValue(type);
}
/**
* Matches if value is not null.
*/
public static <T> org.hamcrest.Matcher<T> notNullValue() {
return org.hamcrest.core.IsNull.notNullValue();
}
/**
* Matches if value is not null. With type inference.
*/
public static <T> org.hamcrest.Matcher<T> notNullValue(java.lang.Class<T> type) {
return org.hamcrest.core.IsNull.notNullValue(type);
}
/**
* Wraps an existing matcher and overrides the description when it fails.
*/
public static <T> org.hamcrest.Matcher<T> describedAs(java.lang.String description, org.hamcrest.Matcher<T> matcher, java.lang.Object... values) {
return org.hamcrest.core.DescribedAs.describedAs(description, matcher, values);
}
}
|
