Assert.java revision f6c387128427e121477c1b32ad35cdcaa5101ba3 
1package junit.framework;
2
3/**
4 * A set of assert methods.  Messages are only displayed when an assert fails.
5 */
6
7public 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}
292