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