Junit的Assert用法

  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         if (message == null) {
 48             throw new AssertionFailedError();
 49         }
 50         throw new AssertionFailedError(message);
 51     }
 52     /**
 53      * Fails a test with no message.
 54      */
 55     static public void fail() {
 56         fail(null);
 57     }
 58     /**
 59      * Asserts that two objects are equal. If they are not
 60      * an AssertionFailedError is thrown with the given message.
 61      */
 62     static public void assertEquals(String message, Object expected, Object actual) {
 63         if (expected == null && actual == null)
 64             return;
 65         if (expected != null && expected.equals(actual))
 66             return;
 67         failNotEquals(message, expected, actual);
 68     }
 69     /**
 70      * Asserts that two objects are equal. If they are not
 71      * an AssertionFailedError is thrown.
 72      */
 73     static public void assertEquals(Object expected, Object actual) {
 74         assertEquals(null, expected, actual);
 75     }
 76     /**
 77      * Asserts that two Strings are equal. 
 78      */
 79     static public void assertEquals(String message, String expected, String actual) {
 80         if (expected == null && actual == null)
 81             return;
 82         if (expected != null && expected.equals(actual))
 83             return;
 84         String cleanMessage= message == null ? "" : message;
 85         throw new ComparisonFailure(cleanMessage, expected, actual);
 86     }
 87     /**
 88      * Asserts that two Strings are equal. 
 89      */
 90     static public void assertEquals(String expected, String actual) {
 91         assertEquals(null, expected, actual);
 92     }
 93     /**
 94      * Asserts that two doubles are equal concerning a delta.  If they are not
 95      * an AssertionFailedError is thrown with the given message.  If the expected
 96      * value is infinity then the delta value is ignored.
 97      */
 98     static public void assertEquals(String message, double expected, double actual, double delta) {
 99         if (Double.compare(expected, actual) == 0)
100             return;
101         if (!(Math.abs(expected-actual) <= delta))
102             failNotEquals(message, new Double(expected), new Double(actual));
103     }
104     /**
105      * Asserts that two doubles are equal concerning a delta. If the expected
106      * value is infinity then the delta value is ignored.
107      */
108     static public void assertEquals(double expected, double actual, double delta) {
109         assertEquals(null, expected, actual, delta);
110     }
111     /**
112      * Asserts that two floats are equal concerning a positive delta. If they
113      * are not an AssertionFailedError is thrown with the given message. If the
114      * expected value is infinity then the delta value is ignored.
115      */
116     static public void assertEquals(String message, float expected, float actual, float delta) {
117         if (Float.compare(expected, actual) == 0)
118             return;
119         if (!(Math.abs(expected - actual) <= delta))
120                 failNotEquals(message, new Float(expected), new Float(actual));
121     }
122     /**
123      * Asserts that two floats are equal concerning a delta. If the expected
124      * value is infinity then the delta value is ignored.
125      */
126     static public void assertEquals(float expected, float actual, float delta) {
127         assertEquals(null, expected, actual, delta);
128     }
129     /**
130      * Asserts that two longs are equal. If they are not
131      * an AssertionFailedError is thrown with the given message.
132      */
133     static public void assertEquals(String message, long expected, long actual) {
134         assertEquals(message, new Long(expected), new Long(actual));
135     }
136     /**
137      * Asserts that two longs are equal.
138      */
139     static public void assertEquals(long expected, long actual) {
140         assertEquals(null, expected, actual);
141     }
142     /**
143      * Asserts that two booleans are equal. If they are not
144      * an AssertionFailedError is thrown with the given message.
145      */
146     static public void assertEquals(String message, boolean expected, boolean actual) {
147             assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));
148       }
149     /**
150      * Asserts that two booleans are equal.
151       */
152     static public void assertEquals(boolean expected, boolean actual) {
153         assertEquals(null, expected, actual);
154     }
155     /**
156      * Asserts that two bytes are equal. If they are not
157      * an AssertionFailedError is thrown with the given message.
158      */
159       static public void assertEquals(String message, byte expected, byte actual) {
160         assertEquals(message, new Byte(expected), new Byte(actual));
161     }
162     /**
163         * Asserts that two bytes are equal.
164      */
165     static public void assertEquals(byte expected, byte actual) {
166         assertEquals(null, expected, actual);
167     }
168     /**
169      * Asserts that two chars are equal. If they are not
170      * an AssertionFailedError is thrown with the given message.
171      */
172       static public void assertEquals(String message, char expected, char actual) {
173             assertEquals(message, new Character(expected), new Character(actual));
174       }
175     /**
176      * Asserts that two chars are equal.
177      */
178       static public void assertEquals(char expected, char actual) {
179         assertEquals(null, expected, actual);
180     }
181     /**
182      * Asserts that two shorts are equal. If they are not
183      * an AssertionFailedError is thrown with the given message.
184      */
185     static public void assertEquals(String message, short expected, short actual) {
186             assertEquals(message, new Short(expected), new Short(actual));
187     }
188       /**
189      * Asserts that two shorts are equal.
190      */
191     static public void assertEquals(short expected, short actual) {
192         assertEquals(null, expected, actual);
193     }
194     /**
195      * Asserts that two ints are equal. If they are not
196      * an AssertionFailedError is thrown with the given message.
197      */
198       static public void assertEquals(String message, int expected, int actual) {
199         assertEquals(message, new Integer(expected), new Integer(actual));
200       }
201       /**
202         * Asserts that two ints are equal.
203      */
204       static public void assertEquals(int expected, int actual) {
205           assertEquals(null, expected, actual);
206     }
207     /**
208      * Asserts that an object isn‘t null.
209      */
210     static public void assertNotNull(Object object) {
211         assertNotNull(null, object);
212     }
213     /**
214      * Asserts that an object isn‘t null. If it is
215      * an AssertionFailedError is thrown with the given message.
216      */
217     static public void assertNotNull(String message, Object object) {
218         assertTrue(message, object != null);
219     }
220     /**
221      * Asserts that an object is null. If it isn‘t an {@link AssertionError} is
222      * thrown.
223      * Message contains: Expected: <null> but was: object
224      * 
225      * @param object
226      *            Object to check or <code>null</code>
227      */
228     static public void assertNull(Object object) {
229         String message = "Expected: <null> but was: " + String.valueOf(object);
230         assertNull(message, object);
231     }
232     /**
233      * Asserts that an object is null.  If it is not
234      * an AssertionFailedError is thrown with the given message.
235      */
236     static public void assertNull(String message, Object object) {
237         assertTrue(message, object == null);
238     }
239     /**
240      * Asserts that two objects refer to the same object. If they are not
241      * an AssertionFailedError is thrown with the given message.
242      */
243     static public void assertSame(String message, Object expected, Object actual) {
244         if (expected == actual)
245             return;
246         failNotSame(message, expected, actual);
247     }
248     /**
249      * Asserts that two objects refer to the same object. If they are not
250      * the same an AssertionFailedError is thrown.
251      */
252     static public void assertSame(Object expected, Object actual) {
253         assertSame(null, expected, actual);
254     }
255     /**
256      * Asserts that two objects do not refer to the same object. If they do
257      * refer to the same object an AssertionFailedError is thrown with the
258      * given message.
259      */
260     static public void assertNotSame(String message, Object expected, Object actual) {
261         if (expected == actual)
262             failSame(message);
263     }
264     /**
265      * Asserts that two objects do not refer to the same object. If they do
266      * refer to the same object an AssertionFailedError is thrown.
267      */
268     static public void assertNotSame(Object expected, Object actual) {
269         assertNotSame(null, expected, actual);
270     }
271 
272     static public void failSame(String message) {
273         String formatted= "";
274          if (message != null)
275              formatted= message+" ";
276          fail(formatted+"expected not same");
277     }
278 
279     static public void failNotSame(String message, Object expected, Object actual) {
280         String formatted= "";
281         if (message != null)
282             formatted= message+" ";
283         fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">");
284     }
285 
286     static public void failNotEquals(String message, Object expected, Object actual) {
287         fail(format(message, expected, actual));
288     }
289 
290     public static String format(String message, Object expected, Object actual) {
291         String formatted= "";
292         if (message != null && message.length() > 0)
293             formatted= message+" ";
294         return formatted+"expected:<"+expected+"> but was:<"+actual+">";
295     }
296 }