Assert


1   package org.junit;
2   
3   import java.lang.reflect.Array  ;
4   
5   import org.junit.internal.ArrayComparisonFailure;
6   
7   /**
8    * A set of assertion methods useful for writing tests. Only failed assertions are recorded.
9    * These methods can be used directly: <code>Assert.assertEquals(...)</code>, however, they
10   * read better if they are referenced through static import:<br/>
11   * <pre>
12   * import static org.junit.Assert.*;
13   *    ...
14   *    assertEquals(...);
15   * </pre>
16   *   
17   * @see AssertionError
18   */
19  public class Assert {
20      /**
21       * Protect constructor since it is a static only class
22       */
23      protected Assert() {
24      }
25      
26      /**
27       * Asserts that a condition is true. If it isn't it throws an
28       * {@link AssertionError} with the given message.
29       * @param message the identifying message or <code>null</code> for the {@link AssertionError}
30       * @param condition condition to be checked
31       */
32      static public void assertTrue(String   message, boolean condition) {
33          if (!condition)
34              fail(message);
35      }
36  
37      /**
38       * Asserts that a condition is true. If it isn't it throws an
39       * {@link AssertionError} without a message.
40       * @param condition condition to be checked
41       */
42      static public void assertTrue(boolean condition) {
43          assertTrue(null, condition);
44      }
45  
46      /**
47       * Asserts that a condition is false. If it isn't it throws an
48       * {@link AssertionError} with the given message.
49       * @param message the identifying message or <code>null</code> for the {@link AssertionError}
50       * @param condition condition to be checked
51       */
52      static public void assertFalse(String   message, boolean condition) {
53          assertTrue(message, !condition);
54      }
55  
56      /**
57       * Asserts that a condition is false. If it isn't it throws an
58       * {@link AssertionError} without a message.
59       * @param condition condition to be checked
60       */
61      static public void assertFalse(boolean condition) {
62          assertFalse(null, condition);
63      }
64  
65      /**
66       * Fails a test with the given message.
67       * @param message the identifying message or <code>null</code> for the {@link AssertionError}
68       * @see AssertionError
69       */
70      static public void fail(String   message) {
71          throw new AssertionError  (message == null ? "" : message);
72      }
73  
74      /**
75       * Fails a test with no message.
76       */
77      static public void fail() {
78          fail(null);
79      }
80      
81      /**
82       * Asserts that two objects are equal. If they are not, an {@link AssertionError} 
83       * is thrown with the given message. If <code>expected</code> and <code>actual</code>
84       * are <code>null</code>, they are considered equal.
85       * @param message the identifying message or <code>null</code> for the {@link AssertionError}
86       * @param expected expected value
87       * @param actual actual value
88       */
89      static public void assertEquals(String   message, Object   expected, Object   actual) {
90          if (expected == null && actual == null)
91              return;
92          if (expected != null && isEquals(expected, actual))
93              return;
94          else if (expected instanceof String   && actual instanceof String  ) {
95              String   cleanMessage= message == null ? "" : message;
96              throw new ComparisonFailure(cleanMessage, (String  )expected, (String  )actual);
97          }
98          else
99              failNotEquals(message, expected, actual);
100     }
101 
102     private static boolean isEquals(Object   expected, Object   actual) {
103         if (expected instanceof Number   && actual instanceof Number  )
104             return ((Number  ) expected).longValue() == ((Number  ) actual).longValue();
105         return expected.equals(actual);
106     }
107 
108     /**
109      * Asserts that two objects are equal. If they are not, an {@link AssertionError} 
110      * without a message is thrown. If <code>expected</code> and <code>actual</code>
111      * are <code>null</code>, they are considered equal.
112      * @param expected expected value
113      * @param actual the value to check against <code>expected</code>
114      */
115     static public void assertEquals(Object   expected, Object   actual) {
116         assertEquals(null, expected, actual);
117     }
118 
119     /**
120      * Asserts that two object arrays are equal. If they are not, an
121      * {@link AssertionError} is thrown with the given message. If <code>expecteds</code> and
122      *  <code>actuals</code> are <code>null</code>, they are considered equal.
123      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
124      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values.
125      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
126      */
127     public static void assertArrayEquals(String   message, Object  [] expecteds,
128             Object  [] actuals) throws ArrayComparisonFailure {
129         internalArrayEquals(message, expecteds, actuals);
130     }
131     
132     /**
133      * Asserts that two object arrays are equal. If they are not, an {@link AssertionError} 
134      * is thrown.  If <code>expected</code> and <code>actual</code> are <code>null</code>, 
135      * they are considered equal.
136      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values
137      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
138      */
139     public static void assertArrayEquals(Object  [] expecteds, Object  [] actuals) {
140         assertArrayEquals(null, expecteds, actuals);
141     }
142 
143     /**
144      * TODO: fix javadoc
145      * Asserts that two object arrays are equal. If they are not, an
146      * {@link AssertionError} is thrown with the given message. If <code>expecteds</code> and
147      *  <code>actuals</code> are <code>null</code>, they are considered equal.
148      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
149      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values.
150      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
151      */
152     public static void assertArrayEquals(String   message, byte[] expecteds,
153             byte[] actuals) throws ArrayComparisonFailure {
154         internalArrayEquals(message, expecteds, actuals);
155     }
156 
157     /**
158      * TODO: fix javadoc
159      * Asserts that two object arrays are equal. If they are not, an {@link AssertionError} 
160      * is thrown.  If <code>expected</code> and <code>actual</code> are <code>null</code>, 
161      * they are considered equal.
162      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values
163      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
164      */
165     public static void assertArrayEquals(byte[] expecteds, byte[] actuals) {
166         assertArrayEquals(null, expecteds, actuals);
167     }
168     
169     /**
170      * TODO: fix javadoc
171      * Asserts that two object arrays are equal. If they are not, an
172      * {@link AssertionError} is thrown with the given message. If <code>expecteds</code> and
173      *  <code>actuals</code> are <code>null</code>, they are considered equal.
174      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
175      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values.
176      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
177      */
178     public static void assertArrayEquals(String   message, char[] expecteds,
179             char[] actuals) throws ArrayComparisonFailure {
180         internalArrayEquals(message, expecteds, actuals);
181     }
182 
183     /**
184      * TODO: fix javadoc
185      * Asserts that two object arrays are equal. If they are not, an {@link AssertionError} 
186      * is thrown.  If <code>expected</code> and <code>actual</code> are <code>null</code>, 
187      * they are considered equal.
188      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values
189      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
190      */
191     public static void assertArrayEquals(char[] expecteds, char[] actuals) {
192         assertArrayEquals(null, expecteds, actuals);
193     }
194     
195     /**
196      * TODO: fix javadoc
197      * Asserts that two object arrays are equal. If they are not, an
198      * {@link AssertionError} is thrown with the given message. If <code>expecteds</code> and
199      *  <code>actuals</code> are <code>null</code>, they are considered equal.
200      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
201      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values.
202      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
203      */
204     public static void assertArrayEquals(String   message, short[] expecteds,
205             short[] actuals) throws ArrayComparisonFailure {
206         internalArrayEquals(message, expecteds, actuals);
207     }
208 
209     /**
210      * TODO: fix javadoc
211      * Asserts that two object arrays are equal. If they are not, an {@link AssertionError} 
212      * is thrown.  If <code>expected</code> and <code>actual</code> are <code>null</code>, 
213      * they are considered equal.
214      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values
215      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
216      */
217     public static void assertArrayEquals(short[] expecteds, short[] actuals) {
218         assertArrayEquals(null, expecteds, actuals);
219     }
220     
221     /**
222      * TODO: fix javadoc
223      * Asserts that two object arrays are equal. If they are not, an
224      * {@link AssertionError} is thrown with the given message. If <code>expecteds</code> and
225      *  <code>actuals</code> are <code>null</code>, they are considered equal.
226      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
227      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values.
228      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
229      */
230     public static void assertArrayEquals(String   message, int[] expecteds,
231             int[] actuals) throws ArrayComparisonFailure {
232         internalArrayEquals(message, expecteds, actuals);
233     }
234 
235     /**
236      * TODO: fix javadoc
237      * Asserts that two object arrays are equal. If they are not, an {@link AssertionError} 
238      * is thrown.  If <code>expected</code> and <code>actual</code> are <code>null</code>, 
239      * they are considered equal.
240      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values
241      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
242      */
243     public static void assertArrayEquals(int[] expecteds, int[] actuals) {
244         assertArrayEquals(null, expecteds, actuals);
245     }
246 
247     /**
248      * TODO: fix javadoc
249      * Asserts that two object arrays are equal. If they are not, an {@link AssertionError} 
250      * is thrown.  If <code>expected</code> and <code>actual</code> are <code>null</code>, 
251      * they are considered equal.
252      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values
253      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
254      */
255     public static void assertArrayEquals(long[] expecteds, long[] actuals) {
256         assertArrayEquals(null, expecteds, actuals);
257     }
258     
259     /**
260      * TODO: fix javadoc
261      * Asserts that two object arrays are equal. If they are not, an
262      * {@link AssertionError} is thrown with the given message. If <code>expecteds</code> and
263      *  <code>actuals</code> are <code>null</code>, they are considered equal.
264      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
265      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values.
266      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
267      */
268     public static void assertArrayEquals(String   message, long[] expecteds,
269             long[] actuals) throws ArrayComparisonFailure {
270         internalArrayEquals(message, expecteds, actuals);
271     }
272     
273     /**
274      * Asserts that two object arrays are equal. If they are not, an
275      * {@link AssertionError} is thrown with the given message. If <code>expecteds</code> and
276      *  <code>actuals</code> are <code>null</code>, they are considered equal.
277      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
278      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values.
279      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
280      */
281     private static void internalArrayEquals(String   message, Object   expecteds,
282             Object   actuals) throws ArrayComparisonFailure {
283         if (expecteds == actuals)
284             return;
285         String   header = message == null ? "" : message + ": ";
286         if (expecteds == null)
287             fail(header + "expected array was null");
288         if (actuals == null)
289             fail(header + "actual array was null");
290         int actualsLength= Array.getLength(actuals);
291         int expectedsLength= Array.getLength(expecteds);
292         if (actualsLength != expectedsLength)
293             fail(header + "array lengths differed, expected.length=" + expectedsLength + " actual.length=" + actualsLength);
294     
295         for (int i= 0; i < expectedsLength; i++) {
296             Object   expected= Array.get(expecteds, i);
297             Object   actual= Array.get(actuals, i);
298             if (isArray(expected) && isArray(actual)) {
299                 try {
300                     internalArrayEquals(message, expected, actual);
301                 } catch (ArrayComparisonFailure e) {
302                     e.addDimension(i);
303                     throw e;
304                 }
305             } else
306                 try {
307                     assertEquals(expected, actual);
308                 } catch (AssertionError   e) {
309                     throw new ArrayComparisonFailure(header, e, i);
310                 }
311         }
312     }
313 
314     private static boolean isArray(Object   expected) {
315         return expected != null && expected.getClass().isArray();
316     }
317 
318     /**
319      * Asserts that two doubles or floats are equal to within a positive delta. If they
320      * are not, an {@link AssertionError} is thrown with the given message. If the
321      * expected value is infinity then the delta value is ignored. NaNs are
322      * considered equal:
323      * <code>assertEquals(Double.NaN, Double.NaN, *)</code> passes
324      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
325      * @param expected expected value
326      * @param actual the value to check against <code>expected</code>
327      * @param delta the maximum delta between <code>expected</code> and <code>actual</code> for which 
328      * both numbers are still considered equal.
329      */
330     static public void assertEquals(String   message, double expected, double actual, double delta) {
331         if (Double.compare(expected, actual) == 0)
332             return;
333         if (!(Math.abs(expected - actual) <= delta))
334             failNotEquals(message, new Double  (expected), new Double  (actual));
335     }
336 
337     /**
338      * Asserts that two doubles or floats are equal to within a positive delta. If they
339      * are not, an {@link AssertionError} is thrown. If the
340      * expected value is infinity then the delta value is ignored.NaNs are
341      * considered equal:
342      * <code>assertEquals(Double.NaN, Double.NaN, *)</code> passes
343      * @param expected expected value
344      * @param actual the value to check against <code>expected</code>
345      * @param delta the maximum delta between <code>expected</code> and <code>actual</code> for which 
346      * both numbers are still considered equal.
347      */
348     static public void assertEquals(double expected, double actual, double delta) {
349         assertEquals(null, expected, actual, delta);
350     }
351 
352     /**
353      * Asserts that an object isn't null. If it is an {@link AssertionError} is
354      * thrown with the given message.
355      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
356      * @param object Object to check or <code>null</code>
357      */
358     static public void assertNotNull(String   message, Object   object) {
359         assertTrue(message, object != null);
360     }
361 
362     /**
363      * Asserts that an object isn't null. If it is an {@link AssertionError} is
364      * thrown.
365      * @param object Object to check or <code>null</code>
366      */
367     static public void assertNotNull(Object   object) {
368         assertNotNull(null, object);
369     }
370     
371     /**
372      * Asserts that an object is null. If it is not, an {@link AssertionError} is
373      * thrown with the given message.
374      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
375      * @param object Object to check or <code>null</code>
376      */
377     static public void assertNull(String   message, Object   object) {
378         assertTrue(message, object == null);
379     }
380 
381     /**
382      * Asserts that an object is null. If it isn't an {@link AssertionError} is
383      * thrown.
384      * @param object Object to check or <code>null</code>
385      */
386     static public void assertNull(Object   object) {
387         assertNull(null, object);
388     }
389     
390     /**
391      * Asserts that two objects refer to the same object. If they are not, an
392      * {@link AssertionError} is thrown with the given message.
393      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
394      * @param expected the expected object
395      * @param actual the object to compare to <code>expected</code>
396      */
397     static public void assertSame(String   message, Object   expected, Object   actual) {
398         if (expected == actual)
399             return;
400         failNotSame(message, expected, actual);
401     }
402 
403     /**
404      * Asserts that two objects refer to the same object. If they are not the
405      * same, an {@link AssertionError} without a message is thrown.
406      * @param expected the expected object
407      * @param actual the object to compare to <code>expected</code>
408      */
409     static public void assertSame(Object   expected, Object   actual) {
410         assertSame(null, expected, actual);
411     }
412 
413     /**
414      * Asserts that two objects do not refer to the same object. If they do
415      * refer to the same object, an {@link AssertionError} is thrown with the given
416      * message.
417      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
418      * @param unexpected the object you don't expect
419      * @param actual the object to compare to <code>unexpected</code>
420      */
421     static public void assertNotSame(String   message, Object   unexpected, Object   actual) {
422         if (unexpected == actual)
423             failSame(message);
424     }
425 
426     /**
427      * Asserts that two objects do not refer to the same object. If they do
428      * refer to the same object, an {@link AssertionError} without a message is thrown.
429      * @param unexpected the object you don't expect
430      * @param actual the object to compare to <code>unexpected</code>
431      */
432     static public void assertNotSame(Object   unexpected, Object   actual) {
433         assertNotSame(null, unexpected, actual);
434     }
435 
436     static private void failSame(String   message) {
437         String   formatted= "";
438         if (message != null)
439             formatted= message + " ";
440         fail(formatted + "expected not same");
441     }
442 
443     static private void failNotSame(String   message, Object   expected, Object   actual) {
444         String   formatted= "";
445         if (message != null)
446             formatted= message + " ";
447         fail(formatted + "expected same:<" + expected + "> was not:<" + actual + ">");
448     }
449 
450     static private void failNotEquals(String   message, Object   expected, Object   actual) {
451         fail(format(message, expected, actual));
452     }
453 
454     static String   format(String   message, Object   expected, Object   actual) {
455         String   formatted= "";
456         if (message != null && ! message.equals(""))
457             formatted= message + " ";
458         String   expectedString= String.valueOf(expected);
459         String   actualString= String.valueOf(actual);
460         if (expectedString.equals(actualString))
461             return formatted + "expected: " + expected.getClass().getName() + "<" + expectedString + "> but was: " + actual.getClass().getName() + "<" + actualString + ">";
462         else
463             return formatted + "expected:<" + expectedString + "> but was:<" + actualString + ">";
464     }
465 
466     /**
467      * Asserts that two object arrays are equal. If they are not, an
468      * {@link AssertionError} is thrown with the given message. If <code>expecteds</code> and
469      *  <code>actuals</code> are <code>null</code>, they are considered equal.
470      * @param message the identifying message or <code>null</code> for the {@link AssertionError}
471      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values.
472      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
473      * @deprecated use assertArrayEquals
474      */
475     @Deprecated  
476     public static void assertEquals(String   message, Object  [] expecteds, Object  [] actuals) {
477         assertArrayEquals(message, expecteds, actuals);
478     }
479 
480     /**
481      * Asserts that two object arrays are equal. If they are not, an {@link AssertionError} 
482      * is thrown.  If <code>expected</code> and <code>actual</code> are <code>null</code>, 
483      * they are considered equal.
484      * @param expecteds Object array or array of arrays (multi-dimensional array) with expected values
485      * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
486      * @deprecated use assertArrayEquals
487      */
488     @Deprecated  
489     public static void assertEquals(Object  [] expecteds, Object  [] actuals) {
490         assertArrayEquals(expecteds, actuals);
491     }
492 
493 }
494
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags