Source code: junit/framework/Assert.java
1 package junit.framework;
2
3 /**
4 * A set of assert methods. Messages are only displayed when an assert fails.
5 */
6
7 public class Assert {
8 /**
9 * Protect constructor since it is a static only class
10 */
11 protected Assert() {
12 }
13
14 /**
15 * Asserts that a condition is true. If it isn't it throws
16 * an AssertionFailedError with the given message.
17 */
18 static public void assertTrue(String message, boolean condition) {
19 if (!condition)
20 fail(message);
21 }
22 /**
23 * Asserts that a condition is true. If it isn't it throws
24 * an AssertionFailedError.
25 */
26 static public void assertTrue(boolean condition) {
27 assertTrue(null, condition);
28 }
29 /**
30 * Asserts that a condition is false. If it isn't it throws
31 * an AssertionFailedError with the given message.
32 */
33 static public void assertFalse(String message, boolean condition) {
34 assertTrue(message, !condition);
35 }
36 /**
37 * Asserts that a condition is false. If it isn't it throws
38 * an AssertionFailedError.
39 */
40 static public void assertFalse(boolean condition) {
41 assertFalse(null, condition);
42 }
43 /**
44 * Fails a test with the given message.
45 */
46 static public void fail(String message) {
47 throw new AssertionFailedError(message);
48 }
49 /**
50 * Fails a test with no message.
51 */
52 static public void fail() {
53 fail(null);
54 }
55 /**
56 * Asserts that two objects are equal. If they are not
57 * an AssertionFailedError is thrown with the given message.
58 */
59 static public void assertEquals(String message, Object expected, Object actual) {
60 if (expected == null && actual == null)
61 return;
62 if (expected != null && expected.equals(actual))
63 return;
64 failNotEquals(message, expected, actual);
65 }
66 /**
67 * Asserts that two objects are equal. If they are not
68 * an AssertionFailedError is thrown.
69 */
70 static public void assertEquals(Object expected, Object actual) {
71 assertEquals(null, expected, actual);
72 }
73 /**
74 * Asserts that two Strings are equal.
75 */
76 static public void assertEquals(String message, String expected, String actual) {
77 if (expected == null && actual == null)
78 return;
79 if (expected != null && expected.equals(actual))
80 return;
81 throw new ComparisonFailure(message, expected, actual);
82 }
83 /**
84 * Asserts that two Strings are equal.
85 */
86 static public void assertEquals(String expected, String actual) {
87 assertEquals(null, expected, actual);
88 }
89 /**
90 * Asserts that two doubles are equal concerning a delta. If they are not
91 * an AssertionFailedError is thrown with the given message. If the expected
92 * value is infinity then the delta value is ignored.
93 */
94 static public void assertEquals(String message, double expected, double actual, double delta) {
95 // handle infinity specially since subtracting to infinite values gives NaN and the
96 // the following test fails
97 if (Double.isInfinite(expected)) {
98 if (!(expected == actual))
99 failNotEquals(message, new Double(expected), new Double(actual));
100 } else if (!(Math.abs(expected-actual) <= delta)) // Because comparison with NaN always returns false
101 failNotEquals(message, new Double(expected), new Double(actual));
102 }
103 /**
104 * Asserts that two doubles are equal concerning a delta. If the expected
105 * value is infinity then the delta value is ignored.
106 */
107 static public void assertEquals(double expected, double actual, double delta) {
108 assertEquals(null, expected, actual, delta);
109 }
110 /**
111 * Asserts that two floats are equal concerning a delta. If they are not
112 * an AssertionFailedError is thrown with the given message. If the expected
113 * value is infinity then the delta value is ignored.
114 */
115 static public void assertEquals(String message, float expected, float actual, float delta) {
116 // handle infinity specially since subtracting to infinite values gives NaN and the
117 // the following test fails
118 if (Float.isInfinite(expected)) {
119 if (!(expected == actual))
120 failNotEquals(message, new Float(expected), new Float(actual));
121 } else if (!(Math.abs(expected-actual) <= delta))
122 failNotEquals(message, new Float(expected), new Float(actual));
123 }
124 /**
125 * Asserts that two floats are equal concerning a delta. If the expected
126 * value is infinity then the delta value is ignored.
127 */
128 static public void assertEquals(float expected, float actual, float delta) {
129 assertEquals(null, expected, actual, delta);
130 }
131 /**
132 * Asserts that two longs are equal. If they are not
133 * an AssertionFailedError is thrown with the given message.
134 */
135 static public void assertEquals(String message, long expected, long actual) {
136 assertEquals(message, new Long(expected), new Long(actual));
137 }
138 /**
139 * Asserts that two longs are equal.
140 */
141 static public void assertEquals(long expected, long actual) {
142 assertEquals(null, expected, actual);
143 }
144 /**
145 * Asserts that two booleans are equal. If they are not
146 * an AssertionFailedError is thrown with the given message.
147 */
148 static public void assertEquals(String message, boolean expected, boolean actual) {
149 assertEquals(message, new Boolean(expected), new Boolean(actual));
150 }
151 /**
152 * Asserts that two booleans are equal.
153 */
154 static public void assertEquals(boolean expected, boolean actual) {
155 assertEquals(null, expected, actual);
156 }
157 /**
158 * Asserts that two bytes are equal. If they are not
159 * an AssertionFailedError is thrown with the given message.
160 */
161 static public void assertEquals(String message, byte expected, byte actual) {
162 assertEquals(message, new Byte(expected), new Byte(actual));
163 }
164 /**
165 * Asserts that two bytes are equal.
166 */
167 static public void assertEquals(byte expected, byte actual) {
168 assertEquals(null, expected, actual);
169 }
170 /**
171 * Asserts that two chars are equal. If they are not
172 * an AssertionFailedError is thrown with the given message.
173 */
174 static public void assertEquals(String message, char expected, char actual) {
175 assertEquals(message, new Character(expected), new Character(actual));
176 }
177 /**
178 * Asserts that two chars are equal.
179 */
180 static public void assertEquals(char expected, char actual) {
181 assertEquals(null, expected, actual);
182 }
183 /**
184 * Asserts that two shorts are equal. If they are not
185 * an AssertionFailedError is thrown with the given message.
186 */
187 static public void assertEquals(String message, short expected, short actual) {
188 assertEquals(message, new Short(expected), new Short(actual));
189 }
190 /**
191 * Asserts that two shorts are equal.
192 */
193 static public void assertEquals(short expected, short actual) {
194 assertEquals(null, expected, actual);
195 }
196 /**
197 * Asserts that two ints are equal. If they are not
198 * an AssertionFailedError is thrown with the given message.
199 */
200 static public void assertEquals(String message, int expected, int actual) {
201 assertEquals(message, new Integer(expected), new Integer(actual));
202 }
203 /**
204 * Asserts that two ints are equal.
205 */
206 static public void assertEquals(int expected, int actual) {
207 assertEquals(null, expected, actual);
208 }
209 /**
210 * Asserts that an object isn't null.
211 */
212 static public void assertNotNull(Object object) {
213 assertNotNull(null, object);
214 }
215 /**
216 * Asserts that an object isn't null. If it is
217 * an AssertionFailedError is thrown with the given message.
218 */
219 static public void assertNotNull(String message, Object object) {
220 assertTrue(message, object != null);
221 }
222 /**
223 * Asserts that an object is null.
224 */
225 static public void assertNull(Object object) {
226 assertNull(null, object);
227 }
228 /**
229 * Asserts that an object is null. If it is not
230 * an AssertionFailedError is thrown with the given message.
231 */
232 static public void assertNull(String message, Object object) {
233 assertTrue(message, object == null);
234 }
235 /**
236 * Asserts that two objects refer to the same object. If they are not
237 * an AssertionFailedError is thrown with the given message.
238 */
239 static public void assertSame(String message, Object expected, Object actual) {
240 if (expected == actual)
241 return;
242 failNotSame(message, expected, actual);
243 }
244 /**
245 * Asserts that two objects refer to the same object. If they are not
246 * the same an AssertionFailedError is thrown.
247 */
248 static public void assertSame(Object expected, Object actual) {
249 assertSame(null, expected, actual);
250 }
251 /**
252 * Asserts that two objects refer to the same object. If they are not
253 * an AssertionFailedError is thrown with the given message.
254 */
255 static public void assertNotSame(String message, Object expected, Object actual) {
256 if (expected == actual)
257 failSame(message);
258 }
259 /**
260 * Asserts that two objects refer to the same object. If they are not
261 * the same an AssertionFailedError is thrown.
262 */
263 static public void assertNotSame(Object expected, Object actual) {
264 assertNotSame(null, expected, actual);
265 }
266
267 static private void failSame(String message) {
268 String formatted= "";
269 if (message != null)
270 formatted= message+" ";
271 fail(formatted+"expected not same");
272 }
273
274 static private void failNotSame(String message, Object expected, Object actual) {
275 String formatted= "";
276 if (message != null)
277 formatted= message+" ";
278 fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">");
279 }
280
281 static private void failNotEquals(String message, Object expected, Object actual) {
282 fail(format(message, expected, actual));
283 }
284
285 static String format(String message, Object expected, Object actual) {
286 String formatted= "";
287 if (message != null)
288 formatted= message+" ";
289 return formatted+"expected:<"+expected+"> but was:<"+actual+">";
290 }
291 }