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
96
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))
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
117
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 do not refer to the same object. If they do
253 * refer to the same object an AssertionFailedError is thrown with the
254 * given message.
255 */
256 static public void assertNotSame(String message, Object expected, Object actual) {
257 if (expected == actual)
258 failSame(message);
259 }
260 /***
261 * Asserts that two objects do not refer to the same object. If they do
262 * refer to the same object an AssertionFailedError is thrown.
263 */
264 static public void assertNotSame(Object expected, Object actual) {
265 assertNotSame(null, expected, actual);
266 }
267
268 static private void failSame(String message) {
269 String formatted= "";
270 if (message != null)
271 formatted= message+" ";
272 fail(formatted+"expected not same");
273 }
274
275 static private void failNotSame(String message, Object expected, Object actual) {
276 String formatted= "";
277 if (message != null)
278 formatted= message+" ";
279 fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">");
280 }
281
282 static private void failNotEquals(String message, Object expected, Object actual) {
283 fail(format(message, expected, actual));
284 }
285
286 static String format(String message, Object expected, Object actual) {
287 String formatted= "";
288 if (message != null)
289 formatted= message+" ";
290 return formatted+"expected:<"+expected+"> but was:<"+actual+">";
291 }
292 }